@oneie/claude 0.6.0 → 0.8.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

@@ -20,11 +20,17 @@ Three spaces wired by default:
 /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
 ```
 
+`read` with no group reads your default space; `read <group>` reads one named
+space. Requires `bash`, `curl`, and `jq` on PATH.
+
 **→ Use `/chat` for the simple two-key interface: read = fan in, send = fan out.**
 
 ## How to invoke

package/commands/chat.md

@@ -32,4 +32,16 @@ Want a desktop popup when something lands? `brew install terminal-notifier` (one
 
 ## Advanced (raw commands, rarely needed)
 
-`/chat` is a shortcut for `.claude/scripts/cc-connect.sh`. 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.
+`/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,22 +41,39 @@ 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
-   - **integration**: every declared surface wired — nav + inbound links + SDK/MCP/CLI exports + docs (deterministic from `.w2-surface-checklist.json`)
-   - **speed**:      Lighthouse held, bundle ≤ W0, tokens lean, cache hit ≥ 80%
-   - composite: `0.30·security + 0.25·stability + 0.20·simplicity + 0.15·integration + 0.10·speed`
-2. POST `http://localhost:4321/api/tasks/{id}/complete`
-3. POST `http://localhost:4321/api/mark-dims` with `{ security, stability, simplicity, integration, 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>",
@@ -72,10 +89,18 @@ This is Rule 1 enforced at the human boundary.
    ```
    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. **Settle the promise** — if the slug has a promise (`text/<slug>.md` with a `proof:`), run
+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; non-zero
-   → `warn`; no observable → dissolved (reported, never silent). If the promise was minted on-chain
+   → `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
@@ -105,7 +130,7 @@ This is Rule 1 enforced at the human boundary.
 
 ### `--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:
    ```
@@ -115,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:
    ```
@@ -125,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:
    ```
@@ -136,8 +161,9 @@ 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

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 that best-effort-POSTed `/api/tasks/sync` was removed
+2026-09-05 — it only ever no-op'd.
 
 ## Steps
 
@@ -36,29 +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
@@ -71,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

@@ -12,7 +12,11 @@ Run this any time local data goes missing (after a `git clean`, fresh checkout,
 
 ## Prerequisites
 
-`CLOUDFLARE_EMAIL` and `CLOUDFLARE_GLOBAL_API_KEY` must be in env (both are in `.env` — already loaded in your shell).
+`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