DUMMIE Engine

https://github.com/srandres629/dummie-engine
Admin
DUMMIE Engine is an experimental multi-layer agentic orchestration system with focus on...
Tokens:127,251
Snippets:1,890
Trust Score:4.9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install @rolldown/pluginutils

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/@rolldown/pluginutils/README.md

Install the library using pnpm.

```sh
pnpm add @rolldown/pluginutils
```

--------------------------------

### Install and Test Picomatch

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/picomatch/README.md

Install project dependencies and run unit tests to familiarize yourself with the library's API.

```shell
npm install && npm test
```

--------------------------------

### Install detect-libc

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/detect-libc/README.md

Install the detect-libc module using npm.

```sh
npm install detect-libc
```

--------------------------------

### Install React and React DOM

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/react-dom/README.md

Install both react and react-dom packages to use React for web applications.

```sh
npm install react react-dom
```

--------------------------------

### Install Protobuf Elixir Protoc Plugin

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/protobuf/README.md

Install the protoc-gen-elixir plugin using mix escript.install to enable code generation from .proto files.

```bash
mix escript.install hex protobuf
```

--------------------------------

### Install Picomatch with npm

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/picomatch/README.md

Install the picomatch package using npm for use in Node.js projects.

```sh
npm install --save picomatch
```

--------------------------------

### Agent System Prompt Assembly Example

Source: https://github.com/srandres629/dummie-engine/blob/main/docs/superpowers/specs/2026-04-25-multi-repo-provider-agent-office-design.md

Illustrates the construction of a system prompt for an agent, including role, objective, and relevant context.

```text
You are the CodeVerifier for repo dummie-engine.
You cannot edit files.
Verify whether the implementer actually fixed the L2-L5 executor contract.
Relevant files:
- layers/l2_brain/daemon.py
- layers/l5_muscle/mcp_driver.py
- layers/l2_brain/tests/test_daemon_real_mcp_driver_contract.py
Required evidence:
- focused test output
- full L2 test output
- git diff summary
Return EvidencePacket JSON only.
```

--------------------------------

### Generate Documentation for Picomatch

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/picomatch/README.md

Install global dependencies and run the verb command to generate the project's README.md file.

```shell
npm install -g verbose/verb#dev verb-generate-readme && verb
```

--------------------------------

### Create a Counter Component with React

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/react/README.md

This example shows how to create a basic counter component using React's `useState` hook and render it to the DOM using `react-dom`. Ensure you have `react` and `react-dom` installed.

```javascript
import { useState } from 'react';
import { createRoot } from 'react-dom/client';

function Counter() {
  const [count, setCount] = useState(0);
  return (
    <>
      <h1>{count}</h1>
      <button onClick={() => setCount(count + 1)}>
        Increment
      </button>
    </>
  );
}

const root = createRoot(document.getElementById('root'));
root.render(<Counter />);
```

--------------------------------

### Minimal Agent Handoff Example

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/agentic/HANDOFF_CONTRACT.md

An example demonstrating the complete structure of an agent handoff. It includes specific details for each field, such as task ID, files changed, commands run, and validation results.

```markdown
# Agent Handoff

## Task ID
phase1-agentic-contracts-builder

## Agent Role
Builder

## Objective
Create the Phase 1 agentic governance contracts and templates without runtime edits.

## Files Changed
- doc/agentic/AGENT_TASK_CONTRACT.md
- doc/agentic/HANDOFF_CONTRACT.md
- doc/agentic/VALIDATION_EVIDENCE.md
- doc/agentic/SCOPE_GUARD_PROTOCOL.md
- doc/agentic/AGENT_RELIABILITY_LEDGER.md
- .aiwg/templates/agent_task_contract.yaml
- .aiwg/templates/agent_handoff.md
- .aiwg/templates/validation_evidence.md

## Commands Run
- `git status --short` - exit 0
- `python3 scripts/validate_specs_docs.py` - exit 1

## Validation Results
- `git status --short`: pass, shows only expected files.
- `python3 scripts/validate_specs_docs.py`: fail, classified as PREEXISTING_FAILURE if the same spec error existed before this task.

## Evidence
- VERIFIED_BY_SOURCE_READ: existing protocols in `doc/agentic/`.
- VERIFIED_BY_COMMAND: command outputs listed above.

## Assumptions
- Optional checker scripts should wait until docs are accepted.

## Risks Remaining
- Manual enforcement remains until checker scripts are implemented.

## Scope Deviations
None.

## Follow-up Recommendation
Create a handoff checker from this contract after Phase 1 text is validated.

## Human Review Needed
Yes. Human should approve contract wording before automation enforces it.
```

--------------------------------

### Picomatch API Example

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/picomatch/README.md

Shows how to use the main picomatch function to create a matcher for a specific glob pattern.

```javascript
const picomatch = require('picomatch');
// picomatch(glob[, options]);

const isMatch = picomatch('*.!(*a)');
console.log(isMatch('a.a')); //=> false
console.log(isMatch('a.b')); //=> true
```

--------------------------------

### Install CSSType via npm

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/csstype/README.md

Shows the command to install the csstype package using npm.

```bash
$ npm install csstype
```

--------------------------------

### Install fdir using npm

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/fdir/README.md

Install the fdir package using npm for your Node.js project.

```sh
npm i fdir
```

--------------------------------

### Start Gnat Connection and Publish/Subscribe

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/gnat/README.md

Demonstrates starting a Gnat connection, subscribing to a topic, and publishing a message. Handles receiving the published message.

```elixir
{:ok, gnat} = Gnat.start_link(%{host: "127.0.0.1", port: 4222})
# Or if the server requires TLS you can start a connection with:
# {:ok, gnat} = Gnat.start_link(%{host: "127.0.0.1", port: 4222, tls: true})

{:ok, subscription} = Gnat.sub(gnat, self(), "pawnee.*")
:ok = Gnat.pub(gnat, "pawnee.news", "Leslie Knope recalled from city council (Jammed)")
receive do
  {:msg, %{body: body, topic: "pawnee.news", reply_to: nil}} ->
    IO.puts(body)
end
```

--------------------------------

### Install fdir using Yarn

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/fdir/README.md

Install the fdir package using Yarn for your Node.js project.

```sh
yarn add fdir
```

--------------------------------

### Install Nx in Livebook or IEx

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/nx/README.md

For interactive environments like Livebook or IEx, you can use `Mix.install` to add Nx as a dependency. This is useful for experimenting or quick scripting.

```elixir
Mix.install([
  {:nx, "~> 0.5"}
])
```

--------------------------------

### Example Scope Review in YAML

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/agentic/SCOPE_GUARD_PROTOCOL.md

An example of a scope review in YAML format, detailing the task ID, changed files, scope verdict, evidence, and deviations.

```yaml
task_id: phase1-agentic-contracts-builder
changed_files:
  - doc/agentic/AGENT_TASK_CONTRACT.md
  - doc/agentic/HANDOFF_CONTRACT.md
  - doc/agentic/VALIDATION_EVIDENCE.md
  - doc/agentic/SCOPE_GUARD_PROTOCOL.md
  - doc/agentic/AGENT_RELIABILITY_LEDGER.md
  - .aiwg/templates/agent_task_contract.yaml
  - .aiwg/templates/agent_handoff.md
  - .aiwg/templates/validation_evidence.md
scope_verdict: PASS_WITH_PREEXISTING_FAILURE
evidence:
  - "git status --short listed only allowed files."
  - "python3 scripts/validate_specs_docs.py failed on a documented preexisting issue outside the task scope."
deviations: []
```

--------------------------------

### Example Agent Reliability Ledger Entry

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/agentic/AGENT_RELIABILITY_LEDGER.md

A complete example of a ledger entry, including scores, file changes, commands run, and recommendations.

```yaml
agent_id: codex-phase1-builder
provider: Codex
role: Builder
task_id: phase1-agentic-contracts-builder
success: partial
scope_adherence_score: 1
evidence_score: 2
validation_score: 2
risk_detection_score: 1
introduced_regression: false
files_changed:
  count: 8
  files:
    - doc/agentic/AGENT_TASK_CONTRACT.md
    - doc/agentic/HANDOFF_CONTRACT.md
    - doc/agentic/VALIDATION_EVIDENCE.md
    - doc/agentic/SCOPE_GUARD_PROTOCOL.md
    - doc/agentic/AGENT_RELIABILITY_LEDGER.md
    - .aiwg/templates/agent_task_contract.yaml
    - .aiwg/templates/agent_handoff.md
    - .aiwg/templates/validation_evidence.md
unrelated_changes:
  count: 0
  files: []
commands_run:
  - git status --short
  - python3 scripts/validate_specs_docs.py
notes:
  - "Docs-only scope respected."
  - "Specs validation failed on a documented preexisting issue outside task scope."
recommended_future_use: allowed

```

--------------------------------

### Install Nightly TypeScript Builds

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/typescript/README.md

Use this command to install the latest nightly build of TypeScript as a development dependency.

```bash
npm install -D typescript@next
```

--------------------------------

### Picomatch Extglob Examples

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/picomatch/README.md

Demonstrates the usage of picomatch's extended globbing features, including zero or more, one or more, and negation patterns. Shows how to match nested extglobs and handle risky quantified extglobs.

```javascript
const pm = require('picomatch');

// *(pattern) matches ZERO or more of "pattern"
console.log(pm.isMatch('a', 'a*(z)')); // true
console.log(pm.isMatch('az', 'a*(z)')); // true
console.log(pm.isMatch('azzz', 'a*(z)')); // true

// +(pattern) matches ONE or more of "pattern"
console.log(pm.isMatch('a', 'a+(z)')); // false
console.log(pm.isMatch('az', 'a+(z)')); // true
console.log(pm.isMatch('azzz', 'a+(z)')); // true

// supports multiple extglobs
console.log(pm.isMatch('foo.bar', '!(foo).!(bar)')); // false

// supports nested extglobs
console.log(pm.isMatch('foo.bar', '!(!(foo)).!(!(bar))')); // true

// risky quantified extglobs are treated literally by default
console.log(pm.makeRe('+(a|aa)'));
//=> /^(?:\+\(a\|aa\))$/

// increase the limit to allow a small amount of nested quantified extglobs
console.log(pm.isMatch('aaa', '+(+(a))', { maxExtglobRecursion: 1 })); // true
```

--------------------------------

### Quick Packet for Analysis Tasks

Source: https://github.com/srandres629/dummie-engine/blob/main/skills/chatgpt/prompt-packets.md

An example prompt packet for comparing tools. It outlines the objective, audience context, data sources, desired output, and specific constraints for the analysis.

```text
Goal: Compare these three tools.
Context: Buyer is technical but budget-conscious.
Source of truth: the feature table and notes below.
Deliverable: Recommendation table plus best choice by use case.
Constraints: Call out unknowns explicitly.
Review standard: Separate confirmed facts from inference.
```

--------------------------------

### Basic Color Formatting with picocolors

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/picocolors/README.md

Demonstrates how to import and use picocolors to apply basic formatting like green color and italic style to terminal output. Ensure picocolors is installed and imported correctly.

```javascript
import pc from "picocolors"

console.log(
  pc.green(`How are ${pc.italic(`you`)} doing?`)
)
```

--------------------------------

### Quick Packet for Writing Tasks

Source: https://github.com/srandres629/dummie-engine/blob/main/skills/chatgpt/prompt-packets.md

A concise prompt packet example for drafting a launch email. It specifies the goal, context, source of truth, deliverable format, and constraints for the output.

```text
Goal: Draft a launch email.
Context: SaaS product for accountants. Audience is current trial users.
Source of truth: product notes below.
Deliverable: Subject line options plus one email under 180 words.
Constraints: Plain English, no hype, no exclamation marks.
Review standard: Check for clarity, specific value, and one CTA.
```

--------------------------------

### Install Arrow Headers

Source: https://github.com/srandres629/dummie-engine/blob/main/scratch/venv/lib/python3.12/site-packages/pyarrow/src/arrow/python/vendored/CMakeLists.txt

Installs all headers for the Arrow Python vendored directory. This is typically used during the build process.

```cmake
arrow_install_all_headers("arrow/python/vendored")
```

--------------------------------

### Start gRPC Server Supervisor

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/grpc/README.md

Add `GRPC.Server.Supervisor` to your application's supervision tree in the `start/2` function. Specify the endpoint and port for the server.

```elixir
# In the start function of your Application
defmodule HelloworldApp do
  use Application
  def start(_type, _args) do
    children = [
      # ...
      {GRPC.Server.Supervisor, endpoint: Helloworld.Endpoint, port: 50051}
    ]

    opts = [strategy: :one_for_one, name: YourApp]
    Supervisor.start_link(children, opts)
  end
end
```

--------------------------------

### YAML Source-Read Evidence Example

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/agentic/VALIDATION_EVIDENCE.md

Record claims supported by reading a source file, specifying the file path and the observed fact. Limitations can be noted.

```yaml
- claim: "DUMMIE already defines a five-step execution protocol."
  category: VERIFIED_BY_SOURCE_READ
  source: "doc/agentic/EXECUTION_PROTOCOL.md"
  result: "The protocol lists Understand, Plan, Implement, Verify, and Close."
  limitations: "The file defines process, not enforcement automation."
```

--------------------------------

### Install Latest Stable TypeScript

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/typescript/README.md

Use this command to install the latest stable version of TypeScript as a development dependency.

```bash
npm install -D typescript
```

--------------------------------

### Create and Get Shape of a Tensor in Elixir

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/nx/README.md

Demonstrates how to create a tensor and retrieve its shape using Nx.tensor and Nx.shape.

```elixir
iex> t = Nx.tensor([[1, 2], [3, 4]])
iex> Nx.shape(t)
{2, 2}
```

--------------------------------

### Example Validation Commands

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/agentic/AGENT_TASK_CONTRACT.md

Include specific commands to validate the task's success. These should be executable by another agent to ensure reproducibility and objective verification.

```bash
git status --short
```

```bash
python3 scripts/validate_specs_docs.py
```

```bash
rg -n "kuzu_data|MemoryState|m\.\*|rm -f.*kuzu|os\.remove\(" layers scripts doc -S
```

--------------------------------

### Install Arrow Python Headers

Source: https://github.com/srandres629/dummie-engine/blob/main/scratch/venv/lib/python3.12/site-packages/pyarrow/src/arrow/python/CMakeLists.txt

Installs all necessary headers for the Arrow Python package. This is a CMake function call.

```cmake
arrow_install_all_headers("arrow/python")
```

--------------------------------

### Regenerate v2 Memory Proto

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l1_nervous/proto/PROTO_REGEN.md

Use this command to regenerate the Go files for the v2 memory proto. Ensure protoc and protoc-gen-go are installed.

```bash
protoc \
  --proto_path=proto/ \
  --go_out=layers/l1_nervous/proto/ \
  --go_opt=paths=source_relative \
  proto/dummie/v2/memory.proto
```

--------------------------------

### Install Source Map JS with npm

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/source-map-js/README.md

Use npm to install the source-map-js library for use in your Node.js project. This command adds the library as a dependency.

```bash
$ npm install source-map-js
```

--------------------------------

### Module Access

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/source-map-js/README.md

How to get a reference to the source-map module in different environments.

```APIDOC
## Module Access

Get a reference to the module:

```js
// Node.js
var sourceMap = require('source-map');

// Browser builds
var sourceMap = window.sourceMap;

// Inside Firefox
const sourceMap = require("devtools/toolkit/sourcemap/source-map.js");
```
```

--------------------------------

### Regenerate Root-Level Protobufs

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l1_nervous/proto/PROTO_REGEN.md

Use this command to regenerate Go and gRPC Go files for root-level protos. Ensure protoc, protoc-gen-go, and protoc-gen-go-grpc are installed.

```bash
protoc \
  --proto_path=proto/ \
  --go_out=layers/l1_nervous/proto/ \
  --go_opt=paths=source_relative \
  --go-grpc_out=layers/l1_nervous/proto/ \
  --go-grpc_opt=paths=source_relative \
  proto/memory.proto proto/orchestration.proto proto/core.proto
```

--------------------------------

### Run All Tests Including Proxy

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/mint/README.md

Run all available tests, including proxy tests. This requires starting a local proxy instance using Docker Compose or Podman Compose before running the tests.

```sh
DOCKER_USER="$UID:$GID" docker compose up --detach # or podman-compose up --detach
mix test --include proxy
```

--------------------------------

### Run Runtime Closure Planner Tests

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/181_runtime_closure_planner.md

Execute the test suite for the runtime closure planner using pytest. Ensure you have pytest installed.

```bash
python3 -m pytest layers/l2_brain/tests/test_runtime_closure_planner.py
```

--------------------------------

### YAML Assumption Evidence Example

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/agentic/VALIDATION_EVIDENCE.md

Record assumptions made by the agent, including the reason for the assumption, the associated risk, and how it can be verified later.

```yaml
- claim: "The first loop should not implement checker scripts."
  category: ASSUMPTION
  source: "Phase 1 task constraints"
  result: "User prompt says scripts are optional and should not be forced without a green baseline."
  limitations: "A human may still request scripts immediately."
```

--------------------------------

### Gnat Publish and Subscribe with Telemetry

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/gnat/README.md

Demonstrates starting Gnat and performing publish and subscribe operations, showing the telemetry events generated. Latency is reported for pub, sub, and request events.

```elixir
{:ok, gnat} = Gnat.start_link()
Gnat.sub(gnat, self(), "topic")
Gnat.pub(gnat, "topic", "ohai")
```

--------------------------------

### Attach to Span Events in Erlang

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/telemetry/README.md

Example of attaching handlers to span events (`start`, `stop`, `exception`) in Erlang using `telemetry:attach_many/4`.

```erlang
ok = telemetry:attach_many(
  <<"log-response-handler">>,
  [
    [worker, processing, start],
    [worker, processing, stop],
    [worker, processing, exception]
  ],
  fun log_response_handler:handle_event/4,
  []
)
```

--------------------------------

### Attach to Span Events in Elixir

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/telemetry/README.md

Example of attaching handlers to span events (`:start`, `:stop`, `:exception`) in Elixir using `telemetry:attach_many/4`.

```elixir
:ok =
  :telemetry.attach_many(
    "log-response-handler",
    [
      [:worker, :processing, :start],
      [:worker, :processing, :stop],
      [:worker, :processing, :exception]
    ],
    &LogResponseHandler.handle_event/4,
    nil
  )
```

--------------------------------

### Create Span Events in Erlang

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/telemetry/README.md

Example of creating span events using `telemetry:span/3` in Erlang. This function generates start and stop/exception events.

```erlang
process_message(Message) ->
  StartMetadata =  #{message => Message},
  Result = telemetry:span(
    [worker, processing],
    StartMetadata,
    fun() ->
      Result = % Process the message
      {Result, #{metadata => "Information related to the processing of the message"}}
    end
  ).
```

--------------------------------

### SpecGraph Deterministic Path Rules

Source: https://github.com/srandres629/dummie-engine/blob/main/docs/superpowers/specs/2026-04-25-multi-repo-provider-agent-office-design.md

Example of deterministic path rules for the initial version of SpecGraph, mapping file paths to graph elements.

```text
layers/l2_brain/** -> layer L2 -> L2 specs
layers/l1_nervous/** -> layer L1 -> L1 specs
layers/l5_muscle/** -> layer L5 -> L5 specs
doc/specs/NN_name.md -> spec node
doc/specs/NN_name.rules.json -> rules node
doc/specs/NN_name.feature -> feature node
```

--------------------------------

### Create Span Events in Elixir

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/telemetry/README.md

Example of creating span events using `telemetry:span/3` in Elixir. This function generates start and stop/exception events.

```elixir
def process_message(message) do
  start_metadata = %{message: message}

  result =
    :telemetry.span(
      [:worker, :processing],
      start_metadata,
      fn ->
        result = ... # Process the message
        {result, %{metadata: "Information related to the processing of the message"}}
      end
    )
end
```

--------------------------------

### JIT Compile and Execute a Numerical Definition with EXLA

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/nx/README.md

Demonstrates how to use EXLA to just-in-time compile a numerical definition for optimized execution on CPU or GPU.

```elixir
will_jit = EXLA.jit(&MyModule.softmax/1)
will_jit.(some_tensor)
```

--------------------------------

### Example Allowed and Forbidden Files

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/agentic/AGENT_TASK_CONTRACT.md

Specify exact files or globs that an agent may read or edit, and those that must be avoided. This ensures agents operate within defined boundaries.

```yaml
allowed_files:
  - doc/agentic/AGENT_TASK_CONTRACT.md
  - .aiwg/templates/agent_task_contract.yaml
forbidden_files:
  - layers/**
  - .env
  - .git/**
```

--------------------------------

### Configure OpenCode MCP Server and Provider

Source: https://github.com/srandres629/dummie-engine/blob/main/memory/2026-05-19.md

Add the Dummie MCP server and OpenRouter provider configuration to opencode.jsonc. Ensure OpenCode is restarted for changes to take effect.

```json
{
  "mcp": {
    "dummie-brain": {
      "path": "layers/l1_nervous/mcp_server.py"
    }
  },
  "provider": {
    "openrouter": {
      "apiKey": "env:OPENROUTER_API_KEY"
    }
  },
  "instructions": [
    "AGENTS.md",
    "MEMORY.md"
  ],
  "skills": {
    "paths": [
      ".agents/skills"
    ]
  },
  "mcp": {
    "dummie-brain": {
      "timeout": "120s"
    }
  }
}
```

--------------------------------

### Connect to an HTTP Server

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/mint/README.md

Initiate a connection to an HTTP server using `Mint.HTTP.connect/3`. This function transparently handles HTTP/1 or HTTP/2 based on the server's capabilities.

```elixir
iex> {:ok, conn} = Mint.HTTP.connect(:http, "httpbin.org", 80)
```

--------------------------------

### Quick Packet for Planning Tasks

Source: https://github.com/srandres629/dummie-engine/blob/main/skills/chatgpt/prompt-packets.md

This prompt packet demonstrates how to structure a request for creating a 2-week plan from an idea dump. It includes details on context, source material, deliverable format, and specific constraints.

```text
Goal: Turn this messy idea dump into a 2-week plan.
Context: Solo founder with 10 hours per week.
Source of truth: the notes below.
Deliverable: Week-by-week plan with dependencies and risks.
Constraints: No generic advice, no tasks without an owner or deadline.
Review standard: Remove anything that cannot fit the time budget.
```

--------------------------------

### Verify Spec Documentation and Tests

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/115_restart_context_efficiency_gate.md

Run this command to check for documentation inconsistencies and execute relevant unit tests for restart integration and context efficiency.

```bash
git diff --check
python3 scripts/validate_specs_docs.py || true
pytest -q \
  layers/l2_brain/tests/test_restart_integration_gate.py \
  layers/l2_brain/tests/test_context_efficiency_benchmark.py
```

--------------------------------

### Basic fdir Usage: Synchronous and Asynchronous Crawling

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/fdir/README.md

Demonstrates how to create a crawler instance, configure it to include full paths, and then crawl a directory synchronously or asynchronously. Requires 'fdir' to be imported.

```typescript
import { fdir } from "fdir";

// create the builder
const api = new fdir().withFullPaths().crawl("path/to/dir");

// get all files in a directory synchronously
const files = api.sync();

// or asynchronously
api.withPromise().then((files) => {
  // do something with the result here.
});
```

--------------------------------

### Basic Usage of Picomatch

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/picomatch/README.md

Demonstrates how to create a matcher function for JavaScript files and use it to test strings.

```javascript
const pm = require('picomatch');
const isMatch = pm('*.js');

console.log(isMatch('abcd')); //=> false
console.log(isMatch('a.js')); //=> true
console.log(isMatch('a.md')); //=> false
console.log(isMatch('a/b.js')); //=> false
```

--------------------------------

### Generate Local Documentation

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/complex/README.md

Generate HTML documentation for the complex package locally by running the `mix docs` task in your shell.

```elixir
mix docs
```

--------------------------------

### Flow At-Rule Type Example

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/csstype/README.md

In Flow, at-rule types are accessed using the `AtRule$` namespace.

```flow
AtRule$FontFace
```

--------------------------------

### Create a new Elixir project

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/nx/README.md

Use the `mix new` command to create a new Elixir project. This sets up the basic project structure.

```bash
mix new my_app
```

--------------------------------

### TypeScript At-Rule Type Example

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/csstype/README.md

Access at-rule types in TypeScript via the `AtRule` namespace, such as `AtRule.FontFace`.

```typescript
AtRule.FontFace
```

--------------------------------

### Run Verification Commands

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/113_prompt_frame_builder.md

Execute these commands to verify the implementation against the specifications. Includes code diff checks, spec validation, and unit tests.

```bash
git diff --check
python3 scripts/validate_specs_docs.py || true
pytest -q layers/l2_brain/tests/test_prompt_frame_builder.py
```

--------------------------------

### Component Scoring for Ledger Entries

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/agentic/AGENT_RELIABILITY_LEDGER.md

Example of how individual component scores are recorded within a ledger entry.

```yaml
scope_adherence_score: 1
evidence_score: 2
validation_score: 2
risk_detection_score: 1

```

--------------------------------

### Hybrid Tutor Flow Steps

Source: https://github.com/srandres629/dummie-engine/blob/main/docs/superpowers/specs/2026-04-25-multi-repo-provider-agent-office-design.md

Outlines the sequence of operations in the hybrid tutor flow, from WorkRoom opening to memory crystallization.

```text
1. WorkRoom opens.
2. SpecGraph maps affected files to specs, rules, features, decisions, and memory.
3. 4D memory retrieves only relevant prior context.
4. Orchestrator creates ContextPacket.
5. Provider adapter opens AgentSession.
6. Agent returns output.
7. Output becomes EvidencePacket, not truth.
8. Contradictor or verifier reviews it.
9. Orchestrator approves, rejects, or assigns implementation.
10. Implementation produces diff and verification output.
11. Orchestrator closes WorkRoom.
12. 4D memory crystallizes decisions and lessons.
13. Provider sessions are closed.
```

--------------------------------

### Add Nkeys Dependency to Mix Project

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/nkeys/README.md

Add the nkeys package to your project's dependencies in mix.exs to install it.

```elixir
def deps do
  [
    {:nkeys, "~> 0.3.0"}
  ]
end
```

--------------------------------

### Update .opencode/agent/dummie-engine.md

Source: https://github.com/srandres629/dummie-engine/blob/main/memory/2026-05-19.md

This markdown file describes the Dummie Engine agent for OpenCode, outlining its architecture, meta-gateway protocol, and quick-start patterns for memory, embeddings, and routing.

```markdown
# Dummie Engine Agent

This agent provides access to the full Dummie Engine protocol within OpenCode.

## Architecture Overview

- **Subagent Mode**: Operates as a subagent, discoverable via `@dummie-engine`.
- **Meta-Gateway Protocol**: Facilitates discovery, analysis, and execution of Dummie's tools.
  - `discover`: Find available capabilities.
  - `analyze`: Get JSON schema for a tool.
  - `execute`: Run a tool.

## Quick-start Patterns

- **Memory**: Persist and recall data using 4D-TES memory.
- **Embeddings**: Utilize semantic recall for information retrieval.
- **Routing**: Optimize context with context shapers.

## Tool Inventory

| Domain          | Tool Name             | Description                                    |
|-----------------|-----------------------|------------------------------------------------|
| Memory          | `local.crystallize`   | 4D-TES memory persistence                      |
| Memory          | `local.semantic_recall`| Semantic memory recall                         |
| Reasoning       | `local.reasoned_rerank`| Local reasoning and reranking                  |
| Context         | `local.context_shaper`| Context optimization                           |
| ... (38 more)   | ...                   | ...                                            |

## Discovery Flow

Handles unknown tool scenarios through the meta-gateway protocol.
```

--------------------------------

### Benchmark Results Comparison

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/lightningcss/README.md

Compares the performance and output size of Lightning CSS, cssnano, and esbuild for different CSS files. Note that Lightning CSS performs safe optimizations, ensuring identical behavior to the input CSS.

```bash
$ node bench.js bootstrap-4.css
cssnano: 544.809ms
159636 bytes

esbuild: 17.199ms
160332 bytes

lightningcss: 4.16ms
143091 bytes


$ node bench.js animate.css
cssnano: 283.105ms
71723 bytes

esbuild: 11.858ms
72183 bytes

lightningcss: 1.973ms
23666 bytes


$ node bench.js tailwind.css
cssnano: 2.198s
1925626 bytes

esbuild: 107.668ms
1961642 bytes

lightningcss: 43.368ms
1824130 bytes
```

--------------------------------

### Flow Property Type Example

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/csstype/README.md

In Flow, property types are accessed using the `Property$` namespace. This differs from the TypeScript approach.

```flow
Property$AlignContent
```

--------------------------------

### Customizing Length Type in TypeScript

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/csstype/README.md

Example of customizing the generic type for length units in CSS properties to accept numbers.

```tsx
const style: CSS.Properties<string | number> = {
  width: 100,
};
```

--------------------------------

### Run Verification Commands

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/116_evolution_flywheel_runtime.md

Execute these commands to verify the implementation against specifications and tests. Ensure Git diff checks are performed before committing.

```bash
git diff --check
python3 scripts/validate_specs_docs.py || true
pytest -q layers/l2_brain/tests/test_evolution_flywheel_runtime.py
```

--------------------------------

### Run Polyglot Probe Orchestrator Tests

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/177_polyglot_probe_orchestrator.md

Execute the test suite for the polyglot probe orchestrator using pytest. Ensure you have pytest installed.

```bash
python3 -m pytest layers/l2_brain/tests/test_polyglot_probe_orchestrator.py
```

--------------------------------

### Consuming a Source Map

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/source-map-js/README.md

Demonstrates how to instantiate a SourceMapConsumer with raw source map data and use its methods to retrieve information about the original source code.

```APIDOC
## Consuming a Source Map

### Description
This example shows how to create a `SourceMapConsumer` instance from raw source map data and then query it to find original source positions and generated positions.

### Usage

```javascript
var rawSourceMap = {
  version: 3,
  file: 'min.js',
  names: ['bar', 'baz', 'n'],
  sources: ['one.js', 'two.js'],
  sourceRoot: 'http://example.com/www/js/',
  mappings: 'CAAC,IAAI,IAAM,SAAUA,GAClB,OAAOC,IAAID;CCDb,IAAI,IAAM,SAAUE,GAClB,OAAOA'
};

var smc = new SourceMapConsumer(rawSourceMap);

console.log(smc.sources);
// Expected output: [
//   'http://example.com/www/js/one.js',
//   'http://example.com/www/js/two.js'
// ]

console.log(smc.originalPositionFor({
  line: 2,
  column: 28
}));
// Expected output: {
//   source: 'http://example.com/www/js/two.js',
//   line: 2,
//   column: 10,
//   name: 'n'
// }

console.log(smc.generatedPositionFor({
  source: 'http://example.com/www/js/two.js',
  line: 2,
  column: 10
}));
// Expected output: { line: 2, column: 28 }

smc.eachMapping(function (m) {
  // Process each mapping
});
```

### API Methods Used
- `new SourceMapConsumer(rawSourceMap)`: Constructor to create a new SourceMapConsumer.
- `SourceMapConsumer.prototype.sources`: An array of source file names.
- `SourceMapConsumer.prototype.originalPositionFor(generatedPosition)`: Returns the original source position for a given generated position.
- `SourceMapConsumer.prototype.generatedPositionFor(originalPosition)`: Returns the generated source position for a given original position.
- `SourceMapConsumer.prototype.eachMapping(callback, context, order)`: Iterates over all mappings in the source map.
```

--------------------------------

### Run Shadow Runtime Classifier Tests

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/171_shadow_runtime_classifier.md

Execute the test suite for the shadow runtime classifier to verify its functionality. Ensure you have pytest installed.

```bash
python3 -m pytest layers/l2_brain/tests/test_shadow_runtime_classifier.py
```

--------------------------------

### Watch Build Command

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/csstype/README.md

Runs the build process automatically on each file save. Useful for continuous development and testing.

```bash
npm run watch
```

--------------------------------

### Connect to gRPC Server and Call RPC

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/grpc/README.md

Connect to the gRPC server using `GRPC.Stub.connect` and then call the desired RPC method on the stub.

```elixir
iex> {:ok, channel} = GRPC.Stub.connect("localhost:50051")
iex> request = Helloworld.HelloRequest.new(name: "grpc-elixir")
iex> {:ok, reply} = channel |> Helloworld.Greeter.Stub.say_hello(request)
```

--------------------------------

### TypeScript Property Type Example

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/csstype/README.md

In TypeScript, access property types using the `Property` namespace. This is a change from previous versions where `AlignContentProperty` was used.

```typescript
Property.AlignContent
```

--------------------------------

### Basic CSS Properties in Flow

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/csstype/README.md

Illustrates the usage of CSSType for CSS properties within a Flow-typed JavaScript environment, similar to TypeScript examples.

```javascript
// @flow strict
import * as CSS from 'csstype';

const style: CSS.Properties<> = {
  colour: 'white', // Type error on property
  textAlign: 'middle', // Type error on value
};
```

--------------------------------

### Initialize SourceMapGenerator

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/source-map-js/README.md

Instantiate a new SourceMapGenerator with optional configuration for file name, source root, and validation behavior.

```javascript
var generator = new sourceMap.SourceMapGenerator({
  file: "my-generated-javascript-file.js",
  sourceRoot: "http://example.com/app/js/"
});
```

--------------------------------

### Run Token Economy Benchmark

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/148_token_economy_benchmark.md

Execute the token economy benchmark script. This is a report-only operation that does not mutate the workspace.

```bash
python3 layers/l2_brain/flat_brain/token_economy_benchmark.py
```

--------------------------------

### Add Mint to Mix Dependencies

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/mint/README.md

Add Mint to your project's `mix.exs` file to include it as a dependency. Run `mix deps.get` to fetch it.

```elixir
defp deps do
  [
    {:mint, "~> 1.0"}
  ]
end
```

--------------------------------

### Register Knowledge Tools

Source: https://github.com/srandres629/dummie-engine/blob/main/docs/superpowers/plans/2026-04-26-universal-knowledge-bus.md

Register provider-agnostic knowledge tools. Internally routes to the configured provider adapter. Use when exposing knowledge management functionalities.

```bash
PYTHONPATH="layers/l2_brain:layers/l1_nervous" pytest -q layers/l1_nervous/tests/test_knowledge_tools.py
```

```bash
git add layers/l1_nervous/tools.py layers/l1_nervous/tools_impl/knowledge.py layers/l1_nervous/tests/test_knowledge_tools.py
git commit -m "feat: expose provider-agnostic knowledge tools"
```

--------------------------------

### SourceMapGenerator.prototype.applySourceMap

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/source-map-js/README.md

Applies mappings from another source map to the current one. This is useful for composing source maps, for example, when processing files that have already been processed.

```APIDOC
## SourceMapGenerator.prototype.applySourceMap(sourceMapConsumer[, sourceFile[, sourceMapPath]])

Applies a SourceMap for a source file to the SourceMap. Each mapping to the supplied source file is rewritten using the supplied SourceMap. Note: The resolution for the resulting mappings is the minimum of this map and the supplied map.

* `sourceMapConsumer`: The SourceMap to be applied.

* `sourceFile`: Optional. The filename of the source file.
  If omitted, sourceMapConsumer.file will be used, if it exists.
  Otherwise an error will be thrown.

* `sourceMapPath`: Optional. The dirname of the path to the SourceMap
  to be applied. If relative, it is relative to the SourceMap.

  This parameter is needed when the two SourceMaps aren't in the same
  directory, and the SourceMap to be applied contains relative source
  paths. If so, those relative source paths need to be rewritten
  relative to the SourceMap.

  If omitted, it is assumed that both SourceMaps are in the same directory,
  thus not needing any rewriting. (Supplying `'.'` has the same effect.)
```

--------------------------------

### Custom format Function for String Normalization

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/picomatch/README.md

Use a custom `format` function with picomatch to preprocess strings before matching, for example, to strip leading './'.

```javascript
// strip leading './' from strings
const format = str => str.replace(/^\.\//, '');
const isMatch = picomatch('foo/*.js', { format });
console.log(isMatch('./foo/bar.js')); //=> true
```

--------------------------------

### YAML Contradiction Evidence Example

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/agentic/VALIDATION_EVIDENCE.md

Record conflicting evidence, detailing the claim, the sources of conflict, and the unresolved question. Limitations highlight confidence factors.

```yaml
- claim: "Docs validation failed after a docs-only change."
  category: CONTRADICTION
  source: "python3 scripts/validate_specs_docs.py and pre-task validation evidence"
  result: "The same validation failure was present before the task or is isolated to files outside the task scope."
  limitations: "Requires a clean pre-task command, prior report, or commit-isolation evidence to classify with confidence."
```

--------------------------------

### Run Entrypoint Enforcement Auditor

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/149_entrypoint_enforcement_auditor.md

Execute the auditor script to perform static analysis on entrypoints. This command initiates the audit process.

```bash
python3 layers/l2_brain/flat_brain/entrypoint_enforcement_auditor.py
```

--------------------------------

### Get Source Map Module Reference

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/source-map-js/README.md

Import or access the source-map module. Usage varies between Node.js, browser builds, and specific Firefox internal modules.

```javascript
// Node.js
var sourceMap = require('source-map');

// Browser builds
var sourceMap = window.sourceMap;

// Inside Firefox
const sourceMap = require("devtools/toolkit/sourcemap/source-map.js");
```

--------------------------------

### Define Custom Module Prefix Option

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/protobuf/README.md

Use custom options like `module_prefix` by importing `elixirpb.proto` and setting the option in your .proto file.

```proto
syntax = "proto2";

package your.pkg;

import "elixirpb.proto";

option (elixirpb.file).module_prefix = "Foo.Bar";

```

--------------------------------

### Run Environment Toolchain Probe Tests

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/180_environment_toolchain_probe.md

Execute the test suite for the environment toolchain probe using pytest. Ensure pytest is installed and accessible in your Python environment.

```bash
python3 -m pytest layers/l2_brain/tests/test_environment_toolchain_probe.py
```

--------------------------------

### Run Daemon/Gateway Heartbeat Bridge Tests

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/176_daemon_gateway_heartbeat_bridge.md

Execute the test suite for the daemon/gateway heartbeat bridge using pytest. Ensure you have pytest installed and are in the correct project directory.

```bash
python3 -m pytest layers/l2_brain/tests/test_daemon_gateway_heartbeat_bridge.py
```

--------------------------------

### Picomatch POSIX Usage

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/picomatch/README.md

Illustrates using picomatch/posix for environments without Node.js, defaulting to POSIX path separators. It also shows how to configure it for Windows paths.

```javascript
const picomatch = require('picomatch/posix');
// the same API, defaulting to posix paths
const isMatch = picomatch('a/*');
console.log(isMatch('a\b')); //=> false
console.log(isMatch('a/b')); //=> true

// you can still configure the matcher function to accept windows paths
const isMatch = picomatch('a/*', { options: windows });
console.log(isMatch('a\b')); //=> true
console.log(isMatch('a/b')); //=> true
```

--------------------------------

### Generated Elixir Protobuf Message Structure

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/protobuf/README.md

Example of Elixir modules generated by protoc for Protobuf messages. These modules define message fields and use the Protobuf macro.

```elixir
defmodule Helloworld.HelloRequest do
  @moduledoc false
  use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3

  field :name, 1, type: :string
end

defmodule Helloworld.HelloReply do
  @moduledoc false
  use Protobuf, protoc_gen_elixir_version: "0.10.0", syntax: :proto3

  field :message, 1, type: :string
end
```

--------------------------------

### Picomatch Scan with Tokens Option

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/picomatch/README.md

Use the `tokens: true` option with `picomatch.scan` to get a detailed breakdown of the glob pattern, including tokens representing each path segment.

```javascript
const picomatch = require('picomatch');
const result = picomatch.scan('!./foo/*.js', { tokens: true });
console.log(result);
// {
//   prefix: '!./',
//   input: '!./foo/*.js',
//   start: 3,
//   base: 'foo',
//   glob: '*.js',
//   isBrace: false,
//   isBracket: false,
//   isGlob: true,
//   isExtglob: false,
//   isGlobstar: false,
//   negated: true,
//   maxDepth: 2,
//   tokens: [
//     { value: '!./', depth: 0, isGlob: false, negated: true, isPrefix: true },
//     { value: 'foo', depth: 1, isGlob: false },
//     { value: '*.js', depth: 1, isGlob: true }
//   ],
//   slashes: [ 2, 6 ],
//   parts: [ 'foo', '*.js' ]
// }
```

--------------------------------

### Enable gRPC Support

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/protobuf/README.md

Generate gRPC code by including `plugins=grpc` in the `--elixir_out` argument when defining services in your protobuf files.

```bash
$ protoc --elixir_out=plugins=grpc:./lib/ *.proto
```

--------------------------------

### Verify Spec Documentation

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/104_plan_v1_cognitive_evolution_operating_layer.md

Runs a script to validate the documentation specifications for the current file.

```bash
python3 scripts/validate_specs_docs.py --check doc/specs/104_plan_v1_cognitive_evolution_operating_layer.md
```

--------------------------------

### Run Readiness Score Calibrator Tests

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/146_readiness_score_calibrator.md

Execute the pytest suite for the readiness score calibrator. Use the -q flag for a quieter output.

```bash
python3 -m pytest layers/l2_brain/tests/test_readiness_score_calibrator.py -q
```

--------------------------------

### Run Kuzu Graph Sync Adapter Tests

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/L2_Brain/91_kuzu_4dtes_sync_adapter.md

Execute the pytest suite for the Kuzu Graph Sync Adapter. Ensure the virtual environment is activated before running.

```bash
layers/l2_brain/.venv/bin/python -m pytest -q layers/l2_brain/tests/test_kuzu_graph_sync_adapter.py
```

--------------------------------

### Run Runtime Dependency Auditor Tests with Pytest

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/178_runtime_dependency_auditor.md

Execute the test suite for the runtime dependency auditor using pytest. Ensure pytest is installed and the test file path is correct.

```bash
python3 -m pytest layers/l2_brain/tests/test_runtime_dependency_auditor.py
```

--------------------------------

### Implement gRPC Server Logic

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/grpc/README.md

Define your server module using `GRPC.Server` and implement the RPC functions. Ensure the function signatures match the service definition and return the expected message types.

```elixir
defmodule Helloworld.Greeter.Server do
  use GRPC.Server, service: Helloworld.Greeter.Service

  @spec say_hello(Helloworld.HelloRequest.t, GRPC.Server.Stream.t) :: Helloworld.HelloReply.t
  def say_hello(request, _stream) do
    Helloworld.HelloReply.new(message: "Hello #{request.name}")
  end
end
```

--------------------------------

### Get Original Position from Generated Position

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/source-map-js/README.md

Use `originalPositionFor` on a SourceMapConsumer to find the original source file, line, and column for a given generated position. Supports bias for inexact matches.

```javascript
consumer.originalPositionFor({ line: 2, column: 10 })
// { source: 'foo.coffee',
//   line: 2,
//   column: 2,
//   name: null }

consumer.originalPositionFor({ line: 99999999999999999, column: 999999999999999 })
// { source: null,
//   line: null,
//   column: null,
//   name: null }
```

--------------------------------

### Implement KnowledgeProvider and WisdomPublisher Protocols

Source: https://github.com/srandres629/dummie-engine/blob/main/docs/superpowers/plans/2026-04-26-universal-knowledge-bus.md

Define the KnowledgeProvider and WisdomPublisher protocols using typing.Protocol in Python. These abstract the core functionalities for interacting with knowledge sources and publishing wisdom.

```python
class KnowledgeProvider(Protocol):
    async def search_context(self, query: str, limit: int = 10) -> list[SourceArtifact]: ...
    async def get_artifact(self, source_uri: str) -> SourceArtifact: ...

class WisdomPublisher(Protocol):
    async def publish_decision(self, decision: ConsensusDecision) -> str: ...
    async def publish_lesson(self, issue: str, correction: str) -> str: ...

```

--------------------------------

### Implement Softmax Function with Nx in Elixir

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l0_overseer/deps/nx/README.md

Shows how to implement the Softmax function using Nx operations for exponentiation, division, and summation.

```elixir
iex> t = Nx.tensor([[1, 2], [3, 4]])
iex> Nx.divide(Nx.exp(t), Nx.sum(Nx.exp(t)))
#Nx.Tensor<
  f32[2][2]
  [
    [0.032058604061603546, 0.08714432269334793],
    [0.23688282072544098, 0.6439142227172852]
  ]
>
```

--------------------------------

### Build Semantic Hardening Index with CLI

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/192_embedding_mesh_foundation.md

Generate the semantic hardening index and reports using the provided Python script. This command requires the repository root and an option to write reports.

```bash
layers/l2_brain/.venv/bin/python scripts/build_semantic_hardening_index.py --repo-root . --write-reports
```

--------------------------------

### Retrieve Original Source Content

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/source-map-js/README.md

Use `sourceContentFor` to get the original source code content for a given source URL. If the content is not found, an error is thrown by default, but passing `true` as the second argument will return `null` instead.

```javascript
consumer.sources
// [ "my-cool-lib.clj" ]

consumer.sourceContentFor("my-cool-lib.clj")
// "..."

consumer.sourceContentFor("this is not in the source map");
// Error: "this is not in the source map" is not in the source map

consumer.sourceContentFor("this is not in the source map", true);
// null
```

--------------------------------

### Verify Agent Session Contract Documentation

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/106_agent_session_operating_contracts.md

Runs a script to validate the documentation for agent session contracts. Ensure all specified contract files exist and are correctly referenced.

```bash
python3 scripts/validate_specs_docs.py --check doc/specs/106_agent_session_operating_contracts.md
```

```python
from pathlib import Path
contracts = [
    '.aiwg/session_contracts/UNIVERSAL_AGENT_SESSION_CONTRACT.md',
    '.aiwg/session_contracts/ANTIGRAVITY_SESSION_CONTRACT.md',
    '.aiwg/session_contracts/CODEX_CLI_SESSION_CONTRACT.md',
    '.aiwg/session_contracts/ANTIGRAVITY_IDE_SESSION_CONTRACT.md',
]
for contract in contracts:
    assert Path(contract).exists(), contract
```

--------------------------------

### Render React App in Browser

Source: https://github.com/srandres629/dummie-engine/blob/main/layers/l6_skin/node_modules/react-dom/README.md

Use `createRoot` from `react-dom/client` to render your React application into the DOM.

```js
import { createRoot } from 'react-dom/client';

function App() {
  return <div>Hello World</div>;
}

const root = createRoot(document.getElementById('root'));
root.render(<App />);
```

--------------------------------

### Run Capability Promotion Governor Tests

Source: https://github.com/srandres629/dummie-engine/blob/main/doc/specs/189_capability_promotion_governor.md

Execute the test suite for the capability promotion governor using pytest. Ensure the virtual environment is activated before running.

```bash
layers/l2_brain/.venv/bin/python -m pytest layers/l2_brain/tests/test_capability_promotion_governor.py
```
Tokens:
Raw