@oneie/sdk 0.15.0 → 0.15.1

package/dist/receivers.js

@@ -974,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",
@@ -1028,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(),
@@ -1039,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,
     }),
@@ -1321,6 +1340,63 @@ 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",
@@ -1472,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
@@ -1851,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 },
@@ -2667,6 +2968,10 @@ export const RECEIVERS = {
             // 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(),
@@ -2879,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(),
         }),
@@ -3659,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({
@@ -3676,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.",
@@ -4319,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(),
@@ -5510,6 +5872,188 @@ export const RECEIVERS = {
         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).