visionclaw 0.1.219-beta.0 → 0.1.219-dev.codex-issue-2805-worker-runtime.2

package/dist/threads/worker-execution-runtime.js

@@ -0,0 +1,142 @@
+import { logger } from "../logger.js";
+import { EXECUTOR_INTERRUPTED_EXIT_CODE } from "./executor-exit.js";
+/** Message meta key carrying the input sequence an injected message delivers. */
+export const EXECUTION_INPUT_SEQ_META_KEY = "executionInputSeq";
+/**
+ * Worker side of an internal execution (#2805 1c).
+ *
+ * The worker never writes the execution store. It reports its result,
+ * progress, questions, applied inputs, usage and tool-call boundaries over
+ * IPC, and the host validates each report against the executor generation it
+ * started. One runtime exists per worker process; tools reach it through
+ * {@link getWorkerExecutionRuntime}.
+ *
+ * An input counts as applied only once it was handed to the model, not when
+ * it arrived over IPC: a result reported before the model saw an input must
+ * not claim to have processed it.
+ */
+export class WorkerExecutionRuntime {
+    executionId;
+    send;
+    requiresUserMessage;
+    processedInputSeq;
+    receivedInputSeq;
+    terminalReported = false;
+    lastError = null;
+    pending = [];
+    constructor(executionId, initialInputSeq, send, requiresUserMessage = false) {
+        this.executionId = executionId;
+        this.send = send;
+        this.requiresUserMessage = requiresUserMessage;
+        this.processedInputSeq = initialInputSeq;
+        this.receivedInputSeq = initialInputSeq;
+    }
+    get hasReportedResult() {
+        return this.terminalReported;
+    }
+    get inputSeq() {
+        return this.processedInputSeq;
+    }
+    /** The last model/session error seen by this worker, for a failure report. */
+    get lastErrorMessage() {
+        return this.lastError;
+    }
+    /**
+     * Note an input delivered by the host; ignore duplicates and stale ones.
+     * The host accepts input only before it commits a result, so a result this
+     * worker reported earlier was refused for it: a new report is allowed.
+     */
+    receiveInput(input) {
+        if (input.executionId !== this.executionId || input.inputSeq <= this.receivedInputSeq)
+            return false;
+        this.terminalReported = false;
+        this.receivedInputSeq = input.inputSeq;
+        this.pending.push(input);
+        this.pending.sort((a, b) => a.inputSeq - b.inputSeq);
+        return true;
+    }
+    /** Take buffered inputs for injection; each becomes `input_applied` once the model receives it. */
+    takePendingInputs() {
+        const taken = this.pending.splice(0);
+        return taken;
+    }
+    markInputApplied(inputSeq) {
+        if (inputSeq <= this.processedInputSeq)
+            return;
+        this.processedInputSeq = inputSeq;
+        this.send({ type: "execution-input-applied", executionId: this.executionId, inputSeq });
+    }
+    reportProgress(summary) {
+        this.send({ type: "execution-progress", executionId: this.executionId, summary: summary.slice(0, 4_000) });
+    }
+    askQuestion(text, choices, delivery = "review") {
+        this.send({
+            type: "execution-question", executionId: this.executionId, text: text.slice(0, 4_000),
+            ...(choices ? { choices: choices.slice(0, 10) } : {}),
+            ...(delivery === "direct" ? { delivery } : {}),
+        });
+    }
+    toolBoundary(callId, toolName, phase) {
+        this.send({ type: "execution-tool", executionId: this.executionId, callId, toolName, phase });
+    }
+    /** The host keeps the authoritative usage; every local change is reported. */
+    reportUsage(usage) {
+        this.send({ type: "execution-usage", executionId: this.executionId, usage });
+    }
+    noteError(message) {
+        this.lastError = message.slice(0, 500);
+    }
+    /**
+     * Report the terminal result once. A success is refused locally while an
+     * input that arrived has not reached the model yet: the model must see it
+     * first. A failure may be reported regardless.
+     */
+    reportResult(result) {
+        if (this.terminalReported)
+            return { accepted: false, reason: "already_reported" };
+        if (result.status === "succeeded" && this.receivedInputSeq > this.processedInputSeq) {
+            return { accepted: false, reason: "pending_input" };
+        }
+        this.terminalReported = true;
+        this.send({
+            type: "execution-result",
+            executionId: this.executionId,
+            processedInputSeq: this.processedInputSeq,
+            ...result,
+        });
+        logger.system(`[execution] Reported ${result.status} for execution=${this.executionId}`);
+        return { accepted: true };
+    }
+}
+let current = null;
+export function installWorkerExecutionRuntime(runtime) {
+    current = runtime;
+}
+export function getWorkerExecutionRuntime() {
+    return current;
+}
+/**
+ * The exit code this process should end with: an execution stopped before it
+ * reported a result (shutdown request, signal, lost host) is an interruption
+ * the host may resume, not a finished task.
+ */
+export function executorExitCode() {
+    return current && !current.hasReportedResult ? EXECUTOR_INTERRUPTED_EXIT_CODE : 0;
+}
+/**
+ * These messages were just handed to the model (a new turn, or injected into
+ * the running one). Execution inputs among them now count as applied.
+ */
+export function noteMessagesHandedToModel(messages) {
+    if (!current)
+        return;
+    let highest = 0;
+    for (const message of messages) {
+        const seq = message.meta?.[EXECUTION_INPUT_SEQ_META_KEY];
+        if (typeof seq === "number" && seq > highest)
+            highest = seq;
+    }
+    if (highest > 0)
+        current.markInputApplied(highest);
+}
+//# sourceMappingURL=worker-execution-runtime.js.map

package/dist/threads/worker-execution-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-execution-runtime.js","sourceRoot":"","sources":["../../src/threads/worker-execution-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC,OAAO,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAEpE,iFAAiF;AACjF,MAAM,CAAC,MAAM,4BAA4B,GAAG,mBAAmB,CAAC;AAMhE;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,sBAAsB;IAQtB;IAEQ;IACR;IAVH,iBAAiB,CAAS;IAC1B,gBAAgB,CAAS;IACzB,gBAAgB,GAAG,KAAK,CAAC;IACzB,SAAS,GAAkB,IAAI,CAAC;IACvB,OAAO,GAAwB,EAAE,CAAC;IAEnD,YACW,WAAmB,EAC5B,eAAuB,EACN,IAA0C,EAClD,sBAAsB,KAAK;QAH3B,gBAAW,GAAX,WAAW,CAAQ;QAEX,SAAI,GAAJ,IAAI,CAAsC;QAClD,wBAAmB,GAAnB,mBAAmB,CAAQ;QAEpC,IAAI,CAAC,iBAAiB,GAAG,eAAe,CAAC;QACzC,IAAI,CAAC,gBAAgB,GAAG,eAAe,CAAC;IAC1C,CAAC;IAED,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAED,8EAA8E;IAC9E,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACH,YAAY,CAAC,KAAwB;QACnC,IAAI,KAAK,CAAC,WAAW,KAAK,IAAI,CAAC,WAAW,IAAI,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,gBAAgB;YAAE,OAAO,KAAK,CAAC;QACpG,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC9B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,QAAQ,CAAC;QACvC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACzB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;QACrD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,mGAAmG;IACnG,iBAAiB;QACf,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACrC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,gBAAgB,CAAC,QAAgB;QAC/B,IAAI,QAAQ,IAAI,IAAI,CAAC,iBAAiB;YAAE,OAAO;QAC/C,IAAI,CAAC,iBAAiB,GAAG,QAAQ,CAAC;QAClC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,yBAAyB,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC1F,CAAC;IAED,cAAc,CAAC,OAAe;QAC5B,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,oBAAoB,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;IAC7G,CAAC;IAED,WAAW,CAAC,IAAY,EAAE,OAAkB,EAAE,WAAgC,QAAQ;QACpF,IAAI,CAAC,IAAI,CAAC;YACR,IAAI,EAAE,oBAAoB,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC;YACrF,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACrD,GAAG,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC/C,CAAC,CAAC;IACL,CAAC;IAED,YAAY,CAAC,MAAc,EAAE,QAAgB,EAAE,KAA6B;QAC1E,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC;IAChG,CAAC;IAED,8EAA8E;IAC9E,WAAW,CAAC,KAA8B;QACxC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;IAC/E,CAAC;IAED,SAAS,CAAC,OAAe;QACvB,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACH,YAAY,CAAC,MAAqH;QAChI,IAAI,IAAI,CAAC,gBAAgB;YAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,CAAC;QAClF,IAAI,MAAM,CAAC,MAAM,KAAK,WAAW,IAAI,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACpF,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;QACtD,CAAC;QACD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC;YACR,IAAI,EAAE,kBAAkB;YACxB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,GAAG,MAAM;SACV,CAAC,CAAC;QACH,MAAM,CAAC,MAAM,CAAC,wBAAwB,MAAM,CAAC,MAAM,kBAAkB,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;QACzF,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;IAC5B,CAAC;CACF;AAED,IAAI,OAAO,GAAkC,IAAI,CAAC;AAElD,MAAM,UAAU,6BAA6B,CAAC,OAAsC;IAClF,OAAO,GAAG,OAAO,CAAC;AACpB,CAAC;AAED,MAAM,UAAU,yBAAyB;IACvC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB;IAC9B,OAAO,OAAO,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC,CAAC,CAAC;AACpF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,yBAAyB,CAAC,QAAmC;IAC3E,IAAI,CAAC,OAAO;QAAE,OAAO;IACrB,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,4BAA4B,CAAC,CAAC;QACzD,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,GAAG,OAAO;YAAE,OAAO,GAAG,GAAG,CAAC;IAC9D,CAAC;IACD,IAAI,OAAO,GAAG,CAAC;QAAE,OAAO,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;AACrD,CAAC"}

package/dist/threads/worker-execution.d.ts

@@ -0,0 +1,35 @@
+import type { AdapterTool } from "../tools/adapter-tool.js";
+import type { VisionClawConfig } from "../config/types.js";
+import type { ActiveWorkerRuntimePolicy } from "./worker-runtime-policy.js";
+import type { ExecutionSnapshot } from "./execution-snapshot.js";
+import type { ExecutionBudgetMeter } from "./execution-budget.js";
+/**
+ * A bounded execution installed by the trusted worker host, after admission.
+ *
+ * Unlike a conversational worker, it receives only dispatched task context,
+ * drains its queue, then returns control to its host. Business adapters own
+ * the prompt and any additional host-backed capabilities. This object never
+ * comes from message metadata or model output.
+ */
+export interface WorkerExecution {
+    id: string;
+    policy: ActiveWorkerRuntimePolicy;
+    /** Effective snapshot frozen by the admitting host and verified at startup. */
+    snapshot: ExecutionSnapshot;
+    /** Task budget restored from this execution's own durable record. */
+    budget: ExecutionBudgetMeter;
+    /** Rebuild against the current config after a model switch or refresh. */
+    buildSystemPrompt: (config: VisionClawConfig) => string;
+    /**
+     * The adapter's own tool registrations (e.g. Lab's lab_run_control). The
+     * host exposes them only through the policy allowlist; an adapter cannot
+     * change any other part of the restricted surface.
+     */
+    adapterTools?: readonly AdapterTool[];
+    /**
+     * The conversation is private data (Dreaming reads and edits memory): its
+     * transcripts are not shipped as runtime telemetry and logs carry no content.
+     */
+    privateContent?: boolean;
+}
+//# sourceMappingURL=worker-execution.d.ts.map

package/dist/threads/worker-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-execution.d.ts","sourceRoot":"","sources":["../../src/threads/worker-execution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,yBAAyB,CAAC;IAClC,+EAA+E;IAC/E,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,qEAAqE;IACrE,MAAM,EAAE,oBAAoB,CAAC;IAC7B,0EAA0E;IAC1E,iBAAiB,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,MAAM,CAAC;IACxD;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B"}

package/dist/threads/worker-execution.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker-execution.js.map

package/dist/threads/worker-execution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-execution.js","sourceRoot":"","sources":["../../src/threads/worker-execution.ts"],"names":[],"mappings":""}

package/dist/threads/worker-runtime-policy.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import type { VisionClawConfig } from "../config/types.js";
+import type { RuntimeSurface } from "../agent/runtime-surface.js";
+import type { AdapterTool } from "../tools/adapter-tool.js";
+/** Capabilities selected by a trusted caller, independent of its business identity. */
+export declare const WorkerRuntimePolicySchema: z.ZodObject<{
+    prompt: z.ZodObject<{
+        trustedOverlay: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>;
+    skills: z.ZodObject<{
+        allowed: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    mcp: z.ZodObject<{
+        staticServers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{}, z.core.$strict>>>;
+    }, z.core.$strict>;
+    tools: z.ZodObject<{
+        allowed: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    channels: z.ZodObject<{
+        outbound: z.ZodTuple<[], null>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type WorkerRuntimePolicy = z.infer<typeof WorkerRuntimePolicySchema>;
+export interface ActiveWorkerRuntimePolicy {
+    policy: WorkerRuntimePolicy;
+    /** Digest of the caller's authorized execution snapshot. */
+    digest: string;
+}
+/** Claude may emit incremental Task tools instead of the legacy TodoWrite. */
+export declare const CLAUDE_TODO_TRACKING_TOOLS: readonly ["TodoWrite", "TaskCreate", "TaskUpdate", "TaskGet", "TaskList"];
+export declare function resolvePiWorkerToolNames(toolNames: readonly string[]): string[];
+export declare function resolveClaudeWorkerNativeToolNames(toolNames: readonly string[]): string[];
+/** Remove owner channels and integrations from the config an internal worker runs with. */
+export declare function isolateWorkerConfig(config: VisionClawConfig): VisionClawConfig;
+/**
+ * The restricted surface of an internal execution. Applied by the host after
+ * everything else, so no adapter can restore credentials or MCP servers,
+ * replace the policy, or attach its own budget. `adapterTools` is the only
+ * adapter-supplied input, and the policy allowlist still filters it.
+ */
+export declare function applyWorkerRuntimePolicyToSurface(surface: RuntimeSurface, active: ActiveWorkerRuntimePolicy, adapterTools?: readonly AdapterTool[]): RuntimeSurface;
+//# sourceMappingURL=worker-runtime-policy.d.ts.map

package/dist/threads/worker-runtime-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-runtime-policy.d.ts","sourceRoot":"","sources":["../../src/threads/worker-runtime-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAI5D,uFAAuF;AACvF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;kBAgB3B,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,mBAAmB,CAAC;IAC5B,4DAA4D;IAC5D,MAAM,EAAE,MAAM,CAAC;CAChB;AAcD,8EAA8E;AAC9E,eAAO,MAAM,0BAA0B,2EAE7B,CAAC;AAiBX,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAE/E;AAED,wBAAgB,kCAAkC,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAKzF;AAED,2FAA2F;AAC3F,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,gBAAgB,CAa9E;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,yBAAyB,EACjC,YAAY,GAAE,SAAS,WAAW,EAAO,GACxC,cAAc,CAmBhB"}

package/dist/threads/worker-runtime-policy.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+const slugSchema = z.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/);
+/** Capabilities selected by a trusted caller, independent of its business identity. */
+export const WorkerRuntimePolicySchema = z.object({
+    prompt: z.object({
+        trustedOverlay: z.string().max(20_000).default(""),
+    }).strict(),
+    skills: z.object({
+        allowed: z.array(slugSchema).max(64).default([]),
+    }).strict(),
+    mcp: z.object({
+        staticServers: z.record(slugSchema, z.object({}).strict()).default({}),
+    }).strict(),
+    tools: z.object({
+        allowed: z.array(slugSchema).min(1).max(64),
+    }).strict(),
+    channels: z.object({
+        outbound: z.tuple([]),
+    }).strict(),
+}).strict();
+const PI_WORKER_TOOL_NAMES = {
+    read: "visionclaw_read",
+    write: "visionclaw_write",
+    edit: "visionclaw_edit",
+    grep: "visionclaw_grep",
+    find: "visionclaw_find",
+    ls: "visionclaw_ls",
+    bash: "visionclaw_bash",
+    todo_write: "TodoWrite",
+    web_fetch: "WebFetch",
+};
+/** Claude may emit incremental Task tools instead of the legacy TodoWrite. */
+export const CLAUDE_TODO_TRACKING_TOOLS = [
+    "TodoWrite", "TaskCreate", "TaskUpdate", "TaskGet", "TaskList",
+];
+const CLAUDE_WORKER_TOOL_NAMES = {
+    read: "Read",
+    write: "Write",
+    edit: "Edit",
+    grep: "Grep",
+    find: "Glob",
+    ls: "Glob",
+    bash: "Bash",
+    todo_write: CLAUDE_TODO_TRACKING_TOOLS,
+    // Subagents run with the parent's restricted tools; their calls are metered.
+    agent: ["Agent", "Task"],
+    web_fetch: "WebFetch",
+    web_search: "WebSearch",
+};
+export function resolvePiWorkerToolNames(toolNames) {
+    return [...new Set(toolNames.map((name) => PI_WORKER_TOOL_NAMES[name] ?? name))];
+}
+export function resolveClaudeWorkerNativeToolNames(toolNames) {
+    return [...new Set(toolNames.flatMap((name) => {
+            const mapped = CLAUDE_WORKER_TOOL_NAMES[name];
+            return mapped ? (typeof mapped === "string" ? [mapped] : [...mapped]) : [];
+        }))];
+}
+/** Remove owner channels and integrations from the config an internal worker runs with. */
+export function isolateWorkerConfig(config) {
+    const isolated = structuredClone(config);
+    isolated.gmail = "";
+    isolated.channels = {};
+    isolated.capabilities = {
+        schemaVersion: 1,
+        ...isolated.capabilities,
+        managedWorkspace: false,
+        proactiveWake: false,
+        tunnel: false,
+        gemini: false,
+    };
+    return isolated;
+}
+/**
+ * The restricted surface of an internal execution. Applied by the host after
+ * everything else, so no adapter can restore credentials or MCP servers,
+ * replace the policy, or attach its own budget. `adapterTools` is the only
+ * adapter-supplied input, and the policy allowlist still filters it.
+ */
+export function applyWorkerRuntimePolicyToSurface(surface, active, adapterTools = []) {
+    return {
+        ...surface,
+        credentialBacked: {
+            eventTrigger: false,
+            financialTool: false,
+            finApp: false,
+            serpApi: false,
+        },
+        externalMcpServers: Object.fromEntries(Object.entries(surface.externalMcpServers)
+            .filter(([name]) => Object.hasOwn(active.policy.mcp.staticServers, name))),
+        workerRuntimePolicy: active,
+        // Every execution requires fresh adapter authorization and its own budget,
+        // even when reusing a surface.
+        adapterTools,
+        executionBudget: undefined,
+    };
+}
+//# sourceMappingURL=worker-runtime-policy.js.map

package/dist/threads/worker-runtime-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-runtime-policy.js","sourceRoot":"","sources":["../../src/threads/worker-runtime-policy.ts"],"names":[],"mappings":"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"}

package/dist/tools/adapter-tool.d.ts

@@ -0,0 +1,12 @@
+import type { SdkMcpToolDefinition } from "@anthropic-ai/claude-agent-sdk";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+/**
+ * A VisionClaw tool registered by a trusted execution adapter, such as the Lab
+ * adapter's `lab_run_control`. Both engines expose these through the same
+ * allowlist filter as built-in tools. The handler's argument type is erased so
+ * differently-typed definitions can share one list.
+ */
+export type AdapterTool = Omit<SdkMcpToolDefinition, "handler"> & {
+    handler: (args: never, extra: unknown) => Promise<CallToolResult>;
+};
+//# sourceMappingURL=adapter-tool.d.ts.map

package/dist/tools/adapter-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-tool.d.ts","sourceRoot":"","sources":["../../src/tools/adapter-tool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAC3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,GAAG;IAChE,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;CACnE,CAAC"}

package/dist/tools/adapter-tool.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adapter-tool.js.map

package/dist/tools/adapter-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-tool.js","sourceRoot":"","sources":["../../src/tools/adapter-tool.ts"],"names":[],"mappings":""}

package/dist/tools/data-service.d.ts

@@ -161,9 +161,9 @@ export declare class DataServiceProvider {
 }
 export declare const queryMarketDataTool: import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
     operation: z.ZodOptional<z.ZodEnum<{
-        query: "query";
         catalog: "catalog";
         plan: "plan";
+        query: "query";
     }>>;
     mode: z.ZodOptional<z.ZodEnum<{
         product: "product";
@@ -187,9 +187,9 @@ export declare const queryMarketDataTool: import("@anthropic-ai/claude-agent-sdk
 export declare function gruReferenceDataRoot(workspaceCwd?: string): string;
 export declare const queryReferenceDataTool: import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
     operation: z.ZodOptional<z.ZodEnum<{
-        query: "query";
         catalog: "catalog";
         plan: "plan";
+        query: "query";
     }>>;
     mode: z.ZodOptional<z.ZodEnum<{
         product: "product";

package/dist/tools/delegation.d.ts

@@ -0,0 +1,121 @@
+export declare const delegateTaskTool: import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    source_message_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    key: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    title: import("zod").ZodString;
+    goal: import("zod").ZodString;
+    requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    expected_output: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    context: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    done: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    remaining: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    artifacts: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    uncertain_operations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    project_dir: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    workspace_mode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<{
+        read_only: "read_only";
+        shared: "shared";
+    }>>>;
+    context_task_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    retry_task_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}>;
+export declare const delegateTasksTool: import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    source_message_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    title: import("zod").ZodString;
+    result_mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        separate: "separate";
+        combined: "combined";
+    }>>;
+    tasks: import("zod").ZodArray<import("zod").ZodObject<{
+        key: import("zod").ZodString;
+        title: import("zod").ZodString;
+        done: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        remaining: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        goal: import("zod").ZodString;
+        requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        artifacts: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        workspace_mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            read_only: "read_only";
+            shared: "shared";
+            isolated: "isolated";
+        }>>;
+        source_message_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        expected_output: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        context: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        uncertain_operations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        project_dir: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        context_task_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>>;
+}>;
+export declare const backgroundTaskStatusTool: import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    task_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}>;
+export declare const backgroundTaskInputTool: import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    task_id: import("zod").ZodString;
+    text: import("zod").ZodString;
+    question_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}>;
+export declare const backgroundTaskCancelTool: import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    task_id: import("zod").ZodString;
+    requested_by_user: import("zod").ZodBoolean;
+    reason: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}>;
+export declare const DELEGATION_TOOLS: readonly [import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    source_message_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    key: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    title: import("zod").ZodString;
+    goal: import("zod").ZodString;
+    requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    expected_output: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    context: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    done: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    remaining: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    artifacts: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    uncertain_operations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    project_dir: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    workspace_mode: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodEnum<{
+        read_only: "read_only";
+        shared: "shared";
+    }>>>;
+    context_task_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    retry_task_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}>, import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    source_message_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    title: import("zod").ZodString;
+    result_mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        separate: "separate";
+        combined: "combined";
+    }>>;
+    tasks: import("zod").ZodArray<import("zod").ZodObject<{
+        key: import("zod").ZodString;
+        title: import("zod").ZodString;
+        done: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        remaining: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        goal: import("zod").ZodString;
+        requirements: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        artifacts: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        workspace_mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            read_only: "read_only";
+            shared: "shared";
+            isolated: "isolated";
+        }>>;
+        source_message_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        expected_output: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        context: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        uncertain_operations: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+        project_dir: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        context_task_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>>;
+}>, import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    task_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}>, import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    task_id: import("zod").ZodString;
+    text: import("zod").ZodString;
+    question_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}>, import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    task_id: import("zod").ZodString;
+    requested_by_user: import("zod").ZodBoolean;
+    reason: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+}>];
+/** A disabled delegation feature still exposes control of already admitted Tasks. */
+export declare function availableTaskTools(): typeof DELEGATION_TOOLS[number][];
+//# sourceMappingURL=delegation.d.ts.map

package/dist/tools/delegation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation.d.ts","sourceRoot":"","sources":["../../src/tools/delegation.ts"],"names":[],"mappings":"AAoFA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;EAK5B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK7B,CAAC;AAEF,eAAO,MAAM,wBAAwB;;EAKpC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;EAKnC,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;EAKpC,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAMnB,CAAC;AAEX,qFAAqF;AACrF,wBAAgB,kBAAkB,IAAI,OAAO,gBAAgB,CAAC,MAAM,CAAC,EAAE,CAMtE"}

package/dist/tools/delegation.js

@@ -0,0 +1,106 @@
+import { randomUUID } from "node:crypto";
+import { tool } from "@anthropic-ai/claude-agent-sdk";
+import { getAgentState } from "../agent/state.js";
+import { buildTaskReplyTarget } from "../agent/reply-target.js";
+import { getMessageDedupKey } from "../channels/message-dedup.js";
+import { getForegroundTaskTracker } from "../threads/foreground-task.js";
+import { BACKGROUND_TASK_CANCEL_ARGS, BACKGROUND_TASK_INPUT_ARGS, BACKGROUND_TASK_STATUS_ARGS, DELEGATE_TASK_ARGS, DELEGATE_TASKS_ARGS, getForemanClient, } from "../threads/foreman-protocol.js";
+/**
+ * General's background-task tools (#2805 stage 3, Foreman). They only
+ * coordinate: the work itself runs in a background worker, and none of these
+ * calls count against the foreground tool-call limit.
+ *
+ * Identity and routing never come from the model: the host binds every task
+ * to the conversation that sends the command, and the dispatch records the
+ * reply target of the inbound message this wake is serving.
+ */
+function reply(text, isError = false) {
+    return { ...(isError ? { isError: true } : {}), content: [{ type: "text", text }] };
+}
+const UNAVAILABLE = "Error: background tasks are not available in this conversation.";
+/** Resolve routing from an actual queue claim, never from model-supplied addresses. */
+function dispatchSource(sourceMessageId) {
+    let state;
+    try {
+        state = getAgentState();
+    }
+    catch {
+        return {};
+    }
+    let claims = [];
+    try {
+        claims = state.messageQueue.currentCycleClaims();
+    }
+    catch { /* legacy callers may have no queue */ }
+    const matches = sourceMessageId ? claims.filter((message) => message.id === sourceMessageId || getMessageDedupKey(message) === sourceMessageId) : [];
+    if (matches.length > 1)
+        throw new Error("Use the unambiguous source_message_id shown beside the message");
+    const selected = matches.at(0);
+    if (sourceMessageId && !selected)
+        throw new Error("source_message_id must name a message in this conversation's active turn");
+    const addressed = claims.filter((message) => message.deliveryTarget !== undefined || message.channel !== "system");
+    const targets = new Set(addressed.map((message) => JSON.stringify(buildTaskReplyTarget(message).delivery)));
+    if (!selected && targets.size > 1)
+        throw new Error(`Choose source_message_id for this Task: ${addressed.map((message) => getMessageDedupKey(message)).join(", ")}`);
+    const message = selected ?? addressed.at(0);
+    return {
+        target: message ? buildTaskReplyTarget(message) : state.currentTaskReplyTarget,
+        dispatchKey: message ? getMessageDedupKey(message) : state.currentDispatchId,
+    };
+}
+async function delegate(type, args) {
+    const client = getForemanClient();
+    if (!client)
+        return reply(UNAVAILABLE, true);
+    const tracker = getForegroundTaskTracker();
+    const foreground = tracker?.taskForHandoff() ?? { taskId: `task-${randomUUID()}`, toolCallsUsed: 0 };
+    try {
+        const source = dispatchSource(args.source_message_id);
+        const result = await client.request({
+            type, args,
+            foreground: { taskId: foreground.taskId, toolCallsUsed: tracker?.unassignedToolCalls ?? 0 },
+            dispatchKey: source.dispatchKey ?? foreground.taskId,
+            ...(source.target ? { replyTarget: source.target.delivery, sender: source.target.sender } : {}),
+        });
+        if (result.ok)
+            tracker?.markHandedOff(foreground.taskId);
+        return reply(result.text, !result.ok);
+    }
+    catch (error) {
+        return reply(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+    }
+}
+async function send(command) {
+    const client = getForemanClient();
+    if (!client)
+        return reply(UNAVAILABLE, true);
+    try {
+        const result = await client.request(command);
+        return reply(result.text, !result.ok);
+    }
+    catch (error) {
+        return reply(`Error: ${error instanceof Error ? error.message : String(error)}`, true);
+    }
+}
+export const delegateTaskTool = tool("delegate_task", "Delegate one Task to the shared worker pool. Reply directly when you already have the answer. Use delegate_tasks for independent work that should run in parallel. Pass the goal, completed work, remaining work and artifacts. Use context_task_id to continue a completed Task's workspace and results as new work. Omit retry_task_id for new work; use it only to retry a finished Task without resetting its cumulative budget. Verified owner-DM Tasks can read email, calendar and Drive through the host; sends and remote changes remain with you. After acceptance, do not continue that Task's work in the foreground: call notify_user on the originating channel with a concise handoff summary (what is done and what remains), then call finish. You may continue coordination or delegate independent Tasks. Do not claim handoff before acceptance and do not duplicate a delegated Task's work in the foreground.", DELEGATE_TASK_ARGS, (args) => delegate("delegate", args));
+export const delegateTasksTool = tool("delegate_tasks", "Admit independent Tasks together, each with its own cumulative budget. Default result_mode=separate creates no parent; choose combined only when the user needs one jointly reviewed result. Use stable unique task keys. project_dir keeps its current files by default: shared access is exclusive, read_only allows concurrent readers without mutation tools, and isolated explicitly creates Git worktrees for parallel modifications. Repeating the same dispatch is idempotent. After acceptance, notify_user with a concise handoff summary and finish this chat turn before doing more work on those Tasks; continue only with coordination or independent Tasks.", DELEGATE_TASKS_ARGS, (args) => delegate("delegate_batch", args));
+export const backgroundTaskStatusTool = tool("background_task_status", "Read the real state of this conversation's background tasks: queued, running, waiting for an answer, stopping, or finished, with the latest progress, open question, result and whether the user was told. Use it to answer progress questions instead of guessing.", BACKGROUND_TASK_STATUS_ARGS, (args) => send({ type: "status", args }));
+export const backgroundTaskInputTool = tool("background_task_input", "Send a running background task the answer to its question, or a new requirement from the user. The input is stored and the worker reads it at its next step; storing it does not mean the worker has applied it. Use this instead of doing the task's work here. To change a finished task's result, use delegate_task with retry_task_id.", BACKGROUND_TASK_INPUT_ARGS, (args) => send({ type: "input", args }));
+export const backgroundTaskCancelTool = tool("background_task_cancel", "Ask a background task to stop. A running task is only reported cancelled after its worker has really stopped, so do not tell the user it has stopped until then; there is no pause.", BACKGROUND_TASK_CANCEL_ARGS, (args) => send({ type: "cancel", args }));
+export const DELEGATION_TOOLS = [
+    delegateTaskTool,
+    delegateTasksTool,
+    backgroundTaskStatusTool,
+    backgroundTaskInputTool,
+    backgroundTaskCancelTool,
+];
+/** A disabled delegation feature still exposes control of already admitted Tasks. */
+export function availableTaskTools() {
+    const client = getForemanClient();
+    if (!client)
+        return [];
+    return client.delegationEnabled === false
+        ? [backgroundTaskStatusTool, backgroundTaskInputTool, backgroundTaskCancelTool]
+        : [...DELEGATION_TOOLS];
+}
+//# sourceMappingURL=delegation.js.map