@oneie/claude 0.3.2 → 0.5.0

package/rules/engine.md

@@ -1,11 +1,14 @@
 ---
 paths:
-  - "agents/src/**/*.ts"
+  - "packages/sdk/src/**/*.ts"
+  - "channels/src/**/*.ts"
+  - "one.ie/web/src/lib/pheromone.ts"
+  - "one.ie/web/src/workers/**/*.ts"
 ---
 
 # Engine Rules
 
-Apply to `src/engine/*.ts`
+Apply to substrate code — the SDK verbs, the pheromone world, and every worker that consumes them.
 
 ---
 
@@ -16,17 +19,20 @@ These three rules compound. Breaking any one breaks the flywheel.
 ### Rule 1 — Closed Loop
 
 **Every signal closes its loop.** `mark()` on result, `warn()` on failure,
-`dissolve` on missing unit/capability. No silent returns. No orphan signals.
+`dissolve` on missing receiver. No silent returns. No orphan signals.
 
 ```typescript
-const { result, timeout, dissolved } = await net.ask({ receiver: next })
-if (result)        net.mark(edge, chainDepth)  // success → path strengthens
-else if (timeout)  /* neutral — not the agent's fault */
-else if (dissolved) net.warn(edge, 0.5)         // mild — path doesn't exist
-else               net.warn(edge, 1)            // failure — agent produced nothing
+// ask() resolves to one of 4 outcomes (packages/sdk/src/types.ts — Outcome<T>)
+const outcome = await one.ask(receiver, data)
+switch (outcome.kind) {
+  case "result":    await one.mark(edge); break        // success → path strengthens
+  case "timeout":   /* neutral — not the agent's fault */ break
+  case "dissolved": await one.warn(edge, 0.5); break   // mild — receiver doesn't exist
+  case "failure":   await one.warn(edge, 1); break     // failure — produced nothing
+}
 ```
 
-Why: pheromone is the only thing that compounds. A handler that returns
+Why: path strength is the only thing that compounds. A handler that returns
 silently leaks learning. Width (parallelism) only compounds if every
 parallel branch deposits a mark or warn on the path it used.
 
@@ -36,10 +42,10 @@ parallel branch deposits a mark or warn on the path it used.
 or any wall-clock unit.
 
 ```
-task    = atomic unit of work (one .on() handler, one file edit)
+task    = atomic unit of work (one receiver handler, one file edit)
 wave    = phase within a cycle (W1 recon → W2 decide → W3 edit → W4 verify)
 cycle   = full W0-W4 sandwich, exits at rubric >= 0.65
-path    = what remembers across cycles (pheromone strength / resistance)
+path    = what remembers across cycles (strength / resistance)
 ```
 
 Why: the substrate measures **width** by tasks-per-wave, **depth** by
@@ -52,7 +58,7 @@ from outside the substrate.
 
 **Every loop reports verified numbers, not vibes.** Tests passed/total.
 Build time in ms. Deploy time per service. Health check latency. Rubric
-dimension scores. These are the deterministic signals that calibrate pheromone.
+dimension scores. These are the deterministic signals that calibrate path strength.
 
 ```typescript
 // Every loop ends like this — not "done", but "done with receipts"
@@ -60,8 +66,8 @@ dimension scores. These are the deterministic signals that calibrate pheromone.
   passed: 320,
   failed: 0,
   buildMs: 22995,
-  deployMs: { gateway: 13705, sync: 8249, nanoclaw: 9163, pages: 17391 },
-  health: { gateway: 292, sync: 270, nanoclaw: 270 },
+  deployMs: { web: 13705, sync: 8249, channels: 9163, api: 17391 },
+  health: { web: 292, sync: 270, channels: 270 },
   // /do code rubric — security/stability/simplicity/speed, gate ≥ 0.65
   rubric: { security: 0.92, stability: 0.85, simplicity: 0.90, speed: 0.80 }
 }
@@ -73,153 +79,48 @@ it's learning. A loop that can't report deterministic results can't
 sandwich applied to every automation skill.
 
 **Where it shows up:**
-- `/work` — reports task count, tests passed, time spent
-- `/wave` — reports dissolved/marked/warned agent counts per wave
+- `/do` — W4 reports tests passed/total, reconcile canons, rubric scores
+- `/close` — reports rubric score (security + stability + simplicity + speed, composite ≥ 0.65) + learnings entry
 - `/sync` — reports tasks synced, hash-delta, KV writes
 - `/deploy` — reports W0 results, build ms, per-service deploy ms, health
-- `/done` — reports rubric score (security + stability + simplicity + speed, composite ≥ 0.65)
-- growth tick — reports per-loop timings (L1-L7 lastAtMs, nextAtMs)
 
 If you can't measure it, you can't route around it.
 
 ---
 
-## The Substrate
-
-```
-~90 lines.  Zero returns.  Two fields.  Queue.
-
-{ receiver, data }
-
-That's all that flows.
-The runtime moves signals. TypeDB remembers.
-```
-
----
-
-## Two Layers
-
-```
-NERVOUS SYSTEM (runtime)         BRAIN (TypeDB)
-signals, strength, resistance, queue     paths, units, skills, knowledge
-loops L1-L3 (ms to minutes)      loops L4-L7 (hours to weeks)
-```
-
-The runtime handles what moves. TypeDB handles what remains.
-
----
-
-## Tasks = Handlers, Dependencies = Continuations
-
-```typescript
-// Tasks are .on() handlers on units
-// Dependencies are .then() continuations
-const bob = net.add('bob')
-  .on('schema', async (data, emit) => buildSchema(data))
-  .then('schema', r => ({ receiver: 'bob:api', data: r }))
-  .on('api', async (data, emit) => buildAPI(data))
-  .then('api', r => ({ receiver: 'bob:test', data: r }))
-
-// No task entities. No dependency relations. No trail relations.
-// Pheromone accumulates on paths automatically.
-```
-
----
-
-## Agent Self-Improvement
-
-Units have `model`, `system-prompt`, `generation`.
-The substrate measures performance. When it's bad enough, the agent evolves.
-
-```typescript
-// TypeDB detects
-needs_evolution(unit) → success-rate < 0.50, sample-count >= 20
-
-// Agent responds
-unit.system-prompt = rewrite(old-prompt, failures)
-unit.generation++
-```
-
-Two layers of learning:
-- **Substrate** — pheromone on paths. World gets smarter.
-- **Agent** — prompt/model evolution. Individual gets smarter.
-
----
-
 ## Signal
 
 ```typescript
 type Signal = {
-  receiver: string      // "unit" or "unit:task"
-  data?: unknown        // { tags?, weight?, content? } by convention
+  receiver: string      // "family" or "family:action"
+  data?: unknown        // typed per receiver via RECEIVERS catalog
 }
 ```
 
-The universal primitive. `data` is untyped — convention shapes it:
-`tags` (routing/classification), `weight` (pheromone deposit), `content` (payload).
+The universal primitive — `{ receiver, data }` is frozen. Capability contracts
+live in the receiver registry (`@oneie/sdk/receivers`); the schema is truth for data.
 
 ---
 
-## Unit
-
-```typescript
-unit(id, route?)
-  .on(name, fn)           // define task (handler)
-  .then(name, template)   // define continuation (dependency)
-  .role(name, task, ctx)  // context-bound task
-  .has(name)              // introspection
-  .list()                 // introspection
-  .id                     // identity
-```
-
-### Task Signature
+## World (the pheromone primitives)
 
-```typescript
-(data, send, ctx) => result
-
-data   // the data
-send   // (signal) => void — fan out
-ctx    // { from: string, self: string }
-```
-
----
-
-## World
+Shipped surface — `createWorld()` in `one.ie/web/src/lib/pheromone.ts`
+(vendored in-RAM for DO bundles; mirrors the SDK verb semantics):
 
 ```typescript
-world()
-  .add(id)                // create unit (auto-drains queued signals)
-  .remove(id)             // remove unit (trails remain, fade naturally)
-  .signal(signal, from?)  // route signal, mark pheromone
-  .enqueue(signal)        // queue for later processing
-  .drain()                // shift from queue, signal it
-  .pending()              // queue length
-  .mark(edge, strength?)  // strengthen path
-  .warn(edge, strength?)  // weaken path
-  .sense(edge)            // read strength
-  .danger(edge)           // read resistance
-  .follow(type)           // best path (deterministic)
-  .select(type?)          // best path (probabilistic, ant-like)
-  .fade(rate?)            // decay all paths (resistance 2x faster)
-  .highways(limit?)       // top weighted paths
-  .has(id)                // introspection
-  .list()                 // introspection
-  .get(id)                // direct access
+world.mark(edge, w?)        // strengthen path
+world.warn(edge, w?)        // weaken path (resistance)
+world.sense(edge)           // read strength
+world.follow(from)          // best path (deterministic)
+world.select(from)          // best path (probabilistic, ant-like)
+world.highways(prefix?, n?) // top weighted paths
+world.fade(rate?)           // decay all paths (resistance 2x faster)
+world.serialize()           // snapshot for KV
+world.restore(snapshot)     // rehydrate
 ```
 
----
-
-## Persist
-
-```typescript
-persist()                           // extends world with TypeDB
-  .actor(id, kind?, opts?)          // add + persist
-  .flow(from, to)                   // mark/warn wrapper
-  .open(n?)                         // top paths as {from, to, strength}
-  .blocked()                        // toxic paths
-  .know()                           // promote highways to knowledge
-  .recall(match?)                   // query knowledge from TypeDB
-```
+Over HTTP the same verbs are `SubstrateClient` methods (`packages/sdk/src/client.ts`).
+`harden` is exposed via `signal("learning:know")`.
 
 ---
 
@@ -228,70 +129,25 @@ persist()                           // extends world with TypeDB
 Positive flow only. Silence is valid.
 
 ```typescript
-// GOOD
-task?.(data, emit, ctx).then(result =>
-  next[name] && route?.(next[name](result), receiver)
-)
+// GOOD — missing handler? Signal dissolves. World continues.
+handler?.(data, send, ctx)
 
 // BAD
-if (!task) return reject(...)
+if (!handler) return reject(...)
 if (!target) throw new Error(...)
 ```
 
-Missing handler? Signal dissolves. Group continues.
-
----
-
-## The Tick
-
-```typescript
-const next = net.select()              // follow pheromone
-next && net.signal({ receiver: next }) // execute
-net.drain()                            // process queue
-net.fade(0.05)                         // decay
-// evolve every 10min, know every hour
-```
-
----
-
-## Signal Flow
-
-```
-signal(sig, from='entry')
-  → unit(sig, from)
-    → task(data, send, {from, self})
-      → send(sig)  // fan out
-        → signal(sig, from=self)
-          → mark(edge)  // path remembers
-      → .then(task)  // continuation fires
-        → signal(next)  // chain continues
-```
-
-Concurrency safe. No global state.
-
----
-
-## Multi-Machine Collaboration
-
-```
-Machine A                           Machine B
-┌──────────┐                        ┌──────────┐
-│  router   │──signal──→ TypeDB ←──signal──│  router   │
-│          │←─paths───→       ←──paths──│          │
-└──────────┘                        └──────────┘
-```
-
-Each machine runs one router process. TypeDB is shared.
-Pheromone builds across machines. The substrate learns end-to-end paths.
+A dissolved signal still closes its loop — the *caller* sees `kind: "dissolved"`
+and warns the edge (Rule 1). Dissolve is an outcome, not an exception.
 
 ---
 
-*Signal. Mark. Warn. Follow. Fade. Highway. Queue. Evolve. Know.*
+*The 6 verbs: signal · mark · warn · fade · follow · harden.*
 
 ---
 
 ## Verb Contracts
 
-Each of the 6 verbs has a **pre / post / invariant** contract. Spec lives in `plans/contracts.md` — loaded only when editing a verb implementation, not every session.
+Each of the 6 verbs has a **pre / post / invariant** contract. Spec lives in `text/contracts.md` — loaded only when editing a verb implementation, not every session.
 
-New verb? You need: contract block in `plans/contracts.md`, row in `one-ie/CLAUDE.md` § The 6 verbs, contract gate in `.claude/agents/w4-verify.md` step 2.5. If you can't write the contract, you can't ship the verb.
+New verb? You need: contract block in `text/contracts.md`, row in `one-ie/CLAUDE.md` § The 6 verbs, contract gate in `.claude/agents/w4-verify.md` step 2.5. If you can't write the contract, you can't ship the verb.

package/scripts/do-auto.sh

@@ -36,11 +36,11 @@ if ! printf '%s' "$SLUG" | grep -qE '^[a-zA-Z0-9][a-zA-Z0-9_-]*$'; then
 fi
 
 # Trust boundary: this script runs in the developer's own workspace, invoked by /do
-# which resolves the slug from a plans/ file the developer controls. The spawned
+# which resolves the slug from a text/ file the developer controls. The spawned
 # claude subprocess uses --dangerously-skip-permissions because it is non-interactive
 # — it cannot prompt the human for tool approvals. The workspace is the isolation
 # boundary. Do not expose this script to untrusted input or run it in shared environments.
-[ -f "plans/${SLUG}-todo.md" ] || { echo "[do-auto] plans/${SLUG}-todo.md not found — run /do $SLUG first" >&2; exit 1; }
+[ -f "text/${SLUG}-todo.md" ] || { echo "[do-auto] text/${SLUG}-todo.md not found — run /do $SLUG first" >&2; exit 1; }
 
 # ── Worktree isolation (one per plan) ────────────────────────────────────────
 # The loop's existence IS the trigger: do-auto only runs for multi-cycle plans
@@ -78,7 +78,7 @@ _setup_worktree() {
   # from HEAD wouldn't have them. Copy only this slug's files — never unrelated
   # working-tree changes — then commit them as the branch baseline.
   local f changed=0
-  for f in "plans/${SLUG}.md" "plans/${SLUG}-todo.md" "text/${SLUG}.md" ".w4-improvements.json"; do
+  for f in "text/${SLUG}.md" "text/${SLUG}-todo.md" ".w4-improvements.json"; do
     if [ -f "$f" ]; then
       mkdir -p "$WT/$(dirname "$f")"
       if ! cmp -s "$f" "$WT/$f" 2>/dev/null; then cp "$f" "$WT/$f"; changed=1; fi
@@ -93,10 +93,10 @@ _setup_worktree() {
 if ! $DRY_RUN; then
   _setup_worktree
   # All loop state now lives in the worktree — read the boxes the subprocess ticks.
-  TODO="$WT/plans/${SLUG}-todo.md"
+  TODO="$WT/text/${SLUG}-todo.md"
   TRUST="$WT/.do-trust.json"
 else
-  TODO="plans/${SLUG}-todo.md"
+  TODO="text/${SLUG}-todo.md"
   TRUST=".do-trust.json"
 fi
 

package/scripts/do-folder.sh

@@ -25,7 +25,7 @@ fi
 doc_only=true
 for p in "${paths[@]}"; do
   case "$p" in
-    *.md|.claude/*|plans/*|text/*|docs/*) ;;
+    *.md|.claude/*|text/*|text/*|docs/*) ;;
     *) doc_only=false ;;
   esac
 done

package/scripts/do-prove.sh

@@ -1,18 +1,18 @@
 #!/usr/bin/env bash
-# do-prove.sh — PROVE (P5). Auto-detect the surface from the changed files and emit the proof
-# action; optional promise-check vs the P0 copy. The shipped thing must let the user do what the
-# promise said. Exit 1 only on a clear over-promise (artifact mentions none of the promise terms).
-# Usage:  do-prove.sh [--promise text/<f>.md] <changed-path>...
+# do-prove.sh — PROVE (pure). Promise-check moved to do-reconcile.sh (design canon).
+# Auto-detects surface from changed files → emits the proof action to run.
+# Usage:  do-prove.sh <changed-path>...   |   git diff --name-only | do-prove.sh
 set -euo pipefail
 
-promise=""
-if [ "${1:-}" = "--promise" ]; then promise="$2"; shift 2; fi
-
 paths=()
-if [ "$#" -gt 0 ]; then paths=("$@"); else while IFS= read -r l; do [ -n "$l" ] && paths+=("$l"); done; fi
+if [ "$#" -gt 0 ]; then
+  paths=("$@")
+else
+  while IFS= read -r l; do [ -n "$l" ] && paths+=("$l"); done
+fi
 [ "${#paths[@]}" -eq 0 ] && { echo "PROVE: no changes"; exit 0; }
 
-# surface detect — substrate wins (upstream), then api, then frontend, else backend
+# Surface detection — substrate wins (upstream), then api, then frontend, else backend
 surface=backend
 for p in "${paths[@]}"; do
   case "$p" in
@@ -28,24 +28,7 @@ case "$surface" in
   backend)   proof="curl against the DEPLOYED runtime (local verify is necessary, not sufficient)" ;;
   substrate) proof="/sync reconcile (TypeDB↔KV↔D1↔SUI) + TypeQL returns the new shape + types compile downhill" ;;
 esac
+
 echo "surface: $surface"
 echo "proof:   $proof"
-
-# promise-check: at least one substantive term from the P0 copy must appear in the shipped files
-if [ -n "$promise" ] && [ -f "$promise" ]; then
-  # drop code keywords + generic verbs so the check keys on domain terms, not coincidences
-  stop='export|function|return|const|class|import|async|await|value|string|number|default|users|allow|enable|create|update|delete|where|which|their'
-  terms=$(grep -oiE '[a-z]{5,}' "$promise" | tr 'A-Z' 'a-z' | sort -u | grep -vwE "$stop" | head -40)
-  hit=0
-  for t in $terms; do
-    for p in "${paths[@]}"; do
-      if [ -f "$p" ] && grep -qi "$t" "$p" 2>/dev/null; then hit=1; break 2; fi
-    done
-  done
-  if [ "$hit" -eq 0 ]; then
-    echo "PROMISE-CHECK: FAIL — shipped artifact mentions none of the promise's terms (over-promise → back to P4 or re-FRAME)"
-    exit 1
-  fi
-  echo "PROMISE-CHECK: ok"
-fi
 echo "PROVE: pass"; exit 0