@oneie/sdk 0.14.14 → 0.15.1

package/dist/receivers.js

@@ -159,6 +159,12 @@ export const RECEIVERS = {
         summary: "Agency mints a scoped invite; on accept the invitee owns a new workspace parented under the agency",
         request: z.object({
             slug: z.string(),
+            // The invitee's slug. Prefer this over `slug`: a trusted service caller
+            // nominates its OWN workspace with `slug` (the ask route reads payload.slug
+            // as the caller identity), so naming the invitee there self-parents the
+            // invite and mints credits against no sponsor. Refused server-side when the
+            // resolved child equals the sponsor.
+            child: z.string().optional(),
             name: z.string().optional(),
             email: z.string().email().optional(),
             plan: z.enum(["free", "pro", "studio", "agency", "enterprise"]).optional(),
@@ -170,7 +176,7 @@ export const RECEIVERS = {
         }),
         response: z.object({ token: z.string(), id: z.string(), child: z.string(), expiresAt: z.number() }),
         effect: "ask", auth: "manage_clients", reversible: false,
-        examples: [{ slug: "beta", email: "owner@beta.com", plan: "studio", credits: 50000, markup: 20 }],
+        examples: [{ slug: "one", child: "beta", email: "owner@beta.com", plan: "studio", credits: 50000, markup: 20 }],
     }),
     "world:accept-client-invite": receiver({
         receiver: "world:accept-client-invite",
@@ -239,6 +245,61 @@ export const RECEIVERS = {
         request: z.object({ gid: z.string(), name: z.string().optional(), tags: z.array(z.string()).optional(), meta: z.unknown().optional() }),
         response: ok, effect: "ask", auth: "manage_groups", roleAction: "update_group",
     }),
+    /**
+     * The only non-HTTP door to a workspace's brand. Tokens previously reached R2
+     * through `pages/api/{branding,settings,onboarding}.ts` only, so a workflow
+     * step, an agent, the CLI and MCP could not persist a theme at all.
+     *
+     * `auth: "manage_workspace"` is chosen because it is already in
+     * bind-receiver.ts's AUTH_POLICY mapping to the ENFORCED `tenant` class — an
+     * invented label would fall through `AUTH_POLICY[label] ?? 'authenticated'`
+     * to the WARN-only class and ship a workspace write with no enforced floor.
+     *
+     * `cost: "free"` is a declaration, not an omission: an R2 read+put costs no
+     * provider dollars, and per text/credit-allocation.md an UNDECLARED cost must
+     * not read as free. `reversible: false` is honest — the response reports which
+     * keys were written but not their prior values, so the caller cannot restore
+     * them from it. Handler: one.ie/web/src/lib/resolvers/brand.ts.
+     *
+     * The write is held to WCAG AA by the SAME `auditBrandContrast` the brand
+     * editor route calls, so a theme written by a workflow step meets the bar a
+     * human-written one does.
+     */
+    "world:set-brand-tokens": receiver({
+        receiver: "world:set-brand-tokens",
+        summary: "Write validated colour tokens to a workspace's brand (site.md)",
+        request: z.object({
+            /** The workspace being rebranded. The ONLY workspace field: authority is
+             *  decided against this value and it is the only one written to. */
+            workspace: z.string(),
+            /** Frontmatter keys to set. The six light tokens (primary, secondary,
+             *  tertiary, background, foreground, font) and their `dark-` overrides;
+             *  any other key is ignored, never written. `"unset"` on a `dark-` key
+             *  deletes the override, re-linking it to the light value. Values are
+             *  syntax-gated with the same HEX_OR_HSL regex `parseSite` reads with, then
+             *  checked readable with `parseColor`, then held to WCAG AA by the same
+             *  `auditBrandContrast` the brand editor route calls. Any invalid value —
+             *  or any AA failure on a pair THIS write touches — refuses the WHOLE
+             *  write; pre-existing failures come back as `warnings`. */
+            tokens: z.record(z.string(), z.string()),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            workspace: z.string().optional(),
+            written: z.array(z.string()).optional(),
+            bytes: z.number().optional(),
+            ignored: z.array(z.string()).optional(),
+            error: z.string().optional(),
+            invalid: z.array(z.object({ field: z.string(), value: z.string(), reason: z.string() })).optional(),
+            /** WCAG AA pairs THIS write touches that fail — the write is refused. */
+            failures: z.array(z.record(z.string(), z.unknown())).optional(),
+            /** Pairs it leaves alone that already fail — reported, never blocking. */
+            warnings: z.array(z.record(z.string(), z.unknown())).optional(),
+        }),
+        effect: "ask", auth: "manage_workspace", roleAction: "update_group",
+        cost: "free", reversible: false, idempotent: true, settles: "none",
+        examples: [{ workspace: "acme", tokens: { primary: "#1a73e8", "dark-primary": "#8ab4f8" } }],
+    }),
     "world:remove-group": receiver({
         receiver: "world:remove-group",
         summary: "Delete a group",
@@ -913,6 +974,16 @@ export const RECEIVERS = {
             board: z.literal("marketplace").optional(),
             slug: z.string().optional(),
             workspace: z.string().optional(),
+            // Rides through unchanged to buildMessage (string field, unaffected)
+            // and is what lets an inbox card show a title instead of a bare tid.
+            title: z.string().optional(),
+            // The structured envelope (`web/src/lib/signal-meta.ts SignalMeta`) —
+            // an object, so buildMessage's string/number-only flatten drops it from
+            // the text body by construction. Declared loosely here (not the exact
+            // shape) because this is the ONE cross-cutting schema every announce
+            // caller reuses; a stricter zod object would have to be kept in lockstep
+            // with the TS type by hand.
+            meta: z.record(z.string(), z.unknown()).optional(),
         }),
         response: z.object({ ok: z.boolean(), taskId: z.string().optional(), matched: z.number().optional(), actors: z.array(z.string()).optional() }),
         effect: "ask",
@@ -967,6 +1038,11 @@ export const RECEIVERS = {
                 name: z.string(),
                 tags: z.array(z.string()),
                 weight: z.number(),
+                // Shipped by the resolver (subscriptions.ts § tasks:everywhere) and undeclared
+                // until now. The response check is WARN-only (bind-receiver.ts:247), so the
+                // field arrived while the contract denied it — and every reader generated FROM
+                // the contract (metaSchema, the MCP tool schema, OpenAPI) could not see it.
+                priority: z.number().optional().describe("Task priority; the ranking input behind `weight`"),
                 notes: z.string().optional(),
                 contextDocs: z.array(z.string()).optional(),
                 workspace: z.string(),
@@ -978,6 +1054,10 @@ export const RECEIVERS = {
                 offeredByMe: z.boolean(),
                 closedAt: z.string().optional(),
             })),
+            // A cap that reports itself (the /api/things standard). The old 200 clamp
+            // was silent: a 595-row queue came back as 200 rows and read as complete.
+            total: z.number().optional().describe("Visible rows before the limit was applied"),
+            truncated: z.boolean().optional().describe("true = more rows exist than were returned; raise limit or use tasks:board"),
         }),
         effect: "ask", idempotent: true,
     }),
@@ -1045,6 +1125,39 @@ export const RECEIVERS = {
         }),
         effect: "ask", idempotent: true, reversible: true,
     }),
+    "factory:recon": receiver({
+        receiver: "factory:recon",
+        summary: "What does this sentence touch — the paths, the route and the verdict `.claude/scripts/do-triage.sh` returns for the same text, answered where a Worker can ask (a Worker cannot exec a shell script, which is the only reason the recon card at factory flow.ts:480 was a gap). Runs UPSTREAM of factory:size: prose in, repo paths out, and the sizer's own contract unchanged. No model call. It ALWAYS answers with a verdict and never refuses — it runs as a workflow tool step (one.ie/ai/workflows/eng-intake.tql:33), where a failed step poisons every step downstream of it; factory:size's `unsized` stays the one refusal on this lane",
+        request: z.object({
+            // The captured sentence. do-triage reads what the text LITERALLY names —
+            // there is no model here, so a sentence that names nothing answers `idea`.
+            intent: z.string().max(2000),
+            // Paths a caller already knows. Accepted so a workflow step can pass the
+            // trigger through whole; recon derives its own from `intent` and does not
+            // widen the answer with these.
+            paths: z.array(z.string()).max(2000).optional(),
+            // The trigger's tags, carried not read. Declared for one measured reason:
+            // zod `.object()` STRIPS unknown keys, so an undeclared field arriving from
+            // a workflow step is a shape error rather than a no-op. It decides nothing —
+            // same rule as factory:size's `workspace`: a body field that decided nothing
+            // cannot be spoofed into deciding something.
+            tags: z.array(z.string()).max(64).optional(),
+        }),
+        response: z.object({
+            // Always true. There is no `ok:false` branch in this receiver.
+            ok: z.boolean(),
+            verdict: z.enum(["sizeable", "idea", "dupe", "split"]).optional(),
+            // Repo-relative, existing, in the order the sentence names them. This is the
+            // array that goes to factory:size unchanged.
+            paths: z.array(z.string()).optional(),
+            route: z.string().nullable().optional(),
+            // Every path-SHAPED token the sentence named, before the existence filter.
+            // The edge can confirm fewer paths than the shell can (it has a page glob,
+            // not a repo), and this is that difference made legible rather than hidden.
+            named: z.array(z.string()).optional(),
+        }),
+        effect: "ask", idempotent: true, reversible: true,
+    }),
     "factory:attempt": receiver({
         receiver: "factory:attempt",
         summary: "Open an attempt contained by its task, or close it with the production edge to what it produced plus the rubric. A do-cycle IS an attempt (factory-plan.md §3.1) — do:cycle-close arms as a caller of the close phase, never as a second writer",
@@ -1084,6 +1197,73 @@ export const RECEIVERS = {
         }),
         effect: "ask", idempotent: true,
     }),
+    "deploy:event": receiver({
+        receiver: "deploy:event",
+        summary: "One deploy gate lands on the same run/event stream the canvas already reads — the ten-gate pipeline (tree·credentials·typecheck·tests·build·smoke·approval·migrations·ship·health) that until now touched the substrate NOWHERE, leaving a committed JSON file as a deploy's only trace. Carries the metrics that file has no shape for: whether the suite was REUSED or re-run, whether a gate passed under a waiver, and which services actually shipped. An unknown stage, status or verdict is REFUSED, never recorded as a default frame",
+        request: z.object({
+            // The deploy's own run id — deploy.sh already mints one for its log name.
+            // It IS half the run key, which is why a retried gate appends to its own
+            // run instead of minting a second one. The sha cannot serve: the same sha
+            // ships to the same target repeatedly (2026-09-06: af3ba5919 gates-only,
+            // red, green, then shipped), and keying on it would interleave them.
+            run: z.string(),
+            // Where it ships. The other half of the key, so "did pay go out" is
+            // answerable without disambiguating five services by timestamp.
+            target: z.string(),
+            // Must equal DEPLOY_SPINE_STEPS (one.ie/web/src/lib/deploy/event.ts).
+            // Retyped because packages/sdk cannot import from one.ie/web; pinned by
+            // tests/unit/deploy/event.test.ts so the two cannot drift.
+            stage: z.enum([
+                "tree", "credentials", "typecheck", "tests", "build",
+                "smoke", "approval", "migrations", "ship", "health",
+            ]).optional(),
+            // There is deliberately no "skip": a gate that did not run must be ABSENT.
+            // deploy.sh already reports four gate states (pass|fail|unrun|n/a) and an
+            // unrun gate is never a pass — a "skip" frame would render like one.
+            status: z.enum(["start", "ok", "fail"]).optional(),
+            // Present only on the final call, and it is what CLOSES the run. Separate
+            // from the stages because --gates-only is a complete, successful run that
+            // legitimately never reaches `ship` or `health`; closing on the last stage
+            // would leave every one of those runs "open" forever.
+            verdict: z.enum(["green", "red"]).optional(),
+            sha: z.string().optional(),
+            // Which door ran it: ./deploy, release.sh ship, land --pr --deploy.
+            door: z.string().optional(),
+            // Board workspace. TAGS ONLY inside the resolver — effectiveWorkspace
+            // reads `workspace` and never `slug`. The same caller-nomination note as
+            // factory:event's `slug` field applies verbatim for a service caller.
+            slug: z.string().optional(),
+            // "dev" flags the projected run is_test so dev.one.ie never pollutes the
+            // production list. --dry-run does not reach here at all: the emitter is
+            // not called on that path, because a run row for a deploy that did not
+            // happen is the theater /deploy already refuses to render.
+            env: z.string().optional(),
+            reason: z.string().optional(),
+            // This gate's own wall clock. Written to workflow_run_event.latency_ms —
+            // the column factory:event binds NULL because a factory stage has no
+            // measured duration. It is the number this whole receiver exists for.
+            wallMs: z.number().optional(),
+            // reused / waived / services — see DeployEventPayload.detail.
+            detail: z.record(z.string(), z.unknown()).optional(),
+            workspace: z.string().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            runId: z.string().optional(),
+            stage: z.string().optional(),
+            status: z.string().optional(),
+            verdict: z.string().optional(),
+            events: z.number().optional(),
+            slug: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        // Same floor and same reasoning as factory:event: authClassFor(undefined)
+        // returns 'open', and the 'authenticated' floor tests exactly the predicate
+        // the handler's own guard uses, one layer earlier. Declaring it makes the
+        // fail-closed intent survive a refactor of the handler.
+        auth: "required",
+        effect: "ask", idempotent: true,
+    }),
     "factory:event": receiver({
         receiver: "factory:event",
         summary: "One factory-executor stage lands on the same run/event stream the canvas already reads — the six-stage pipeline (ready·claim·build·review·prove·close) that until now touched the substrate only at claim and close, so every surface could show a job before and after but never during. An unknown stage or status is REFUSED, never recorded as a default frame",
@@ -1160,6 +1340,171 @@ export const RECEIVERS = {
         // a dedupe. The RUN row dedupes (INSERT OR IGNORE); the events do not.
         effect: "ask", idempotent: false,
     }),
+    // ── ehc: ───────────────────────────────────────────────────────────────────
+    //
+    // The first member of this namespace, and it sets the convention: an `ehc:`
+    // receiver acts on ONE named child's plan, and the child's address comes from
+    // the case registry (`one.ie/web/src/lib/ehc/address.ts`), never from a string
+    // a caller typed.
+    //
+    // Read the summary as a limit, not a feature list. This door cannot record a
+    // CYP's own words \u2014 it accepts no voice key, so every record it writes is a
+    // proxy record and renders as MARKED INTERPRETATION naming the adult. A child
+    // speaks through the page that minted their credential. An agent-class caller
+    // is refused outright: Section A is what a child said or an adult's marked
+    // account of what a child communicated, and a generated sentence is neither.
+    "ehc:voice-record": receiver({
+        receiver: "ehc:voice-record",
+        summary: "Record what a child or young person communicated into Section A of their EHC plan, as MARKED INTERPRETATION attributed to the attested adult who recorded it. Authorship is derived from the credential and never from the payload; an agent-class caller is refused (machines do not speak for children); a case that is not synthetic is refused pending a data-residency decision (Article 9 special category data)",
+        request: z.object({
+            cyp: z.string(), // case id, e.g. 'cyp-005' \u2014 resolved through the registry
+            body: z.string(), // exactly what was communicated. Never smoothed.
+            proxyRole: z.string().optional(), // 'parent' | 'keyworker' | 'advocate' \u2014 shown to every reader
+            prompt: z.string().optional(), // which portal question this answers
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            id: z.string().optional(),
+            provenance: z.string().optional(), // always 'proxy-observed' from this door
+            saidAt: z.string().optional(),
+            error: z.string().optional(), // 'not_found' | 'residency_undecided' | 'machines_do_not_speak_for_children' | 'no_voice' | 'empty' | 'too_long'
+            detail: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", reversible: false, idempotent: false, auth: "session",
+    }),
+    // The event a provision's `verification.closesOn` names (cases/cyp-001.ts H1).
+    // A receiver cannot be per-child, so the child rides in `cyp` and the instance
+    // name `ehc:<cyp>:meal-served` is what the event row carries. It records a
+    // human tick that a meal was SERVED — never that one was ordered.
+    "ehc:meal-served": receiver({
+        receiver: "ehc:meal-served",
+        summary: "A named adult ticks that a child was served a meal. Writes one event row named by the provision's closesOn (e.g. ehc:cyp-001:meal-served) attributed to the attested caller, never a payload field; refuses an agent-class caller, an unknown case, a non-synthetic case, and a case with no meal provision",
+        request: z.object({
+            cyp: z.string(), // case id, e.g. 'cyp-001' — resolved through the registry
+            meal: z.enum(["breakfast", "lunch", "tea"]),
+            servedOn: z.string().optional(), // YYYY-MM-DD; defaults to today (UTC)
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            id: z.string().optional(),
+            event: z.string().optional(),
+            provision: z.string().optional(),
+            meal: z.string().optional(),
+            servedOn: z.string().optional(),
+            adult: z.string().optional(),
+            error: z.string().optional(),
+            detail: z.string().optional(),
+        }),
+        effect: "signal", cost: "free", reversible: false, idempotent: false, auth: "session",
+    }),
+    "story:chain": receiver({
+        receiver: "story:chain",
+        summary: "The stories, counted: sets of two or more signals sharing one `origin`, read from the D1 lineage ledger (migrations/0244_story_link.sql). A story is a COUNT over a shared origin, not an entity \u2014 zero new types, zero new dimensions. The number moves as a side effect of signals that already flow; nobody types a row. `count` is the whole qualifying population, `stories` a page of at most 50 ordered by members desc \u2014 a capped count would plateau exactly when the substrate got busy. Zero is a real answer, never an error",
+        request: z.object({
+            // Where "a story is two or more" lives. The floor is the caller's, so 1
+            // legitimately means "every origin"; the default is the contract's 2.
+            minMembers: z.number().int().min(1).max(1_000_000).optional(),
+            // Narrow to one story. The same floor still applies: an origin holding a
+            // single signal answers count:0, because one signal is not yet a story.
+            origin: z.string().max(128).optional(),
+            // Page size only. Capped at 50 by the reader; it can never widen the scan.
+            limit: z.number().int().min(1).max(50).optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            count: z.number(),
+            minMembers: z.number().optional(),
+            stories: z.array(z.object({
+                origin: z.string(),
+                members: z.number(),
+                // NULLABLE on purpose: `ts` is nullable in 0244, so MIN/MAX over a row
+                // that carried none is NULL. Typing these bare numbers would be a lie
+                // the response validator eventually catches in prod.
+                first: z.number().nullable().optional(),
+                last: z.number().nullable().optional(),
+            })).optional(),
+        }),
+        // PUBLIC, and the reason is the ledger's shape, not an oversight. 0244 stores
+        // signal_id, origin, receiver and ts \u2014 "no actor, no payload and no ip", in
+        // its own words \u2014 so there is nothing here to scope to a tenant and nothing
+        // to leak by reading it. The alternative is worse than permissive: the binder
+        // attests on `staff || ownerSlug` (bind-receiver.ts applyAuth), and a service
+        // caller nominates ownerSlug only via a `slug`/`workspace` body field, which
+        // this contract has no reason to carry \u2014 so an `authenticated` label would
+        // refuse the very call the promise's Proof makes.
+        auth: "public",
+        // A pure read. Same inputs, same answer, until a signal moves the number.
+        effect: "ask", idempotent: true, reversible: true,
+    }),
+    // story:event — the funnel's doors. text/story-framework.md § "The story is
+    // alive" names nine steps and schema/story.tql block 4 declares the EVENT
+    // CONVENTION they are counted by; until this receiver existed nothing in the
+    // estate WROTE one, so every block-4 fun answered 0 and block 5's story_death
+    // answered "queen" for every story that had ever been told
+    // (text/story-tracking-plan.md § Gaps 4). This is the write half.
+    //
+    // ONE signal per call, under the story's origin, carrying the block-4 payload
+    // pairs: {"origin":"<o>","event":"story:<kind>"} plus "parent" on a retell and
+    // an `amount` attribute on a convert. The graph write and the trail marks are
+    // deferred to waitUntil — the brain takes the write, never the request path
+    // (root CLAUDE.md § The brain and the edge).
+    //
+    // AUTH IS PER-KIND, which no single label can express, so the label is the
+    // widest kind and the resolver holds the rest: `told`, `convert` and `retell`
+    // refuse an unattested caller (they name a teller, move money, or claim
+    // lineage), while `framed`/`view`/`complete`/`share` are open — a reader of a
+    // published story has no session and a view nobody can send is not a funnel.
+    // The identity is ALWAYS ctx, never the body (memory: resolver-body-actorid).
+    "story:event": receiver({
+        receiver: "story:event",
+        summary: "One step of a story's life, written as a signal under its origin: told · framed · view · complete · share · convert · retell. The payload carries the block-4 event convention (schema/story.tql), so story_views / story_conversions / story_revenue / story_retells / story_teller start answering from real traffic instead of 0. A convert also marks the two craft trails — tag:<board>:story → tag:<board>:frame:<x> and → tag:<board>:medium:<x> — and a retell marks teller → reteller, the referral edge. told/convert/retell need an attested caller; view/complete/share may be anonymous and are deduped per (origin, viewer, event) for an hour",
+        request: z.object({
+            // The story. Minted by the door (C3) and echoed on every response, so a
+            // caller always has one to quote; never derived from a task id.
+            origin: z.string().min(1).max(128),
+            // The nine-step funnel's kinds, minus the four a rung already writes
+            // (promised/building/settled are the promise's own states).
+            event: z.enum(["told", "framed", "view", "complete", "share", "convert", "retell"]),
+            // Revenue on a convert. 0 is a real answer — a sign-up converts and moves
+            // no money — so it is not conflated with absent.
+            amount: z.number().nonnegative().max(1_000_000).optional(),
+            // REQUIRED on a retell: the origin of the story this one was told from.
+            // A retell without it is lineage that names no parent, which is what
+            // story_children reads, so it is refused rather than written half-formed.
+            parent: z.string().max(128).optional(),
+            // What converted — the framework and the medium. Named on a convert, they
+            // become the two marks; absent, the convert still counts and marks nothing.
+            frame: z.string().max(64).optional(),
+            medium: z.string().max(64).optional(),
+            // TENANCY: honoured only when it equals the attested caller's own slug.
+            // A caller that could name another board could poison another tenant's
+            // routing weights (resolvers/subscriptions.ts:399-403).
+            board: z.string().max(64).optional(),
+            // Whether the medium played to the end — the one thing story_completes
+            // reads `has success true` for. Defaults true.
+            success: z.boolean().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            origin: z.string().optional(),
+            // The full pair as written, e.g. "story:view" — so a caller can grep the
+            // same string schema/story.tql matches on.
+            event: z.string().optional(),
+            // TRUE means the window already held this (origin, viewer, event) and no
+            // second signal was written. A real answer, never an error.
+            deduped: z.boolean().optional(),
+            // The trails this call will move, as "<source>→<target>". Empty is honest:
+            // a convert naming no frame and no medium marks nothing.
+            marked: z.array(z.string()).optional(),
+            error: z.string().optional(),
+        }),
+        // The widest kind. See the note above: the narrower kinds are gated in the
+        // resolver on ctx, because one label cannot say "open to read, closed to tell".
+        auth: "public",
+        // It writes. Not idempotent: two views an hour apart are two views, and the
+        // dedupe window is a window, not a key.
+        effect: "signal", cost: "free", reversible: false, idempotent: false,
+    }),
     "do:halt": receiver({
         receiver: "do:halt",
         summary: "Stop a factory run, or release the stop. Sets a halt latch on the plan thing that `factory:attempt` phase \"open\" refuses against, so no new attempt can be claimed; with `attempt`, also closes that in-flight attempt as dissolved. It does NOT kill an OS process — a cycle already executing stops at its next substrate write",
@@ -1203,6 +1548,11 @@ export const RECEIVERS = {
             // task. Without it the task is an orphan: on the board, unreachable from any plan.
             // Refused unless the caller has operate access to the parent.
             parent: z.string().optional(),
+            // 0..1, the same fraction tasks:priority stores. Added 2026-09-14: without it this
+            // door could not express a priority, so every row it filed was invisible to the only
+            // sort the board pages by — 407 of 730 on the day it was added. Omit to leave the
+            // attribute ABSENT (never judged), which is distinct from 0 (judged unimportant).
+            priority: z.number().min(0).max(1).optional(),
             // The viewed /u/<slug> workspace to file the task under. Honored only when the
             // caller is authorized for it (attested staff or owner-tree control); otherwise
             // the resolver falls back to the caller's own slug. Reconciles the create tag
@@ -1504,6 +1854,26 @@ export const RECEIVERS = {
             slug: z.string().optional(),
             body: z.string().optional(),
             workspace: z.string().optional(),
+            // WHICH CONVERSATION THIS CAME FROM. A comment and a chat message already
+            // live in the same D1 message store (`getOrCreateThread`, keyed
+            // `task:<tid>`); what was missing was a field naming the OTHER thread, so
+            // a discussion in the inbox and the row it is about could not be joined.
+            //
+            // It must be DECLARED to exist: `validateReceiver` returns the parsed
+            // object and a zod schema STRIPS undeclared keys, so an undeclared field
+            // never reaches the resolver. That is the same mechanism behind this
+            // door's older surprise — an unknown key degrades the call to a read that
+            // still answers ok:true.
+            threadId: z.string().optional(),
+            // WHO WROTE IT. Declared because a zod schema STRIPS an undeclared key
+            // before the resolver ever sees it — the exact mechanism that left
+            // `thread:append`'s already-implemented agent branch unreachable for every
+            // gateway caller. `authorKind` stays UNDECLARED for the same reason it
+            // does there: its value is a TRUST LABEL, and a caller naming its own is
+            // the estate's most-repeated defect. The resolver derives the label and
+            // honours this field only for an ATTESTED platform-staff caller; a bare
+            // agent key already speaks as itself from ctx and needs no field.
+            author: z.string().optional(),
         }).refine((v) => !!v.tid || !!v.slug, {
             message: "address the task by tid or slug",
             path: ["tid"],
@@ -1562,6 +1932,226 @@ export const RECEIVERS = {
         }),
         effect: "ask", idempotent: true, auth: "member",
     }),
+    // tasks:board — the ONE-REQUEST read of a whole board, with the context a planner needs.
+    //
+    // WHY. Measured 2026-09-13: an agent asked for the board, hit a 200-row page
+    // (the MCP tool's documented cap; `tasks:everywhere` clamps to 200), paged by six
+    // tags, found 353 more rows by NAME ONLY, and never learned the real total.
+    // `tasks:list` has no cap but refuses without a `tag`, so the unfiltered
+    // question — "every task in this group" — had no door at all.
+    //
+    // CONTRACT. (1) `total` is the count that matched the filters BEFORE paging, and
+    // is never an estimate; a partial page carries `nextCursor`, and any budget the
+    // underlying read could not honour is named in `truncated` — a short answer
+    // always says it is short. (2) `summary` is computed over ALL matched rows, not
+    // the page, so a planner can reason about 2,000 tasks while reading 0 of them.
+    // (3) Rows are compact by default; `include` widens them. (4) Served from the
+    // edge snapshot (KV memo of the board, `asOf` stamps it) — never a live TypeDB
+    // read per call (CLAUDE.md § The brain and the edge). `fresh: true` asks for a
+    // rebuild and is honoured at most once per memo window.
+    "tasks:board": receiver({
+        receiver: "tasks:board",
+        surfaces: { mcp: true },
+        summary: "The whole task board in ONE request: every task in a group (or its whole subtree with scope:'tree'), filtered in RAM, with `total` before paging, a `nextCursor` when there is more, `truncated` naming any budget that bit, and a `summary` over ALL matched rows — counts by status/tag/assignee/workspace, the ready set, the blocked set, overdue, unassigned, orphans, no-notes. Use this to plan; use tasks:bulk to act on what it shows.",
+        request: z.object({
+            workspace: z.string().optional().describe("Group slug. Omit for your own. Honoured only if you may read it."),
+            scope: z.enum(["own", "tree"]).optional().describe("tree = this group AND every descendant group (the CEO / agency lens). Default own."),
+            status: z.union([z.string(), z.array(z.string())]).optional()
+                .describe("open | blocked | picked | done | verified | failed | dissolved, one or many. 'active' = open+blocked+picked (the default). 'all' = every status."),
+            tags: z.array(z.string()).optional().describe("Row must carry EVERY tag (AND)."),
+            anyTags: z.array(z.string()).optional().describe("Row must carry AT LEAST ONE of these tags (OR)."),
+            assignee: z.string().optional().describe("Actor slug. '' = unassigned only."),
+            parent: z.string().optional().describe("Only direct children of this task id. '' = top-level rows (no parent)."),
+            search: z.string().optional().describe("Case-insensitive substring on the task name."),
+            ready: z.boolean().optional().describe("true = only rows claimable now (open, and every blocker closed). false = only rows that are NOT claimable now (not open, or at least one blocker still open). Omit for both."),
+            include: z.array(z.enum(["notes", "graph", "dates", "thread"])).optional()
+                .describe("Widen each row. notes = the prose goal, CLIPPED to the first 2000 chars per row (read the whole text one task at a time); graph = children + blocks (the reverse edges); dates = startAt/createdAt/closedAt; thread = the task's inbox conversation (id, comment count, last message). Compact rows already carry parent, blockedBy, dueAt."),
+            view: z.enum(["rows", "summary", "both"]).optional().describe("summary = counts and sets only, no rows (cheapest way to see a 2,000-row board). Default both."),
+            sort: z.enum(["priority", "due-at", "updated-at", "created-at", "name"]).optional().describe("Default priority (desc)."),
+            dir: z.enum(["asc", "desc"]).optional(),
+            limit: z.number().int().min(1).max(2000).optional().describe("Rows per page. Default 500, max 2000."),
+            cursor: z.string().optional().describe("The nextCursor from the previous page."),
+            fresh: z.boolean().optional().describe("Rebuild the snapshot instead of reading the memo. Rate-limited to once per memo window."),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            workspace: z.string().optional(),
+            workspaces: z.array(z.string()).optional().describe("Every group the rows were read from (scope:'tree')."),
+            asOf: z.string().optional().describe("ISO time the snapshot was built. Rows are at most this stale."),
+            cached: z.boolean().optional(),
+            total: z.number().optional().describe("Rows matching the filters, before paging. Exact — UNLESS `truncated.rows` is present, in which case the snapshot itself was capped and total is a floor."),
+            returned: z.number().optional(),
+            nextCursor: z.string().optional().describe("Present iff more rows match. Absent = you have them all."),
+            truncated: z.object({
+                rows: z.number().optional().describe("The snapshot hit its row budget; this many unique rows were read. total is a floor."),
+                edges: z.boolean().optional().describe("parent/blockedBy edges were capped — a row may read as unblocked or orphaned when it is not."),
+                tags: z.number().optional().describe("This many returned rows may be missing tags."),
+            }).optional().describe("Absent = nothing was cut. Present = say so before you plan on it."),
+            summary: z.object({
+                byStatus: z.record(z.string(), z.number()),
+                byTag: z.record(z.string(), z.number()).describe("Bare tags only (no workspace:/slug:/@ namespaces), top 100 by count."),
+                byAssignee: z.record(z.string(), z.number()).describe("'' key = unassigned."),
+                byWorkspace: z.record(z.string(), z.number()),
+                ready: z.number().describe("Open with every blocker closed — claimable now."),
+                blocked: z.number().describe("Has at least one open blocker, or status blocked."),
+                overdue: z.number(),
+                unassigned: z.number(),
+                orphans: z.number().describe("No parent — unreachable from any plan's containment walk."),
+                noNotes: z.number().describe("No prose goal — the rows a puller cannot act on."),
+                readyIds: z.array(z.string()).describe("Top 50 ready rows by priority."),
+                blockedIds: z.array(z.string()).describe("Top 50 blocked rows by priority."),
+            }).optional(),
+            tasks: z.array(z.object({
+                tid: z.string(),
+                name: z.string(),
+                status: z.string(),
+                priority: z.number(),
+                tags: z.array(z.string()).describe("Bare tags; workspace:/@assignee are lifted into their own fields."),
+                assignee: z.string().optional(),
+                workspace: z.string(),
+                parent: z.string().optional(),
+                blockedBy: z.array(z.string()).optional(),
+                openBlockers: z.number().optional().describe("How many of blockedBy are not yet done/verified/dissolved."),
+                ready: z.boolean(),
+                dueAt: z.string().optional(),
+                overdue: z.boolean().optional(),
+                // include: dates
+                startAt: z.string().optional(),
+                createdAt: z.string().optional(),
+                closedAt: z.string().optional(),
+                // include: notes
+                notes: z.string().optional(),
+                // include: graph
+                children: z.array(z.string()).optional(),
+                blocks: z.array(z.string()).optional(),
+                // include: thread — the same D1 conversation tasks:comment writes and /in lists
+                thread: z.object({
+                    threadId: z.string().optional().describe("The inbox thread id; absent = nobody has commented yet."),
+                    comments: z.number(),
+                    lastAt: z.string().optional(),
+                    lastAuthor: z.string().optional(),
+                    lastBody: z.string().optional().describe("First 280 chars of the latest message."),
+                }).optional(),
+            })).optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", idempotent: true, auth: "member",
+        examples: [
+            { workspace: "one", view: "summary" },
+            { workspace: "one", scope: "tree", status: "active", ready: true, limit: 100 },
+            { workspace: "one", anyTags: ["launch", "story"], include: ["notes", "graph"] },
+        ],
+    }),
+    // tasks:bulk — the ONE-REQUEST door for N task mutations.
+    //
+    // Every other task write here takes a single `tid`, so refining a 595-row board
+    // (measured, workspace `one`, 2026-09-11) costs 595+ round trips. That is the
+    // reason the board has never been refined. This takes up to 25 rows and reports
+    // a receipt PER ROW — never a single top-level ok that hides a partial run.
+    //
+    // It reimplements no write: the resolver loops and calls the existing
+    // single-tid resolvers with the SAME attested ctx, so authority, the status
+    // gates and the D1 tag mirror are all inherited rather than re-derived. The
+    // `workspace` field (envelope or per row) is a REQUEST, exactly as on every
+    // single-tid write — effectiveWorkspace downgrades it when the caller is
+    // neither staff nor in control of it.
+    "tasks:bulk": receiver({
+        receiver: "tasks:bulk",
+        surfaces: { mcp: true },
+        summary: "Plan and act on many tasks in ONE request. Three modes, combinable: `creates` files up to 25 new tasks (with `ref` handles so rows in the same call can parent/block each other — a whole plan tree in one call); `edits` changes up to 25 named rows (title/status/priority/notes/assignee/tags/dates/dependencies/parent/comment — `parent` MOVES a row under another, the one door that writes `containment` after birth, and an empty string makes it a root again); `where`+`set` applies ONE edit to every row a tasks:board filter matches (dryRun defaults TRUE — you see the matched tids before anything moves; applies 25 per call and returns `nextCursor` to continue). Returns a receipt PER ROW (ok, per-field reason, retryable) plus total/attempted/applied/failed — a row never attempted says so by name, so a partial run can never read as a success.",
+        request: z.object({
+            edits: z.array(z.object({
+                tid: z.string(),
+                title: z.string().optional(),
+                status: z.string().optional().describe("open | blocked | picked | done | verified | failed | dissolved"),
+                priority: z.number().optional().describe("1-100 slider, same scale as tasks:priority"),
+                notes: z.string().optional().describe("Prose goal; empty string clears"),
+                parent: z.string().optional().describe("MOVE this row under another — the only door that writes a `containment` edge AFTER birth (tasks:create and tasks:subtask write one only at birth, which is why a story could never be made a sub-story of another). An existing task id, or a `ref` created EARLIER in `creates`. EMPTY STRING CLEARS: the row becomes a root again, and clearing a row that already had no parent is a silent success. Refused by name, never silently: `cycle` if the new parent is this row or any row beneath it (walked transitively, and a walk that could not FINISH answers `undetermined` and is refused — never guessed at); `not_found` if the parent does not exist, OR the caller lacks operate access to it, OR the row's CURRENT parent is one the caller cannot operate (detaching changes that tree too) — the same rule, and the same word, tasks:create's `parent` uses; `cross_workspace` if the two ends live in different workspaces and the caller is not staff. CLAIM-GATE CONSEQUENCE — this is not only a tree edit: `tasks:claim` refuses `picked` while an OPEN `containment` child exists, so hanging an open row under a claimable parent makes that parent UNCLAIMABLE, and moving the last open child away makes it claimable again. Deliberately absent from `set`: a filter-driven mass re-parent moves whole subtrees at once — and multiplies that claim-gate consequence by the match count — so this is per-row only."),
+                assignee: z.string().optional().describe("Actor slug; empty string unassigns"),
+                addTags: z.array(z.string()).optional().describe("Bare words only — no ':' and no leading '@'"),
+                removeTags: z.array(z.string()).optional(),
+                dueAt: z.string().nullable().optional().describe("ISO date; null or '' clears. Same semantics as tasks:schedule"),
+                startAt: z.string().nullable().optional(),
+                addBlockedBy: z.array(z.string()).optional().describe("Task ids (or `ref`s from `creates`) this row must wait for — tasks:depend per id"),
+                removeBlockedBy: z.array(z.string()).optional().describe("tasks:undepend per id"),
+                comment: z.string().optional().describe("Post to the task's inbox thread (tasks:comment) — say WHY you changed it, so the humans watching the thread see the decision"),
+                workspace: z.string().optional().describe("Per-row override of the envelope workspace. A request, never a grant."),
+            })).max(25).optional(),
+            creates: z.array(z.object({
+                ref: z.string().optional().describe("A local handle, e.g. 'a'. Other rows in THIS call may name it in parent/blockedBy/addBlockedBy; the receipt maps ref → tid."),
+                title: z.string(),
+                notes: z.string().optional(),
+                tags: z.array(z.string()).optional(),
+                assignee: z.string().optional(),
+                priority: z.number().optional(),
+                parent: z.string().optional().describe("Existing task id or a ref created EARLIER in this array"),
+                blockedBy: z.array(z.string()).optional().describe("Existing task ids or refs created earlier in this array"),
+                dueAt: z.string().optional(),
+                workspace: z.string().optional(),
+            })).max(25).optional(),
+            where: z.object({
+                status: z.union([z.string(), z.array(z.string())]).optional(),
+                tags: z.array(z.string()).optional(),
+                anyTags: z.array(z.string()).optional(),
+                assignee: z.string().optional(),
+                parent: z.string().optional(),
+                search: z.string().optional(),
+                ready: z.boolean().optional(),
+                scope: z.enum(["own", "tree"]).optional(),
+            }).optional().describe("A tasks:board filter. Requires `set`. Matches are read from the same snapshot tasks:board serves."),
+            set: z.object({
+                status: z.string().optional(),
+                priority: z.number().optional(),
+                assignee: z.string().optional(),
+                addTags: z.array(z.string()).optional(),
+                removeTags: z.array(z.string()).optional(),
+                dueAt: z.string().nullable().optional(),
+                comment: z.string().optional(),
+            }).optional().describe("The ONE edit applied to every `where` match. title/notes are deliberately absent — those are per-row."),
+            dryRun: z.boolean().optional().describe("For `where`: defaults TRUE. Pass false to apply. Ignored by edits/creates."),
+            cursor: z.string().optional().describe("For `where`: the nextCursor from the previous call"),
+            workspace: z.string().optional().describe("Workspace to act in, for every row. Honoured only if you are staff or control it."),
+        }).refine((v) => (v.edits?.length ?? 0) + (v.creates?.length ?? 0) > 0 || (!!v.where && !!v.set), {
+            message: "send edits, creates, or where+set",
+            path: ["edits"],
+        }).refine((v) => !v.where === !v.set, { message: "where and set go together", path: ["where"] }),
+        response: z.object({
+            ok: z.boolean().describe("The CALL's outcome, not the rows'. Read applied/failed."),
+            total: z.number().optional(),
+            attempted: z.number().optional(),
+            applied: z.number().optional(),
+            failed: z.number().optional(),
+            notAttempted: z.number().optional(),
+            error: z.string().optional(),
+            detail: z.string().optional(),
+            created: z.record(z.string(), z.string()).optional().describe("ref → tid for every `creates` row that landed"),
+            matched: z.number().optional().describe("`where`: rows the filter matched in total, across all pages"),
+            matchedIds: z.array(z.string()).optional().describe("`where`: the tids this call covers (the ones it would apply, on dryRun)"),
+            dryRun: z.boolean().optional(),
+            nextCursor: z.string().optional().describe("`where`: present iff more matches remain — resend the same call with this cursor"),
+            results: z.array(z.object({
+                tid: z.string(),
+                ref: z.string().optional(),
+                ok: z.boolean(),
+                reason: z.string().optional(),
+                retryable: z.boolean().optional(),
+                fields: z.array(z.object({
+                    field: z.string(),
+                    ok: z.boolean(),
+                    reason: z.string().optional(),
+                    detail: z.string().optional(),
+                    retryable: z.boolean().optional(),
+                })).optional(),
+            })).optional(),
+        }),
+        effect: "ask", idempotent: false, auth: "member",
+        examples: [
+            { edits: [{ tid: "task:abc", status: "dissolved", comment: "Superseded by task:def" }, { tid: "task:def", notes: "Done when X", addTags: ["planning"] }], workspace: "one" },
+            { creates: [{ ref: "plan", title: "Launch the pricing page" }, { ref: "copy", title: "Write pricing copy", parent: "plan" }, { title: "Ship pricing page", parent: "plan", blockedBy: ["copy"] }], workspace: "one" },
+            { where: { status: "open", tags: ["launch"], assignee: "" }, set: { assignee: "cmo", comment: "Routing unowned launch work to marketing" }, dryRun: true, workspace: "one" },
+            { creates: [{ ref: "arc", title: "The story we are actually telling", tags: ["story"] }], edits: [{ tid: "task:oldstory", parent: "arc", comment: "Nested under the main story" }, { tid: "task:looseplan", parent: "" }], workspace: "one" },
+        ],
+    }),
     "tasks:follow": receiver({
         receiver: "tasks:follow",
         surfaces: { mcp: true },
@@ -2008,10 +2598,12 @@ export const RECEIVERS = {
         request: z.object({
             limit: z.number().optional(), since: z.number().optional(),
             from: z.number().optional(), to: z.number().optional(),
+            intent: z.string().optional(),
         }),
         response: z.array(z.object({
             id: z.string(), from: z.string(), to: z.string(), skill: z.string().optional(),
             outcome: z.enum(["success", "failure", "timeout"]), revenue: z.number(), ts: z.number(),
+            intent: z.string().optional(),
         })),
         effect: "ask", cost: "free", idempotent: true,
     }),
@@ -2126,6 +2718,78 @@ export const RECEIVERS = {
         effect: "ask", cost: "free", idempotent: true,
         examples: [{ feature: "premium" }],
     }),
+    // ════════════════════════════════════════════════════════════════════════
+    // id: — one door for every address in the estate. `id:resolve` is a pure
+    // projection over `one.ie/web/src/data/id-inventory.json`, the artifact
+    // `.claude/scripts/id-inventory.mjs` writes and its `--check` regenerates in
+    // memory to fail on drift. NOTHING HERE IS HAND-DECLARED: kind, provenance,
+    // count, id_prefix, summary and source are each read off that file, so this
+    // door cannot claim a population the generator never counted.
+    //
+    // Seven kinds — signal · skill · workflow · component · doc · function ·
+    // thing. `thing` is the LOCKED dimension-3 word: a ref whose prefix is
+    // `object:` is REFUSED, never silently rewritten, because a door that
+    // rewrites teaches callers a name the substrate does not have. Functions
+    // address as `fn:` (the estate's existing address — `fn:run`'s FN_MAP),
+    // never `fun:`.
+    // ════════════════════════════════════════════════════════════════════════
+    "id:resolve": receiver({
+        receiver: "id:resolve",
+        summary: "Resolve one address to its metadata card — seven generated kinds behind one door, every field projected from the generated id inventory. `object:` is refused in favour of `thing`; a ref the inventory does not hold answers `unknown_ref` rather than a guess",
+        request: z.object({
+            // The grammar `TID_RE` already admits (resolvers/factory.ts:32): MINTED
+            // `<type>:<24-hex>` or DERIVED `<type>:<scope>[:<n>][/<part>]`. A bare
+            // receiver name is its own address — `factory:size` resolves as a signal,
+            // not as a `factory` scope, because an exact registry name is matched
+            // before any prefix is read (21 receiver names would collide otherwise).
+            ref: z.string().min(1).max(128),
+        }),
+        // `factory:size`'s idiom deliberately: one flat schema, `ok: z.boolean()`,
+        // everything else optional — never a discriminated union. A refusal is the
+        // same shape as an answer, so a caller reads `ok` and nothing else.
+        response: z.object({
+            ok: z.boolean(),
+            ref: z.string().optional(),
+            kind: z.string().optional(),
+            // Lexical, per trace.ts:26-31 — the last colon segment decides. Never
+            // temporal: `attempt:<hex>:<n>` is DERIVED because its last segment is an
+            // ordinal, which is the same answer `traceIdMintedAt` already gives.
+            lane: z.enum(["minted", "derived"]).optional(),
+            name: z.string().optional(),
+            title: z.string().optional(),
+            summary: z.string().optional(),
+            source: z.string().optional(),
+            // BARE, never composed — the inventory stores `fn`, and `fn:<name>` is
+            // built at read time. null for `signal`: a receiver's name IS its address.
+            id_prefix: z.string().nullable().optional(),
+            // Read off the kind record, not asserted here. `generated` for the five
+            // counted kinds; `graph` is what `workflow` and `thing` carry, and they
+            // hold no entries, so they answer `unknown_ref` until the graph is walked.
+            provenance: z.string().optional(),
+            // The kind's population, or null where the inventory refused to count.
+            // null is UNRUN, never zero.
+            count: z.number().nullable().optional(),
+            // The commit the inventory was generated at — the answer's receipt.
+            generated_at: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        // `auth: "authenticated"` — C20, the auditor's second finding. This door has
+        // no `auth:` field until now, and an ABSENT label is the one case
+        // `authClassFor` answers 'open' for (bind-receiver.ts:119), while the doc
+        // five lines above it says an unlisted label falls to 'authenticated'. So
+        // the declaration and the default disagreed, and this receiver was on the
+        // wrong side of it: what it projects IS the web's internals — every id,
+        // summary, source path and population count in the estate, from one
+        // uncredentialed POST. 320 of 335 receivers share the absent label; the
+        // default is NOT inverted this cycle (that needs the census bind-receiver.ts
+        // now logs), so this one says so explicitly instead of waiting for it.
+        //
+        // Costs the contract nothing: text/story.md:24's accept sends
+        // GATEWAY_API_KEY, which `isVerifiedServiceCaller` attests, so the promise's
+        // own check passes unchanged.
+        effect: "ask", auth: "authenticated", cost: "free", idempotent: true,
+        examples: [{ ref: "factory:size" }, { ref: "fn:uncovered" }],
+    }),
     "plugins:list": receiver({
         receiver: "plugins:list",
         summary: "List all available ONE plugins with their feature key, price, and description",
@@ -2294,6 +2958,20 @@ export const RECEIVERS = {
             content: z.string(),
             ts: z.number().optional(),
             tags: z.array(z.string()).optional(),
+            // The resolver implements this branch (messaging.ts) — an agent mirroring
+            // its own reply back into the inbox writes role "assistant", which the
+            // resolver turns into authorKind "agent". Undeclared, zod stripped it
+            // before the resolver ever saw it, so the branch was unreachable for
+            // EVERY gateway caller and every agent post landed as role "user" /
+            // authorKind "customer". `authorKind` stays UNDECLARED deliberately: its
+            // only reachable value is "staff", which is a caller naming its own
+            // author (resolver-body-actorId-not-identity) and needs an attestation
+            // decision, not a schema line.
+            role: z.enum(["user", "assistant"]).optional(),
+            // The structured envelope forwarded from `/signal/:group` — see
+            // `web/src/lib/signal-meta.ts SignalMeta`. Loose on purpose (see
+            // tasks:announce's `meta` field for why).
+            meta: z.record(z.string(), z.unknown()).optional(),
         }),
         response: z.object({
             ok: z.boolean(),
@@ -2506,6 +3184,7 @@ export const RECEIVERS = {
         response: z.object({
             ok: z.boolean(),
             delivered: z.string().optional(), // 'web' | 'telegram' | 'discord' | 'failed'
+            deliveryError: z.string().optional(), // present iff delivered==='failed' — the platform's own words; the reply IS still persisted
             kind: z.string().optional(),
             error: z.string().optional(),
         }),
@@ -3039,6 +3718,9 @@ export const RECEIVERS = {
                 actor: z.string(), chain: z.string(), address: z.string(), balance: z.string().nullable(),
             })).optional(),
             addresses: z.array(z.object({ actor: z.string(), chain: z.string(), address: z.string() })).optional(),
+            // The per-agent PROJECTION of the on-chain ceiling (text/launch.md §0d).
+            // Zod strips unknown keys, so a field absent here never reaches AgentCaps.
+            agentCaps: z.array(z.record(z.string(), z.unknown())).optional(),
             delegated: z.array(z.record(z.string(), z.unknown())).optional(),
             error: z.string().optional(),
         }),
@@ -3063,6 +3745,37 @@ export const RECEIVERS = {
         effect: "ask", cost: "free", reversible: true, idempotent: true, settles: "none", auth: "member",
         examples: [{ limit: 20 }, { workspace: "acme", limit: 100 }],
     }),
+    // wallet:transfer — INTERNAL credits only. TRANSFER, NEVER MINT: a
+    // solvency-checked debit and a credit that sum to zero, so a compromised caller
+    // can move credits around but cannot create them. Bounded by the payer's cap so
+    // an agent cannot transfer its way past its ceiling. Deliberately NOT
+    // `surfaces: { mcp: true }` — it never touches a chain and settles in the
+    // ledger, so it declares `settles: "offchain"` and stays reversible by a
+    // compensating transfer, unlike wallet:send.
+    "wallet:transfer": receiver({
+        receiver: "wallet:transfer",
+        summary: "Move credits between workspaces inside the ledger — solvency-checked, cap-bounded, zero-sum. Never mints; never touches a chain",
+        request: z.object({
+            to: z.string().describe("Recipient workspace slug"),
+            amount: z.number().describe("Credits; must be > 0 and an integer"),
+            workspace: z.string().optional().describe("Payer workspace; falls back to `from`, then the attested caller"),
+            from: z.string().optional().describe("Alias for `workspace` — the source the authority walk runs against"),
+            transferId: z.string().optional().describe("Idempotency key; both legs share it as rail_ref"),
+            memo: z.string().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            from: z.string().optional(),
+            to: z.string().optional(),
+            amount: z.number().optional(),
+            transferId: z.string().optional(),
+            error: z.string().optional().describe("forbidden | insufficient_credits | cap_exceeded | invalid_amount"),
+        }),
+        // Zero-sum inside the credit ledger — real value, settled OFFCHAIN (never on
+        // chain), reversible by a compensating transfer. Idempotent on `transferId`.
+        effect: "ask", cost: "free", reversible: true, idempotent: true, settles: "offchain", auth: "manage_workspace",
+        examples: [{ to: "acme", amount: 500 }],
+    }),
     // The caller signs and broadcasts the transfer CLIENT-SIDE and passes the
     // resulting `paymentTx`; this composes pay.one.ie's create → quote → claim and
     // never holds a key. It VERIFIES that an on-chain transfer settled, so it
@@ -3252,7 +3965,14 @@ export const RECEIVERS = {
         surfaces: { mcp: true },
         summary: "List a workspace's pages with status",
         request: z.object({ slug: z.string() }),
-        response: z.object({ pages: z.array(z.object({ slug: z.string(), title: z.string(), status: z.string() })) }),
+        response: z.object({ pages: z.array(z.object({
+                slug: z.string(),
+                title: z.string(),
+                status: z.string(),
+                url: z.string().optional().describe("The page's public path, /p/<slug>"),
+                updated_at: z.number().optional().describe("Last modified, epoch ms"),
+                views: z.number().nullable().optional().describe("Pageviews from the analytics pixel. NULL means no pageview row exists — render it as '—', NOT as 0. A page live for five minutes with no visitors and a page nothing is measuring must not read the same."),
+            })) }),
         effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "member",
     }),
     "pages:publish": receiver({
@@ -3269,6 +3989,55 @@ export const RECEIVERS = {
         response: z.object({ ok: z.boolean(), published: z.number().optional(), error: z.string().optional() }),
         effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "member",
     }),
+    // WHY THIS IS DECLARED. `pages:delete` shipped as a resolver with no registry
+    // row, so it reached the handler only through the undeclared-receiver escape
+    // hatch — no edge zod parsing, no auth floor. Its two live callers send
+    // `{slug, page}` (`scripts/demo-instantiate-movers.ts`) and
+    // `{slug, actorId, page}` (`channels/src/tools/pages.ts`). `actorId` is NOT
+    // declared here on purpose: `pagesDenyReason` authorizes off `ctx` alone and
+    // has never read it, so declaring it would publish a field nothing consumes
+    // and invite a caller to think it authorizes something.
+    //
+    // `auth: "member"` matches every sibling in this family. A tighter floor
+    // reasoned out fresh would break the channels tool, and the break would look
+    // like a bug in whatever called it.
+    "pages:delete": receiver({
+        receiver: "pages:delete",
+        summary: "Permanently delete a workspace page. NOT REVERSIBLE — pages:restore only UPDATEs an existing row and cannot re-insert a deleted one, so nothing that ships can undo this.",
+        request: z.object({ slug: z.string(), page: z.string() }),
+        response: z.object({ ok: z.boolean(), slug: z.string().optional(), title: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: false, idempotent: true, auth: "member",
+    }),
+    "pages:unpublish": receiver({
+        receiver: "pages:unpublish",
+        summary: "Take a published page back to draft — the inverse of pages:publish. Writes no version snapshot (no content changes) and leaves published_at as the record of when it last went live.",
+        request: z.object({ slug: z.string(), page: z.string() }),
+        response: z.object({ ok: z.boolean(), slug: z.string().optional(), title: z.string().optional(), url: z.string().optional(), status: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "member",
+    }),
+    "pages:bulk": receiver({
+        receiver: "pages:bulk",
+        summary: "Apply ONE op (publish | unpublish | delete) to an EXPLICIT list of pages — one authority walk, one round trip, a per-row answer.",
+        request: z.object({
+            slug: z.string(),
+            op: z.enum(["publish", "unpublish", "delete"]),
+            pages: z.array(z.string()).min(1).max(100).describe("Page slugs, REQUIRED and non-empty. There is deliberately no omitted-means-all case: pages:publish-pack has one, and an implicit whole-workspace scope is exactly what a selection UI must never be able to send. Over 100 is refused BY NAME (`too_many:N>100`), never truncated."),
+        }),
+        response: z.object({
+            ok: z.boolean().describe("Describes THE CALL, not the rows. A run where every row failed still answers ok:true — read `changed` and `failed`, never this, to report what happened."),
+            op: z.string().optional(),
+            requested: z.number().optional().describe("Rows attempted, after de-duplication."),
+            changed: z.number().optional().describe("Rows the op actually changed. This is the number to quote."),
+            failed: z.number().optional().describe("requested - changed. Present even when 0, so a caller cannot miss it."),
+            results: z.array(z.object({
+                slug: z.string(), ok: z.boolean(), title: z.string().optional(), error: z.string().optional(),
+            })).optional().describe("Per-row outcome, in the order attempted. A failed row names its own reason (`not_found`, `no_db`)."),
+            error: z.string().optional(),
+        }),
+        // `reversible: false` because delete is one of the three ops and the
+        // envelope cannot be conditional. publish/unpublish are each other's undo.
+        effect: "ask", cost: "free", reversible: false, idempotent: true, auth: "member",
+    }),
     "pages:fill-pack": receiver({
         receiver: "pages:fill-pack",
         summary: "Fill a pack's instantiated pages with real business facts — one call, still drafts. Never fabricates a testimonial; pricing derives from one rate, not typed per page.",
@@ -3912,7 +4681,7 @@ export const RECEIVERS = {
         receiver: "workflow:runs",
         surfaces: { mcp: true },
         summary: "List recent runs of a workflow (D1 workflow_run) for the monitor + history surfaces",
-        request: z.object({ workflowId: z.string(), runId: z.string().optional(), limit: z.number().int().min(1).max(200).optional() }),
+        request: z.object({ workflowId: z.string(), runId: z.string().optional(), limit: z.number().int().min(1).max(200).optional(), stepId: z.string().optional(), stepLimit: z.number().int().min(1).max(100).optional() }),
         response: z.object({
             runs: z.array(z.object({
                 id: z.string(), status: z.string(),
@@ -3930,7 +4699,7 @@ export const RECEIVERS = {
     "workflow:step-stats": receiver({
         receiver: "workflow:step-stats",
         surfaces: { mcp: true },
-        summary: "Per-step run counts and latency for one workflow (aggregated over D1 workflow_run_event) — what the canvas prints on each step card",
+        summary: "Per-step run counts, latency and last messages for one workflow (over D1 workflow_run_event) — what the canvas prints on each step card",
         request: z.object({ workflowId: z.string(), sinceMs: z.number().int().optional() }),
         response: z.object({
             stats: z.array(z.object({
@@ -3938,8 +4707,28 @@ export const RECEIVERS = {
                 runs: z.number().int(),
                 failures: z.number().int(),
                 avgMs: z.number().nullable(),
+                minMs: z.number().nullable(),
                 maxMs: z.number().nullable(),
+                /** Total ms this step has spent across every completed run. */
+                totalMs: z.number(),
+                /** This step's slice of the whole workflow's execution time, 0-1 — which
+                 *  step is the bottleneck. null when nothing has completed yet (never 0:
+                 *  no share of nothing is not "0% of the time"). */
+                share: z.number().nullable(),
                 lastAt: z.number().nullable(),
+                // The step's last few events, newest first — what it SAID, not just how
+                // often it ran. `text` is already truncated server-side; a card that wants
+                // the whole payload opens the run monitor.
+                messages: z.array(z.object({
+                    kind: z.string(),
+                    status: z.string().nullable(),
+                    latencyMs: z.number().nullable(),
+                    at: z.number(),
+                    text: z.string(),
+                })),
+                /** Recent completed latencies, OLDEST → NEWEST, for the card's sparkline.
+                 *  Empty when the step has completed nothing recently. */
+                series: z.array(z.number()),
             })),
             error: z.string().optional(),
         }),
@@ -5039,6 +5828,232 @@ export const RECEIVERS = {
         effect: "ask", cost: "variable", reversible: true, idempotent: false, auth: "member",
         examples: [{ site_url: "https://one.ie/", start_date: "2026-01-01", end_date: "2026-06-01" }],
     }),
+    // ── promise: — the contract a story signs (resolvers/promises.ts) ──────────
+    // Declared here because a workflow step may only bind a REGISTERED name:
+    // `story-intake` binds both, and campaign-ads-social.test.ts refuses a binding
+    // no receiver implements. `promise:get` is deliberately NOT declared — nothing
+    // binds it and this cycle registers only what a template reaches.
+    "promise:make": receiver({
+        receiver: "promise:make",
+        summary: "State terms and exactly one proof observable — the terms FREEZE (sha-256 terms_hash, insert-once) and the promise enters state 'promised'. The maker is the attested caller, never a body field",
+        request: z.object({
+            slug: z.string().describe("Stable id for the promise, e.g. story:<origin>. [A-Za-z0-9_:/-], max 128"),
+            terms: z.string().describe("What is promised — hashed verbatim into terms_hash and never rewritten"),
+            proof: z.string().describe("The ONE observable that decides kept vs broken. A shell-shaped proof settles at PROVE via the CLI, never in the worker"),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            slug: z.string().optional(),
+            state: z.literal("promised").optional(),
+            terms_hash: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", auth: "member",
+        reversible: false, idempotent: true, settles: "none",
+        examples: [{ slug: "story:demo", terms: "a mover in Austin tells her origin story on her own page", proof: "test -f one.ie/web/src/pages/story.astro" }],
+    }),
+    "promise:settle": receiver({
+        receiver: "promise:settle",
+        summary: "Close the loop on a promise — kept marks the path, broken warns it, and a terminal promise never re-settles. Only the PERSISTED maker may settle; the verdict is the maker's assertion, the resolver never runs the proof",
+        request: z.object({
+            slug: z.string(),
+            kept: z.boolean().optional().describe("Defaults to true. false ⇒ settled-broken: resistance += 1, the path decays honestly"),
+            composite: z.number().optional().describe("Rubric composite; scales the mark by 5× when kept"),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            slug: z.string().optional(),
+            state: z.enum(["settled-kept", "settled-broken", "dissolved"]).optional(),
+            strength: z.number().optional(),
+            resistance: z.number().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", auth: "member",
+        reversible: false, idempotent: false, settles: "none",
+        examples: [{ slug: "story:demo", kept: false }],
+    }),
+    // ── duty: — provision that was PROMISED, recorded as delivered or missed ──
+    // (resolvers/duty.ts · migrations/0245_duties.sql · lib/ehc/duty.ts)
+    //
+    // The family exists because `promise:*` inverts wrong for a statutory duty:
+    // `promises.ts:96` lets the maker settle its own promise, and `:112` defaults
+    // a missing verdict to KEPT. Here the certifier is a DIFFERENT actor, refused
+    // at write time by `CHECK (certifier <> holder)`, and NO caller supplies a
+    // verdict at all — the state is computed from counts and the clock, so a
+    // window that lapsed with nothing recorded reads as `breached`, not as blank.
+    // Spec: text/ehc-substrate-plan.md §3.1.
+    "duty:make": receiver({
+        receiver: "duty:make",
+        summary: "State a duty you OWE — terms, one observable, an owed count, a due_at, and a certifier who must not be you. The holder is the attested caller, never a body field; certifier === holder is refused by the resolver and by a D1 CHECK",
+        request: z.object({
+            slug: z.string().describe("Stable id, e.g. ehc:cyp-005:H2. [A-Za-z0-9_:/-], max 128"),
+            terms: z.string().describe("What is owed — hashed verbatim into terms_hash"),
+            observable: z.string().describe("What ONE delivery looks like: 'a meal, on a date, received' — not 'a meal service was commissioned'"),
+            certifier: z.string().describe("Who may attest delivery. MUST NOT be the holder — the duty-holder never grades its own homework"),
+            owed: z.number().int().describe("How many deliveries are owed. 0 means not yet quantified and computes to state 'unknown', never 'met'"),
+            due_at: z.number().optional().describe("Epoch ms the window closes. ABSENT IS UNKNOWN, never 'no deadline' — an unwritten window computes to 'unknown', never to on-track"),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            slug: z.string().optional(),
+            version: z.number().optional(),
+            state: z.enum(["unknown", "owed", "part-met", "met", "breached"]).optional(),
+            terms_hash: z.string().optional(),
+            certifier: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", auth: "member",
+        reversible: false, idempotent: true, settles: "none",
+        examples: [{ slug: "ehc:cyp-005:H2", terms: "A hot meal every weekday, including school holidays", observable: "A meal, on a date, received", certifier: "ehc-social-worker", owed: 45 }],
+    }),
+    "duty:amend": receiver({
+        receiver: "duty:amend",
+        summary: "Amend by LINEAGE — writes a new row at version+1 with `supersedes`; the prior version is never mutated and never deleted. Holder only today: an amendment against the holder's will needs a tribunal rung that does not exist yet (§3.3 Q3) and is refused by name",
+        request: z.object({
+            slug: z.string(),
+            terms: z.string().optional(),
+            observable: z.string().optional(),
+            certifier: z.string().optional().describe("Still must not equal the holder"),
+            owed: z.number().int().optional(),
+            due_at: z.number().nullable().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            slug: z.string().optional(),
+            version: z.number().optional(),
+            supersedes: z.string().nullable().optional(),
+            state: z.enum(["unknown", "owed", "part-met", "met", "breached"]).optional(),
+            terms_hash: z.string().optional(),
+            blocked_on: z.string().optional().describe("'tribunal-rung' — the missing authority, named rather than silently allowed"),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", auth: "member",
+        reversible: false, idempotent: false, settles: "none",
+        examples: [{ slug: "ehc:cyp-005:H2", owed: 190, terms: "A hot meal every weekday of the YEAR, holidays included" }],
+    }),
+    "duty:evidence": receiver({
+        receiver: "duty:evidence",
+        summary: "File ONE delivery against the current version — the CERTIFIER only, matched against the persisted certifier from the attested caller. Idempotent by sha256(slug‖version‖ref), so a re-file changes nothing. A new delivery MARKS the holder's path",
+        request: z.object({
+            slug: z.string(),
+            ref: z.string().describe("The delivery, named: 'meal 2026-09-12', 'SLT session note wk37'"),
+            version: z.number().int().optional().describe("Defaults to the current version; an older one is refused, not back-filed quietly"),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            slug: z.string().optional(),
+            version: z.number().optional(),
+            id: z.string().optional(),
+            evidenced: z.number().optional().describe("A COUNT over duty_evidence, never a stored column"),
+            owed: z.number().optional(),
+            state: z.enum(["unknown", "owed", "part-met", "met", "breached"]).optional(),
+            recorded: z.boolean().optional().describe("false ⇒ this exact delivery was already on record"),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", auth: "member",
+        reversible: false, idempotent: true, settles: "none",
+        examples: [{ slug: "ehc:cyp-005:H2", ref: "hot meal received 2026-09-12" }],
+    }),
+    "duty:breach": receiver({
+        receiver: "duty:breach",
+        summary: "Compute the verdict and land it in the record. SILENCE IS BREACH: owed > count(evidence) with the window closed is `breached`, and no caller supplies a verdict. Warns the holder's path on the transition into breach — once, because the TRANSITION is the event. `breached` is NOT terminal: late evidence recomputes to `met`",
+        request: z.object({ slug: z.string() }),
+        response: z.object({
+            ok: z.boolean(),
+            slug: z.string().optional(),
+            version: z.number().optional(),
+            state: z.enum(["unknown", "owed", "part-met", "met", "breached"]).optional(),
+            changed: z.boolean().optional(),
+            owed: z.number().optional(),
+            evidenced: z.number().optional(),
+            due_at: z.number().nullable().optional(),
+            holder: z.string().optional(),
+            breached: z.boolean().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", auth: "member",
+        reversible: true, idempotent: true, settles: "none",
+        examples: [{ slug: "ehc:cyp-005:H2" }],
+    }),
+    "duty:get": receiver({
+        receiver: "duty:get",
+        summary: "Read a duty with its state COMPUTED, writing nothing — the read a plan surface makes. NOT public (a duty names a child): holder, certifier or platform staff only. The family's own rung is not modelled yet",
+        request: z.object({ slug: z.string() }),
+        response: z.object({
+            ok: z.boolean(),
+            slug: z.string().optional(),
+            version: z.number().optional(),
+            supersedes: z.string().nullable().optional(),
+            holder: z.string().optional(),
+            certifier: z.string().optional(),
+            terms: z.string().optional(),
+            observable: z.string().optional(),
+            owed: z.number().optional(),
+            evidenced: z.number().optional(),
+            due_at: z.number().nullable().optional(),
+            state: z.enum(["unknown", "owed", "part-met", "met", "breached"]).optional(),
+            stored_state: z.string().optional().describe("The cached column. It should equal `state`; a divergence means nothing has recomputed since the window closed"),
+            error: z.string().optional(),
+        }),
+        effect: "ask", cost: "free", auth: "member",
+        reversible: true, idempotent: true, settles: "none",
+        examples: [{ slug: "ehc:cyp-005:H2" }],
+    }),
+    // ── ui: — an agent's hand on the operator's own browser ───────────────────
+    //
+    // The ONLY receiver in the registry whose effect is a MOVE OF A HUMAN'S
+    // SCREEN, so it is the only one where "authority off ctx, never the payload"
+    // is not hygiene but the whole feature. Given a target-viewer field, this
+    // receiver is a machine for pushing any actor's reader anywhere — so there is
+    // no such field, and a payload that names one is REFUSED rather than ignored
+    // (silently stripping it would answer ok:true to a caller whose model of the
+    // world is wrong, and teach it the call worked).
+    "ui:navigate": receiver({
+        receiver: "ui:navigate",
+        summary: "Move the CALLER'S OWN reader to a same-origin path. Two independent checks, because one of them runs in code an untrusted caller can reach: (1) the SERVER addresses only the session that made this call — authority comes off the attested ctx, there is NO field naming a principal — `viewer`, `viewerId`, `actorId`, `actor`, `target`, `targetViewer`, `targetActor`, `session`, `sessionId`, `userId`, `uid`, `ownerSlug`, `audience` — and a payload carrying any of them is REFUSED outright rather than silently stripped (`workspace`/`slug` are NOT refused: they scope, they cannot name a reader); (2) the BROWSER independently drops any command that did not arrive on a stream it opened itself, so a command that somehow escaped (1) still moves nobody. Same-origin PATHS only — an absolute URL, a scheme, or a protocol-relative href is refused, never rewritten.",
+        request: z
+            .object({
+            href: z
+                .string()
+                .min(1)
+                .describe("Where to. A SAME-ORIGIN PATH: one leading '/', e.g. '/u/one/in'. Refused, never sanitised: an absolute URL ('https://evil.com/x'), any scheme ('javascript:', 'data:'), a protocol-relative href ('//evil.com'), the backslash form ('/\\evil.com'), a bare host ('evil.com/x'), and any href containing a tab/CR/LF. Measured against node's WHATWG parser: new URL('//evil.com', 'https://one.ie'), new URL('/\\evil.com', …) and new URL('/<TAB>/evil.com', …) ALL resolve to https://evil.com/ — the parser strips tab/CR/LF anywhere in the input, so the tab form is a real bypass of a naive startsWith('/') check. A navigate receiver that accepts arbitrary hrefs is an open redirect with an agent attached."),
+            reason: z
+                .enum(["select", "command", "agent"])
+                .optional()
+                .describe("Why the move happened, for the host's own judgment. Mirrors NavigateRequest.reason in one.ie/web/src/lib/navigate.ts, and is ECHOED back on the response so the transport has something to forward. CALLER-ASSERTED and carrying NO authority: an agent is free to send 'select', which reads as 'an operator clicked'. Nothing gates on it, and a host must not read it as evidence that a human was there."),
+            replace: z
+                .boolean()
+                .optional()
+                .describe("Replace the current history entry instead of pushing a new one. Default false: collapsing the entry deletes the operator's way back, so it is opt-in."),
+        })
+            .describe("There is deliberately no field naming WHO to move. The reader moved is always the caller's own, resolved from the attested session server-side. If you find yourself wanting a target, that is the defect arriving."),
+        response: z.object({
+            ok: z.boolean(),
+            href: z.string().optional().describe("The href as accepted — byte-identical to the request, never a rewritten one"),
+            replace: z.boolean().optional(),
+            reason: z
+                .enum(["select", "command", "agent"])
+                .optional()
+                .describe("The request's `reason`, echoed unchanged. Caller-asserted — never evidence of a human"),
+            audience: z
+                .string()
+                .optional()
+                .describe("The caller's OWN attested slug — echoed so a caller can see whose reader it addressed. Never a value the caller supplied"),
+            delivered: z
+                .boolean()
+                .optional()
+                .describe("Whether the command actually reached a browser. FALSE today for every call: the receiver validates and addresses, and the transport that carries it to the reader is a separate row (task:01a0a3789956c0b2d78d2487). A receiver that reached nobody must say so rather than answer a bare ok:true — the route:to-* namespace is the standing example of what the other choice costs"),
+            note: z.string().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask",
+        cost: "free",
+        auth: "session",
+        reversible: true,
+        idempotent: false,
+        settles: "none",
+        examples: [{ href: "/u/one/in", reason: "agent" }],
+    }),
 };
 /**
  * RECIPES — the four agent journeys as typed, ordered receiver sequences (C6).