@oneie/claude 0.6.0 → 0.7.0

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 still best-effort-POSTs `/api/tasks/sync` and silently
+no-ops — known drift, not a working wire.
 
 ## 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