@oneie/claude 0.8.0 → 0.10.0

package/skills/deploy/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: deploy
+description: Run a deploy as tracked work — file the tasks template when the run opens, report each gate through deploy:event, and read what is still open or never ran. Use whenever a deploy is started, watched, or explained; when asked "did the tests actually run", "what is left in this deploy", "which gate bit", "why is the run still open"; or when wiring anything to the deploy tag. Refuses to call a run green while any gate is open. Does NOT ship — the ship door is release.sh.
+---
+
+# deploy — a deploy as work on a board, not lines in a log
+
+**Purpose:** every deploy files its own work as ten open rows the moment it
+starts, each owned by a named crew member, all joined by the run key the deploy
+page already reads. Closing gates close rows. Gates that never fire stay open.
+
+Source of truth: `one.ie/web/src/lib/deploy/event.ts` (the spine + mapper) ·
+`one.ie/web/src/lib/deploy/tasks.ts` (the template) · `schema/deploy.tql` (the
+questions) · promise: `text/deploy.md` · mechanism: `text/intake.md`.
+
+---
+
+## HARD RULES
+
+- **An unrun gate is never a pass.** `deploy.sh` distinguishes four states
+  (`pass|fail|unrun|n/a`) and a board that only knows open/done renders an unrun
+  gate exactly like one still in flight. A gate is UNRUN when
+  `deploy_gate_open($run,$stage)` is true and `deploy_gate_ran($gate,$target)` is
+  empty — you join the two, because TypeQL cannot concatenate `"deploy:"+stage`
+  and a function that pretended to would be vacuous. (It was, once: the first
+  `deploy_unrun` asked for a *signal* per gate, but `deploy:event` writes to D1
+  and paths, never a signal — so it returned every open gate, always.)
+- **Green means every gate CLOSED, never "none failed".** A run where four gates
+  never fired and none failed is **not** green. `deploy_green()` is defined as the
+  absence of open work precisely so this asymmetry cannot be argued with.
+- **File the template when the run OPENS.** Not as gates finish. Work that
+  appears only once it is done is a changelog, not a board — and a gate that
+  never runs would never get a row at all.
+- **Never retype the gate names.** `DEPLOY_SPINE_STEPS` is the authority; the
+  workflow diff, the event mapper and the tasks template all derive from it.
+  A fourth copy is how a ten-gate run quietly files nine rows.
+- **Bare words only.** The crew stakes are `health` (doctor), `ship`
+  (release-manager), `deploy` (ceo). A namespaced subscribe tag matches zero
+  signals and fails silently.
+- **Chain with `call`, never `await`.** `__awaitParent` is written at
+  `workflow-executor.ts:923` and read nowhere; `settle()` has no parent-resume
+  leg, so an `await` chain step parks its parent forever, looking exactly like a
+  slow step. Anything that runs after a deploy declares `deploy:done` as its own
+  `trigger_source`.
+- **A stale-but-clean tree makes every door script old.** `git status` clean says
+  nothing about how old `release.sh`/`land.sh`/`deploy.sh` are — measured
+  2026-09-14, the shared main tree was **479 commits behind `origin/main`** and
+  clean, so `promote` ran a pre-fix version and refused a valid sha **4×**. Check
+  first: `git rev-list --count HEAD..origin/main` — non-zero is exactly how many
+  commits old the script you are about to run is.
+- **`git merge-base --is-ancestor` proves REACHABLE, not EXECUTING.** Ancestry is
+  a fact about the ref; which code runs is a fact about the checkout. A commit
+  can be an ancestor of `main` and absent from the tree whose script you invoked.
+- **A non-run must never read as a pass.** `gate-run.sh` exits **127** when its
+  target is not on `PATH` (mechanism unconfirmed: govern.ts spawns with no env override, so PATH should inherit — measured anyway, twice) — invoke by
+  absolute path. And never pipe a gate through `tail`: measured 2026-09-14,
+  `verify` exited 1 while the pipeline reported **0**. `PIPESTATUS[0]`, or no pipe.
+- **This skill does not ship, and neither do you.** It tracks. The ship is driven
+  by **`release-manager`**, spawned as a subagent with `model: "opus"` — that holds
+  however the ask arrived, `/deploy` or "ship it" in a sentence
+  (`../../CLAUDE.md § The dev → prod loop` · `.claude/commands/deploy.md`). This
+  skill reads what that agent reports and says what is still open. Production ships
+  from `.release/` via `release.sh ship`; `./deploy --allow-dirty` ships every
+  neighbour's uncommitted file and must never be suggested.
+
+---
+
+## The ten gates and who owns them
+
+| # | Gate | Owner | The question it asks |
+|---|---|---|---|
+| 1 | `tree` | doctor | Can a receipt bind to this tree? A dirty tree hashes differently every second. |
+| 2 | `credentials` | doctor | Are the secrets actually present — not merely named in a config? |
+| 3 | `typecheck` | release-manager | Zero new type errors. The ratchet tightens, never loosens. |
+| 4 | `tests` | release-manager | Did the FULL lane run, or be REUSED from a receipt for an identical tree? |
+| 5 | `build` | release-manager | Does each target produce an artifact? A skipped build is not a passed build. |
+| 6 | `smoke` | release-manager | Does it answer locally? The last cheap red. |
+| 7 | `approval` | **human** (ceo notified) | The one gate no agent closes. |
+| 8 | `migrations` | release-manager | Applied in order, and is the rollback known? |
+| 9 | `ship` | release-manager | Shipped from `.release/`, where the receipt binds. |
+| 10 | `health` | doctor | Do all five targets answer after the ship? "Deployed" is not "healthy". |
+
+---
+
+## The wire
+
+```
+signal("deploy:event", {
+  run,            // the deploy's own id — the stamp in deploy.sh's log name
+  target,         // one-prod | one-dev | pay | channels | api
+  stage?,         // one of DEPLOY_SPINE_STEPS
+  status?,        // start | ok | fail     (there is deliberately no `skip`)
+  verdict?,       // green | red — final call only, closes the run
+  sha?, door?, reason?, wallMs?, detail?
+})
+```
+
+The run key is `deploy:<target>:<run>` (`deployRunKey`) — id **and**
+idempotency_key, so a double-write returns the same row. It is also the `run:`
+tag on every task the template files, so one string joins the board, the run
+list and every `deploy_*()` function. **Never mint a second run-scoped key.**
+
+Tasks are idempotent by a `slug:<runKey>:<stage>` tag — `tasks:create` returns
+the existing row rather than inserting a twin, so a retried deploy does not pile
+up duplicates. No dedupe logic to write.
+
+---
+
+## Asking the substrate
+
+| Question | Function |
+|---|---|
+| What is left? | `deploy_open($run)` · `deploy_open_count($run)` |
+| **What never ran?** | `deploy_gate_open($run,$stage)` ∧ NOT `deploy_gate_ran($gate,$target)` |
+| Is it actually green? | `deploy_green($run)` |
+| What can run now? | `deploy_ready($run)` |
+| What is waiting on something? | `deploy_blocked($run)` |
+| Which gate next? | `deploy_next($run)` — the ant's pick, strongest net trail |
+| What does the doctor still owe? | `deploy_crew_open($run, "health")` |
+| Which gate keeps biting? | `deploy_gate_trail($gate,$target)` — net, across runs |
+
+`schema/deploy.tql` is **functions only, zero new types** — the `story.tql`
+pattern. A deploy is the set of signals and tasks sharing one run key: a count,
+not an entity. Never add a `deploy-run` entity; the row already exists.
+
+---
+
+## Reporting a deploy honestly
+
+When asked how a deploy went, say in this order:
+
+1. **Verdict** — green/red, and green only if `deploy_open_count() == 0`.
+2. **Unrun gates, named.** If any, the run is not green no matter what the
+   verdict field says. Say which.
+3. **Which lane the tests took** — full, or REUSED from a receipt. A fast pass
+   is never reported as a full pass.
+4. **What bit**, in the gate's own words (`reason`).
+
+Never report "deployed" as "healthy" — gate 10 is a separate question, and
+`deploy.astro` probes it live rather than trusting the ship.

package/skills/fleet-audit/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: fleet-audit
+description: How to run multi-fleet agent audits without contradiction — probe before reading, shared measurement pack, one join fleet, default REFUTED, fleet-prompt rules. Use when the operator opts into multi-agent audits or fleets.
+---
+
+# Multi-fleet audits — how the 2026-08-25 launch audit actually worked
+
+When the operator opts into multi-agent work, this shape holds up. Six fleets ran
+concurrently from one window without contradicting each other.
+
+**1. Probe before you read.** Every launch-blocking finding that day came from a
+live probe; not one would have been caught by reading source. The codebase is
+honest about intent and silent about reachability — *declared ≠ wired ≠ configured
+≠ reachable ≠ working from this egress IP*. Mint a real checkout to learn the
+Stripe mode. Read a D1 **count** (`2 of 68`) to learn if a feature is used. Probe a
+third-party API **from where the code runs** — Solana's public RPC 403s CF egress
+and serves a laptop happily. Treat any `/status` route as a claim: `pay/backend/src/routes/status.ts:37`
+hardcodes its chain list as a literal array.
+
+**2. Synchronise by shared evidence, not by orchestration.** Build ONE measurement
+pack of file:line facts, then embed it verbatim in every fleet prompt. Fleets given
+identical facts cannot drift; fleets given only a task description will.
+
+**3. One fleet is the join.** A final fleet folds every other fleet's findings back
+into `text/one.md`, which already carries the rule: *the specific doc wins and the
+spine gets reconciled.*
+
+**4. Default REFUTED on every verify, and demand the quoted stopping line.** "No
+quotable line ⇒ not proven" is what catches plausible-but-wrong fixes.
+
+**5. Two instances of one defect shape ⇒ fix the seam, never the sites.** Two
+unrelated fleets hit the same unenforced-auth-label bug. That is a root cause and a
+base rate, not two bugs — patching both sites would have left ~300 receivers open.
+
+**6. Kill a fleet the moment its premise dies.** When the design changed from
+"convert a stranger" to "an agent provisions the account", the in-flight blocker
+fleet was still building an *anonymous checkout* — the exact unauthenticated write
+path every other verifier was hunting. Stop it; discard the worktree.
+
+**Four rules for the fleet prompts themselves:**
+
+- **Never let a fleet spend money to prove a point.** One audit billed ~$0.215 of
+  real DataForSEO credit demonstrating an anonymous-spend hole. Correct finding,
+  wrong method — once the first call proves the door is open, reason from code, and
+  say so in the prompt.
+- **Never simulate a run and report it as one.** Instruct explicitly: *if you
+  cannot execute for real, say so and STOP.* A fabricated run report poisons every
+  decision downstream of it.
+- **Give a legitimate "no change needed" exit.** Telling one fleet that "leave it
+  gated, fix the funnel order" was an acceptable answer stopped it punching a hole
+  in the payment path to make a landing page prettier.
+- **Name the forbidden sentence.** For anything customer-facing, have the fleet
+  emit the sentences that would be FALSE, quoted verbatim, so nobody ships them by
+  accident. This is what caught "Google recovers your wallet".
+
+**Isolation:** worktrees for writers only; doc-only and read-only fleets don't need
+one. Watch for a fleet editing shared `main` — that is how a neighbour's work gets
+swept into the wrong commit.

package/skills/meeting/SKILL.md

@@ -0,0 +1,220 @@
+---
+name: meeting
+description: Host a meeting in /u/<slug>/in where heads claim, delegate, chat and chain rows — not report. Use whenever the chairman (or any convener) convenes heads on a plan, a board, a blocker, or a launch — "hold a meeting", "convene the team", "get the heads on this", "chairman hosts", "everyone claims tasks", "chain these tasks together", "run the board meeting". Writes a measurement pack, opens ONE thread, spawns heads that must each leave with a tid, and closes with a ledger read back from D1. Refuses a meeting whose output is a document and no moved row.
+---
+
+# meeting — the room where rows move
+
+**Purpose:** a meeting is not where heads report. It is where they **take a row, hand a row,
+argue on the row, and put the rows in order** — claim · delegate · chat · chain. The output is
+the board's diff, not a document.
+
+Shape: `text/template-meeting.md` — **copy it, never write a meeting from scratch.**
+
+```
+cp text/template-meeting.md text/meeting-<subject>-<yyyy-mm-dd>.md
+```
+
+**Why this skill exists, measured.** On 2026-09-11 four capable agents ran a full board meeting,
+produced the best design document in the estate, and **closed zero rows** — net effect **+3**.
+On 2026-09-12 five heads were spawned into a session budget that could not carry them and **all
+five died mid-orientation**, before one number was reported. Both failures are in the template's
+rules. Neither was a failure of the heads.
+
+---
+
+## §0 — THE FOUR LAWS
+
+1. **The room is `/u/<slug>/in`, and there is ONE thread.** A meeting in a session transcript did
+   not happen. A meeting whose record lives in `/tmp` dies with the session.
+2. **Heads talk to each other, not to the convener.** Cross-examination (§4) is mandatory. Four
+   heads reporting upward and never reading each other is four interviews, not a meeting.
+3. **A document is not a deliverable. A moved row is.** Grade every attendee on the board, not
+   the prose.
+4. **Size the spawn to the budget before you write a brief.** Two heads that finish beat five
+   that die. The convener checks capacity first; a rate-limited head reports nothing at all.
+
+---
+
+## §1 — THE DOORS  (measured; do not improvise)
+
+| Purpose | Door |
+|---|---|
+| post to the room | `thread:append` → `{"data":{"slug":"one","group":"space:one","sender":"<agent>","role":"assistant","content":"..."}}` |
+| chat on a row | `tasks:comment` → `{"data":{"tid":"task:<24hex>","workspace":"one","body":"..."}}` |
+| claim | `tasks:claim` → `{"data":{"tid":"task:<24hex>","workspace":"one"}}` **then** `tasks:reassign` → `{"data":{"tid":"…","assignee":"<your slug>","workspace":"one"}}` — under the shared gateway key every head claims as `@one`; the reassign is what puts YOUR name on the row. One act, two calls |
+| delegate, in place | `tasks:reassign` → `{"data":{"tid":"...","assignee":"<slug>","workspace":"one"}}` |
+| delegate, to the world | `tasks:announce` → `{"data":{"taskId":"...","tags":["bare","words"],"workspace":"one"}}` |
+| chain — split | `tasks:subtask` → `{"data":{"parent":"task:...","title":"...","blockedBy":["task:..."],"workspace":"one"}}` |
+| chain — order | `tasks:depend` → `{"data":{"tid":"<blocked>","blockedBy":"<blocker>","workspace":"one"}}` |
+| close | `tasks:status` → `{"data":{"tid":"...","status":"done","workspace":"one"}}` |
+| see the whole board | `tasks:board` → `{"data":{"workspace":"one","view":"summary","scope":"tree"}}` first (exact `total`, ready/blocked sets, counts — no rows), then `{"data":{"workspace":"one","ready":true,"tags":["<tag>"]}}` for rows; follow `nextCursor`, and say so if `truncated` is present |
+| act on many rows | `tasks:bulk` → `creates` (with `ref`s) / `edits` / `where`+`set` — `where` is **dryRun by default**; put a `comment` on every change so the thread records why |
+| read the rungs by tag | `tasks:list` → `{"data":{"workspace":"one","tag":"<tag>"}}` — exact tag, any string (`plan:<slug>` for a /do plan's cycle rows), uncapped; answers `{tid,status,name}` only, no assignee |
+
+All writes: `POST https://one.ie/api/ask/<receiver>`, `Authorization: Bearer $GATEWAY_API_KEY`
+(from `one.ie/web/.dev.vars`, **not `.env`** — prod refuses the `.env` key), body wrapped in
+`{"data":{…}}` or you get `envelope_missing`.
+
+**Read a post back from D1 before claiming it landed:**
+
+```bash
+cd one.ie/web && npx wrangler d1 execute one-owners --remote --json --command \
+  "SELECT id, role, length(content_json) AS len, substr(content_json,1,80) AS head, ts \
+   FROM messages WHERE thread_id='<THREAD>' ORDER BY ts DESC LIMIT 5"
+```
+
+### The doors that lie
+
+- **BANNED — `space:post` and `chat:send`.** Both return `ok:true` and write **zero rows**;
+  `live:0` is the tell. Six chairman reports were lost to `space:post` on 2026-09-11.
+- **`tasks:notes` with an absent `notes` field CLEARS the row.** Reading a note deletes it.
+- **`tasks:comment` truncates at 4000 bytes**, silently, and still returns `ok:true`.
+- **`tasks:everywhere` is a follow-scoped queue, not the board** — it sorts by weight DESC and
+  ignores the `tag` argument, so a weight-0 row can sit below any page. On 2026-09-12 fifteen
+  filed rungs were invisible on that read, which is why they had all sat open. **See the board
+  with `tasks:board`** (`total` is exact, `truncated` names any cut), or read rungs with
+  `tasks:list` by tag. MCP `tasks_list` is one page of `/api/things` — never the whole board.
+- **Only the FIRST `@mention` in a comment creates a follow** (no `g` flag,
+  `resolvers/tasks.ts:1899`). Three heads pulled in = three separate comments.
+- One shape under all of these: **a boundary that is silent on the way past it.** Report the cap
+  you hit, always.
+
+---
+
+## §2 — THE PRE-READ  *(the convener writes this BEFORE any head is spawned)*
+
+ONE measurement pack, identical for every attendee, **embedded verbatim in every brief.** Heads
+given the same facts cannot drift; heads given only a task description always will.
+
+- [ ] Every number carries the command that produced it.
+- [ ] Every claim from a doc or a task note is marked **UNVERIFIED** until re-measured. Stale
+      notes are the norm.
+- [ ] The pack states what the convener did **not** check.
+- [ ] The board's open count is recorded, **with the door that produced it** — a capped read is
+      not a count.
+- [ ] Capacity checked. Name how many heads the budget carries, and spawn that many.
+
+**THE ONE QUESTION** — one sentence. If you cannot write it, you are calling a status update.
+
+---
+
+## §3 — ROUND 1 · WHAT EACH HEAD MEASURED
+
+```
+@<head> — ROUND 1
+MEASURED:    <number> — <the exact command>
+REFUTES:     <which pack line this contradicts, or "nothing">
+DID NOT RUN: <every check skipped — an unrun check is not a pass>
+I WAS WRONG ABOUT: <anything from earlier, corrected>
+```
+
+**Default REFUTED.** No quotable stopping line ⇒ not proven. A head that reports its own error
+unprompted is doing the job.
+
+---
+
+## §4 — ROUND 2 · CROSS-EXAMINATION  *(the round that makes it a meeting)*
+
+Mandatory. The convener does **not** relay it — heads post at each other.
+
+```
+@<head> → @<other-head>
+YOUR NUMBER: … / MY NUMBER: … / THE GAP: <scoping? door? stale read?> / WHO RECONCILES: <name>
+```
+
+On 2026-09-11 one head measured **13** dependency edges and another **259**. Both competent;
+neither had read the other. 13 was not a substrate count — it was what a door surfaced, ~5% of
+the graph. That gap was the day's most important finding and nearly went unnoticed.
+
+- [ ] Every contested number is reconciled or **explicitly parked with a named owner**.
+- [ ] **Nobody quotes a contested number at the board until it is reconciled.**
+
+---
+
+## §5 — CHAIN THE WORK  *(before anyone fans out)*
+
+**Chaining is not bookkeeping — it is what makes the board sequence itself.** `tasks:claim` is
+**blocker-gated**, and `tasks:depend` writes the very `blocks` edge that gate reads. An unchained
+board hands every head every row at once and nothing knows what comes first. **Chain first, or
+the fan-out is a race.**
+
+| verb | use |
+|---|---|
+| `tasks:subtask` | split a rung — writes row + notes + tags + `containment` + every `blockedBy` in ONE pipeline, so a child never appears claimable with an empty body or missing ordering |
+| `tasks:depend` | order two existing rows. Refuses a self-edge and a reverse edge, so a cycle cannot be filed |
+
+**Never split with `tasks:create`** — a child made that way is an orphan somebody claims before
+it is ready.
+
+Two rules keep a chain honest, and they are one rule twice:
+- **A child's cast is a subset of its parent's.** Inherit by default, declare to narrow, **never
+  to widen.**
+- **Depth needs a floor.** A parent spawning children while none settle is a leak, not a big
+  plan. Freeze the parent's outcome before children mint; let `fade`/`warn` decay what goes quiet.
+
+---
+
+## §6 — DECISIONS
+
+| # | Decision | Owner | Recommendation + the measured reason | tid |
+|---|---|---|---|---|
+
+Split honestly:
+- **Human-only** — needs a credential, money, or a judgement no measurement settles. **List these
+  first, each with a recommendation.** The highest-value output of any meeting is the short list
+  of decisions only the operator can make, each made cheap to answer.
+- **Head-owned** — if it reached the convener, it was mis-routed. Hand it back.
+
+---
+
+## §7 — CLOSE · EVERY HEAD LEAVES WITH A TID
+
+| Head | tid | Action | If not closed: the ONE thing that would close it |
+|---|---|---|---|
+
+Five honest exits, graded differently:
+
+| | |
+|---|---|
+| **closed** | the row is done and proven |
+| **claimed** | taken, in flight, named |
+| **delegated** | handed on with `tasks:reassign` — **name who to.** Never by filing a second row |
+| **chained** | split or ordered — **name the parent and the edge** |
+| **declined** | refused on principle, **with an argument**. Sometimes the best act available |
+| **blocked** | by something measured and **named** with a tid or `file:line`. "Blocked" with no named blocker is a shrug |
+| **stale** | the row describes a problem that no longer exists. **This IS a close**, often the best outcome. Prove it |
+| ⚠️ **artifact, not outcome** | produced a document instead of a change. A failure, however good the document — and the one that most looks like success |
+
+---
+
+## §8 — THE LEDGER  *(the convener posts it; it is the minutes)*
+
+```
+MEETING: <subject>    THREAD: <id>    ROWS: <before> → <after>
+CLOSED:     <tids>
+CLAIMED:    <tid — head>
+DELEGATED:  <tid — from → to>
+CHAINED:    <parent tid → child tids, and the blockedBy edges>
+BLOCKED ON A HUMAN: <tid — the decision, one line>
+STILL OPEN: <tid — why, named>
+I GOT WRONG: <the convener's own errors, FIRST>
+```
+
+Read the ledger back from D1 and quote the row. **The convener is graded too, by name.** A
+chairman who edits their own record is worth nothing. If a brief asked for a *report*, the open
+row is a **convener** failure — what you ask for is what you get.
+
+---
+
+## Checklist — the convener runs this or the meeting does not start
+
+- [ ] §2 pack written, one copy, embedded verbatim in every brief
+- [ ] THE ONE QUESTION in a single sentence
+- [ ] Capacity checked; spawn count sized to the budget
+- [ ] Thread opened with `thread:append` **and read back from D1**
+- [ ] Every brief says **CLAIM · DELEGATE · CHAIN · CLOSE** — never "report" or "return a summary"
+- [ ] §4 cross-examination named as mandatory in every brief
+- [ ] §5 chaining done before fan-out
+- [ ] Board open count recorded before, with the door named
+- [ ] §8 ledger posted, read back, convener's own errors first