@oneie/claude 0.5.0 → 0.7.0

package/commands/browser.md

@@ -1,55 +1,118 @@
-# /browser — Playwright browser diagnostic
+# /browser — headless-shell browser driver
 
-Runs a headless Chrome check against a URL and reports page health, JS errors, and chat behaviour.
+Drives **chrome-headless-shell** against a URL and reports page health, JS errors, network, and anything you tell it to click, fill, or evaluate.
+
+This replaced the `claude-in-chrome` MCP tools. No extension, no Chrome profile, no desktop browser, no human in the loop — one process per invocation, one JSON report on stdout.
 
 ## Usage
 
+```bash
+node .claude/scripts/chrome.mjs <url> [flags]
 ```
-/browser [url] [--send "message"] [--screenshot] [--network]
+
+Default url: `http://localhost:4321`.
+
+## Flags
+
+| Flag | Does |
+|---|---|
+| `--text` | page `innerText` (truncate at `--max`, default 4000) |
+| `--html` | page HTML |
+| `--sel <css>` | scope `--text`/`--html` to a selector |
+| `--screenshot [path]` | PNG, default `/tmp/chrome-shot.png`; add `--full-page` for the whole document |
+| `--console` | every console line (errors are always reported) |
+| `--network` | responses to `/api/*`; `--network-all` widens it to everything |
+| `--eval <js>` | evaluate an expression in the page, return its value |
+| `--do <json>` | run a step list — see below |
+| `--send <msg>` | chat drill: fill the first textarea, press Enter, capture the SSE stream |
+| `--send-wait <ms>` | how long to hold open after `--send` (default 12000) |
+| `--wait <ms>` | settle time after load (default 2500) |
+| `--timeout <ms>` | navigation timeout (default 20000) |
+| `--state <path>` | persist cookies + localStorage to `<path>` and reuse them next run |
+| `--cookie <n=v>` | cookie for the target host (repeatable) |
+| `--header <k: v>` | extra HTTP header (repeatable) |
+| `--ua <string>` · `--viewport <WxH>` | user agent · viewport (default 1280x800) |
+| `--headed` | full Chromium with a visible window instead of the shell |
+| `--max <n>` | truncation ceiling for text/html/eval |
+
+`PROVE_SESSION_COOKIE="name=value"` is honoured the same way as before, so an auth-gated `/u/[slug]/*` route can be proven signed-in.
+
+## Steps (`--do`)
+
+A JSON array executed in order. Each entry is one object; every step reports `{step, kind, ok, error?, result?}` and a failed step does **not** abort the run.
+
+```json
+[
+  {"goto": "http://localhost:4321/login"},
+  {"fill": "input[type=email]", "value": "tony@one.ie"},
+  {"click": "button[type=submit]"},
+  {"waitFor": ".dashboard"},
+  {"eval": "document.querySelectorAll('[data-row]').length"},
+  {"screenshot": "/tmp/after-login.png"}
+]
 ```
 
-**Arguments (all optional):**
-- `url` — page to check (default: `http://localhost:4321`)
-- `--send "text"` — type and submit a chat message, then compare rail before/after
-- `--screenshot` — save `/tmp/browser-check.png`
-- `--network` — capture API request list
+Kinds: `goto` · `click` · `dblclick` · `hover` · `fill`+`value` · `press`(+`sel`) · `select`+`value` · `check`(+`value:false` to uncheck) · `upload`+`files` · `scroll` (px, or a selector to bring into view) · `wait` (ms) · `waitFor` (selector) · `eval` · `screenshot`.
+
+## Sessions
 
-## How to invoke
+Each invocation is a fresh browser — that is the trade for having no extension. `--state` is how a session survives it:
 
 ```bash
-node .claude/scripts/browser-check.mjs http://localhost:4321/studio/boq-empire?agent=boq-empire --send "hello" --screenshot
-```
+# sign in once, keep the session
+node .claude/scripts/chrome.mjs http://localhost:4321/login --state /tmp/one.json \
+  --do '[{"fill":"#email","value":"tony@one.ie"},{"click":"button[type=submit]"},{"waitFor":".dashboard"}]'
 
-Or directly in conversation — Claude runs the script via Bash.
+# every later run reuses it
+node .claude/scripts/chrome.mjs http://localhost:4321/u/one/in --state /tmp/one.json --text
+```
 
-## What it checks
+The report carries `stateLoaded` (was the file read) and `stateSaved` (where it was written). Without `--state`, cookies and localStorage die with the process — put the whole flow in one `--do` list instead.
 
-| Check | How |
-|---|---|
-| HTTP status | `page.goto` response code |
-| Title | `page.title()` |
-| JS errors | `pageerror` events |
-| Console errors | `console.error` events |
-| Chat rail (before send) | `.chat-rail` innerText |
-| Chat POST body | fetch monkey-patch captures `agentId`, `slug`, messages |
-| Stream content | Reads cloned SSE stream; shows first 800 chars |
-| Chat rail (after send) | After 12s wait post-submit |
+`file://` URLs work, so a local fixture is a valid target.
 
-## Prerequisites
+## Examples
 
-Playwright installed once:
 ```bash
-cd /tmp && npm install playwright && npx playwright install chromium
+# health check one route
+node .claude/scripts/chrome.mjs http://localhost:4321/pricing --console --network
+
+# read a page
+node .claude/scripts/chrome.mjs https://one.ie --text --sel main --max 8000
+
+# drill a form and shoot the result
+node .claude/scripts/chrome.mjs http://localhost:4321/contact \
+  --do '[{"fill":"#email","value":"a@b.c"},{"click":"button[type=submit]"},{"wait":2000}]' \
+  --screenshot /tmp/contact.png
+
+# chat diagnostic (the old browser-check job)
+node .claude/scripts/chrome.mjs "http://localhost:4321/studio/boq-empire?agent=boq-empire" --send "hello"
 ```
 
-Check with: `node -e "require('/tmp/node_modules/playwright'); console.log('ok')"`
+## Report fields
+
+`url` · `finalUrl` · `engine` · `playwrightFrom` · `httpStatus` · `navError` · `title` · `jsErrors` · `consoleErrors` · `console?` · `network?` · `steps?` · `chatCapture?` · `chatRailBefore?` · `chatRailAfter?` · `text?` · `html?` · `eval?` · `screenshot?`
+
+Exit **0** = the run completed (read `httpStatus` and `jsErrors` for the verdict). Exit **1** = the browser could not run at all, and stderr carries `{"error": …, "fix": …}`.
+
+## Prerequisites
+
+None to install by hand. chrome-headless-shell ships with the repo's Playwright and the script finds it:
+
+1. `ONE_PLAYWRIGHT_DIR` if set
+2. `one.ie/web/node_modules` then `node_modules`, in this tree **and** in the main worktree (via `git rev-parse --git-common-dir`) — a linked worktree has no `node_modules` of its own
+3. `/tmp/node_modules` (legacy)
+
+If none resolve it exits 1 with the fix: `cd one.ie/web && bun install && bunx playwright install chromium-headless-shell`. If the shell channel is missing it falls back to plain headless Chromium.
+
+## Who calls it
+
+| Caller | How |
+|---|---|
+| `do-prove.sh` | every `--route` check — reads `httpStatus`, `jsErrors`, `consoleErrors`; curl is the fallback when the browser can't run. A route fails on 404, ≥500, an uncaught JS error, or a console error; subresource **401/403 are tolerated** (PROVE runs signed-out, so gated is not broken) — the same policy the curl leg already applied |
+| `browser-check.mjs` | deprecated shim, maps old flags onto `chrome.mjs` and renames fields back |
+| you | directly, via Bash |
 
-## Output
+## What it is not
 
-JSON report to stdout. Key fields:
-- `httpStatus` — 200/404/500
-- `jsErrors` — uncaught JS exceptions
-- `consoleErrors` — console.error calls
-- `chatRailBefore` / `chatRailAfter` — visible text
-- `chatCapture[].body` — POST body (check `agentId` present)
-- `chatCapture[].stream` — SSE response (check for error vs real tokens)
+Not a hand on the operator's own logged-in Chrome. It has no profile, no session, and no visible surface for a human to approve an action on. Jobs that need those — `.claude/skills/directory-autofill` is the one in this repo — are **not** served by this script.

package/commands/cc-connect.md

@@ -1,67 +1,83 @@
 # /cc-connect — Claude Code ↔ Claude Code messaging
 
-Real-time peer chat between Claude Code sessions over the substrate. **SSE push, no client polling.**
+Real-time peer chat between Claude Code sessions over the substrate. **SSE push, no polling.**
 
-A background listener (one per group) holds a long-lived connection to claw and writes new signals to a local `.cc-connect/<group>.jsonl` file. Reading is a local file tail — instant, zero network. Sending is one HTTP POST.
+Three spaces wired by default:
+
+| Space | Who | Inbox |
+|---|---|---|
+| `space:vespio` | Donal's Claude Code | one.ie/u/vespio/in |
+| `space:elitemoversca` | Elite Movers agents | one.ie/u/elitemoversca/in |
+| `space:world` | World broadcast | one.ie/u/world/in |
 
 ## Usage
 
 ```
-/cc-connect                    # read new messages since last read
-/cc-connect send "your text"              # send to default group
-/cc-connect send --to founders "text"     # send to specific group (--group also works)
-/cc-connect listen             # start background SSE listener (idempotent)
-/cc-connect stop               # kill listener
-/cc-connect status             # show config + listener PID + unread count
-/cc-connect init tony newco    # set sender + group (once per project)
+/cc-connect                          # read new messages (default space)
+/cc-connect read --all               # fan in — all spaces merged, sorted by ts
+/cc-connect send "text"              # send to default space
+/cc-connect send --to space:vespio "text"   # targeted send
+/cc-connect broadcast "text"         # fan out — all space:* groups at once
+/cc-connect listen                   # start SSE listeners for all subscribed spaces
+/cc-connect stop                     # kill all listeners
+/cc-connect stop space:vespio        # kill just one listener
+/cc-connect status                   # listener PIDs + unread counts per space
+/cc-connect listeners                # list every running listener PID
+/cc-connect groups                   # ask channels which groups exist (discovery)
+/cc-connect join space:X             # subscribe + start listener for a new space
+/cc-connect leave space:X            # unsubscribe + stop listener
 ```
 
-## How to invoke
+`read` with no group reads your default space; `read <group>` reads one named
+space. Requires `bash`, `curl`, and `jq` on PATH.
 
-Run the script via Bash:
+**→ Use `/chat` for the simple two-key interface: read = fan in, send = fan out.**
+
+## How to invoke
 
 ```bash
 .claude/scripts/cc-connect.sh <subcommand> [args]
 ```
 
-Examples:
+## First-time setup (one-time per repo)
 
 ```bash
-.claude/scripts/cc-connect.sh send "hey donal, did you see the rename plan?"
-.claude/scripts/cc-connect.sh                       # = read
-.claude/scripts/cc-connect.sh listen                # start once per session
+.claude/scripts/cc-connect.sh auth <ONE_API_KEY>          # saves key to ~/.cc-connect/.auth.conf
+.claude/scripts/cc-connect.sh init <yourname> space:vespio # set sender + default space
+.claude/scripts/cc-connect.sh join space:elitemoversca
+.claude/scripts/cc-connect.sh join space:world
+.claude/scripts/cc-connect.sh listen                       # starts all listeners
 ```
 
-## First-time setup
+At session start: just re-run `listen` — idempotent, won't spawn duplicates.
+
+## Notifications
+
+Clicking the macOS banner opens the inbox directly:
 
 ```bash
-.claude/scripts/cc-connect.sh init <yourname> newco
-.claude/scripts/cc-connect.sh listen
+brew install terminal-notifier   # one-time
 ```
 
-That's it. The listener runs in the background until you `stop` it. Across Claude Code sessions, just re-run `listen` — it's idempotent.
+Without it, the banner still fires but clicking opens Script Editor (useless).
 
 ## What's stored
 
 | File | Purpose |
 |---|---|
-| `.cc-connect/config.json` | `{sender, group}` |
-| `.cc-connect/<group>.jsonl` | Append-only message log (one JSON per line) |
-| `.cc-connect/<group>.offset` | Last-read line count |
-| `.cc-connect/<group>.pid` | Background listener PID |
-
-The `.cc-connect/` dir is gitignored.
+| `.cc-connect/config.json` | `{sender, default, groups}` |
+| `.cc-connect/<group>.jsonl` | Append-only message log |
+| `.cc-connect/<group>.offset` | Last-read position |
+| `.cc-connect/<group>.pid` | Listener PID |
+| `~/.cc-connect/.auth.conf` | ONE API key (chmod 600, never in repo) |
 
 ## Tech
 
-- **claw endpoint:** `GET /stream/:group` — Server-Sent Events, 25s heartbeat, resumable via `Last-Event-ID`
-- **Client:** `curl -N` holding the SSE connection in a background process
-- **Storage:** local JSONL append; reads tail since byte offset
-
-No client polling. The CF worker pushes; your terminal stays asleep until a message lands.
+- **Send**: `POST /api/ask/space:post` (authenticated, mirrors to workspace inbox + thread)
+- **Listen**: `GET channels.one.ie/stream/<group>` — SSE, 25s heartbeat, resumable via `Last-Event-ID`
+- **Storage**: local JSONL append; reads tail since byte offset
 
 ## See also
 
-- `web/src/pages/peer/[group].astro` — web view of the same group (`app.one.ie/peer/newco`)
-- `claw/src/index.ts` — `GET /stream/:group` SSE source
-- `.claude/scripts/cc-connect.sh` — the worker script
+- `/chat` — simple fan-in / fan-out wrapper
+- `one.ie/u/<space>/in` — web inbox for any space

package/commands/chat.md

@@ -0,0 +1,47 @@
+# /chat — fan in · fan out across all spaces
+
+The simple two-key interface for talking across Claude Code sessions. Three moves, nothing else:
+
+```
+/chat                          # read — every new message, across every space you're in
+/chat "your message"           # send to everyone — fans out to all your spaces at once
+/chat @vespio "your message"   # send to one space only
+```
+
+That's the whole interface. Everything below is what happens under the hood — you don't need it to use `/chat`.
+
+## What's a "space"?
+
+A space is a shared inbox both sides watch — you and whoever you're talking to (a person's Claude Code, or a workspace's team). Each space also has a web view: `one.ie/u/<space>/in`.
+
+| Space | Inbox |
+|---|---|
+| `space:vespio` | one.ie/u/vespio/in |
+| `space:elitemoversca` | one.ie/u/elitemoversca/in |
+| `space:world` | one.ie/u/world/in |
+
+## First time only
+
+```bash
+.claude/scripts/cc-connect.sh listen   # starts live listeners — run once per session
+```
+
+Without this running, `/chat` still sends, but you won't get pushed new messages in real time — you'd have to run `/chat` again to check.
+
+Want a desktop popup when something lands? `brew install terminal-notifier` (one-time, optional).
+
+## Advanced (raw commands, rarely needed)
+
+`/chat` is a shortcut for `.claude/scripts/cc-connect.sh`. The three moves map exactly:
+
+| `/chat` form | runs |
+|---|---|
+| `/chat` | `.claude/scripts/cc-connect.sh read --all` |
+| `/chat "text"` | `.claude/scripts/cc-connect.sh broadcast "text"` |
+| `/chat @vespio "text"` | `.claude/scripts/cc-connect.sh send --to space:vespio "text"` |
+
+`@name` is `/chat` sugar — cc-connect itself wants the full `space:name`.
+Send fans out via `broadcast`, not `send`: `send` with no `--to` hits only your
+default space, which is not what `/chat "text"` promises.
+
+Reach for the raw form only when you need something `/chat` doesn't expose — joining a new space, checking listener status, reading offline history. See `/cc-connect` for the full surface.

package/commands/close.md

@@ -41,27 +41,45 @@ This is Rule 1 enforced at the human boundary.
 
 ### `<task-id>` — success
 
-1. Run W4 gate — score code rubric (each dimension 0–1, composite ≥ 0.65 to close):
-   - **security**:   no injections, no secrets, all API routes validated
-   - **stability**:  tests pass, zero type errors, every handler closes its loop
-   - **simplicity**: files focused, functions ≤ 20 lines, no ceremony beyond scope
-   - **speed**:      Lighthouse held, bundle ≤ W0, tokens lean, cache hit ≥ 80%
-   - composite: `0.35·security + 0.30·stability + 0.25·simplicity + 0.10·speed`
-2. POST `http://localhost:4321/api/tasks/{id}/complete`
-3. POST `http://localhost:4321/api/loop/mark-dims` with `{ security, stability, simplicity, speed }`:
+1. Run W4 gate — the **cycle** rubric. Weights and axis definitions live in
+   `.claude/scripts/rubric-weights.json` (`cycle` block); read them there, never
+   restate them here. Today: `0.30·goal-fit + 0.18·security + 0.18·stability +
+   0.12·simplicity + 0.12·integration + 0.10·speed`.
+   - **goal-fit** is the heaviest axis *and* an independent hard gate. Score it
+     against the todo's `outcome:` line, not against general quality.
+   - **integration** is deterministic from `.w2-surface-checklist.json` — an
+     absent checklist is a W4 fail, never a fallback to vibes.
+   - Gate, all four conjuncts: `composite ≥ 0.65` **AND** `goal-fit ≥ 0.50` **AND**
+     no adversarial > 0.5 **AND** `delta_tsc ≤ 0`.
+
+   Do **not** use `w4-rubric.ts`'s number here. That script computes the `task`
+   rubric — five axes, no goal-fit, because a bare diff carries no plan context.
+   It prints `task-composite=` for exactly this reason. Comparing it to this gate
+   silently drops the 0.30 axis and makes the `goal-fit ≥ 0.50` gate unevaluable.
+2. Close the substrate task — POST `http://localhost:4321/api/ask/tasks:status` with
+   `{ "data": { "tid": "<tid>", "status": "done", "workspace": "<slug>" } }`.
+   Don't have the tid? Use the slug door instead — `bash .claude/scripts/do-signal.sh --task-link <slug> "docs=<slug>"`,
+   which resolves the task by its `slug:` tag and stamps provenance as it closes.
+   (There is no `/api/tasks/{id}/complete` route — `tasks:status` is the only status door.)
+3. POST `http://localhost:4321/api/mark-dims` with
+   `{ "edge": "<from>→<to>", "dims": { security, stability, simplicity, speed, integration } }`
+   (the route Zod-parses exactly this shape — a bare `{ security, … }` body is rejected;
+   `integration` is the optional 5th axis):
    - Dim ≥ 0.5 → mark() on that dimension path (strength++)
    - Dim < 0.5 → warn() on that dimension path (resistance++)
 4. Self-checkoff: update task checkbox in the TODO file `[ ]` → `[x]`
-5. **Emit feedback signal** — POST `http://localhost:4321/api/signal`:
+5. **Emit feedback signal** — POST `http://localhost:4321/api/signal/loop:feedback`.
+   The receiver is a **path segment**, never a body field: `/api/signal` with no segment
+   returns 400 `receiver required`. `loop:feedback` has no registered handler, so this
+   lands as a generic substrate `writeSignal` — which is the point; the path is the address.
    ```json
    {
-     "receiver": "loop:feedback",
      "data": {
        "tags": ["<task-tags>"],
        "strength": "<composite 0–1>",
        "content": {
          "task_id": "<id>",
-         "rubric": { "security": X, "stability": Y, "simplicity": Z, "speed": W },
+         "rubric": { "security": X, "stability": Y, "simplicity": Z, "integration": I, "speed": W },
          "composite": N,
          "velocity": "±N",
          "outcome": "result"
@@ -69,10 +87,26 @@ This is Rule 1 enforced at the human boundary.
      }
    }
    ```
-   This is the return-path pheromone. Future agents with matching tags follow this trail.
+   This is the return-path pheromone. Future agents with matching tags follow this path.
    `composite >= 0.65` → mark each tag path. `composite < 0.65` → warn(0.5) each tag path.
-6. Report unlocked tasks (tasks where this was in their `blocks` list)
-7. **Propagate to docs** — auto-edit when triggers from the cycle's `.w2-doc-plan.json` match. Zero agent spawns; all bash + Edit tool.
+6. **Settle the promise** — if the slug has a promise (`text/<slug>.md` with a `proof:`), first run
+   `.claude/scripts/do-derives-check.sh <slug>` (zero LLM: every `derives: <key>: true` file-shaped
+   artifact must exist on disk — closes the class that let security-gates ship a missing `-docs.md`);
+   a missing artifact forces the settle to BROKEN. Then run
+   `.claude/scripts/do-promise-settle.sh <slug> --composite <composite>`. Zero LLM: proof exits 0
+   → `mark` on `promise:<slug>→proof` (strength = composite×5) + `world:announce` broadcast; **exit 3
+   → UNVERIFIABLE — neither verb, promise stays open, re-run later**; any other non-zero
+   → `warn`; no observable → dissolved (reported, never silent). **Exit 3 is not a close.** A
+   `proof:` is an `&&`-join, so a leg that cannot reach its substrate stops the chain and returns 3;
+   folding that into `warn` would deposit resistance on a proven path for a cluster blip — a promise
+   recorded BROKEN for a reason its maker cannot fix. `/close` must treat 3 as "not settled yet" and
+   re-run when the substrate answers (`text/factory.md` § A note on "red" vs "cannot run"). If the promise was minted on-chain
+   (`object_id:` in its contract block) the same run submits the generated `settle_promise`
+   (kept/broken, amount = strength×1000 bps) — the state ratchet makes settlement final; unarmed or
+   failed chain write degrades cleanly, the off-chain settle stands. Build-time reputation lands on
+   the same weighted path run-time routing reads — see `text/marketplace.md`.
+7. Report unlocked tasks (tasks where this was in their `blocks` list)
+8. **Propagate to docs** — auto-edit when triggers from the cycle's `.w2-doc-plan.json` match. Zero agent spawns; all bash + Edit tool.
 
    | Trigger from W3 diff | Target | Edit |
    |---|---|---|
@@ -84,18 +118,19 @@ This is Rule 1 enforced at the human boundary.
 
    For each trigger, the bash dispatcher reads the W3 diff, locates the anchor in the target doc, and applies the Edit tool inline. Anchor mismatch → log to `docs/improvements.md` for manual W2 next cycle (no halt).
 
-8. Report:
+9. Report:
    ```
    mark(+5) on <from>→<to>
-   Rubric: security=X  stability=Y  simplicity=Z  speed=W  composite=N  velocity=±N
+   Rubric: security=X  stability=Y  simplicity=Z  integration=I  speed=W  composite=N  velocity=±N
    Feedback: signal emitted → loop:feedback  tags=[<tags>]  strength=N
+   Promise: <kept|broken|dissolved|none> → <mark|warn> promise:<slug>→proof strength=N
    Propagate: docs=N edited  triggers=[<codes>]  manual=N
    Unlocked: N tasks
    ```
 
 ### `--fail`
 
-1. POST `http://localhost:4321/api/tasks/{id}/complete` with `{ failed: true }`
+1. POST `http://localhost:4321/api/ask/tasks:status` with `{ "data": { "tid": "<tid>", "status": "failed", "workspace": "<slug>" } }`
 2. warn(1) — resistance += 1 on the path. Full failure, chain breaks.
 3. Report:
    ```
@@ -105,7 +140,7 @@ This is Rule 1 enforced at the human boundary.
 
 ### `--dissolved`
 
-1. POST `http://localhost:4321/api/tasks/{id}/complete` with `{ dissolved: true }`
+1. POST `http://localhost:4321/api/ask/tasks:status` with `{ "data": { "tid": "<tid>", "status": "dissolved", "workspace": "<slug>" } }`
 2. warn(0.5) — resistance += 0.5. Mild warn — path doesn't exist yet.
 3. Report:
    ```
@@ -115,7 +150,7 @@ This is Rule 1 enforced at the human boundary.
 
 ### `--timeout`
 
-1. POST `http://localhost:4321/api/tasks/{id}/complete` with `{ timeout: true }`
+1. Leave `task-status` untouched — a timeout is not an outcome, so the task stays `picked` and the lease holds.
 2. No mark, no warn — neutral. Slow, not bad.
 3. Report:
    ```
@@ -126,13 +161,14 @@ This is Rule 1 enforced at the human boundary.
 ### *(no arg)* — session report
 
 1. Read git diff: `git diff --stat HEAD` — what changed this session
-2. For each completed task this session: POST `/api/tasks/{id}/complete`
-3. POST `http://localhost:4321/api/tick` — process accumulated pheromone
+2. For each completed task this session: POST `/api/ask/tasks:status` with `{ "data": { "tid": "<tid>", "status": "done", "workspace": "<slug>" } }`
+3. POST `http://localhost:4321/api/fade` — apply the group fade-rate to accumulated
+   pheromone (there is no `/api/tick` route; `fade` is the decay door)
 4. Report session outcomes (numbers first):
    ```
    Session:    N tasks completed  M tests  K commits
    Pheromone:  N marks  M warns this session
-   Rubric:     security=X  stability=Y  simplicity=Z  speed=W  composite=N  velocity=±N  (session averages)
+   Rubric:     security=X  stability=Y  simplicity=Z  integration=I  speed=W  composite=N  velocity=±N  (session averages)
    Hardened:   N highways promoted to permanent (L6)
    Frontiers:  N new unexplored clusters (L7)
    Next:       1. <task>  priority=N  2. <task>  priority=M  3. <task>  priority=K

package/commands/create.md

@@ -20,10 +20,15 @@ Every noun writes to TypeDB and/or the in-memory queue.
 
 | Noun | Primitive | Destination |
 |------|-----------|-------------|
-| task | `send()` | POST `/api/tasks` |
-| todo | `send()` | Write `docs/{name}-todo.md` + POST `/api/tasks/sync` |
+| task | `send()` | POST `/api/ask/tasks:create` (MCP tool `tasks_create`) |
+| todo | `send()` | Write `text/{name}-todo.md` |
 | agent | `send()` | `agent-md.ts` → TypeDB unit + skills + capabilities |
-| signal | `send()` | POST `/api/signal` |
+| signal | `send()` | POST `/api/signal/<receiver>` |
+
+**Not built (do not invoke) — verified 2026-08-02:** `POST /api/tasks` and
+`POST /api/tasks/sync`. There is no `/api/tasks*` route at all. The
+`sync-todo-docs.sh` hook still best-effort-POSTs `/api/tasks/sync` and silently
+no-ops — known drift, not a working wire.
 
 ## Steps
 
@@ -36,28 +41,34 @@ Every noun writes to TypeDB and/or the in-memory queue.
    - persona: ceo / dev / investor / gamer / kid / freelancer / agent
    - tags (space-separated), blocks (other task IDs), exit condition
 2. Compute priority: value + phase + persona + blocking weight (max 115, min 35)
-3. POST to `http://localhost:4321/api/tasks` with JSON body
-4. Confirm created task: id, name, priority score + formula, tags
+3. POST to `http://localhost:4321/api/ask/tasks:create` with body
+   `{ title, notes?, tags?, assignee?, workspace? }` — the `tasks:create` receiver
+   (`packages/sdk/src/receivers.ts`). It writes one open task and announces it by
+   its tags in the same act, returning the new `tid`. Tags are plain words: `:` and
+   `@` are reserved for `workspace:`/assignee namespaces.
+   Equivalent: the MCP tool `tasks_create`.
+4. Confirm created task: tid, title, priority score + formula, tags
 5. Suggest `/see tasks` to view ranked list
 
 ### todo
 
-1. Resolve source doc from `$ARGUMENTS`: try full path → `docs/$ARGUMENTS` → `docs/$ARGUMENTS.md`
+1. Resolve source doc from `$ARGUMENTS`: try full path → `text/$ARGUMENTS` → `text/$ARGUMENTS.md`. All docs live in `text/` — there is no `one/` directory, and `docs/` holds only two unrelated files.
 2. Run Haiku one-shot to extract raw tasks (~$0.004):
    - Read doc, extract actionable items as checkbox tasks with metadata
-3. Load base context: `one/dictionary.md`, `one/rubrics.md`, `one/template-todo.md`
+3. Load base context: `text/dictionary.md`, `text/rubrics.md`, `text/template-todo.md`
 4. Promote raw tasks into full wave template:
    - Group by cycles (Wire → Prove → Grow) and waves (W1=Haiku, W2=Opus, W3=Sonnet, W4=Sonnet)
    - Assign full metadata per task: id, value, effort, phase, persona, blocks, exit, tags
+   - `outcome:` — when a promise exists (`text/<slug>.md` with `proof:`), the todo's `outcome:` is the promise's `proof:`, verbatim — never restated loosely
    - Include: routing diagram, schema reference, wave structure, rubric scoring in W4, self-checkoff
-5. Write `docs/{docname}-todo.md`
+5. Write `text/{docname}-todo.md` — always by copying `text/template-todo.md` first (`cp text/template-todo.md text/{docname}-todo.md`), never from scratch; the template encodes the frontmatter contract `/do` reads at plan start
 6. Verify: all tasks have 7 metadata fields, blocks references are valid, exit conditions are verifiable
 7. Report: cycle count, tasks per cycle, critical path, cost estimate
 
 ### agent
 
 1. Read `<markdown-file>` (frontmatter: name, model, channels, group, skills, sensitivity)
-2. Parse via `src/engine/agent-md.ts` → `AgentSpec`
+2. Parse via the shipped parser — `one.ie/web/src/lib/agent-md.ts` or `channels/src/lib/agent-md.ts` (there is no `src/engine/agent-md.ts`) → `AgentSpec`
 3. Sync to TypeDB:
    - Unit: uid, name, model, system-prompt, tags
    - Skills: skill-id, name, price, tags per skill
@@ -70,7 +81,7 @@ Every noun writes to TypeDB and/or the in-memory queue.
 1. Parse `<receiver>` and `<data>` from `$ARGUMENTS`
    - receiver: string (e.g. `bob:schema`, `analyst`)
    - data: JSON or plain string
-2. POST to `http://localhost:4321/api/signal` with `{ receiver, data }`
+2. POST to `http://localhost:4321/api/signal/<receiver>` with `{ data }` — the receiver is a **path segment**, not a body field (`src/pages/api/signal/[receiver].ts`, with `[...receiver].ts` handling multi-segment names)
 3. Report: signal sent, response outcome (result / timeout / dissolved / failure), any path marks triggered
 
 ---

package/commands/db-sync.md

@@ -0,0 +1,55 @@
+# /db-sync — Sync production D1 → local miniflare
+
+Mirror the production `one-owners` D1 database into the local miniflare SQLite state.
+Run this any time local data goes missing (after a `git clean`, fresh checkout, or new worktree).
+
+## What it does
+
+1. Exports the remote `one-owners` D1 via `wrangler d1 export --remote`
+2. Drops all non-`_cf_` tables in the local SQLite file
+3. Imports the prod SQL dump via `sqlite3` (bypasses wrangler's SQLITE_TOOBIG limit)
+4. Re-inserts the local-only `one` workspace seed row (not in prod)
+
+## Prerequisites
+
+`CLOUDFLARE_EMAIL` and `CLOUDFLARE_GLOBAL_API_KEY` must reach `process.env`. Both
+are declared in `one.ie/web/.env`, and Bun auto-loads `.env` from the working
+directory — which is why every command below `cd`s into `one.ie/web` first. Run
+it from anywhere else and the script exits with
+`ERROR: CLOUDFLARE_EMAIL and CLOUDFLARE_GLOBAL_API_KEY must be set in env.`
+
+## One-shot command
+
+```bash
+cd /Users/toc/Server/one-ie/one.ie/web && bun scripts/sync-from-prod.ts --only=d1
+```
+
+Or via the npm script:
+
+```bash
+cd /Users/toc/Server/one-ie/one.ie/web && bun run db:sync
+```
+
+To also sync R2 content and KV namespaces (SESSION, CHAT_CACHE, THREADS) — slower, ~5–10 min:
+
+```bash
+cd /Users/toc/Server/one-ie/one.ie/web && bun run db:sync:all
+```
+
+## After sync
+
+No migrations to apply — the D1 export from prod includes the migration ledger and all schema.
+Local state will reflect prod exactly, plus the seeded `one` workspace row.
+
+Verify with:
+
+```bash
+sqlite3 /Users/toc/Server/one-ie/one.ie/web/.wrangler/state/v3/d1/miniflare-D1DatabaseObject/*.sqlite \
+  "SELECT 'owners', COUNT(*) FROM owners UNION SELECT 'messages', COUNT(*) FROM messages UNION SELECT 'threads', COUNT(*) FROM threads;" 2>/dev/null | grep -v metadata
+```
+
+## Why data gets lost
+
+`.wrangler/` is gitignored — it does not survive `git clean -fd`, a fresh worktree (`git worktree add`), or a fresh clone. The `/kill` command explicitly preserves it, but `git clean` doesn't know that.
+
+Run `/db-sync` whenever local feels stale or empty.