toolroll 0.9.36 → 0.9.37

package/dist/contracts/gateway-tools.d.ts

@@ -0,0 +1,374 @@
+/**
+ * The MCP gateway's tools (docs/plans/zod-revamp.md, item 5; docs/mcp-gateway-spec.md): one input schema per tool and
+ * one output schema for what each returns. The input schema is the `inputSchema` tools/list advertises and the check
+ * a call is read with before its handler runs (mcp.ts): a call it refuses is a JSON-RPC InvalidParams error naming each
+ * path, never a tool refusal. The assignment tools' schemas are also what `toolroll assignment` reads its flags with
+ * (assignment-adapters.ts), so the CLI and the gateway take exactly the same arguments.
+ *
+ * A coordinator names a project by its path and a task by `ref`; the lead's tools (lead-tools.ts) say r1 and `task`.
+ * Output schemas describe a result's top level: checked in tests, logged when a result disagrees, never a refusal.
+ */
+import { z } from "zod";
+/** The assignment tools, by the operation `toolroll assignment` names them. */
+export declare const ASSIGNMENT_INPUTS: {
+    readonly show: z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>;
+    readonly updates: z.ZodObject<{
+        after: z.ZodOptional<z.ZodInt>;
+        limit: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    readonly claim: z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>;
+    readonly check: z.ZodObject<{
+        ref: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>;
+    readonly brief: z.ZodObject<{
+        repo: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    readonly inbox: z.ZodObject<{
+        consumer: z.ZodString;
+        limit: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    readonly ack: z.ZodObject<{
+        consumer: z.ZodString;
+        batchId: z.ZodString;
+    }, z.core.$strict>;
+};
+export type AssignmentOperation = keyof typeof ASSIGNMENT_INPUTS;
+export type AssignmentInput<O extends AssignmentOperation> = z.infer<(typeof ASSIGNMENT_INPUTS)[O]>;
+export declare const GATEWAY_TOOL_INPUTS: {
+    readonly get_project_context: z.ZodObject<{
+        repo: z.ZodString;
+        query: z.ZodString;
+        mode: z.ZodOptional<z.ZodEnum<{
+            impact: "impact";
+            search: "search";
+        }>>;
+    }, z.core.$strict>;
+    readonly get_assignment: z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>;
+    readonly list_assignment_updates: z.ZodObject<{
+        after: z.ZodOptional<z.ZodInt>;
+        limit: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    readonly claim_assignment: z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>;
+    readonly acknowledge_assignment: z.ZodObject<{
+        ref: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>;
+    readonly get_assignment_brief: z.ZodObject<{
+        repo: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    readonly get_assignment_inbox: z.ZodObject<{
+        consumer: z.ZodString;
+        limit: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    readonly acknowledge_assignment_delivery: z.ZodObject<{
+        consumer: z.ZodString;
+        batchId: z.ZodString;
+    }, z.core.$strict>;
+    readonly status: z.ZodObject<{}, z.core.$strict>;
+    readonly list_tasks: z.ZodObject<{
+        state: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            done: "done";
+            failed: "failed";
+            queued: "queued";
+            running: "running";
+        }>>;
+        repo: z.ZodOptional<z.ZodString>;
+        cursor: z.ZodOptional<z.ZodInt>;
+        limit: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+    readonly get_task: z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>;
+    readonly list_repos: z.ZodObject<{}, z.core.$strict>;
+    readonly recap: z.ZodObject<{
+        since: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly list_decisions: z.ZodObject<{}, z.core.$strict>;
+    readonly queue: z.ZodObject<{
+        repo: z.ZodString;
+    }, z.core.$strict>;
+    readonly get_decision: z.ZodObject<{
+        decision: z.ZodInt;
+    }, z.core.$strict>;
+    readonly propose_next: z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>;
+    readonly propose_reserve: z.ZodObject<{
+        ref: z.ZodString;
+        worker: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    readonly propose_hold: z.ZodObject<{
+        ref: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>;
+    readonly propose_unhold: z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$strict>;
+    readonly propose_scope: z.ZodObject<{
+        ref: z.ZodString;
+        goal: z.ZodString;
+        not: z.ZodOptional<z.ZodString>;
+        touches: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    readonly propose_cancel: z.ZodObject<{
+        ref: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>;
+    readonly propose_answer: z.ZodObject<{
+        decision: z.ZodInt;
+        option: z.ZodString;
+        rationale: z.ZodString;
+    }, z.core.$strict>;
+    readonly get_contract: z.ZodObject<{}, z.core.$strict>;
+    readonly file_proposal: z.ZodObject<{
+        repo: z.ZodString;
+        title: z.ZodString;
+        intent: z.ZodOptional<z.ZodString>;
+        idempotency_key: z.ZodString;
+        deliverable: z.ZodOptional<z.ZodEnum<{
+            branch: "branch";
+            report: "report";
+        }>>;
+    }, z.core.$strict>;
+};
+export type GatewayToolName = keyof typeof GATEWAY_TOOL_INPUTS;
+export type GatewayToolInput<N extends GatewayToolName> = z.infer<(typeof GATEWAY_TOOL_INPUTS)[N]>;
+export declare const GATEWAY_TOOL_OUTPUTS: {
+    readonly get_project_context: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        readOnly: z.ZodBoolean;
+        query: z.ZodString;
+        mode: z.ZodEnum<{
+            impact: "impact";
+            search: "search";
+        }>;
+        asOf: z.ZodString;
+        excerpts: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>;
+    readonly get_assignment: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        rootId: z.ZodString;
+        activeTaskId: z.ZodString;
+        title: z.ZodString;
+        state: z.ZodString;
+        detail: z.ZodString;
+        attention: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>;
+    readonly list_assignment_updates: z.ZodObject<{
+        events: z.ZodArray<z.ZodUnknown>;
+        nextCursor: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+    }, z.core.$loose>;
+    readonly claim_assignment: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        rootId: z.ZodString;
+        activeTaskId: z.ZodString;
+        title: z.ZodString;
+        state: z.ZodString;
+        detail: z.ZodString;
+        attention: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>;
+    readonly acknowledge_assignment: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        rootId: z.ZodString;
+        activeTaskId: z.ZodString;
+        title: z.ZodString;
+        state: z.ZodString;
+        detail: z.ZodString;
+        attention: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>;
+    readonly get_assignment_brief: z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        asOf: z.ZodString;
+        readOnly: z.ZodLiteral<true>;
+        assignments: z.ZodArray<z.ZodUnknown>;
+        projects: z.ZodArray<z.ZodUnknown>;
+        omissions: z.ZodObject<{}, z.core.$loose>;
+    }, z.core.$loose>;
+    readonly get_assignment_inbox: z.ZodObject<{
+        batch: z.ZodObject<{
+            id: z.ZodNullable<z.ZodString>;
+            consumer: z.ZodString;
+            events: z.ZodArray<z.ZodUnknown>;
+            hasMore: z.ZodBoolean;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    readonly acknowledge_assignment_delivery: z.ZodObject<{
+        alreadyAcknowledged: z.ZodBoolean;
+    }, z.core.$loose>;
+    readonly status: z.ZodObject<{
+        waitsOnYou: z.ZodNumber;
+        waits: z.ZodObject<{
+            approvals: z.ZodNumber;
+            questions: z.ZodNumber;
+            incidents: z.ZodNumber;
+            picks: z.ZodNumber;
+        }, z.core.$loose>;
+    }, z.core.$loose>;
+    readonly list_tasks: z.ZodObject<{
+        tasks: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>;
+    readonly get_task: z.ZodObject<{
+        ref: z.ZodString;
+    }, z.core.$loose>;
+    readonly list_repos: z.ZodObject<{
+        repos: z.ZodArray<z.ZodObject<{
+            repo: z.ZodString;
+            mode: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+    readonly recap: z.ZodObject<{
+        since: z.ZodNullable<z.ZodString>;
+        repos: z.ZodArray<z.ZodUnknown>;
+        waitsOnYou: z.ZodObject<{
+            decisions: z.ZodArray<z.ZodUnknown>;
+            incidents: z.ZodNumber;
+            scopesAwaitingApproval: z.ZodArray<z.ZodUnknown>;
+        }, z.core.$loose>;
+        running: z.ZodArray<z.ZodUnknown>;
+        truncated: z.ZodBoolean;
+    }, z.core.$loose>;
+    readonly list_decisions: z.ZodObject<{
+        decisions: z.ZodArray<z.ZodObject<{
+            decision: z.ZodNumber;
+            task: z.ZodString;
+            question: z.ZodString;
+            options: z.ZodArray<z.ZodUnknown>;
+            ageHours: z.ZodNumber;
+        }, z.core.$loose>>;
+        truncated: z.ZodBoolean;
+    }, z.core.$loose>;
+    readonly queue: z.ZodObject<{
+        columns: z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            tasks: z.ZodArray<z.ZodUnknown>;
+        }, z.core.$loose>>;
+        repo: z.ZodString;
+    }, z.core.$loose>;
+    readonly get_decision: z.ZodObject<{
+        repo: z.ZodString;
+        decision: z.ZodNumber;
+        task: z.ZodString;
+        state: z.ZodString;
+        question: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            reversible: z.ZodBoolean;
+            consequence: z.ZodString;
+        }, z.core.$loose>>;
+        ageHours: z.ZodNumber;
+    }, z.core.$loose>;
+    readonly propose_next: z.ZodObject<{
+        proposal: z.ZodNumber;
+        kind: z.ZodEnum<{
+            answer: "answer";
+            cancel: "cancel";
+            hold: "hold";
+            next: "next";
+            reserve: "reserve";
+            scope: "scope";
+            unhold: "unhold";
+        }>;
+        awaiting: z.ZodString;
+    }, z.core.$loose>;
+    readonly propose_reserve: z.ZodObject<{
+        proposal: z.ZodNumber;
+        kind: z.ZodEnum<{
+            answer: "answer";
+            cancel: "cancel";
+            hold: "hold";
+            next: "next";
+            reserve: "reserve";
+            scope: "scope";
+            unhold: "unhold";
+        }>;
+        awaiting: z.ZodString;
+    }, z.core.$loose>;
+    readonly propose_hold: z.ZodObject<{
+        proposal: z.ZodNumber;
+        kind: z.ZodEnum<{
+            answer: "answer";
+            cancel: "cancel";
+            hold: "hold";
+            next: "next";
+            reserve: "reserve";
+            scope: "scope";
+            unhold: "unhold";
+        }>;
+        awaiting: z.ZodString;
+    }, z.core.$loose>;
+    readonly propose_unhold: z.ZodObject<{
+        proposal: z.ZodNumber;
+        kind: z.ZodEnum<{
+            answer: "answer";
+            cancel: "cancel";
+            hold: "hold";
+            next: "next";
+            reserve: "reserve";
+            scope: "scope";
+            unhold: "unhold";
+        }>;
+        awaiting: z.ZodString;
+    }, z.core.$loose>;
+    readonly propose_scope: z.ZodObject<{
+        proposal: z.ZodNumber;
+        kind: z.ZodEnum<{
+            answer: "answer";
+            cancel: "cancel";
+            hold: "hold";
+            next: "next";
+            reserve: "reserve";
+            scope: "scope";
+            unhold: "unhold";
+        }>;
+        awaiting: z.ZodString;
+    }, z.core.$loose>;
+    readonly propose_cancel: z.ZodObject<{
+        proposal: z.ZodNumber;
+        kind: z.ZodEnum<{
+            answer: "answer";
+            cancel: "cancel";
+            hold: "hold";
+            next: "next";
+            reserve: "reserve";
+            scope: "scope";
+            unhold: "unhold";
+        }>;
+        awaiting: z.ZodString;
+    }, z.core.$loose>;
+    readonly propose_answer: z.ZodObject<{
+        proposal: z.ZodNumber;
+        kind: z.ZodEnum<{
+            answer: "answer";
+            cancel: "cancel";
+            hold: "hold";
+            next: "next";
+            reserve: "reserve";
+            scope: "scope";
+            unhold: "unhold";
+        }>;
+        awaiting: z.ZodString;
+    }, z.core.$loose>;
+    readonly get_contract: z.ZodObject<{
+        contract: z.ZodString;
+    }, z.core.$loose>;
+    readonly file_proposal: z.ZodObject<{
+        ref: z.ZodString;
+        replayed: z.ZodBoolean;
+        admission: z.ZodString;
+    }, z.core.$loose>;
+};
+export type GatewayToolOutput<N extends GatewayToolName> = z.infer<(typeof GATEWAY_TOOL_OUTPUTS)[N]>;

package/dist/contracts/gateway-tools.js

@@ -0,0 +1,94 @@
+/**
+ * The MCP gateway's tools (docs/plans/zod-revamp.md, item 5; docs/mcp-gateway-spec.md): one input schema per tool and
+ * one output schema for what each returns. The input schema is the `inputSchema` tools/list advertises and the check
+ * a call is read with before its handler runs (mcp.ts): a call it refuses is a JSON-RPC InvalidParams error naming each
+ * path, never a tool refusal. The assignment tools' schemas are also what `toolroll assignment` reads its flags with
+ * (assignment-adapters.ts), so the CLI and the gateway take exactly the same arguments.
+ *
+ * A coordinator names a project by its path and a task by `ref`; the lead's tools (lead-tools.ts) say r1 and `task`.
+ * Output schemas describe a result's top level: checked in tests, logged when a result disagrees, never a refusal.
+ */
+import { z } from "zod";
+import { TEXT_LIMITS } from "../text-limits.js";
+import { catchUpOutput, decisionOutput, decisionsOutput, LISTED_TASK_STATES, queueColumnsOutput, recapOutput, repositoryContextOutput, scopeText, touches } from "./lead-tools.js";
+const text = (key) => z.string().max(TEXT_LIMITS[key]);
+const ref = z.string().min(1).max(TEXT_LIMITS.taskRef);
+const projectPath = text("projectPath").min(1);
+const gatewayRepo = text("gatewayRepo").min(1);
+const consumer = z.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9-]{0,63}$/, { error: "must be a stable consumer name: lowercase letters, digits and hyphens" });
+const limit = (most) => z.int().min(1).max(most);
+/** The assignment tools, by the operation `toolroll assignment` names them. */
+export const ASSIGNMENT_INPUTS = {
+    show: z.strictObject({ ref }),
+    updates: z.strictObject({ after: z.int().min(0).optional(), limit: limit(100).optional() }),
+    claim: z.strictObject({ ref }),
+    check: z.strictObject({ ref, digest: z.string().min(64).max(64).regex(/^[a-f0-9]{64}$/, { error: "must be the exact 64-character receipt digest from assignment show" }) }),
+    brief: z.strictObject({ repo: projectPath.optional(), limit: limit(25).optional() }),
+    inbox: z.strictObject({ consumer, limit: limit(100).optional() }),
+    ack: z.strictObject({ consumer, batchId: z.string().min(32).max(32).regex(/^[a-f0-9]{32}$/, { error: "must be the exact batchId from assignment inbox" }) }),
+};
+export const GATEWAY_TOOL_INPUTS = {
+    get_project_context: z.strictObject({ repo: projectPath, query: text("contextQuery").min(1), mode: z.enum(["search", "impact"]).optional() }),
+    get_assignment: ASSIGNMENT_INPUTS.show,
+    list_assignment_updates: ASSIGNMENT_INPUTS.updates,
+    claim_assignment: ASSIGNMENT_INPUTS.claim,
+    acknowledge_assignment: ASSIGNMENT_INPUTS.check,
+    get_assignment_brief: ASSIGNMENT_INPUTS.brief,
+    get_assignment_inbox: ASSIGNMENT_INPUTS.inbox,
+    acknowledge_assignment_delivery: ASSIGNMENT_INPUTS.ack,
+    status: z.strictObject({}),
+    list_tasks: z.strictObject({ state: z.enum(LISTED_TASK_STATES).optional(), repo: text("gatewayRepo").optional(), cursor: z.int().min(0).optional(), limit: limit(50).optional() }),
+    get_task: z.strictObject({ ref }),
+    list_repos: z.strictObject({}),
+    recap: z.strictObject({ since: text("recapSince").optional() }),
+    list_decisions: z.strictObject({}),
+    queue: z.strictObject({ repo: gatewayRepo }),
+    get_decision: z.strictObject({ decision: z.int().min(1) }),
+    propose_next: z.strictObject({ ref }),
+    propose_reserve: z.strictObject({ ref, worker: text("workerName").nullable() }),
+    propose_hold: z.strictObject({ ref, reason: text("proposalReason") }),
+    propose_unhold: z.strictObject({ ref }),
+    propose_scope: z.strictObject({ ref, goal: scopeText, not: scopeText.optional(), touches: touches.optional() }),
+    propose_cancel: z.strictObject({ ref, reason: text("proposalReason") }),
+    propose_answer: z.strictObject({ decision: z.int().min(1), option: text("answerOption").min(1), rationale: text("answerRationale") }),
+    get_contract: z.strictObject({}),
+    file_proposal: z.strictObject({
+        repo: gatewayRepo, title: text("taskTitle").min(1), intent: scopeText.optional(), idempotency_key: text("idempotencyKey").min(8),
+        deliverable: z.enum(["branch", "report"]).optional(),
+    }),
+};
+// ------------------------------------------------------------- outputs
+const str = z.string();
+const int = z.number().int();
+const list = z.array(z.unknown());
+const rows = (shape) => z.array(z.looseObject(shape));
+const proposed = z.looseObject({ proposal: int, kind: z.enum(["next", "reserve", "hold", "unhold", "scope", "cancel", "answer"]), awaiting: str });
+/** One assignment (assignment.ts `AssignmentSnapshot`). */
+const assignmentOutput = z.looseObject({ version: z.literal(1), rootId: str, activeTaskId: str, title: str, state: str, detail: str, attention: z.array(str) });
+export const GATEWAY_TOOL_OUTPUTS = {
+    get_project_context: repositoryContextOutput,
+    get_assignment: assignmentOutput,
+    list_assignment_updates: z.looseObject({ events: list, nextCursor: int, hasMore: z.boolean() }),
+    claim_assignment: assignmentOutput,
+    acknowledge_assignment: assignmentOutput,
+    get_assignment_brief: catchUpOutput,
+    get_assignment_inbox: z.looseObject({ batch: z.looseObject({ id: str.nullable(), consumer: str, events: list, hasMore: z.boolean() }) }),
+    acknowledge_assignment_delivery: z.looseObject({ alreadyAcknowledged: z.boolean() }),
+    status: z.looseObject({ waitsOnYou: int, waits: z.looseObject({ approvals: int, questions: int, incidents: int, picks: int }) }),
+    list_tasks: z.looseObject({ tasks: list }),
+    get_task: z.looseObject({ ref: str }),
+    list_repos: z.looseObject({ repos: rows({ repo: str, mode: str }) }),
+    recap: recapOutput,
+    list_decisions: decisionsOutput,
+    queue: z.looseObject({ repo: str, ...queueColumnsOutput }),
+    get_decision: decisionOutput,
+    propose_next: proposed,
+    propose_reserve: proposed,
+    propose_hold: proposed,
+    propose_unhold: proposed,
+    propose_scope: proposed,
+    propose_cancel: proposed,
+    propose_answer: proposed,
+    get_contract: z.looseObject({ contract: str }),
+    file_proposal: z.looseObject({ ref: str, replayed: z.boolean(), admission: str }),
+};

package/dist/contracts/lead-context.d.ts

@@ -0,0 +1,165 @@
+/**
+ * The lead's catch-up bundle (lead-context.ts): one schema for the DATA each lead turn opens with, built fresh from the
+ * local database, in order of importance. The bundle is checked before it is scrubbed and serialized; its whole size
+ * (TEXT_LIMITS.leadContextBytes, in UTF-8 bytes) is met in plain code after, by dropping the least important parts.
+ */
+import { z } from "zod";
+/** How many tasks the bundle reads, projects it names, and open promises, corrections and proposals it shows. */
+export declare const LEAD_CONTEXT_COUNTS: {
+    readonly tasks: 8;
+    readonly projects: 8;
+    readonly promises: 10;
+    readonly corrections: 5;
+    readonly proposals: 5;
+};
+export declare const LEAD_CHANNELS: readonly ["console", "terminal", "telegram", "slack", "discord", "teams"];
+/** A task as the lead reads it: which project (`r1`...), its ids, state, goal, outcome, checks, the next action and
+ * the questions still open on it. */
+export declare const leadTaskSchema: z.ZodObject<{
+    repo: z.ZodString;
+    id: z.ZodString;
+    currentExecution: z.ZodString;
+    title: z.ZodString;
+    state: z.ZodString;
+    goal: z.ZodNullable<z.ZodString>;
+    outcome: z.ZodNullable<z.ZodString>;
+    checks: z.ZodNullable<z.ZodString>;
+    next: z.ZodNullable<z.ZodString>;
+    decisions: z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        question: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** The lead's own open promise in this conversation, and when it is due. */
+export declare const leadPromiseSchema: z.ZodObject<{
+    id: z.ZodInt;
+    what: z.ZodString;
+    when: z.ZodString;
+    expires: z.ZodString;
+}, z.core.$strict>;
+/** A correction the operator confirmed since the lead's last reply. */
+export declare const leadCorrectionSchema: z.ZodObject<{
+    proposal: z.ZodInt;
+    change: z.ZodString;
+}, z.core.$strict>;
+/** A proposal still open in this conversation, which a correction may affect. */
+export declare const leadOpenProposalSchema: z.ZodObject<{
+    proposal: z.ZodInt;
+    kind: z.ZodString;
+    about: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const LEAD_CONTEXT_VERSION = 3;
+export declare const leadContextSchema: z.ZodObject<{
+    snapshotVersion: z.ZodLiteral<3>;
+    source: z.ZodLiteral<"local-database">;
+    me: z.ZodObject<{
+        name: z.ZodString;
+        persona: z.ZodString;
+    }, z.core.$strict>;
+    you: z.ZodObject<{
+        firstName: z.ZodNullable<z.ZodString>;
+        timeZone: z.ZodString;
+        today: z.ZodString;
+    }, z.core.$strict>;
+    aboutYou: z.ZodArray<z.ZodString>;
+    people: z.ZodObject<{
+        people: z.ZodArray<z.ZodString>;
+        teammates: z.ZodArray<z.ZodString>;
+        teams: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    channel: z.ZodNullable<z.ZodObject<{
+        id: z.ZodEnum<{
+            console: "console";
+            discord: "discord";
+            slack: "slack";
+            teams: "teams";
+            telegram: "telegram";
+            terminal: "terminal";
+        }>;
+        fit: z.ZodString;
+        replyLimit: z.ZodNullable<z.ZodInt>;
+    }, z.core.$strict>>;
+    needsYou: z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        id: z.ZodString;
+        currentExecution: z.ZodString;
+        title: z.ZodString;
+        state: z.ZodString;
+        goal: z.ZodNullable<z.ZodString>;
+        outcome: z.ZodNullable<z.ZodString>;
+        checks: z.ZodNullable<z.ZodString>;
+        next: z.ZodNullable<z.ZodString>;
+        decisions: z.ZodArray<z.ZodObject<{
+            id: z.ZodInt;
+            question: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    commitments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodInt;
+        what: z.ZodString;
+        when: z.ZodString;
+        expires: z.ZodString;
+    }, z.core.$strict>>>;
+    corrections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        proposal: z.ZodInt;
+        change: z.ZodString;
+    }, z.core.$strict>>>;
+    openProposals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        proposal: z.ZodInt;
+        kind: z.ZodString;
+        about: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>>;
+    followThrough: z.ZodOptional<z.ZodString>;
+    projects: z.ZodArray<z.ZodObject<{
+        repo: z.ZodString;
+        name: z.ZodString;
+        decisions: z.ZodArray<z.ZodObject<{
+            id: z.ZodInt;
+            title: z.ZodString;
+            why: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    rest: z.ZodObject<{
+        tasks: z.ZodArray<z.ZodObject<{
+            repo: z.ZodString;
+            id: z.ZodString;
+            currentExecution: z.ZodString;
+            title: z.ZodString;
+            state: z.ZodString;
+            goal: z.ZodNullable<z.ZodString>;
+            outcome: z.ZodNullable<z.ZodString>;
+            checks: z.ZodNullable<z.ZodString>;
+            next: z.ZodNullable<z.ZodString>;
+            decisions: z.ZodArray<z.ZodObject<{
+                id: z.ZodInt;
+                question: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        knowledge: z.ZodArray<z.ZodObject<{
+            repo: z.ZodString;
+            status: z.ZodEnum<{
+                none: "none";
+                stored: "stored";
+                unavailable: "unavailable";
+            }>;
+            revision: z.ZodNullable<z.ZodInt>;
+            instructions: z.ZodString;
+            sources: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    omissions: z.ZodObject<{
+        assignments: z.ZodInt;
+        decisions: z.ZodInt;
+        projects: z.ZodInt;
+        textFields: z.ZodInt;
+        candidateScanLimited: z.ZodBoolean;
+        notes: z.ZodArray<z.ZodString>;
+        people: z.ZodInt;
+    }, z.core.$strict>;
+    notice: z.ZodString;
+}, z.core.$strict>;
+export type LeadContextBundle = z.infer<typeof leadContextSchema>;
+export type LeadChannel = (typeof LEAD_CHANNELS)[number];