toolroll 0.9.62 → 0.9.65

package/dist/contracts/console-api.d.ts

@@ -66,16 +66,23 @@ export declare const CONSOLE_FORMS: {
     readonly projectCeiling: FormContract<"repo">;
     readonly demo: FormContract<"message" | "note">;
     readonly updatesDismiss: FormContract<"quiet" | "return" | "version">;
+    readonly forgetPassword: FormContract<"return">;
+    readonly runReveal: FormContract<"return">;
     readonly updatesChecks: FormContract<"check">;
     readonly code: FormContract<"acceptance" | "answers" | "base" | "candidate" | "decision" | "goal" | "model" | "password" | "prompt" | "repo" | "requestId" | "title" | "visual" | `question:${string}`>;
+    readonly sweep: FormContract<"confirm" | "snapshot">;
+    readonly passwordless: FormContract<"action" | "password">;
+    readonly term: FormContract<"password" | "program" | "repo">;
     readonly skillsRevise: FormContract<"feedback" | "nonce" | "repo" | "run">;
     readonly skillsChange: FormContract<"action" | "content" | "files" | "identity" | "method" | "nonce" | "repo" | "restore" | "revision" | "sample" | "sha" | "url">;
     readonly kit: FormContract<"repo">;
     readonly subagents: FormContract<"choice" | "dailyTurns" | "id" | "manager" | "model" | "name" | "note" | "op" | "repo" | "schedule" | "soul" | "state" | "template" | "text" | "tool" | `field.${string}` | `over.${string}` | `undo.${string}` | `use.${string}`>;
     readonly galleryUse: FormContract<string>;
-    readonly flows: FormContract<"about" | "address" | "answers" | "approve" | "body" | "choice" | "confirm" | "decision" | "definition" | "description" | "document" | "draft" | "entry" | "file" | "key" | "label" | "language" | "name" | "note" | "owner" | "password" | "previewed" | "remove" | "repo" | "revision" | "secret" | "stage" | "template" | "timeoutMinutes" | "title" | "trigger" | "url" | "value" | "watching" | `param.${string}`>;
+    readonly flows: FormContract<"about" | "address" | "answers" | "approve" | "body" | "budget" | "choice" | "confirm" | "days" | "decision" | "definition" | "description" | "document" | "draft" | "entry" | "file" | "include" | "key" | "label" | "language" | "name" | "note" | "owner" | "password" | "previewed" | "project" | "remove" | "repo" | "revision" | "runs" | "schedules" | "secret" | "sender" | "stage" | "team" | "template" | "timeoutMinutes" | "title" | "trigger" | "url" | "value" | "watching" | `param.${string}`>;
     readonly spendBudget: FormContract<"action" | "password" | "stop" | "target" | "usd">;
     readonly projectConcurrency: FormContract<"concurrency" | "repo">;
+    readonly projectLiveView: FormContract<"act" | "nonce" | "password" | "repo">;
+    readonly projectNetwork: FormContract<"hosts" | "local" | "mode" | "password" | "repo">;
     readonly projectDelete: FormContract<"name" | "password" | "repo" | "step">;
     readonly policy: FormContract<"ceiling" | "models" | "password" | "provider" | "tools">;
     readonly approval: FormContract<"not_requester" | "password" | "paths" | "protect" | "repo">;
@@ -144,6 +151,7 @@ export declare const CONSOLE_FORMS: {
     readonly leadFollow: FormContract<"enabled" | "return">;
     readonly leadEnd: FormContract<"return">;
     readonly leadStop: FormContract<"return" | "turn">;
+    readonly leadQueuedRemove: FormContract<"return">;
     readonly leadProposal: FormContract<"confirm" | "nonce" | "return" | "token">;
     readonly coordinatorProposal: FormContract<"confirm" | "return">;
     readonly chat: FormContract<"message" | "mode" | "project" | "request" | "request-session" | "result" | "task" | "token">;
@@ -156,7 +164,7 @@ export declare const CONSOLE_FORMS: {
     readonly revise: FormContract<"batch" | "return" | "source">;
     readonly followUp: FormContract<"level" | "return">;
     readonly resolveIncident: FormContract<"return">;
-    readonly taskSteer: FormContract<"note" | "return" | "run">;
+    readonly taskSteer: FormContract<"after" | "key" | "note" | "request" | "return" | "run">;
     readonly taskReply: FormContract<"answer" | "question">;
     readonly taskHold: FormContract<"reason">;
     readonly taskBlock: FormContract<"on">;
@@ -170,11 +178,11 @@ export declare const CONSOLE_FORMS: {
     readonly taskCancel: FormContract<"reason">;
     readonly taskRoute: FormContract<"agent" | "clear-phase" | "model" | "phase" | "provider" | "return" | "risky" | "sawDigest" | "size">;
     readonly taskScope: FormContract<"acceptance" | "budget-microusd" | "budget-usd" | "goal" | "goal-brief" | "not" | "permission-mode" | "quality-mode" | "requirement" | "requirement-new" | "sawDigest" | "touches">;
-    readonly taskApprove: FormContract<"digest" | "nonce" | "return" | "token">;
+    readonly taskApprove: FormContract<"digest" | "nonce" | "rebuild" | "return" | "token">;
     readonly taskAcceptProof: FormContract<"note" | "return" | "run">;
     readonly taskComplete: FormContract<"accept" | "note" | "publish" | "receipt" | "return" | "run">;
     readonly taskStop: FormContract<"return" | "run">;
-    readonly taskPause: FormContract<"mode" | "note" | "request" | "return" | "run">;
+    readonly taskPause: FormContract<"key" | "mode" | "note" | "request" | "return" | "run">;
     readonly taskResume: FormContract<"nonce" | "return" | "run" | "token">;
 };
 export type ConsoleFormName = keyof typeof CONSOLE_FORMS;
@@ -318,6 +326,15 @@ export declare const flowViewSchema: z.ZodObject<{
     selectedCard: z.ZodNullable<z.ZodNumber>;
     live: z.ZodNullable<z.ZodString>;
     canEdit: z.ZodBoolean;
+    unattended: z.ZodObject<{
+        active: z.ZodNullable<z.ZodObject<{
+            until: z.ZodString;
+            signedBy: z.ZodString;
+        }, z.core.$loose>>;
+        canSign: z.ZodBoolean;
+        problem: z.ZodNullable<z.ZodString>;
+        scheduled: z.ZodBoolean;
+    }, z.core.$loose>;
     approvers: z.ZodArray<z.ZodString>;
     kinds: z.ZodArray<z.ZodObject<{
         kind: z.ZodString;
@@ -467,6 +484,15 @@ export declare const CONSOLE_RESPONSES: {
             selectedCard: z.ZodNullable<z.ZodNumber>;
             live: z.ZodNullable<z.ZodString>;
             canEdit: z.ZodBoolean;
+            unattended: z.ZodObject<{
+                active: z.ZodNullable<z.ZodObject<{
+                    until: z.ZodString;
+                    signedBy: z.ZodString;
+                }, z.core.$loose>>;
+                canSign: z.ZodBoolean;
+                problem: z.ZodNullable<z.ZodString>;
+                scheduled: z.ZodBoolean;
+            }, z.core.$loose>;
             approvers: z.ZodArray<z.ZodString>;
             kinds: z.ZodArray<z.ZodObject<{
                 kind: z.ZodString;

package/dist/contracts/console-api.js

@@ -75,16 +75,23 @@ export const CONSOLE_FORMS = {
     projectCeiling: formContract("POST (project ceiling)", ["repo"]),
     demo: formContract("POST /chat/demo/ask, /chat/demo/<id>/approve|change|revise|complete", ["message", "note"]),
     updatesDismiss: formContract("POST /settings/updates/dismiss", ["version", "quiet", "return"]),
+    forgetPassword: formContract("POST /session/forget-password", ["return"]),
+    runReveal: formContract("POST /r/<run>/reveal", ["return"]),
     updatesChecks: formContract("POST /settings/updates/checks", ["check"]),
     code: formContract("POST /code, /code/start, /code/<session>/<act>, /code/<anything else>", ["repo", "password", "title", "model", "prompt", "requestId", "base", "candidate", "goal", "acceptance", "visual", "decision", "answers"], { prefixes: ["question:"] }),
+    sweep: formContract("POST /sweeps/<sweep>/cancel-rest", ["confirm", "snapshot"]),
+    passwordless: formContract("POST /settings/passwordless", ["action", "password"]),
+    term: formContract("POST /term/start, /term/<terminal>/close, /term/<terminal>/remove", ["repo", "program", "password"]),
     skillsRevise: formContract("POST /settings/skills/revise", ["run", "repo", "feedback", "nonce"]),
     skillsChange: formContract("POST /settings/skills/import, /settings/skills/change", ["repo", "identity", "revision", "method", "content", "files", "url", "action", "sha", "sample", "nonce", "restore"]),
     kit: formContract("POST /kits/<kit>/<act>", ["repo"]),
     subagents: formContract("POST /settings/lead/subagents/new, /settings/lead/subagents/<id>/<part>, /settings/lead/subagents/questions/<id>/answer", ["choice", "text", "repo", "template", "name", "soul", "op", "id", "schedule", "tool", "state", "note", "model", "dailyTurns", "manager"], { prefixes: ["use.", "undo.", "field.", "over."] }),
     galleryUse: formContract("POST /flows/new/<template>", ["repo", "send-result", "name", "intent", "previewed"], { dynamic: true }),
-    flows: formContract("POST /flows/new, /flows/example, /flows/import, /flows/<id>/<act>, /flows/<id>/cards/<card>/<act>, /flows/<id>/triggers/<trigger>/<act>", ["repo", "document", "url", "confirm", "previewed", "template", "name", "answers", "password", "secret", "trigger", "approve", "remove", "about", "body", "timeoutMinutes", "language", "file", "address", "key", "definition", "owner", "revision", "value", "title", "description", "stage", "decision", "note", "draft", "choice", "entry", "label", "watching"], { prefixes: ["param."] }),
+    flows: formContract("POST /flows/new, /flows/example, /flows/import, /flows/<id>/<act>, /flows/<id>/cards/<card>/<act>, /flows/<id>/triggers/<trigger>/<act>", ["repo", "document", "url", "confirm", "previewed", "template", "name", "answers", "password", "secret", "sender", "project", "team", "trigger", "approve", "remove", "about", "body", "timeoutMinutes", "language", "file", "address", "key", "definition", "owner", "revision", "value", "title", "description", "stage", "decision", "note", "draft", "choice", "entry", "label", "watching", "days", "budget", "runs", "include", "schedules"], { prefixes: ["param."] }),
     spendBudget: formContract("POST /spend/budget", ["password", "target", "action", "usd", "stop"]),
     projectConcurrency: formContract("POST /settings/project/concurrency", ["repo", "concurrency"]),
+    projectLiveView: formContract("POST /settings/project/live-view", ["repo", "act", "password", "nonce"]),
+    projectNetwork: formContract("POST /settings/project/network", ["repo", "mode", "local", "hosts", "password"]),
     projectDelete: formContract("POST /settings/project/delete", ["repo", "name", "step", "password"]),
     policy: formContract("POST /settings/policy", ["password", "provider", "models", "tools", "ceiling"]),
     approval: formContract("POST /settings/approval", ["repo", "password", "protect", "paths", "not_requester"]),
@@ -153,6 +160,7 @@ export const CONSOLE_FORMS = {
     leadFollow: formContract("POST /chat/mate/follow", ["enabled", "return"]),
     leadEnd: formContract("POST /chat/mate/end", ["return"]),
     leadStop: formContract("POST /chat/mate/stop", ["return", "turn"]),
+    leadQueuedRemove: formContract("POST /chat/queued/<message>/remove", ["return"]),
     leadProposal: formContract("POST /chat/proposal/<id>/confirm|dismiss", ["return", "nonce", "confirm", "token"]),
     coordinatorProposal: formContract("POST /proposals/<id>/confirm|dismiss", ["return", "confirm"]),
     chat: formContract("POST /chat", ["task", "project", "result", "mode", "request", "request-session", "message", "token"]),
@@ -167,7 +175,7 @@ export const CONSOLE_FORMS = {
     followUp: formContract("POST /r/<run>/checks|add-tests", ["return", "level"]),
     resolveIncident: formContract("POST /i/<id>/resolve", ["return"]),
     // A task's verbs (/t/<task>/<verb>), one body each.
-    taskSteer: formContract("POST /t/<task>/steer", ["note", "return", "run"]),
+    taskSteer: formContract("POST /t/<task>/steer", ["note", "return", "run", "key", "after", "request"]),
     taskReply: formContract("POST /t/<task>/reply", ["question", "answer"]),
     taskHold: formContract("POST /t/<task>/hold", ["reason"]),
     taskBlock: formContract("POST /t/<task>/block|unblock", ["on"]),
@@ -181,13 +189,13 @@ export const CONSOLE_FORMS = {
     taskCancel: formContract("POST /t/<task>/cancel", ["reason"]),
     taskRoute: formContract("POST /t/<task>/route", ["size", "risky", "phase", "clear-phase", "agent", "provider", "model", "sawDigest", "return"]),
     taskScope: formContract("POST /t/<task>/scope", ["sawDigest", "permission-mode", "quality-mode", "budget-usd", "budget-microusd", "requirement", "requirement-new", "goal-brief", "goal", "not", "touches", "acceptance"]),
-    taskApprove: formContract("POST /t/<task>/approve", ["return", "digest", "token", "nonce"]),
+    taskApprove: formContract("POST /t/<task>/approve", ["return", "digest", "token", "nonce", "rebuild"]),
     taskAcceptProof: formContract("POST /t/<task>/accept-proof", ["run", "note", "return"]),
     taskComplete: formContract("POST /t/<task>/complete", ["receipt", "run", "accept", "note", "publish", "return"]),
     taskStop: formContract("POST /t/<task>/stop", ["run", "return"]),
     // Pause, or Pause and steer when a note rides along, or Resume (mode=resume): the exact run shown, and the page's own
     // request id.
-    taskPause: formContract("POST /t/<task>/pause", ["run", "request", "note", "mode", "return"]),
+    taskPause: formContract("POST /t/<task>/pause", ["run", "request", "note", "mode", "return", "key"]),
     taskResume: formContract("POST /t/<task>/resume|resume-arm", ["run", "token", "nonce", "return"]),
 };
 /** The console POSTs whose handlers read no field (sign-out not even the shared guard): their contract is the empty form. */
@@ -255,6 +263,7 @@ export const flowViewSchema = z.looseObject({
     selectedCard: z.number().nullable(),
     live: z.string().nullable(),
     canEdit: z.boolean(),
+    unattended: z.looseObject({ active: z.looseObject({ until: z.string(), signedBy: z.string() }).nullable(), canSign: z.boolean(), problem: z.string().nullable(), scheduled: z.boolean() }),
     approvers: z.array(z.string()),
     kinds: z.array(z.looseObject({ kind: z.string(), label: z.string() })),
     colors: z.array(z.string()),

package/dist/contracts/flow-card.d.ts

@@ -29,6 +29,10 @@ export declare const flowCardSchema: z.ZodObject<{
     outputs: z.ZodObject<{}, z.core.$catchall<z.ZodString>>;
     attached: z.ZodObject<{}, z.core.$catchall<z.ZodString>>;
     createdBy: z.ZodString;
+    createdKind: z.ZodEnum<{
+        automation: "automation";
+        person: "person";
+    }>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
     owner: z.ZodNullable<z.ZodString>;

package/dist/contracts/flow-card.js

@@ -30,6 +30,9 @@ export const flowCardSchema = z.strictObject({
     outputs: cardOutputsSchema.shape.outputs,
     attached: cardOutputsSchema.shape.attached,
     createdBy: z.string(),
+    /** v126: whether a person or an automation (a delivery, a poll, a schedule, a public form) made it. Decided where it
+     * was made, never read from its label: filing passes it on as the requester's kind. */
+    createdKind: z.enum(["person", "automation"]),
     createdAt: z.string(),
     updatedAt: z.string(),
     owner: z.string().nullable(),

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/integration-metadata.d.ts

@@ -22,11 +22,12 @@ export declare const protectedResourceSchema: z.ZodObject<{
     authorization_servers: z.ZodOptional<z.ZodArray<z.ZodString>>;
     scopes_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
-/** RFC 8414 (or OpenID) authorization-server metadata: where to sign in, trade a code, and register. */
+/** RFC 8414 (or OpenID) authorization-server metadata: where to sign in, trade a code, register, and revoke. */
 export declare const authorizationServerSchema: z.ZodObject<{
     authorization_endpoint: z.ZodOptional<z.ZodString>;
     token_endpoint: z.ZodOptional<z.ZodString>;
     registration_endpoint: z.ZodOptional<z.ZodString>;
+    revocation_endpoint: z.ZodOptional<z.ZodString>;
     code_challenge_methods_supported: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 /** RFC 7591 registration answer: the client Toolroll is, and its secret when the server gives one. */

package/dist/contracts/integration-metadata.js

@@ -44,11 +44,12 @@ export const protectedResourceSchema = z.object({
     authorization_servers: z.array(z.string()).optional(),
     scopes_supported: z.array(z.string().regex(SCOPE_TOKEN)).optional(),
 });
-/** RFC 8414 (or OpenID) authorization-server metadata: where to sign in, trade a code, and register. */
+/** RFC 8414 (or OpenID) authorization-server metadata: where to sign in, trade a code, register, and revoke. */
 export const authorizationServerSchema = z.object({
     authorization_endpoint: z.string().optional(),
     token_endpoint: z.string().optional(),
     registration_endpoint: z.string().optional(),
+    revocation_endpoint: z.string().optional(),
     code_challenge_methods_supported: z.array(z.string()).optional(),
 });
 /** RFC 7591 registration answer: the client Toolroll is, and its secret when the server gives one. */

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);