@oneie/sdk 0.14.10 → 0.14.12

package/dist/receivers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"receivers.d.ts","sourceRoot":"","sources":["../src/receivers.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmyGc,CAAC;AAErC,sDAAsD;AACtD,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,SAAS,CAAC;AAElD,+CAA+C;AAC/C,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,YAAY,IACtC,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzF,iDAAiD;AACjD,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,YAAY,IACtC,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,CAAC,CAAC,CAAC,UAAU,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE1F;;;;;GAKG;AACH,eAAO,MAAM,OAAO;IAClB,iFAAiF;;IAEjF,wDAAwD;;IAExD,iEAAiE;;IAEjE,mDAAmD;;IAEnD,8DAA8D;;IAE9D,wFAAwF;;CAEvC,CAAC;AAEpD,8BAA8B;AAC9B,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,OAAO,CAAC"}
+{"version":3,"file":"receivers.d.ts","sourceRoot":"","sources":["../src/receivers.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAikHc,CAAC;AAErC,sDAAsD;AACtD,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,SAAS,CAAC;AAElD,+CAA+C;AAC/C,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,YAAY,IACtC,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAEzF,iDAAiD;AACjD,MAAM,MAAM,KAAK,CAAC,CAAC,SAAS,YAAY,IACtC,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,QAAQ,CAAC,CAAC,CAAC,UAAU,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE1F;;;;;GAKG;AACH,eAAO,MAAM,OAAO;IAClB,iFAAiF;;IAEjF,wDAAwD;;IAExD,iEAAiE;;IAEjE,mDAAmD;;IAEnD,8DAA8D;;IAE9D,wFAAwF;;CAEvC,CAAC;AAEpD,8BAA8B;AAC9B,MAAM,MAAM,UAAU,GAAG,MAAM,OAAO,OAAO,CAAC"}

package/dist/receivers.js

@@ -734,24 +734,49 @@ export const RECEIVERS = {
     }),
     "world:route": receiver({
         receiver: "world:route",
-        summary: "Route a tagged signal to THE handler via the ladder: learned tag-node path (follow_route) → staked subscribers (reputation-ranked) → CEO standing workflow; marks the delivery path so the next route is smarter. reply:true also invokes the resolved actor and returns its answer inline",
+        summary: "Route a tagged signal to THE handler via the ladder: learned tag-node path (follow_route) → staked subscribers (reputation-ranked) → CEO standing workflow; marks the delivery path so the next route is smarter. reply:true also invokes the resolved actor and returns its answer inline. decide:true instead answers the deterministic verdict { receiver, rung, reason } (reason: highway|classified|ceo) from the learned lane — a pure read, zero side effects, zero tokens; TypeQL twin: route_verdict (migration 0043)",
         request: z.object({
             tags: z.array(z.string()),
+            decide: z.boolean().optional(), // true → verdict-only: no delivery, no mark, no CEO trigger
             deliver: z.boolean().optional(),
             reply: z.boolean().optional(),
             board: z.literal("marketplace").optional(),
             slug: z.string().optional(),
             workspace: z.string().optional(),
-        }).catchall(z.unknown()), // extra keys = the message payload (e.g. content) — carried through to the resolved actor, never stripped
+        }).catchall(z.unknown()), // extra keys = the message payload (e.g. content, text) — carried through to the resolved actor, never stripped
         response: z.object({
             ok: z.boolean(),
             routed: z.enum(["learned", "staked", "explore", "ceo"]).optional(),
             actor: z.string().optional(),
+            // decide:true verdict fields — receiver null ⇔ reason 'ceo'; rung 1:1 with reason (highway→1 classified→2 ceo→3)
+            receiver: z.string().nullable().optional(),
+            rung: z.number().optional(),
+            reason: z.enum(["highway", "classified", "ceo"]).optional(),
             tags: z.array(z.string()).optional(),
             reply: z.object({ ok: z.boolean(), text: z.string().optional(), error: z.string().optional() }).optional(),
         }),
         effect: "ask",
     }),
+    "world:suggest-workflow": receiver({
+        receiver: "world:suggest-workflow",
+        summary: "Rank staked workflows by tag match + earned track record (claw_paths), read-only — no delivery, no run, no auto-trigger. Requires >=3 successful runs before a workflow is surfaced; caps at 3 suggestions",
+        request: z.object({
+            tags: z.array(z.string()),
+            workspace: z.string().optional(),
+            slug: z.string().optional(),
+        }).catchall(z.unknown()),
+        response: z.object({
+            ok: z.boolean(),
+            suggestions: z.array(z.object({
+                workflowId: z.string(),
+                name: z.string(),
+                weight: z.number(),
+                tags: z.array(z.string()),
+            })).optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", idempotent: true,
+    }),
     "tasks:announce": receiver({
         receiver: "tasks:announce",
         summary: "Announce a task into the world by its tags — the first caller of world:announce",
@@ -768,7 +793,17 @@ export const RECEIVERS = {
     "tasks:mine": receiver({
         receiver: "tasks:mine",
         summary: "My work queue: the open tasks whose words match what I subscribed to, ranked by learned weight (context-strength), not static priority",
-        request: z.object({ limit: z.number().optional() }),
+        // `workspace` is not decoration — /api/ask reads a SERVICE caller's nominated slug off
+        // validation.payload.slug|workspace, and zod .object() STRIPS unknown keys. Omitting the
+        // field here meant a service call could never name a workspace: ctx.ownerSlug stayed
+        // empty and the resolver answered "forbidden: authentication required" no matter which
+        // key was presented. A session-authenticated browser call was unaffected (locals.slug
+        // supplies the workspace), which is why this only ever failed for the harness.
+        request: z.object({
+            limit: z.number().optional(),
+            workspace: z.string().optional(),
+            slug: z.string().optional(),
+        }),
         response: z.object({
             ok: z.boolean(),
             tasks: z.array(z.object({
@@ -788,7 +823,14 @@ export const RECEIVERS = {
     "tasks:everywhere": receiver({
         receiver: "tasks:everywhere",
         summary: "Every workspace I belong to, one queue: open+picked tasks visible by assignment/follow/ownership, with claimable + mine + offeredByMe flags; closed:true returns the logbook (done/verified, newest first)",
-        request: z.object({ limit: z.number().optional(), closed: z.boolean().optional() }),
+        // See tasks:mine — a service caller nominates its workspace here, and zod strips any
+        // field the schema does not declare.
+        request: z.object({
+            limit: z.number().optional(),
+            closed: z.boolean().optional(),
+            workspace: z.string().optional(),
+            slug: z.string().optional(),
+        }),
         response: z.object({
             ok: z.boolean(),
             tasks: z.array(z.object({
@@ -810,6 +852,105 @@ export const RECEIVERS = {
         }),
         effect: "ask", idempotent: true,
     }),
+    "factory:elaborate": receiver({
+        receiver: "factory:elaborate",
+        summary: "Create one rung of the derivation ladder (objective | deliverable | task) and hang it under its parent with containment — the ELABORATE move. The rung id is derived from slug + ordinal, so a retry dedupes instead of duplicating",
+        request: z.object({
+            type: z.enum(["objective", "deliverable", "task"]),
+            // The promise/plan slug the rung belongs to, and its ordinal within that slug.
+            // Both required: together they derive the rung id (Interface Contract #1,
+            // text/factory-todo.md) and the `rung:<type>:<slug>:<ordinal>` idempotency tag.
+            slug: z.string(),
+            ordinal: z.number(),
+            name: z.string(),
+            // The rung above — its containment container. Must live in the same resolved
+            // workspace; a parent the caller cannot see is refused, never silently skipped.
+            parent: z.string().optional(),
+            // The machine-observable accept: check for this rung (factory-plan.md §7.3).
+            exitCondition: z.string().optional(),
+            notes: z.string().optional(),
+            tags: z.array(z.string()).optional(),
+            // Same authorization contract as tasks:create's workspace — honored only for an
+            // authorized caller, otherwise it falls back to the caller's own slug.
+            workspace: z.string().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            tid: z.string().optional(),
+            type: z.string().optional(),
+            parent: z.string().nullable().optional(),
+            tags: z.array(z.string()).optional(),
+            deduped: z.boolean().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", idempotent: 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",
+        request: z.object({
+            phase: z.enum(["open", "close"]),
+            // open
+            task: z.string().optional(),
+            ordinal: z.number().optional(),
+            // Which actor ran it — provenance (path attempt → actor), never authority.
+            actorId: z.string().optional(),
+            tags: z.array(z.string()).optional(),
+            // close
+            attempt: z.string().optional(),
+            status: z.enum(["done", "verified", "failed", "dissolved"]).optional(),
+            produced: z.string().optional(),
+            // Scores land on the ATTEMPT — the graph is the authority; a composite on the
+            // plan thing is a cached projection over the attempts it contains (§3.2).
+            rubric: z.object({
+                composite: z.number().optional(),
+                security: z.number().optional(),
+                stability: z.number().optional(),
+                simplicity: z.number().optional(),
+                speed: z.number().optional(),
+            }).optional(),
+            workspace: z.string().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            tid: z.string().optional(),
+            task: z.string().optional(),
+            phase: z.string().optional(),
+            status: z.string().optional(),
+            produced: z.string().nullable().optional(),
+            rubric: z.array(z.string()).optional(),
+            deduped: z.boolean().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", idempotent: true,
+    }),
+    "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",
+        request: z.object({
+            // The plan slug the operator sees ("factory"). The plan tid is resolved server-side;
+            // a tid from the body would be an addressable another tenant could guess.
+            slug: z.string(),
+            // Lift the latch instead of setting it. A stop with no release bricks the only
+            // write path the ladder has.
+            release: z.boolean().optional(),
+            // Optionally dissolve one in-flight attempt in the same act.
+            attempt: z.string().optional(),
+            // Same authorization contract as factory:elaborate's workspace — honored only for
+            // an authorized caller, otherwise it resolves back to the caller's own slug.
+            workspace: z.string().optional(),
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            tid: z.string().optional(),
+            slug: z.string().optional(),
+            halted: z.boolean().optional(),
+            attempt: z.string().nullable().optional(),
+            deduped: z.boolean().optional(),
+            error: z.string().optional(),
+        }),
+        effect: "ask", idempotent: true,
+    }),
     "tasks:create": receiver({
         receiver: "tasks:create",
         summary: "Write one open task to the substrate and announce it by its tags in the same act — the quick-add entry point",
@@ -831,11 +972,21 @@ export const RECEIVERS = {
     }),
     "tasks:claim": receiver({
         receiver: "tasks:claim",
-        summary: "Take a task off the queue: blocker-gate → status picked → tag the claimant @<slug>. The claimant is the attested caller, never a body field",
+        summary: "Take a task off the queue: blocker-gate → status picked → tag the claimant @<slug>. Address it by tid, or by the /do slug the task was created under. The claimant is the attested caller, never a body field",
+        // Addressable two ways, and BOTH must be optional here. The resolver has always
+        // supported slug (resolveTaskBySlug) because create returns a random task:<traceId>
+        // that no caller can derive — but this schema required `tid`, so every slug-addressed
+        // claim (do-signal.sh --task-claim, do-fleet.sh's lease) was rejected at validation
+        // before the resolver ran. The contract, not the resolver, was the dead wire.
         request: z.object({
-            tid: z.string(),
+            tid: z.string().optional(),
+            // The kebab /do slug the task carries as a `slug:` tag.
+            slug: z.string().optional(),
             // Viewed workspace — same authorization contract as tasks:create's workspace.
             workspace: z.string().optional(),
+        }).refine((v) => !!v.tid || !!v.slug, {
+            message: "address the task by tid or slug",
+            path: ["tid"],
         }),
         response: z.object({
             ok: z.boolean().optional(),
@@ -883,8 +1034,12 @@ export const RECEIVERS = {
     "tasks:link": receiver({
         receiver: "tasks:link",
         summary: "Close the handoff: record that a claimed task was built via /do <slug> — append a provenance line to the task's notes (the id back-ref + doc stems) and move it to done. Auth: attested caller only",
+        // The slug IS the handle here — the resolver requires it and resolves the origin tid
+        // from the `slug:` tag, treating an explicit tid as an optional override for direct
+        // callers. Requiring tid (as this did) rejected every /do close, which knows the plan
+        // slug and never the generated task:<traceId>.
         request: z.object({
-            tid: z.string(),
+            tid: z.string().optional(),
             // The kebab /do slug the task was built into (the docs backfilled under text/<slug>*).
             slug: z.string(),
             // Doc stems the /do run produced (e.g. ["usage-billing", "usage-billing-plan"]).
@@ -979,6 +1134,8 @@ export const RECEIVERS = {
             price: z.number().nonnegative(),
             currency: z.string().default("credits"),
             deadline: z.string().datetime(),
+            pid: z.string().optional(),
+            ppid: z.string().optional(),
         }),
         response: z.union([
             z.object({ ok: z.literal(true), deal: z.object({ id: z.string(), stage: z.string(), version: z.number() }) }),
@@ -1077,6 +1234,20 @@ export const RECEIVERS = {
         ]),
         effect: "ask", auth: "required", reversible: false, idempotent: false,
     }),
+    "market:offers": receiver({
+        receiver: "market:offers",
+        summary: "List the caller's own deals (as buyer or seller), optionally filtered by stage",
+        request: z.object({ stage: z.string().optional() }),
+        response: z.union([
+            z.object({ ok: z.literal(true), deals: z.array(z.object({
+                    id: z.string(), buyer: z.string(), seller: z.string(), skill: z.string(),
+                    price: z.number(), currency: z.string(), stage: z.string(), version: z.number(),
+                    pid: z.string().optional(), ppid: z.string().optional(),
+                })) }),
+            z.object({ ok: z.literal(false), error: z.string() }),
+        ]),
+        effect: "ask", auth: "required", cost: "free", idempotent: true,
+    }),
     // ── market (TRADE) ──
     "market:hire": receiver({
         receiver: "market:hire",
@@ -1911,6 +2082,76 @@ export const RECEIVERS = {
         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:publish-pack': receiver({
+        receiver: "pages:publish-pack",
+        summary: "Publish all (or a listed subset of) a workspace's draft pack pages in one call — the go-live step. Reuses pages:publish's exact UPDATE, looped once, gated once.",
+        request: z.object({ slug: z.string(), pages: z.array(z.union([z.string(), z.object({ slug: z.string() })])).optional() }),
+        response: z.object({ ok: z.boolean(), published: z.number().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: true, 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.",
+        request: z.object({
+            slug: z.string(),
+            pages: z.array(z.object({ pageSlug: z.string(), slug: z.string() })),
+            facts: z.object({
+                identity: z.object({
+                    company: z.string(),
+                    ownerName: z.string(),
+                    phone: z.string(),
+                    foundedYear: z.number(),
+                    city: z.string(),
+                    state: z.string(),
+                    metro: z.string(),
+                    streetAddress: z.string(),
+                }),
+                licensing: z.object({
+                    usdot: z.string().optional(),
+                    mc: z.string().optional(),
+                    stateLicenseNumber: z.string(),
+                    regulatorOverride: z.string().optional(),
+                }),
+                reputation: z.object({ starRating: z.number(), reviewCount: z.number(), movesCompleted: z.number() }),
+                serviceArea: z.object({ neighborhoods: z.array(z.string()).min(1) }),
+                pricing: z.object({
+                    hourlyRatePerMover: z.number(),
+                    truckFee: z.number(),
+                    tiers: z.record(z.string(), z.object({ low: z.number(), high: z.number() })).optional(),
+                }),
+                story: z.object({ originSentence: z.string().optional() }).optional(),
+                testimonials: z.array(z.object({ quote: z.string(), reviewerName: z.string(), moveType: z.string() })).optional(),
+                source: z.object({ url: z.string().optional() }).optional(),
+            }),
+        }),
+        response: z.object({ ok: z.boolean(), filled: z.number().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: false, auth: "member",
+    }),
+    "pages:fill-pack-extract": receiver({
+        receiver: "pages:fill-pack-extract",
+        summary: "Best-effort business facts from an operator's own URL or a free-text description — fetch-then-confirm, never fetch-then-apply. Returns candidate facts for a form to pre-fill; nothing here writes a page.",
+        request: z.object({ slug: z.string(), url: z.string().optional(), text: z.string().optional() }),
+        response: z.object({ ok: z.boolean(), facts: z.record(z.string(), z.unknown()).optional(), error: z.string().optional() }),
+        effect: "ask", cost: "variable", reversible: true, idempotent: true, auth: "member",
+    }),
+    "movers:build": receiver({
+        receiver: "movers:build",
+        summary: "The one intake orchestrator — takes a URL or a free-text description, extracts MoverBusinessFacts, clones the movers-factory template, and starts the run. The single op every door (web form, chat) shares; composes pages:fill-pack-extract + workflow:create + workflow:run, adds no new build primitive.",
+        request: z.object({ slug: z.string(), url: z.string().optional(), describe: z.string().optional() }),
+        response: z.object({ ok: z.boolean(), runId: z.string().optional(), facts: z.record(z.string(), z.unknown()).optional(), error: z.string().optional() }),
+        effect: "ask", cost: "variable", reversible: false, idempotent: false, auth: "member",
+        examples: [{ slug: "summit-movers", describe: "We're Summit Movers, family-run in Austin since 2015, licensed CAL-T, $65/hr per mover." }],
+        surfaces: { chat: true },
+    }),
+    "movers:funnel-provision": receiver({
+        receiver: "movers:funnel-provision",
+        summary: "Open, sponsored no-account provision — takes a company name plus a URL or description, provisions a capped child workspace under moverchat, and starts movers:build. Rate-limited per visitor + a global daily ceiling; refuses past any wall rather than draining moverchat's operating credits. The single writer behind both the homepage door and this chat tool.",
+        request: z.object({ name: z.string(), url: z.string().optional(), describe: z.string().optional(), phone: z.string().optional(), email: z.string().optional(), visitorHash: z.string() }),
+        response: z.object({ ok: z.boolean(), previewToken: z.string().optional(), slug: z.string().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "variable", reversible: false, idempotent: false, auth: "public",
+        examples: [{ name: "Summit Movers", url: "https://summitmovers.example.com", visitorHash: "chat:web:conv-123" }],
+        surfaces: { chat: true },
+    }),
     "pages:versions": receiver({
         receiver: "pages:versions",
         summary: "List a page's saved version snapshots, newest first",
@@ -1925,6 +2166,13 @@ export const RECEIVERS = {
         response: z.object({ ok: z.boolean(), slug: z.string().optional(), title: z.string().optional(), url: z.string().optional(), status: z.string().optional(), restoredTs: z.number().optional(), error: z.string().optional() }),
         effect: "ask", cost: "free", reversible: false, idempotent: false, auth: "member",
     }),
+    "mover:agent-context": receiver({
+        receiver: "mover:agent-context",
+        summary: "The fact→agent bridge — render MoverBusinessFacts into ground-truth prose and write it to the workspace's company_context, so the mounted chat agent answers as the operator's real business. Never invents a service/review/policy; same facts as pages:fill-pack, one intake, two artifacts.",
+        request: z.object({ slug: z.string(), facts: z.record(z.string(), z.unknown()) }),
+        response: z.object({ ok: z.boolean(), chars: z.number().optional(), error: z.string().optional() }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, auth: "member",
+    }),
     "settings:write": receiver({
         receiver: "settings:write",
         summary: "Write a workspace setting value (caller or authorized descendant)",
@@ -2088,7 +2336,7 @@ export const RECEIVERS = {
             slug: z.string(), // provider workspace
             service: z.string().optional(), // service_id; omitted → the workspace's first active
             date: z.string().optional(), // 'YYYY-MM-DD'; omitted → next N open days
-            days: z.number().int().min(1).max(14).optional(), // window size when date omitted
+            days: z.number().int().min(1).max(62).optional(), // window size when date omitted (month calendar needs ~2 months)
         }),
         response: z.object({
             service: z.object({
@@ -2387,13 +2635,31 @@ export const RECEIVERS = {
         response: z.object({
             ok: z.boolean(),
             stepCount: z.number().optional(),
+            warnings: z.array(z.string()).optional(), // §9 advisories (never block); grammar: code | code:stepId
             idMap: z.record(z.string(), z.string()).optional(), // tempId → persisted id
-            error: z.string().optional(), // 'cycle_detected' | 'conflict' | 'invalid_diff'
+            error: z.string().optional(), // 'cycle_detected' | 'conflict' | 'invalid_diff' | 'multiple_triggers' | 'edge_unknown_step' | 'invalid_config' | 'bad_expr' | 'unsupported_field'
         }),
         effect: "ask", cost: "free", reversible: true, idempotent: false, simulatable: true,
         auth: "manage_workflows",
         examples: [{ workflowId: "wf_abc", diff: { add: [{ tempId: "s1", kind: "trigger", name: "On signup", config: "{}" }] }, simulate: true }],
     }),
+    "workflow:validate": receiver({
+        receiver: "workflow:validate",
+        summary: "Run the §9 gate on a WorkflowDiff without persisting — kinds/config shapes, exactly-one-trigger, edges reference real steps, chain cycles; advisories ride back as warnings (grammar: code | code:stepId, never block). Every save door calls this.",
+        request: z.object({
+            workflowId: z.string(),
+            diff: WorkflowDiffSchema,
+        }),
+        response: z.object({
+            ok: z.boolean(),
+            stepCount: z.number().optional(),
+            warnings: z.array(z.string()).optional(),
+            error: z.string().optional(), // 'multiple_triggers'|'edge_unknown_step'|'invalid_config'|'bad_expr'|'cycle_detected'|'invalid_diff'|'unsupported_field'
+        }),
+        effect: "ask", cost: "free", reversible: true, idempotent: true, simulatable: true,
+        auth: "manage_workflows",
+        examples: [{ workflowId: "wf_abc", diff: { add: [{ tempId: "s1", kind: "trigger", name: "On signup", config: "{}" }] } }],
+    }),
     "workflow:run": receiver({
         receiver: "workflow:run",
         summary: "Start a run — spawns the WorkflowRun DO, executes each step, marks path strength on traversed edges",
@@ -2497,6 +2763,19 @@ export const RECEIVERS = {
         effect: "signal", cost: "free", idempotent: true, simulatable: false, auth: "manage_workflows",
         examples: [{ runId: "run_1", stepId: "s2", stepName: "Approve contract" }],
     }),
+    "workflow:settled-notify": receiver({
+        receiver: "workflow:settled-notify",
+        summary: "Tell a run's started_by that it finished when there is no chat conversation to carry the outcome (manual/canvas/scheduled runs). settle() fires this group-less terminal only; a plain status line, never approval markup. Sibling of workflow:resumed-notify.",
+        request: z.object({
+            runId: z.string(),
+            group: z.string(), // started_by — the workspace to notify
+            status: z.string().optional(), // 'done' | 'failed'
+            workflowName: z.string().optional(),
+        }),
+        response: z.object({ ok: z.boolean(), group: z.string().optional(), error: z.string().optional() }),
+        effect: "signal", cost: "free", idempotent: true, simulatable: false, auth: "manage_workflows",
+        examples: [{ runId: "run_1", group: "acme", status: "done" }],
+    }),
     "workflow:stop": receiver({
         receiver: "workflow:stop",
         summary: "Park a live run at its current step (status → paused); preserves the resume cursor so human:resolve or a re-run continues it",