toolroll 0.9.63 → 0.9.67

package/dist/contracts/flow.d.ts

@@ -10792,6 +10792,8 @@ export declare function legacySubagentStep(step: unknown): unknown;
 export declare const legacyFlowNeed: (need: unknown) => unknown;
 /** The keys people and models write for the ones a step means: refusals suggest them (contract.ts). */
 export declare const FLOW_ALIASES: ContractOptions;
+/** v126: who signs a webhook's deliveries (webhook-signing.ts); `none` is the secret address alone. */
+export declare const WEBHOOK_SENDERS: readonly ["none", "standard", "github-style", "sentry", "vercel"];
 export declare const triggerInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     zone: z.ZodOptional<z.ZodString>;
     kind: z.ZodLiteral<"button">;
@@ -10845,6 +10847,17 @@ export declare const triggerInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     titleField: z.ZodOptional<z.ZodString>;
     bodyField: z.ZodOptional<z.ZodString>;
+    sender: z.ZodOptional<z.ZodEnum<{
+        "github-style": "github-style";
+        none: "none";
+        sentry: "sentry";
+        standard: "standard";
+        vercel: "vercel";
+    }>>;
+    project: z.ZodOptional<z.ZodString>;
+    team: z.ZodOptional<z.ZodString>;
+    idField: z.ZodOptional<z.ZodString>;
+    urlField: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     zone: z.ZodOptional<z.ZodString>;
     kind: z.ZodLiteral<"email">;
@@ -10907,6 +10920,17 @@ export declare const flowFileTriggerSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     title: z.ZodOptional<z.ZodString>;
     titleField: z.ZodOptional<z.ZodString>;
     bodyField: z.ZodOptional<z.ZodString>;
+    sender: z.ZodOptional<z.ZodEnum<{
+        "github-style": "github-style";
+        none: "none";
+        sentry: "sentry";
+        standard: "standard";
+        vercel: "vercel";
+    }>>;
+    project: z.ZodOptional<z.ZodString>;
+    team: z.ZodOptional<z.ZodString>;
+    idField: z.ZodOptional<z.ZodString>;
+    urlField: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     zone: z.ZodOptional<z.ZodString>;
     kind: z.ZodLiteral<"email">;
@@ -11075,6 +11099,17 @@ export declare const triggerConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     title: z.ZodString;
     titleField: z.ZodNullable<z.ZodString>;
     bodyField: z.ZodNullable<z.ZodString>;
+    sender: z.ZodOptional<z.ZodEnum<{
+        "github-style": "github-style";
+        none: "none";
+        sentry: "sentry";
+        standard: "standard";
+        vercel: "vercel";
+    }>>;
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    team: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    idField: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    urlField: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>, z.ZodObject<{
     zone: z.ZodNullable<z.ZodString>;
     kind: z.ZodLiteral<"email">;
@@ -19412,6 +19447,17 @@ export declare const flowFileSchema: z.ZodObject<{
         title: z.ZodOptional<z.ZodString>;
         titleField: z.ZodOptional<z.ZodString>;
         bodyField: z.ZodOptional<z.ZodString>;
+        sender: z.ZodOptional<z.ZodEnum<{
+            "github-style": "github-style";
+            none: "none";
+            sentry: "sentry";
+            standard: "standard";
+            vercel: "vercel";
+        }>>;
+        project: z.ZodOptional<z.ZodString>;
+        team: z.ZodOptional<z.ZodString>;
+        idField: z.ZodOptional<z.ZodString>;
+        urlField: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>, z.ZodObject<{
         zone: z.ZodOptional<z.ZodString>;
         kind: z.ZodLiteral<"email">;

package/dist/contracts/flow.js

@@ -297,6 +297,9 @@ export const FLOW_ALIASES = {
 };
 // ------------------------------------------------------------------ triggers
 const zoneRef = { zone: z.string().max(TEXT_LIMITS.flowRef).optional() };
+/** v126: who signs a webhook's deliveries (webhook-signing.ts); `none` is the secret address alone. */
+export const WEBHOOK_SENDERS = ["none", "standard", "github-style", "sentry", "vercel"];
+const webhookSender = z.enum(WEBHOOK_SENDERS);
 const delivery = z.enum(["poll", "webhook"]);
 /** A trigger's settings as they are given: the console, `toolroll flows trigger add`, a flow file, a template, the lead. */
 const TRIGGER_INPUTS = {
@@ -311,7 +314,10 @@ const TRIGGER_INPUTS = {
     }),
     linear: z.strictObject({ kind: z.literal("linear"), team: short("triggerTeam").optional(), state: short("triggerState").optional(), label: short("triggerLabel").optional(), delivery: delivery.optional(), ...zoneRef }),
     flow: z.strictObject({ kind: z.literal("flow"), flow: z.int().min(1), when: z.string().max(TEXT_LIMITS.flowRef).optional(), ...zoneRef }),
-    webhook: z.strictObject({ kind: z.literal("webhook"), title: short("triggerWebhookTitle").optional(), titleField: short("triggerWebhookField").optional(), bodyField: short("triggerWebhookField").optional(), ...zoneRef }),
+    /** v126: `sender` signs it; Sentry and Vercel read their own payloads (scoped by `project`, Vercel's also by `team`),
+     * the others pick `titleField`, `bodyField`, `idField` and `urlField` from the JSON. */
+    webhook: z.strictObject({ kind: z.literal("webhook"), title: short("triggerWebhookTitle").optional(), titleField: short("triggerWebhookField").optional(), bodyField: short("triggerWebhookField").optional(),
+        sender: webhookSender.optional(), project: short("triggerWebhookScope").optional(), team: short("triggerWebhookScope").optional(), idField: short("triggerWebhookField").optional(), urlField: short("triggerWebhookField").optional(), ...zoneRef }),
     email: z.strictObject({ kind: z.literal("email"), folder: short("triggerFolder").optional(), sender: short("triggerSender").optional(), subject: short("triggerSubject").optional(), ...zoneRef }),
     "plane-review": z.strictObject({ kind: z.literal("plane-review"), at: z.string().regex(/^\d{1,2}:\d{2}$/, { error: "must be a time like 07:30" }).optional(), timeZone: z.string().max(TEXT_LIMITS.flowTimeZone).optional(), ...zoneRef }),
 };
@@ -357,7 +363,10 @@ export const triggerConfigSchema = z.discriminatedUnion("kind", [
     z.strictObject({ kind: z.literal("github"), repo: z.string().min(1).max(TEXT_LIMITS.triggerGithubRepo), watch: z.enum(["issues", "pulls", "checks"]), label: z.string().max(TEXT_LIMITS.triggerLabel).nullable(), branch: z.string().max(TEXT_LIMITS.triggerBranch).nullable(), from: z.enum(["team", "anyone"]), delivery, ...ZONE_OR_NULL }),
     z.strictObject({ kind: z.literal("linear"), team: z.string().max(TEXT_LIMITS.triggerTeam).nullable(), state: z.string().max(TEXT_LIMITS.triggerState).nullable(), label: z.string().max(TEXT_LIMITS.triggerLabel).nullable(), delivery, ...ZONE_OR_NULL }),
     z.strictObject({ kind: z.literal("flow"), flow: z.int().min(1), when: zoneId, ...ZONE_OR_NULL }),
-    z.strictObject({ kind: z.literal("webhook"), title: z.string().min(1).max(TEXT_LIMITS.triggerWebhookTitle), titleField: z.string().max(TEXT_LIMITS.triggerWebhookField).nullable(), bodyField: z.string().max(TEXT_LIMITS.triggerWebhookField).nullable(), ...ZONE_OR_NULL }),
+    /** v126: a webhook saved before its sender was chosen reads unsigned, with no scope and no identity or link field. */
+    z.strictObject({ kind: z.literal("webhook"), title: z.string().min(1).max(TEXT_LIMITS.triggerWebhookTitle), titleField: z.string().max(TEXT_LIMITS.triggerWebhookField).nullable(), bodyField: z.string().max(TEXT_LIMITS.triggerWebhookField).nullable(),
+        sender: webhookSender.optional(), project: z.string().max(TEXT_LIMITS.triggerWebhookScope).nullable().optional(), team: z.string().max(TEXT_LIMITS.triggerWebhookScope).nullable().optional(),
+        idField: z.string().max(TEXT_LIMITS.triggerWebhookField).nullable().optional(), urlField: z.string().max(TEXT_LIMITS.triggerWebhookField).nullable().optional(), ...ZONE_OR_NULL }),
     /** `sender`: addresses or domains, comma-separated; `subject`: words the subject must contain. */
     z.strictObject({ kind: z.literal("email"), folder: z.string().min(1).max(TEXT_LIMITS.triggerFolder), sender: z.string().max(TEXT_LIMITS.triggerSender).nullable(), subject: z.string().max(TEXT_LIMITS.triggerSubject).nullable(), ...ZONE_OR_NULL }),
     /** A channel in a chat app; `binding` is the pairing of the person who connected it (whose chat answers there). */

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

@@ -135,6 +135,9 @@ export declare const LEAD_TOOL_INPUTS: {
         since: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     readonly list_repos: z.ZodObject<{}, z.core.$strict>;
+    readonly find_tools: z.ZodObject<{
+        query: z.ZodString;
+    }, z.core.$strict>;
     readonly get_project_tools: z.ZodObject<{
         repo: z.ZodString;
     }, z.core.$strict>;
@@ -640,6 +643,33 @@ export declare const LEAD_TOOL_INPUTS: {
         report: z.ZodOptional<z.ZodBoolean>;
         checks: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
+    readonly propose_sweep: z.ZodObject<{
+        repo: z.ZodString;
+        title: z.ZodString;
+        brief: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            item: z.ZodString;
+        }, z.core.$strict>>;
+        acceptance: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            how: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            evidence: z.ZodArray<z.ZodEnum<{
+                "changed-path": "changed-path";
+                check: "check";
+                "manual-review": "manual-review";
+                screenshot: "screenshot";
+            }>>;
+        }, z.core.$strict>>;
+        max_parallel: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly get_sweep: z.ZodObject<{
+        sweep: z.ZodInt;
+    }, z.core.$strict>;
+    readonly propose_sweep_cancel: z.ZodObject<{
+        sweep: z.ZodInt;
+    }, z.core.$strict>;
     readonly propose_next: z.ZodObject<{
         task: z.ZodString;
     }, z.core.$strict>;
@@ -831,6 +861,9 @@ export declare const LEAD_TOOL_READ_INPUTS: {
         since: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
     readonly list_repos: z.ZodObject<{}, z.core.$strict>;
+    readonly find_tools: z.ZodObject<{
+        query: z.ZodString;
+    }, z.core.$strict>;
     readonly get_project_tools: z.ZodObject<{
         repo: z.ZodString;
     }, z.core.$strict>;
@@ -1309,6 +1342,33 @@ export declare const LEAD_TOOL_READ_INPUTS: {
         report: z.ZodOptional<z.ZodBoolean>;
         checks: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
+    readonly propose_sweep: z.ZodObject<{
+        repo: z.ZodString;
+        title: z.ZodString;
+        brief: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            title: z.ZodString;
+            item: z.ZodString;
+        }, z.core.$strict>>;
+        acceptance: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            statement: z.ZodString;
+            how: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            evidence: z.ZodArray<z.ZodEnum<{
+                "changed-path": "changed-path";
+                check: "check";
+                "manual-review": "manual-review";
+                screenshot: "screenshot";
+            }>>;
+        }, z.core.$strict>>;
+        max_parallel: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly get_sweep: z.ZodObject<{
+        sweep: z.ZodInt;
+    }, z.core.$strict>;
+    readonly propose_sweep_cancel: z.ZodObject<{
+        sweep: z.ZodInt;
+    }, z.core.$strict>;
     readonly propose_next: z.ZodObject<{
         task: z.ZodString;
     }, z.core.$strict>;
@@ -1629,6 +1689,13 @@ export declare const LEAD_TOOL_OUTPUTS: {
             repo: z.ZodString;
         }, z.core.$loose>>;
     }, z.core.$loose>;
+    readonly find_tools: z.ZodObject<{
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            summary: z.ZodString;
+        }, z.core.$loose>>;
+        next: z.ZodString;
+    }, z.core.$loose>;
     readonly get_project_tools: z.ZodObject<{
         rule: z.ZodString;
         tools: z.ZodArray<z.ZodObject<{
@@ -1860,6 +1927,31 @@ export declare const LEAD_TOOL_OUTPUTS: {
         kind: z.ZodLiteral<"task">;
         awaiting: z.ZodString;
     }, z.core.$loose>;
+    readonly propose_sweep: z.ZodObject<{
+        proposal: z.ZodNumber;
+        label: z.ZodString;
+        awaiting: z.ZodString;
+        executed: z.ZodLiteral<false>;
+    }, z.core.$loose>;
+    readonly get_sweep: z.ZodObject<{
+        sweep: z.ZodNumber;
+        title: z.ZodString;
+        line: z.ZodString;
+        table: z.ZodString;
+        maxParallel: z.ZodNumber;
+        items: z.ZodArray<z.ZodObject<{
+            item: z.ZodNumber;
+            label: z.ZodString;
+            task: z.ZodString;
+            state: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+    readonly propose_sweep_cancel: z.ZodObject<{
+        proposal: z.ZodNumber;
+        label: z.ZodString;
+        awaiting: z.ZodString;
+        executed: z.ZodLiteral<false>;
+    }, z.core.$loose>;
     readonly propose_next: z.ZodObject<{
         proposal: z.ZodNumber;
         kind: z.ZodLiteral<"next">;

package/dist/contracts/lead-tools.js

@@ -80,6 +80,7 @@ export const LEAD_TOOL_INPUTS = {
     }),
     recap: z.strictObject({ since: text("recapSince").optional() }),
     list_repos: z.strictObject({}),
+    find_tools: z.strictObject({ query: z.string().min(1).max(200).describe("What you want to do, in a few words (\"make a flow\", \"add a subagent\", \"hold a task\").") }),
     get_project_tools: z.strictObject({ repo: repoId }),
     get_flows: z.strictObject({ repo: repoId.optional(), flow: id.optional(), card: id.optional() }),
     // The flow contract's own schema (src/contracts/flow-propose.ts), never a second one here.
@@ -126,6 +127,14 @@ export const LEAD_TOOL_INPUTS = {
         not: scopeText.nullable().optional(), touches: touches.optional(), acceptance,
         planning: z.enum(["auto", "required", "skip"]).optional(), report: z.boolean().optional(), checks: text("checksWords").optional(),
     }),
+    // Lead fan-out (docs/plans/lead-fan-out.md): 2 to 20 independent items under one shared brief and one success test.
+    propose_sweep: z.strictObject({
+        repo: repoId, title: text("taskTitle"), brief: scopeText,
+        items: z.array(z.strictObject({ title: text("taskTitle"), item: scopeText })).min(2).max(20),
+        acceptance, max_parallel: z.number().int().min(1).max(8).optional(),
+    }),
+    get_sweep: z.strictObject({ sweep: id }),
+    propose_sweep_cancel: z.strictObject({ sweep: id }),
     propose_next: z.strictObject({ task: taskRef }),
     propose_reserve: z.strictObject({ task: taskRef, worker: text("workerName").nullable() }),
     propose_hold: z.strictObject({ task: taskRef, reason: text("proposalReason") }),
@@ -209,6 +218,7 @@ export const LEAD_TOOL_OUTPUTS = {
     propose_review: proposed("review", { operation: z.enum(["note", "revise"]) }),
     recap: recapOutput,
     list_repos: z.looseObject({ repos: rows({ repo: str }) }),
+    find_tools: z.looseObject({ tools: rows({ name: str, summary: str }), next: str }),
     get_project_tools: z.looseObject({ rule: str, tools: rows({ name: str }), connectBySigningIn: list, commonTools: list, foundOnThisComputer: list, notice: str }),
     get_flows: z.union([
         z.looseObject({ flow: int, name: str, steps: rows({ id: str, title: str, kind: str }), cards: rows({ card: int, title: str }), scripts: list, triggers: list, rule: str }),
@@ -247,6 +257,9 @@ export const LEAD_TOOL_OUTPUTS = {
     get_decision: decisionOutput,
     queue: z.looseObject({ repo: str, queueRevision: int, ...queueColumnsOutput }),
     propose_task: proposed("task", { repo: str, deliverable: z.enum(["branch", "report"]), planning: str }),
+    propose_sweep: cardDrafted,
+    get_sweep: z.looseObject({ sweep: int, title: str, line: str, table: str, maxParallel: int, items: z.array(z.looseObject({ item: int, label: str, task: str, state: str })) }),
+    propose_sweep_cancel: cardDrafted,
     propose_next: proposed("next", { task: str }),
     propose_reserve: proposed("reserve", { task: str, worker: nullable(str) }),
     propose_hold: proposed("hold", { task: str }),

package/dist/contracts/provider.d.ts

@@ -8,21 +8,31 @@
  * credential would land, and a refusal is shown, logged and sent on.
  */
 import { z } from "zod";
-export declare const PROVIDER_ID_VALUES: readonly ["claude", "codex", "openrouter", "gemini"];
+export declare const PROVIDER_ID_VALUES: readonly ["claude", "codex", "openrouter", "gemini", "opencode", "cursor", "cline", "qwen", "goose"];
 export declare const providerIdSchema: z.ZodEnum<{
     claude: "claude";
+    cline: "cline";
     codex: "codex";
+    cursor: "cursor";
     gemini: "gemini";
+    goose: "goose";
+    opencode: "opencode";
     openrouter: "openrouter";
+    qwen: "qwen";
 }>;
 export declare const MODEL_ID: RegExp;
 export declare const modelIdSchema: z.ZodString;
 export declare const agentSpecSchema: z.ZodObject<{
     provider: z.ZodEnum<{
         claude: "claude";
+        cline: "cline";
         codex: "codex";
+        cursor: "cursor";
         gemini: "gemini";
+        goose: "goose";
+        opencode: "opencode";
         openrouter: "openrouter";
+        qwen: "qwen";
     }>;
     model: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;

package/dist/contracts/provider.js

@@ -8,7 +8,7 @@
  * credential would land, and a refusal is shown, logged and sent on.
  */
 import { z } from "zod";
-export const PROVIDER_ID_VALUES = ["claude", "codex", "openrouter", "gemini"];
+export const PROVIDER_ID_VALUES = ["claude", "codex", "openrouter", "gemini", "opencode", "cursor", "cline", "qwen", "goose"];
 export const providerIdSchema = z.enum(PROVIDER_ID_VALUES);
 export const MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;
 export const modelIdSchema = z.string().regex(MODEL_ID);

package/dist/contracts/route.d.ts

@@ -16,7 +16,7 @@ import { type ContractResult } from "./contract.js";
 export declare const ROUTE_PHASES: readonly ["plan", "build", "repair", "review"];
 /** provider.ts's provider ids, restated (provider.ts sits above phase-routing.ts in the module graph) and pinned to
  * them by the test suite. */
-export declare const ROUTE_PROVIDERS: readonly ["claude", "codex", "openrouter", "gemini"];
+export declare const ROUTE_PROVIDERS: readonly ["claude", "codex", "openrouter", "gemini", "opencode", "cursor", "cline", "qwen", "goose"];
 /** provider.ts's MODEL_ID, restated for the same reason: an exact model id is argv-safe — no leading dash, no
  * whitespace or control bytes. */
 export declare const MODEL_ID_SHAPE: RegExp;
@@ -49,9 +49,14 @@ export declare const routeOverrideSchema: z.ZodObject<{
     }>;
     provider: z.ZodEnum<{
         claude: "claude";
+        cline: "cline";
         codex: "codex";
+        cursor: "cursor";
         gemini: "gemini";
+        goose: "goose";
+        opencode: "opencode";
         openrouter: "openrouter";
+        qwen: "qwen";
     }>;
     model: z.ZodString;
     by: z.ZodString;
@@ -67,9 +72,14 @@ export declare const routeLegSchema: z.ZodObject<{
     }>;
     provider: z.ZodEnum<{
         claude: "claude";
+        cline: "cline";
         codex: "codex";
+        cursor: "cursor";
         gemini: "gemini";
+        goose: "goose";
+        opencode: "opencode";
         openrouter: "openrouter";
+        qwen: "qwen";
     }>;
     model: z.ZodString;
     tier: z.ZodEnum<{
@@ -85,9 +95,14 @@ export declare const routeLegSchema: z.ZodObject<{
     recommended: z.ZodObject<{
         provider: z.ZodEnum<{
             claude: "claude";
+            cline: "cline";
             codex: "codex";
+            cursor: "cursor";
             gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
             openrouter: "openrouter";
+            qwen: "qwen";
         }>;
         model: z.ZodString;
         tier: z.ZodEnum<{
@@ -135,9 +150,14 @@ export declare const sealedRouteV1Schema: z.ZodObject<{
         }>;
         provider: z.ZodEnum<{
             claude: "claude";
+            cline: "cline";
             codex: "codex";
+            cursor: "cursor";
             gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
             openrouter: "openrouter";
+            qwen: "qwen";
         }>;
         model: z.ZodString;
         tier: z.ZodEnum<{
@@ -152,9 +172,14 @@ export declare const sealedRouteV1Schema: z.ZodObject<{
         recommended: z.ZodObject<{
             provider: z.ZodEnum<{
                 claude: "claude";
+                cline: "cline";
                 codex: "codex";
+                cursor: "cursor";
                 gemini: "gemini";
+                goose: "goose";
+                opencode: "opencode";
                 openrouter: "openrouter";
+                qwen: "qwen";
             }>;
             model: z.ZodString;
             tier: z.ZodEnum<{
@@ -174,9 +199,14 @@ export declare const sealedRouteV1Schema: z.ZodObject<{
         }>;
         provider: z.ZodEnum<{
             claude: "claude";
+            cline: "cline";
             codex: "codex";
+            cursor: "cursor";
             gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
             openrouter: "openrouter";
+            qwen: "qwen";
         }>;
         model: z.ZodString;
         by: z.ZodString;
@@ -219,9 +249,14 @@ export declare const sealedRouteV2Schema: z.ZodObject<{
         }>;
         provider: z.ZodEnum<{
             claude: "claude";
+            cline: "cline";
             codex: "codex";
+            cursor: "cursor";
             gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
             openrouter: "openrouter";
+            qwen: "qwen";
         }>;
         model: z.ZodString;
         tier: z.ZodEnum<{
@@ -237,9 +272,14 @@ export declare const sealedRouteV2Schema: z.ZodObject<{
         recommended: z.ZodObject<{
             provider: z.ZodEnum<{
                 claude: "claude";
+                cline: "cline";
                 codex: "codex";
+                cursor: "cursor";
                 gemini: "gemini";
+                goose: "goose";
+                opencode: "opencode";
                 openrouter: "openrouter";
+                qwen: "qwen";
             }>;
             model: z.ZodString;
             tier: z.ZodEnum<{
@@ -260,9 +300,14 @@ export declare const sealedRouteV2Schema: z.ZodObject<{
         }>;
         provider: z.ZodEnum<{
             claude: "claude";
+            cline: "cline";
             codex: "codex";
+            cursor: "cursor";
             gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
             openrouter: "openrouter";
+            qwen: "qwen";
         }>;
         model: z.ZodString;
         by: z.ZodString;
@@ -320,9 +365,14 @@ export declare const sealedRouteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         provider: z.ZodEnum<{
             claude: "claude";
+            cline: "cline";
             codex: "codex";
+            cursor: "cursor";
             gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
             openrouter: "openrouter";
+            qwen: "qwen";
         }>;
         model: z.ZodString;
         tier: z.ZodEnum<{
@@ -337,9 +387,14 @@ export declare const sealedRouteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         recommended: z.ZodObject<{
             provider: z.ZodEnum<{
                 claude: "claude";
+                cline: "cline";
                 codex: "codex";
+                cursor: "cursor";
                 gemini: "gemini";
+                goose: "goose";
+                opencode: "opencode";
                 openrouter: "openrouter";
+                qwen: "qwen";
             }>;
             model: z.ZodString;
             tier: z.ZodEnum<{
@@ -359,9 +414,14 @@ export declare const sealedRouteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         provider: z.ZodEnum<{
             claude: "claude";
+            cline: "cline";
             codex: "codex";
+            cursor: "cursor";
             gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
             openrouter: "openrouter";
+            qwen: "qwen";
         }>;
         model: z.ZodString;
         by: z.ZodString;
@@ -403,9 +463,14 @@ export declare const sealedRouteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         provider: z.ZodEnum<{
             claude: "claude";
+            cline: "cline";
             codex: "codex";
+            cursor: "cursor";
             gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
             openrouter: "openrouter";
+            qwen: "qwen";
         }>;
         model: z.ZodString;
         tier: z.ZodEnum<{
@@ -421,9 +486,14 @@ export declare const sealedRouteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         recommended: z.ZodObject<{
             provider: z.ZodEnum<{
                 claude: "claude";
+                cline: "cline";
                 codex: "codex";
+                cursor: "cursor";
                 gemini: "gemini";
+                goose: "goose";
+                opencode: "opencode";
                 openrouter: "openrouter";
+                qwen: "qwen";
             }>;
             model: z.ZodString;
             tier: z.ZodEnum<{
@@ -444,9 +514,14 @@ export declare const sealedRouteSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         provider: z.ZodEnum<{
             claude: "claude";
+            cline: "cline";
             codex: "codex";
+            cursor: "cursor";
             gemini: "gemini";
+            goose: "goose";
+            opencode: "opencode";
             openrouter: "openrouter";
+            qwen: "qwen";
         }>;
         model: z.ZodString;
         by: z.ZodString;

package/dist/contracts/route.js

@@ -17,7 +17,7 @@ import { limited, parseContract, versioned } from "./contract.js";
 export const ROUTE_PHASES = ["plan", "build", "repair", "review"];
 /** provider.ts's provider ids, restated (provider.ts sits above phase-routing.ts in the module graph) and pinned to
  * them by the test suite. */
-export const ROUTE_PROVIDERS = ["claude", "codex", "openrouter", "gemini"];
+export const ROUTE_PROVIDERS = ["claude", "codex", "openrouter", "gemini", "opencode", "cursor", "cline", "qwen", "goose"];
 /** provider.ts's MODEL_ID, restated for the same reason: an exact model id is argv-safe — no leading dash, no
  * whitespace or control bytes. */
 export const MODEL_ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/;

package/dist/contracts/store-json.d.ts

@@ -208,6 +208,8 @@ declare const STORE_COLUMN_VALUES: {
             subagent_state: "subagent_state";
             subagent_tools: "subagent_tools";
             subagent_undo: "subagent_undo";
+            sweep_cancel_rest: "sweep_cancel_rest";
+            sweep_file: "sweep_file";
             task_cancel: "task_cancel";
             task_resume: "task_resume";
             tool_add: "tool_add";

package/dist/control-setup.d.ts

@@ -19,7 +19,7 @@ export declare function previewSetup(store: Store, repo: string, inputs: SetupIn
     fingerprint: string;
     command: string;
     seconds: number;
-    provider: "claude" | "codex" | "gemini" | "openrouter";
+    provider: "claude" | "cline" | "codex" | "cursor" | "gemini" | "goose" | "opencode" | "openrouter" | "qwen";
     model: string;
 };
 export declare function approveSetup(store: Store, repo: string, inputs: SetupInputs, fingerprint: string, by: string, token: string, now: Date): {

package/dist/control-ui.js

@@ -1,5 +1,5 @@
 /** Shared setup views over the existing project configuration and approval doors. */
-import { html, joinHtml, postForm } from "./html.js";
+import { html, joinHtml, postForm, reauth } from "./html.js";
 import { ASSISTANTS } from "./setup-guide.js";
 import { openRouterPicker } from "./openrouter-models.js";
 export function connectionWords(connection) {
@@ -24,5 +24,5 @@ export function controlSetupHtml(data) {
 /** `fields` may still carry the session's csrf (a caller's habit): postForm writes the one CSRF field. */
 export function setupPreviewHtml(inputs, fields) {
     const { csrf: _csrf, ...rest } = fields;
-    return html `<h1>Approve project setup</h1><div class="card"><p>${fields.repo ?? ""}</p><p><strong>Builder:</strong> ${inputs.provider} · ${inputs.model}</p><p><strong>Preparation:</strong></p><pre class="recap">${inputs.command || "No preparation command"}</pre><p>Preparation timeout: ${inputs.seconds} seconds.</p><p>The builder default applies to new tasks. Preparation applies to subsequent runs, including already approved tasks. Existing signed task settings and verification rules remain in force.</p>${postForm("/control/setup-approve", html `<label>Your password<input type="password" name="token" autocomplete="current-password" required></label><button>Approve project setup</button>`, { hidden: { ...rest, ...inputs } })}</div>`;
+    return html `<h1>Approve project setup</h1><div class="card"><p>${fields.repo ?? ""}</p><p><strong>Builder:</strong> ${inputs.provider} · ${inputs.model}</p><p><strong>Preparation:</strong></p><pre class="recap">${inputs.command || "No preparation command"}</pre><p>Preparation timeout: ${inputs.seconds} seconds.</p><p>The builder default applies to new tasks. Preparation applies to subsequent runs, including already approved tasks. Existing signed task settings and verification rules remain in force.</p>${postForm("/control/setup-approve", html `${reauth(html `<label>Your password<input type="password" name="token" autocomplete="current-password" required></label>`)}<button>Approve project setup</button>`, { hidden: { ...rest, ...inputs } })}</div>`;
 }

package/dist/converse.d.ts

@@ -180,13 +180,24 @@ export type LeadToolCall = {
     args: Record<string, unknown>;
 };
 /** A provider answer with tool calls allowed: text, calls, usage. */
+/** `tokensIn` is ALL input tokens of the request; of them, `cacheWriteTokens` were written to the provider's prompt cache
+ * and `cacheReadTokens` read from it (absent: the provider reported none — never assumed zero for a cached request). */
 export type LeadProviderAnswer = {
     text: string;
     calls: LeadToolCall[];
     tokensIn: number;
     tokensOut: number;
     reportedCostMicrousd: number | null;
+    cacheWriteTokens?: number;
+    cacheReadTokens?: number;
 };
+/** Anthropic prices a cache write at 1.25x and a cache read at 0.1x the input price (5-minute cache). */
+export declare const CACHE_WRITE_RATIO = 1.25;
+export declare const CACHE_READ_RATIO = 0.1;
+/** The price a worst case reserves at while prompt caching is on: every input token as a cache write (the dearest). */
+export declare function cacheWorstPrice(price: ModelPrice): ModelPrice;
+/** A step's settlement with its cache categories: plain input, cache writes and cache reads each at their own rate. */
+export declare function settleWithCache(price: ModelPrice, answer: Pick<LeadProviderAnswer, "tokensIn" | "tokensOut" | "cacheWriteTokens" | "cacheReadTokens">): number;
 /** One message of the lead's own history, provider-neutral. */
 export type LeadHistoryMessage = {
     role: "operator";
@@ -224,6 +235,11 @@ export declare function composeLeadRequest(args: {
     dataDocument: string;
     history: readonly LeadHistoryMessage[];
     tools: readonly LeadToolSchema[];
+    /** Anthropic prompt caching: breakpoints after the first `coreTools` tools (stable across replies), on the system
+     * block, and on the DATA message (stable across the steps of one reply). Absent: no cache annotations. */
+    cache?: {
+        coreTools: number;
+    };
 }): {
     url: string;
     headers: Record<string, string>;