@tea-agent/loop-agent 0.43.0-next.17 → 0.43.0-next.3

package/dist/worker/console/chat/browser-routes.js

@@ -1,162 +0,0 @@
-/**
- * HTTP routes for the Operator Chat browser panel: one read-only probe
- * endpoint the panel uses to explain an iframe refusal (X-Frame-Options /
- * CSP frame-ancestors are exactly the signals the browser enforces when it
- * refuses to embed a site). The probe is display-only (headers back to the
- * caller), restricted to http(s) URLs, with a hard timeout. Local addresses
- * are allowed — the panel routinely browses local dev servers.
- */
-import { embeddabilityOf, extractFrameAncestors, normalizeBrowserUrl, } from "./browser-policy.js";
-function workspaceIdOf(req) {
-    try {
-        return new URL(req.url ?? "/", "http://localhost").searchParams.get("workspaceId") ?? undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function sendJson(res, status, body) {
-    res.writeHead(status, {
-        "content-type": "application/json; charset=utf-8",
-        "cache-control": "no-store",
-    });
-    res.end(JSON.stringify(body));
-}
-/** Route dispatcher; returns true when the request was handled. */
-export async function handleBrowserRequest(req, res, deps, pathname) {
-    if (!pathname.startsWith("/api/operator/v1/chat/browser"))
-        return false;
-    const method = (req.method ?? "GET").toUpperCase();
-    const rest = pathname.slice("/api/operator/v1/chat/browser".length);
-    const parts = rest.split("/").filter(Boolean);
-    const sub = parts[0] ?? "";
-    try {
-        if (method === "GET" && sub === "probe" && parts.length === 1) {
-            // Fail-closed: the probe needs a workspaceId like every chat API.
-            if (deps.requireWorkspace) {
-                const ws = deps.requireWorkspace(req);
-                if (!ws.ok) {
-                    sendJson(res, 400, {
-                        ok: false,
-                        error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
-                    });
-                    return true;
-                }
-            }
-            else if (!workspaceIdOf(req)) {
-                sendJson(res, 400, {
-                    ok: false,
-                    error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
-                });
-                return true;
-            }
-            const url = new URL(req.url ?? "/", "http://localhost");
-            const raw = url.searchParams.get("url") ?? "";
-            const normalized = normalizeBrowserUrl(raw);
-            if (normalized.kind !== "ok") {
-                sendJson(res, 400, {
-                    ok: false,
-                    error: {
-                        code: normalized.kind === "blocked" ? "BAD_SCHEME" : "INVALID_URL",
-                        message: normalized.kind === "blocked"
-                            ? "only http/https urls can be probed"
-                            : "invalid url",
-                    },
-                });
-                return true;
-            }
-            const parsed = new URL(normalized.url);
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), 8000);
-            try {
-                let response = await fetch(parsed, {
-                    method: "HEAD",
-                    redirect: "follow",
-                    signal: controller.signal,
-                });
-                // Some servers answer HEAD with 405/501; retry once as GET
-                // (the body is discarded — only the headers matter).
-                if (response.status === 405 || response.status === 501) {
-                    response = await fetch(parsed, {
-                        method: "GET",
-                        redirect: "follow",
-                        signal: controller.signal,
-                    });
-                }
-                const csp = response.headers.get("content-security-policy");
-                const frameAncestors = extractFrameAncestors(csp);
-                const xFrameOptions = response.headers.get("x-frame-options");
-                const probe = {
-                    reachable: true,
-                    url: response.url,
-                    status: response.status,
-                    ...(xFrameOptions !== null ? { xFrameOptions } : {}),
-                    ...(frameAncestors !== undefined ? { frameAncestors } : {}),
-                };
-                sendJson(res, 200, {
-                    ok: true,
-                    data: { probe, verdict: embeddabilityOf(probe) },
-                });
-                return true;
-            }
-            catch {
-                // DNS / TLS / connection / timeout: nothing to judge — the
-                // client keeps the plain iframe.
-                sendJson(res, 200, {
-                    ok: true,
-                    data: { probe: { reachable: false }, verdict: "unknown" },
-                });
-                return true;
-            }
-            finally {
-                clearTimeout(timer);
-            }
-        }
-        if (method === "GET" && sub === "commands" && parts.length === 1) {
-            const ws = workspaceIdOf(req);
-            if (!ws) {
-                sendJson(res, 400, {
-                    ok: false,
-                    error: { code: "WORKSPACE_REQUIRED", message: "workspaceId is required" },
-                });
-                return true;
-            }
-            if (deps.requireWorkspace) {
-                const scope = deps.requireWorkspace(req);
-                if (!scope.ok) {
-                    sendJson(res, 403, {
-                        ok: false,
-                        error: { code: "WORKSPACE_DENIED", message: "workspace scope mismatch" },
-                    });
-                    return true;
-                }
-            }
-            if (!deps.automation) {
-                sendJson(res, 200, { ok: true, data: { commands: [] } });
-                return true;
-            }
-            sendJson(res, 200, { ok: true, data: { commands: deps.automation.take() } });
-            return true;
-        }
-        sendJson(res, 404, {
-            ok: false,
-            error: { code: "NOT_FOUND", message: `unknown browser route: ${method} ${pathname}` },
-        });
-        return true;
-    }
-    catch (error) {
-        if (!res.headersSent) {
-            sendJson(res, 500, {
-                ok: false,
-                error: {
-                    code: "BROWSER_INTERNAL",
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            });
-        }
-        else {
-            res.end();
-        }
-        return true;
-    }
-}

package/dist/worker/console/chat/pi-runtime/custom-tools/ask-user-question.js

@@ -1,44 +0,0 @@
-/**
- * Session-bound ask_user_question custom tool.
- * ConsolePiRuntime supplies the sessionId and UserQuestionRegistry.
- */
-const ASK_USER_QUESTION_DESCRIPTION = "Ask the user concise questions when a confirmation, choice, or missing detail is required before proceeding. " +
-    "The tool pauses until the user answers. Use it instead of writing questions as ordinary assistant text. " +
-    "Send one or more questions with stable ids; recommended options should be first and end with (Recommended).";
-export async function buildAskUserQuestionTool(options) {
-    const [{ Type }, { defineTool }] = await Promise.all([
-        import("typebox"),
-        import("@earendil-works/pi-coding-agent"),
-    ]);
-    return defineTool({
-        name: "ask_user_question",
-        label: "Ask user",
-        description: ASK_USER_QUESTION_DESCRIPTION,
-        promptSnippet: ASK_USER_QUESTION_DESCRIPTION,
-        parameters: Type.Object({
-            questions: Type.Array(Type.Object({
-                id: Type.String({ description: "Stable question id echoed in the answer." }),
-                question: Type.String({ description: "Specific user-facing question." }),
-                header: Type.Optional(Type.String({ description: "Optional short heading." })),
-                detail: Type.Optional(Type.String({ description: "Optional Markdown context shown below the question." })),
-                options: Type.Optional(Type.Array(Type.Object({
-                    label: Type.String({ description: "Short user-facing option label." }),
-                    description: Type.Optional(Type.String({ description: "One sentence explaining impact or tradeoff." })),
-                }, { additionalProperties: false }))),
-                multi_select: Type.Optional(Type.Boolean({ description: "Allow more than one option." })),
-            }, { additionalProperties: false }), { minItems: 1, maxItems: 20 }),
-        }, { additionalProperties: false }),
-        async execute(toolCallId, params, signal) {
-            const answer = await options.registry.ask({
-                sessionId: options.sessionId,
-                toolCallId,
-                questions: params.questions,
-                signal,
-            });
-            return {
-                content: [{ type: "text", text: JSON.stringify(answer) }],
-                details: answer,
-            };
-        },
-    });
-}

package/dist/worker/console/chat/pi-runtime/custom-tools/browser-tools.js

@@ -1,89 +0,0 @@
-/**
- * Session-independent browser tools shared by workflow and Pi chat modes.
- * Navigation is visible in the Console sidebar; inspection is server-side and
- * bounded to avoid exposing raw credentials or arbitrary page scripts.
- */
-const BROWSER_TOOLS_DESCRIPTION = "Operate the Console sidebar browser. `browser_navigate` shows a URL in the panel; `browser_search` opens a search URL and returns elements; `browser_inspect` returns title/links/form controls; `browser_act` fills/submits a static GET form or clicks a static link. For natural-language search requests, prefer `browser_search` over navigating to a homepage and simulating its form. It never edits the workspace and cannot execute browser scripts. Dynamic-page and POST-form operations are out of scope.";
-export async function buildBrowserTools(options) {
-    const [{ Type }, { defineTool }] = await Promise.all([
-        import("typebox"),
-        import("@earendil-works/pi-coding-agent"),
-    ]);
-    const automation = options.automation;
-    const urlParameter = Type.String({
-        description: "Absolute http(s) URL. Prefer URLs/element selectors returned by prior browser tools.",
-    });
-    async function execute(operation) {
-        try {
-            const result = await operation();
-            return {
-                content: [{ type: "text", text: JSON.stringify(result) }],
-                details: result,
-            };
-        }
-        catch (error) {
-            const payload = {
-                error: error instanceof Error ? error.message : String(error),
-                code: error instanceof Error && "code" in error
-                    ? String(error.code)
-                    : "BROWSER_OPERATION_FAILED",
-            };
-            return {
-                content: [{ type: "text", text: JSON.stringify(payload) }],
-                details: payload,
-            };
-        }
-    }
-    return [
-        defineTool({
-            name: "browser_navigate",
-            label: "Sidebar browser navigate",
-            description: BROWSER_TOOLS_DESCRIPTION,
-            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
-            parameters: Type.Object({ url: urlParameter }, { additionalProperties: false }),
-            async execute(_toolCallId, params) {
-                return execute(() => automation.navigate(params.url, { includeSnapshot: true }));
-            },
-        }),
-        defineTool({
-            name: "browser_search",
-            label: "Sidebar browser search",
-            description: BROWSER_TOOLS_DESCRIPTION,
-            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
-            parameters: Type.Object({
-                query: Type.String({ description: "Search query." }),
-                engineUrl: Type.Optional(urlParameter),
-            }, { additionalProperties: false }),
-            async execute(_toolCallId, params) {
-                return execute(() => automation.search(params.query, params.engineUrl));
-            },
-        }),
-        defineTool({
-            name: "browser_inspect",
-            label: "Sidebar browser inspect",
-            description: BROWSER_TOOLS_DESCRIPTION,
-            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
-            parameters: Type.Object({ url: urlParameter }, { additionalProperties: false }),
-            async execute(_toolCallId, params) {
-                return execute(() => automation.inspect(params.url));
-            },
-        }),
-        defineTool({
-            name: "browser_act",
-            label: "Sidebar browser act",
-            description: BROWSER_TOOLS_DESCRIPTION,
-            promptSnippet: BROWSER_TOOLS_DESCRIPTION,
-            parameters: Type.Object({
-                url: urlParameter,
-                type: Type.Union([Type.Literal("click"), Type.Literal("fill")]),
-                selector: Type.String({ description: "Selector returned by browser_inspect." }),
-                value: Type.Optional(Type.String()),
-            }, { additionalProperties: false }),
-            async execute(_toolCallId, params) {
-                return execute(() => automation.act(params.url, params.type === "click"
-                    ? { type: "click", selector: params.selector }
-                    : { type: "fill", selector: params.selector, value: params.value ?? "" }));
-            },
-        }),
-    ];
-}

package/dist/worker/console/chat/pi-runtime/custom-tools/explore-tools.js

@@ -1,202 +0,0 @@
-/**
- * Session-less safe explore custom tools (safe-read / safe-grep / git-status /
- * git-diff). Execution uses explore-tools.ts path guards and secret scrubbing.
- * ConsolePiRuntime owns the sessionless cache.
- */
-/**
- * Build the safe explore custom tools (roadmap M0-A / G16): safe-read,
- * safe-grep, gitStatus, gitDiff. These replace the bare SDK bash/read/grep so
- * the model can probe the repo WITHOUT write escapes (echo redirect, tee,
- * sed -i, node -e) and WITHOUT reading sensitive files (env files, key/pem,
- * auth.json, sessions dir) — and every returned byte is secret-scrubbed
- * before reaching the model context.
- *
- * gitStatus/gitDiff use a FIXED argv (typed, no shell) so they cannot be
- * turned into an arbitrary-shell vector.
- */
-export async function buildExploreCustomTools(options) {
-    const [{ Type }, { defineTool }] = await Promise.all([
-        import("typebox"),
-        import("@earendil-works/pi-coding-agent"),
-    ]);
-    const { execFileSync } = await import("node:child_process");
-    const repoRoot = options.repoRoot;
-    const { safeReadFile, safeGrep, scrubSecrets } = await import("../../explore-tools.js");
-    function safeGit(args) {
-        try {
-            const stdout = execFileSync("git", args, {
-                cwd: repoRoot,
-                encoding: "utf8",
-                // Fixed argv, no shell, bounded output.
-                maxBuffer: 512 * 1024,
-                timeout: 10_000,
-                windowsHide: true,
-            });
-            return { ok: true, stdout };
-        }
-        catch (e) {
-            return {
-                ok: false,
-                code: "GIT_FAILED",
-                message: e instanceof Error ? e.message : String(e),
-            };
-        }
-    }
-    const safeReadTool = defineTool({
-        name: "safe-read",
-        label: "safe-read",
-        description: "Read a repo-relative file with sensitive-file denylist (.env*/*.key/*.pem/.git/**/auth.json/sessions/**) and secret scrubbing. Absolute paths and .. are rejected.",
-        promptSnippet: "safe-read: read a repo file (safe; secrets scrubbed)",
-        parameters: Type.Object({
-            path: Type.String({ description: "repo-relative file path" }),
-        }, { additionalProperties: false }),
-        async execute(_toolCallId, params) {
-            const raw = String(params.path ?? "");
-            try {
-                const result = await safeReadFile(repoRoot, raw);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result) }],
-                    details: result,
-                };
-            }
-            catch (e) {
-                const err = e;
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                error: err.message ?? String(e),
-                                code: err.code ?? "READ_FAILED",
-                            }),
-                        },
-                    ],
-                    details: {
-                        error: err.message ?? String(e),
-                        code: err.code ?? "READ_FAILED",
-                    },
-                };
-            }
-        },
-    });
-    const safeGrepTool = defineTool({
-        name: "safe-grep",
-        label: "safe-grep",
-        description: "Line search across the repo working tree with sensitive-file denylist and secret scrubbing. pattern is a JS regex source; optional glob filters paths.",
-        promptSnippet: "safe-grep: search repo files (safe; secrets scrubbed)",
-        parameters: Type.Object({
-            pattern: Type.String({ description: "regex source (no shell)" }),
-            caseInsensitive: Type.Optional(Type.Boolean()),
-            glob: Type.Optional(Type.String({ description: "optional glob filter e.g. *.ts" })),
-        }, { additionalProperties: false }),
-        async execute(_toolCallId, params) {
-            try {
-                const result = await safeGrep(repoRoot, String(params.pattern ?? ""), {
-                    caseInsensitive: Boolean(params.caseInsensitive),
-                    glob: params.glob ? String(params.glob) : undefined,
-                });
-                return {
-                    content: [{ type: "text", text: JSON.stringify(result) }],
-                    details: result,
-                };
-            }
-            catch (e) {
-                const err = e;
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                error: err.message ?? String(e),
-                                code: err.code ?? "GREP_FAILED",
-                            }),
-                        },
-                    ],
-                    details: {
-                        error: err.message ?? String(e),
-                        code: err.code ?? "GREP_FAILED",
-                    },
-                };
-            }
-        },
-    });
-    const gitStatusTool = defineTool({
-        name: "git-status",
-        label: "git-status",
-        description: "Typed `git status --porcelain` (fixed argv, no shell). Returns scrubbed working-tree status.",
-        promptSnippet: "git-status: working tree status (read-only)",
-        parameters: Type.Object({}, { additionalProperties: false }),
-        async execute() {
-            const r = safeGit(["status", "--porcelain"]);
-            if (!r.ok) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({ error: r.message, code: r.code }),
-                        },
-                    ],
-                    details: { error: r.message, code: r.code },
-                };
-            }
-            const { scrubbed, redactions } = scrubSecrets(r.stdout);
-            const payload = { status: scrubbed, redactions };
-            return {
-                content: [{ type: "text", text: JSON.stringify(payload) }],
-                details: payload,
-            };
-        },
-    });
-    const gitDiffTool = defineTool({
-        name: "git-diff",
-        label: "git-diff",
-        description: "Typed `git diff` (fixed argv: --stat or a single -- path; no shell). Returns scrubbed diff. path must be repo-relative and not sensitive.",
-        promptSnippet: "git-diff: diff (read-only, scrubbed)",
-        parameters: Type.Object({
-            path: Type.Optional(Type.String({
-                description: "optional repo-relative path to diff (default: whole tree --stat)",
-            })),
-        }, { additionalProperties: false }),
-        async execute(_toolCallId, params) {
-            let rawPath = params.path ? String(params.path) : undefined;
-            // If a path is supplied, validate it via the read-path guard so git diff
-            // cannot be aimed at sensitive files (.env* / auth.json / sessions).
-            if (rawPath) {
-                const { guardReadPath } = await import("../../explore-tools.js");
-                const g = await guardReadPath(repoRoot, rawPath);
-                if (!g.ok) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({ error: g.message, code: g.code }),
-                            },
-                        ],
-                        details: { error: g.message, code: g.code },
-                    };
-                }
-                rawPath = g.repoRelative;
-            }
-            const args = rawPath ? ["diff", "--", rawPath] : ["diff", "--stat"];
-            const r = safeGit(args);
-            if (!r.ok) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({ error: r.message, code: r.code }),
-                        },
-                    ],
-                    details: { error: r.message, code: r.code },
-                };
-            }
-            const { scrubbed, redactions } = scrubSecrets(r.stdout);
-            const payload = { diff: scrubbed, redactions };
-            return {
-                content: [{ type: "text", text: JSON.stringify(payload) }],
-                details: payload,
-            };
-        },
-    });
-    return [safeReadTool, safeGrepTool, gitStatusTool, gitDiffTool];
-}

package/dist/worker/console/chat/pi-runtime/custom-tools/goal-tools.js

@@ -1,79 +0,0 @@
-/**
- * Session-bound Goal tools (shared by workflow and Pi modes since
- * 2026-09-10; see exec-plan 2026-09-10-console-chat-goal-for-pi-mode).
- * create_goal still requires a consumed model-create grant from the registry.
- */
-const GET_GOAL_DESCRIPTION = "Read the current session's durable cross-turn Goal, including revision, status, round limit, and whether this Console process is authorized to continue it.";
-const CREATE_GOAL_DESCRIPTION = "Create a durable cross-turn Goal only when the user explicitly asks to start or create a Goal. Never silently upgrade an ordinary request. A session may have only one unfinished Goal.";
-const UPDATE_GOAL_DESCRIPTION = "Finish or block the current durable Goal using its exact goalId and revision. Set complete only when the objective is genuinely achieved and no required work remains. Set blocked only when safe progress cannot continue; include the blocker.";
-export async function buildGoalTools(options) {
-    const [{ Type }, { defineTool }] = await Promise.all([
-        import("typebox"),
-        import("@earendil-works/pi-coding-agent"),
-    ]);
-    const textResult = (value) => ({
-        content: [{ type: "text", text: JSON.stringify(value) }],
-        details: value,
-    });
-    return [
-        defineTool({
-            name: "get_goal",
-            label: "Get goal",
-            description: GET_GOAL_DESCRIPTION,
-            promptSnippet: GET_GOAL_DESCRIPTION,
-            parameters: Type.Object({}, { additionalProperties: false }),
-            async execute() {
-                return textResult({ goal: options.registry.get(options.sessionId) });
-            },
-        }),
-        defineTool({
-            name: "create_goal",
-            label: "Create goal",
-            description: CREATE_GOAL_DESCRIPTION,
-            promptSnippet: CREATE_GOAL_DESCRIPTION,
-            parameters: Type.Object({
-                objective: Type.String({
-                    description: "Concrete final objective and completion standard explicitly requested by the user.",
-                }),
-            }, { additionalProperties: false }),
-            async execute(_toolCallId, params) {
-                if (!options.registry.consumeModelCreateGrant(options.sessionId)) {
-                    return textResult({
-                        ok: false,
-                        code: "GOAL_EXPLICIT_REQUEST_REQUIRED",
-                        message: "create_goal requires an explicit user request to create or start a Goal",
-                    });
-                }
-                return textResult(options.registry.create({
-                    sessionId: options.sessionId,
-                    objective: params.objective,
-                }));
-            },
-        }),
-        defineTool({
-            name: "update_goal",
-            label: "Update goal",
-            description: UPDATE_GOAL_DESCRIPTION,
-            promptSnippet: UPDATE_GOAL_DESCRIPTION,
-            parameters: Type.Object({
-                goalId: Type.String(),
-                revision: Type.Number({ minimum: 1 }),
-                status: Type.Union([
-                    Type.Literal("complete"),
-                    Type.Literal("blocked"),
-                ]),
-                blocker: Type.Optional(Type.String()),
-            }, { additionalProperties: false }),
-            async execute(_toolCallId, params) {
-                return textResult(options.registry.update({
-                    sessionId: options.sessionId,
-                    goalId: params.goalId,
-                    expectedRevision: params.revision,
-                    phase: params.status,
-                    blocker: params.blocker,
-                    arm: false,
-                }));
-            },
-        }),
-    ];
-}

package/dist/worker/console/chat/pi-runtime/custom-tools/operator-tools.js

@@ -1,86 +0,0 @@
-/**
- * Session-less operator-action custom tools (workflow-mode business tools).
- * Definitions and execute() live here; ConsolePiRuntime owns caching and
- * composition with session-bound tools.
- */
-import { authorizeChatSessionTool, DEFAULT_CONSOLE_CHAT_SESSION_MODE, } from "../../session-mode.js";
-import { buildModelCallableToolSchemas } from "../../tool-adapter.js";
-/**
- * Build Pi custom ToolDefinition objects for every whitelisted operator action.
- * Each tool's execute() routes into the operator action dispatcher (Gate 3).
- * Requires the `typebox` + `defineTool` packages (both bundled with the SDK).
- */
-export async function buildCustomOperatorTools(options) {
-    // typebox is a transitive dep of @earendil-works/pi-coding-agent; Node's
-    // resolver hoists to the SDK's nested copy. defineTool is re-exported by SDK.
-    const [{ Type }, { defineTool }] = await Promise.all([
-        import("typebox"),
-        import("@earendil-works/pi-coding-agent"),
-    ]);
-    const schemas = buildModelCallableToolSchemas();
-    const ctx = options.actionContext;
-    return schemas.map((schema) => {
-        // TypeBox schema is built dynamically; cast through unknown to the builder
-        // since Static<TParams> is structural and cannot be statically inferred here.
-        const parameters = Type.Object(schema.inputParams.reduce((acc, param) => {
-            // Carry the registry's param description into the tool schema so
-            // the model sees parameter semantics, not just names/types.
-            const desc = param.description?.trim()
-                ? { description: param.description }
-                : {};
-            let t;
-            switch (param.type) {
-                case "string":
-                    t = Type.String(desc);
-                    break;
-                case "boolean":
-                    t = Type.Boolean(desc);
-                    break;
-                case "number":
-                    t = Type.Number(desc);
-                    break;
-                case "array":
-                    t = Type.Array(Type.String({}), Object.keys(desc).length ? desc : {});
-                    break;
-                default:
-                    t = Type.Object({}, { additionalProperties: true });
-            }
-            acc[param.name] = param.required ? t : Type.Optional(t);
-            return acc;
-        }, {}), { additionalProperties: false });
-        return defineTool({
-            name: schema.toolId,
-            label: schema.toolId,
-            description: `${schema.description} (kind=${schema.kind}; cli: ${schema.cli})`,
-            promptSnippet: schema.description,
-            parameters: parameters,
-            async execute(toolCallId, params) {
-                const decision = authorizeChatSessionTool(schema.toolId, options.sessionMode ?? DEFAULT_CONSOLE_CHAT_SESSION_MODE);
-                if (!decision.ok) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    error: decision.message,
-                                    code: decision.code,
-                                }),
-                            },
-                        ],
-                        details: { error: decision.message, code: decision.code },
-                    };
-                }
-                // Defer require to avoid circular import at module load.
-                const { dispatchChatToolCall } = await import("../../session-store.js");
-                const result = await dispatchChatToolCall(ctx, decision.toolId, params, toolCallId, options.sessionMode);
-                const payload = result.ok
-                    ? result.result
-                    : { error: result.message, code: result.errorCode };
-                return {
-                    content: [{ type: "text", text: JSON.stringify(payload) }],
-                    details: payload,
-                };
-            },
-        });
-    });
-}