@oneie/claude 0.4.0 → 0.6.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,10 +66,10 @@ 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 },
-  // /do code rubric — security/stability/simplicity/speed, gate ≥ 0.65
-  rubric: { security: 0.92, stability: 0.85, simplicity: 0.90, speed: 0.80 }
+  deployMs: { web: 13705, sync: 8249, channels: 9163, api: 17391 },
+  health: { web: 292, sync: 270, channels: 270 },
+  // /do code rubric — security/stability/simplicity/integration/speed, gate ≥ 0.65
+  rubric: { security: 0.92, stability: 0.85, simplicity: 0.90, integration: 0.88, speed: 0.80 }
 }
 ```
 
@@ -73,153 +79,54 @@ 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 + integration + speed, composite ≥ 0.65) + learnings entry + promise settle (kept/broken/dissolved/none)
 - `/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
+## World (the pheromone primitives)
 
-```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
-
-```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
+Over HTTP the same verbs are `SubstrateClient` methods (`packages/sdk/src/client.ts`).
+`harden` is exposed via `signal("learning:know")`.
 
-```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
-```
+**Promise paths.** `promise:<slug>→proof` is a first-class weighted path
+family. At close, `.claude/scripts/do-promise-settle.sh` re-runs the
+promise's `proof:` and `mark`s the path with the W4 composite (kept) or
+`warn`s it (broken). Build-time and run-time reputation are one ledger —
+cycle composites land on the same weighted paths run-time routing reads.
 
 ---
 
@@ -228,70 +135,80 @@ 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.
+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.
 
 ---
 
-## The Tick
+*The 6 verbs: signal · mark · warn · fade · follow · harden.*
+
+---
+
+## Rules 4–6 (from The Shape of the System)
+
+### Rule 4 — Deadlines + Ceilings
+
+**Every external call has a deadline. Every caller-controlled loop has a ceiling.**
 
 ```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
+// GOOD — AbortController on every fetch to an uncontrolled boundary
+const controller = new AbortController()
+const id = setTimeout(() => controller.abort(), TIMEOUT_MS)
+try {
+  const res = await fetch(url, { signal: controller.signal })
+} finally {
+  clearTimeout(id)
+}
+
+// BAD — no deadline = the caller's failure becomes your hang
+const res = await fetch(url)
 ```
 
----
+Ungated retries and uncapped allocations (sockets, threads, recursion) are DoS bugs — fixed on sight, no profiling required. Applies to: TypeDB calls, KV reads, chain RPCs, price oracles, any `fetch` to an external host.
 
-## Signal Flow
+### Rule 5 — Drain Before Exit
 
-```
-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
+**CF Workers drain before returning.** Stop accepting → drain in-flight within deadline → flush durable writes → return.
+
+```typescript
+// pattern for Durable Objects and long-running handlers
+ctx.waitUntil(drainAndFlush())
+return new Response('accepted', { status: 202 })
 ```
 
-Concurrency safe. No global state.
+Half-finished work silently corrupts downstream. The OS reclaims memory; it never reclaims meaning. Signal loss between "credits granted" and "signal emitted" is this failure mode.
 
----
+### Rule 6 — Monotonic Durations
 
-## Multi-Machine Collaboration
+**Durations use a monotonic source. Wall clock is for display and TTL anchoring at write time only.**
 
-```
-Machine A                           Machine B
-┌──────────┐                        ┌──────────┐
-│  router   │──signal──→ TypeDB ←──signal──│  router   │
-│          │←─paths───→       ←──paths──│          │
-└──────────┘                        └──────────┘
-```
+```typescript
+// GOOD — duration from performance.now() (monotonic)
+const start = performance.now()
+// ... work ...
+const elapsedMs = performance.now() - start
 
-Each machine runs one router process. TypeDB is shared.
-Pheromone builds across machines. The substrate learns end-to-end paths.
+// GOOD — TTL anchored once at write time (wall clock OK here)
+await KV.put(key, value, { expirationTtl: TTL_SECONDS })
 
----
+// BAD — wall clock for ordering or mid-flight deadline check
+if (Date.now() > deadline) throw new Error('expired') // skews under NTP
+```
 
-*Signal. Mark. Warn. Follow. Fade. Highway. Queue. Evolve. Know.*
+Wall clock can jump or skew under NTP corrections. Never use it to compare event ordering across Workers or to check a deadline computed from a prior `Date.now()` call.
 
 ---
 
 ## Verb Contracts
 
-Each of the 6 verbs has a **pre / post / invariant** contract. Spec lives in `text/contracts-plan.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 `text/contracts-plan.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/rules/react.md

@@ -114,16 +114,16 @@ export default function AgentCard() { ... }
 ## With Substrate
 
 ```tsx
-import { colony } from '@/engine/substrate'
+import { createWorld } from '@/lib/pheromone'
 
 export function SwarmView() {
-  const [net] = useState(() => colony())
+  const [net] = useState(() => createWorld())
   const [highways, setHighways] = useState([])
 
   useEffect(() => {
     const interval = setInterval(() => {
       net.fade(0.1)
-      setHighways(net.highways(10))
+      setHighways(net.highways(undefined, 10))
     }, 1000)
     return () => clearInterval(interval)
   }, [net])

package/scripts/browser-check.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * browser-check.mjs — Playwright browser diagnostic tool.
+ *
+ * Usage:
+ *   node .claude/scripts/browser-check.mjs [url] [--send "message"] [--screenshot] [--network]
+ *
+ * Requires: playwright in /tmp/node_modules (installed once, persists across sessions)
+ * Install:  cd /tmp && npm install playwright && npx playwright install chromium
+ *
+ * What it checks:
+ *   - Page load (status, title, console errors)
+ *   - Chat rail text before/after sending a message (--send)
+ *   - API request/response monitoring (--network)
+ *   - Screenshot saved to /tmp/browser-check.png (--screenshot)
+ *   - JS errors, React hydration errors
+ */
+
+import pkg from '/tmp/node_modules/playwright/index.js'
+const { chromium } = pkg
+import { writeFileSync } from 'fs'
+
+const args = process.argv.slice(2)
+const urlArg = args.find(a => a.startsWith('http')) ?? 'http://localhost:4321'
+const sendMsg = args.find((_, i) => args[i - 1] === '--send') ?? null
+const doScreenshot = args.includes('--screenshot')
+const doNetwork = args.includes('--network')
+
+const browser = await chromium.launch({ headless: true })
+const page = await browser.newPage()
+
+// Capture console output
+const consoleLogs = []
+const jsErrors = []
+page.on('console', m => consoleLogs.push({ type: m.type(), text: m.text() }))
+page.on('pageerror', e => jsErrors.push(String(e)))
+
+// Network monitoring
+const apiRequests = []
+const apiResponses = []
+if (doNetwork) {
+  page.on('request', req => {
+    if (req.url().includes('/api/')) {
+      apiRequests.push({ method: req.method(), url: req.url().split('?')[0] })
+    }
+  })
+}
+
+// Patch fetch to capture chat API body + stream
+await page.addInitScript(() => {
+  const orig = window.fetch
+  window.__chatCapture = []
+  window.fetch = async (...args) => {
+    const url = args[0]?.toString() || ''
+    if (url.includes('/api/chat') && !url.includes('warmup') && !url.includes('tts')) {
+      const method = args[1]?.method || 'GET'
+      const body = typeof args[1]?.body === 'string' ? args[1].body : ''
+      if (method === 'POST') {
+        window.__chatCapture.push({ type: 'request', body: body.substring(0, 200) })
+        const resp = await orig(...args)
+        const clone = resp.clone()
+        const reader = clone.body?.getReader()
+        if (reader) {
+          let chunks = ''
+          while (true) {
+            const { done, value } = await reader.read()
+            if (done) break
+            chunks += new TextDecoder().decode(value)
+          }
+          window.__chatCapture.push({ type: 'stream', status: resp.status, body: chunks.substring(0, 800) })
+        }
+        return resp
+      }
+    }
+    return orig(...args)
+  }
+})
+
+// Load page
+const res = await page.goto(urlArg, { waitUntil: 'load', timeout: 15000 }).catch(e => ({ status: () => 0, error: e.message }))
+const httpStatus = typeof res?.status === 'function' ? res.status() : 0
+await page.waitForTimeout(2500)
+
+const title = await page.title().catch(() => '(no title)')
+const chatRailBefore = await page.evaluate(() => document.querySelector('.chat-rail')?.innerText?.substring(0, 200) || null)
+
+// Send message if requested
+let chatRailAfter = null
+if (sendMsg) {
+  const ta = await page.$('textarea')
+  if (ta) {
+    await ta.fill(sendMsg)
+    await ta.press('Enter')
+    await page.waitForTimeout(12000)
+    chatRailAfter = await page.evaluate(() => document.querySelector('.chat-rail')?.innerText?.substring(0, 400) || null)
+  }
+}
+
+// Screenshot
+if (doScreenshot) {
+  await page.screenshot({ path: '/tmp/browser-check.png', fullPage: false })
+}
+
+const chatCapture = await page.evaluate(() => window.__chatCapture || [])
+
+await browser.close()
+
+// Report
+const report = {
+  url: urlArg,
+  httpStatus,
+  title,
+  jsErrors,
+  consoleErrors: consoleLogs.filter(l => l.type === 'error').map(l => l.text),
+  chatRailBefore,
+  chatRailAfter: sendMsg ? chatRailAfter : undefined,
+  chatCapture: sendMsg ? chatCapture : undefined,
+  apiRequests: doNetwork ? apiRequests : undefined,
+  screenshot: doScreenshot ? '/tmp/browser-check.png' : undefined,
+}
+
+console.log(JSON.stringify(report, null, 2))

package/scripts/bun.lock

@@ -0,0 +1,27 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "@oneie/claude-scripts",
+      "dependencies": {
+        "@anthropic-ai/sdk": "^0.100.1",
+      },
+    },
+  },
+  "packages": {
+    "@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.100.1", "", { "dependencies": { "json-schema-to-ts": "^3.1.1", "standardwebhooks": "^1.0.0" }, "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" }, "optionalPeers": ["zod"], "bin": { "anthropic-ai-sdk": "bin/cli" } }, "sha512-RANcEe7LpiLczkKGOwoXOTuFdPhuubS0i4xaAKOMpcqc55YO0mukgxppV7eygx3DXNjxWT6RYOLPyOy0aIAmwg=="],
+
+    "@babel/runtime": ["@babel/runtime@7.29.7", "", {}, "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw=="],
+
+    "@stablelib/base64": ["@stablelib/base64@1.0.1", "", {}, "sha512-1bnPQqSxSuc3Ii6MhBysoWCg58j97aUjuCSZrGSmDxNqtytIi0k8utUenAwTZN4V5mXXYGsVUI9zeBqy+jBOSQ=="],
+
+    "fast-sha256": ["fast-sha256@1.3.0", "", {}, "sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ=="],
+
+    "json-schema-to-ts": ["json-schema-to-ts@3.1.1", "", { "dependencies": { "@babel/runtime": "^7.18.3", "ts-algebra": "^2.0.0" } }, "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g=="],
+
+    "standardwebhooks": ["standardwebhooks@1.0.0", "", { "dependencies": { "@stablelib/base64": "^1.0.0", "fast-sha256": "^1.3.0" } }, "sha512-BbHGOQK9olHPMvQNHWul6MYlrRTAOKn03rOe4A8O3CLWhNf4YHBqq2HJKKC+sfqpxiBY52pNeesD6jIiLDz8jg=="],
+
+    "ts-algebra": ["ts-algebra@2.0.0", "", {}, "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw=="],
+  }
+}