@cjhyy/code-shell-core 0.6.0-rc.9 → 0.7.0

package/dist/tool-system/builtin/worktree.js

@@ -1,122 +1,345 @@
 /**
- * EnterWorktree / ExitWorktree tools — create and manage isolated git worktrees.
+ * EnterWorktree / ExitWorktree tools — switch a session between git workspaces.
  */
-import { createWorktree, removeWorktree, validateWorktreeSlug, selectPlatformScript, runWorktreeSetup, } from "../../git/worktree.js";
-// Global worktree state
-let _activeWorktree;
-export function getActiveWorktree() {
-    return _activeWorktree;
-}
-export const enterWorktreeToolDef = {
-    name: "EnterWorktree",
-    description: "Create an isolated git worktree for safe code modifications. " +
-        "The worktree is a separate copy of the repository on a new branch. " +
-        "Changes made in the worktree do not affect the main working directory. " +
-        "Use this when you need to make experimental changes or work in isolation.",
+import { existsSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import { createWorktree, removeWorktree, listWorktrees, validateWorktreeSlug, selectPlatformScript, runWorktreeSetup, worktreeHasUncommittedOrAheadChanges, currentBranch, } from "../../git/worktree.js";
+export const switchSessionWorkspaceToolDef = {
+    name: "SwitchSessionWorkspace",
+    description: "Switch this current conversation session into or out of a workspace through the host UI path. " +
+        "Use this when you need isolated or parallel work in a git worktree, when you need to move " +
+        "this conversation to an existing worktree path/branch, or when you are done and should return " +
+        "this current conversation to main. This is the correct way to move THIS conversation's session " +
+        "into or out of a worktree on desktop.",
     inputSchema: {
         type: "object",
         properties: {
-            slug: {
+            target: {
                 type: "string",
-                description: "A short identifier for the worktree (alphanumeric, dots, dashes only, max 64 chars). " +
-                    "Example: 'fix-auth-bug', 'refactor-api'",
+                description: "Workspace target: 'main', a new slug, an existing worktree path, or an existing branch name.",
             },
         },
-        required: ["slug"],
+        required: ["target"],
     },
 };
-export async function enterWorktreeTool(args, ctx) {
-    const slug = args.slug;
-    if (!slug)
-        return "Error: slug is required";
-    if (_activeWorktree) {
-        return `Error: Already in a worktree at ${_activeWorktree.worktreePath}. Exit it first with ExitWorktree.`;
+export async function switchSessionWorkspaceTool(args, ctx) {
+    const target = stringArg(args.target);
+    if (!target)
+        return "Error: target is required";
+    const bridge = ctx?.workspace;
+    if (!bridge) {
+        return ("SwitchSessionWorkspace is not available in this host. " +
+            "Use the host's supported workspace controls instead.");
     }
     try {
-        validateWorktreeSlug(slug);
+        const workspace = await bridge.switch(target);
+        ctx?.setSessionWorkspace?.(workspace);
+        const details = workspace.kind === "worktree" && workspace.worktree
+            ? `\n  Branch: ${workspace.worktree.branch}`
+            : "";
+        return (`Switched session workspace:\n` +
+            `  Path: ${workspace.root}` +
+            details +
+            `\n\n` +
+            nextTurnNotice(workspace.root, ctx?.cwd ?? workspace.root));
     }
     catch (err) {
-        return `Error: ${err.message}`;
+        return `Error switching workspace: ${err.message}`;
     }
+}
+export const enterWorktreeToolDef = {
+    name: "EnterWorktree",
+    description: "Switch the current session workspace. Target can be a new worktree slug, " +
+        "an existing worktree path or branch, or 'main' to return to the main repository. " +
+        "Switching leaves the previous worktree on disk.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            target: {
+                type: "string",
+                description: "Workspace target: 'main', a new slug (alphanumeric, dots, dashes, underscores), " +
+                    "or an existing worktree path/branch to switch to.",
+            },
+            slug: {
+                type: "string",
+                description: "Deprecated alias for target. Prefer target.",
+            },
+        },
+        required: [],
+    },
+};
+export async function enterWorktreeTool(args, ctx) {
+    const target = stringArg(args.target) ?? stringArg(args.slug);
+    if (!target)
+        return "Error: target is required";
+    const resolved = sessionServices(ctx);
+    if (!resolved.ok)
+        return resolved.error;
+    const { sessionId, sessionManager } = resolved;
+    const mainRoot = sessionManager.readCwd(sessionId) ?? ctx?.cwd ?? process.cwd();
+    const fromWorkspace = sessionManager.getSessionWorkspace(sessionId) ?? {
+        root: mainRoot,
+        kind: "main",
+    };
+    const fromRoot = fromWorkspace.root;
+    const currentTurnRoot = ctx?.cwd ?? fromRoot;
+    const branchPrefix = ctx?.engine?.readWorktreeBranchPrefix?.(mainRoot);
     try {
-        // Use a placeholder session ID (the agent should set this properly)
-        const sessionId = args.__sessionId ?? `wt-${Date.now()}`;
-        const cwd = args.__cwd ?? ctx?.cwd ?? process.cwd();
-        _activeWorktree = createWorktree(cwd, slug, sessionId);
-        // Run the project's localEnvironment.setupScripts once in the new
-        // worktree root (Beta decision 2026-06-08: setup belongs to the worktree
-        // lifecycle, not the conversation). Failure warns-but-continues — a broken
-        // setup script must not strand the agent outside a worktree it just made.
-        let setupNote = "";
-        const setupScripts = ctx?.engine?.readWorktreeSetupScripts(cwd);
-        const script = selectPlatformScript(setupScripts);
-        if (script) {
-            const setup = await runWorktreeSetup(_activeWorktree.worktreePath, script, {
-                sandbox: ctx?.sandbox,
-                shellEnv: ctx?.shellEnv,
-                signal: ctx?.signal,
-            });
-            if (setup.ok) {
-                setupNote = `\n\nRan setup script (exit 0).${setup.output ? `\n${truncate(setup.output)}` : ""}`;
-            }
-            else {
-                setupNote =
-                    `\n\n⚠️ Setup script failed (exit ${setup.exitCode ?? "?"}) — continuing anyway. ` +
-                        `You may need to run setup manually.${setup.output ? `\n${truncate(setup.output)}` : ""}`;
-            }
+        if (target === "main") {
+            const workspace = { root: mainRoot, kind: "main" };
+            persistSessionWorkspace(sessionManager, sessionId, workspace, ctx);
+            sessionManager.recordWorkspaceHandoff(sessionId, fromWorkspace, workspace);
+            return (`Switched to main workspace:\n` +
+                `  Path: ${mainRoot}\n` +
+                `  From: ${fromRoot}\n\n` +
+                nextTurnNotice(mainRoot, currentTurnRoot));
         }
-        return (`Worktree created:\n` +
-            `  Path:   ${_activeWorktree.worktreePath}\n` +
-            `  Branch: ${_activeWorktree.worktreeBranch}\n` +
-            `  From:   ${_activeWorktree.originalBranch ?? "HEAD"}\n\n` +
-            `You are now working in an isolated copy. Changes here won't affect the main repo.` +
+        const selected = await resolveWorktreeTarget({
+            target,
+            cwd: ctx?.cwd ?? mainRoot,
+            mainRoot,
+            sessionId,
+            currentWorkspace: fromWorkspace,
+            branchPrefix,
+        });
+        const workspace = toSessionWorkspace(selected, fromWorkspace);
+        persistSessionWorkspace(sessionManager, sessionId, workspace, ctx);
+        sessionManager.recordWorkspaceHandoff(sessionId, fromWorkspace, workspace);
+        const setupNote = selected.created
+            ? await runSetupIfConfigured(selected.session.worktreePath, mainRoot, ctx)
+            : "";
+        const verb = selected.created ? "Worktree created and switched" : "Switched to worktree";
+        return (`${verb}:\n` +
+            `  Path:   ${workspace.worktree.path}\n` +
+            `  Branch: ${workspace.worktree.branch}\n` +
+            `  From:   ${selected.from}\n` +
+            `  Previous: ${fromRoot}\n\n` +
+            nextTurnNotice(workspace.root, currentTurnRoot) +
             setupNote);
     }
     catch (err) {
-        return `Error creating worktree: ${err.message}`;
+        return `Error switching worktree: ${err.message}`;
     }
 }
 /** Keep setup output from bloating the tool result — head+tail-ish trim. */
 function truncate(s, max = 2000) {
     return s.length <= max ? s : `${s.slice(0, max)}\n…(${s.length - max} more chars)`;
 }
+function persistSessionWorkspace(sessionManager, sessionId, workspace, ctx) {
+    sessionManager.setSessionWorkspace(sessionId, workspace);
+    ctx?.setSessionWorkspace?.(workspace);
+}
+function nextTurnNotice(nextRoot, currentTurnRoot) {
+    return (`Workspace switched to ${nextRoot}. This takes effect on the next turn - ` +
+        `file/shell/sandbox tools in the CURRENT turn still target ${currentTurnRoot}.`);
+}
 export const exitWorktreeToolDef = {
     name: "ExitWorktree",
-    description: "Exit the current worktree and return to the main working directory. " +
-        "Choose whether to keep or discard the changes made in the worktree.",
+    description: "Switch the current session back to the main working directory. " +
+        "Choose whether to keep the worktree, detach it while preserving the branch, " +
+        "or discard it entirely.",
     inputSchema: {
         type: "object",
         properties: {
             action: {
                 type: "string",
-                enum: ["keep", "discard"],
-                description: "'keep' preserves the worktree branch for later merging. " +
-                    "'discard' removes the worktree and its branch entirely.",
+                enum: ["keep", "detach", "discard"],
+                description: "'keep' preserves the worktree directory and branch for later. " +
+                    "'detach' removes the directory but keeps the branch. " +
+                    "'discard' removes the directory and its branch entirely. " +
+                    "If omitted, a clean worktree is detached automatically; a dirty worktree requires keep/discard.",
             },
         },
-        required: ["action"],
+        required: [],
     },
 };
-export async function exitWorktreeTool(args) {
-    if (!_activeWorktree) {
+export async function exitWorktreeTool(args, ctx) {
+    const resolved = sessionServices(ctx);
+    if (!resolved.ok)
+        return resolved.error;
+    const { sessionId, sessionManager } = resolved;
+    const workspace = sessionManager.getSessionWorkspace(sessionId);
+    if (!workspace || workspace.kind !== "worktree" || !workspace.worktree) {
         return "Not currently in a worktree.";
     }
-    const action = args.action;
-    const session = _activeWorktree;
-    _activeWorktree = undefined;
+    const requested = args.action;
+    if (requested !== undefined &&
+        requested !== "keep" &&
+        requested !== "detach" &&
+        requested !== "discard") {
+        return `Error: unknown action "${requested}" (expected keep, detach, or discard).`;
+    }
+    const hasPendingChanges = existsSync(workspace.worktree.path) &&
+        (await worktreeHasUncommittedOrAheadChanges(workspace.worktree.path, workspace.worktree.baseRef));
+    const action = requested ?? (hasPendingChanges ? undefined : "detach");
+    if (!action) {
+        return (`Error: worktree has uncommitted changes or new commits. Choose action "keep" to preserve ` +
+            `the directory or "discard" to delete the worktree and branch.`);
+    }
+    if (action === "detach" && hasPendingChanges) {
+        return (`Error: detach would drop uncommitted changes or new commits. Choose action "keep" to preserve ` +
+            `the directory or "discard" to delete the worktree and branch.`);
+    }
+    const mainRoot = sessionManager.readCwd(sessionId) ?? workspace.root;
+    const currentTurnRoot = ctx?.cwd ?? workspace.root;
+    const branchPrefix = ctx?.engine?.readWorktreeBranchPrefix?.(mainRoot);
     try {
+        let removal;
+        if (action === "discard" || action === "detach") {
+            const otherOwners = await otherSessionOwnersForWorktree(sessionManager, sessionId, mainRoot, workspace.worktree.path);
+            if (otherOwners.length > 0) {
+                const mainWorkspace = { root: mainRoot, kind: "main" };
+                persistSessionWorkspace(sessionManager, sessionId, mainWorkspace, ctx);
+                sessionManager.recordWorkspaceHandoff(sessionId, workspace, mainWorkspace);
+                return sharedWorktreeRemovalSkippedMessage(otherOwners, mainRoot, currentTurnRoot);
+            }
+        }
         if (action === "discard") {
-            removeWorktree(session.worktreePath, true);
-            return `Worktree removed and branch ${session.worktreeBranch} deleted. Back to ${session.originalCwd}.`;
+            removal = removeWorktree(workspace.worktree.path, true, { prefix: branchPrefix });
+        }
+        else if (action === "detach") {
+            removal = removeWorktree(workspace.worktree.path, false);
+        }
+        const mainWorkspace = { root: mainRoot, kind: "main" };
+        persistSessionWorkspace(sessionManager, sessionId, mainWorkspace, ctx);
+        sessionManager.recordWorkspaceHandoff(sessionId, workspace, mainWorkspace);
+        if (action === "keep") {
+            return (`Worktree preserved at ${workspace.worktree.path}. ` +
+                `Branch ${workspace.worktree.branch} preserved.\n` +
+                `Back to ${mainRoot} starting next turn.\n` +
+                nextTurnNotice(mainRoot, currentTurnRoot));
         }
-        else {
-            removeWorktree(session.worktreePath, false);
-            return (`Worktree removed. Branch ${session.worktreeBranch} preserved.\n` +
-                `To merge: git merge ${session.worktreeBranch}\n` +
-                `Back to ${session.originalCwd}.`);
+        if (action === "discard") {
+            if (removal?.branchDeleted === false) {
+                const branch = removal.branch ?? workspace.worktree.branch;
+                return (`WARNING: worktree removed; branch ${branch} could not be deleted: ` +
+                    `${removal.branchError ?? "unknown error"}\n` +
+                    `Delete it manually with git branch -D ${branch}.\n` +
+                    `Back to ${mainRoot} starting next turn.\n` +
+                    nextTurnNotice(mainRoot, currentTurnRoot));
+            }
+            return (`Worktree removed and branch ${workspace.worktree.branch} deleted. ` +
+                `Back to ${mainRoot} starting next turn.\n` +
+                nextTurnNotice(mainRoot, currentTurnRoot));
         }
+        return (`Worktree removed${requested ? "" : " (auto-detached clean worktree)"}. ` +
+            `Branch ${workspace.worktree.branch} preserved.\n` +
+            `To merge: git merge ${workspace.worktree.branch}\n` +
+            `Back to ${mainRoot} starting next turn.\n` +
+            nextTurnNotice(mainRoot, currentTurnRoot));
     }
     catch (err) {
         return `Error exiting worktree: ${err.message}`;
     }
 }
+function sessionServices(ctx) {
+    const sessionId = ctx?.sessionId;
+    if (!sessionId)
+        return { ok: false, error: "Error: worktree tools require a sessionId." };
+    const sessionManager = ctx?.engine?.getSessionManager?.();
+    if (!sessionManager) {
+        return { ok: false, error: "Error: worktree tools require a session manager." };
+    }
+    return { ok: true, sessionId, sessionManager };
+}
+async function otherSessionOwnersForWorktree(sessionManager, sessionId, mainRoot, worktreePath) {
+    const workspaceOwners = sessionManager
+        .list(Number.MAX_SAFE_INTEGER)
+        .map((session) => ({ sessionId: session.sessionId, workspace: session.workspace }))
+        .filter((owner) => owner.workspace !== undefined);
+    const entry = (await listWorktrees(mainRoot, {
+        currentSessionId: sessionId,
+        workspaceOwners,
+    })).find((worktree) => resolve(worktree.path) === resolve(worktreePath));
+    return (entry?.occupiedBySessionIds ?? []).filter((owner) => owner !== sessionId);
+}
+function sharedWorktreeRemovalSkippedMessage(otherOwners, mainRoot, currentTurnRoot) {
+    return (`Error: this worktree is also in use by session(s) ${otherOwners.join(", ")}; ` +
+        `switching to main, but removal has been skipped.\n` +
+        `Back to ${mainRoot} starting next turn.\n` +
+        nextTurnNotice(mainRoot, currentTurnRoot));
+}
+async function resolveWorktreeTarget(opts) {
+    const entries = await listWorktrees(opts.mainRoot);
+    const pathTarget = pathLike(opts.target) ? resolvePathTarget(opts.target, opts.cwd) : undefined;
+    const branchTarget = normalizeBranchName(opts.target);
+    const match = entries.find((entry) => {
+        if (pathTarget && resolve(entry.path) === pathTarget)
+            return true;
+        return entry.branch === branchTarget;
+    });
+    if (match) {
+        return {
+            created: false,
+            session: {
+                originalCwd: opts.mainRoot,
+                worktreePath: match.path,
+                worktreeName: match.path.split(/[\\/]/).pop() ?? match.branch,
+                worktreeBranch: match.branch,
+                originalBranch: await currentBranch(opts.mainRoot),
+                sessionId: opts.sessionId,
+                createdAt: Date.now(),
+            },
+            from: opts.currentWorkspace.root,
+        };
+    }
+    if (pathTarget) {
+        throw new Error(`no existing worktree found at ${opts.target}`);
+    }
+    validateWorktreeSlug(opts.target);
+    const created = await createWorktree(opts.mainRoot, opts.target, opts.sessionId, {
+        prefix: opts.branchPrefix,
+    });
+    return { created: true, session: created, from: created.originalBranch ?? "HEAD" };
+}
+function toSessionWorkspace(selected, currentWorkspace) {
+    const previous = currentWorkspace.kind === "worktree" &&
+        currentWorkspace.worktree &&
+        resolve(currentWorkspace.worktree.path) === resolve(selected.session.worktreePath)
+        ? currentWorkspace.worktree
+        : undefined;
+    return {
+        root: selected.session.worktreePath,
+        kind: "worktree",
+        worktree: {
+            path: selected.session.worktreePath,
+            branch: selected.session.worktreeBranch,
+            baseRef: previous?.baseRef ?? selected.session.originalBranch ?? "HEAD",
+            createdBy: "codeshell",
+        },
+    };
+}
+async function runSetupIfConfigured(worktreePath, mainRoot, ctx) {
+    const setupScripts = ctx?.engine?.readWorktreeSetupScripts(mainRoot);
+    const script = selectPlatformScript(setupScripts);
+    if (!script)
+        return "";
+    const setupSandbox = ctx?.engine?.resolveWorktreeSetupSandbox
+        ? await ctx.engine.resolveWorktreeSetupSandbox(worktreePath)
+        : ctx?.sandbox;
+    const setupShellEnv = ctx?.engine?.readWorktreeSetupShellEnv
+        ? ctx.engine.readWorktreeSetupShellEnv(worktreePath)
+        : ctx?.shellEnv;
+    const setup = await runWorktreeSetup(worktreePath, script, {
+        sandbox: setupSandbox,
+        shellEnv: setupShellEnv,
+        signal: ctx?.signal,
+    });
+    if (setup.ok) {
+        return `\n\nRan setup script (exit 0).${setup.output ? `\n${truncate(setup.output)}` : ""}`;
+    }
+    return (`\n\n⚠️ Setup script failed (exit ${setup.exitCode ?? "?"}) — continuing anyway. ` +
+        `You may need to run setup manually.${setup.output ? `\n${truncate(setup.output)}` : ""}`);
+}
+function stringArg(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function pathLike(target) {
+    return (isAbsolute(target) || target.startsWith(".") || target.includes("/") || target.includes("\\"));
+}
+function resolvePathTarget(target, cwd) {
+    return resolve(cwd, target);
+}
+function normalizeBranchName(branch) {
+    return branch.replace(/^refs\/heads\//, "");
+}

package/dist/tool-system/builtin/write.js

@@ -2,7 +2,7 @@
  * Built-in Write file tool.
  */
 import { writeFile, mkdir } from "node:fs/promises";
-import { dirname } from "node:path";
+import { dirname, isAbsolute, resolve } from "node:path";
 import { fileCache } from "./file-cache.js";
 export const writeToolDef = {
     name: "Write",
@@ -18,12 +18,14 @@ export const writeToolDef = {
     },
 };
 export async function writeTool(args, ctx) {
-    const filePath = args.file_path;
+    const rawPath = args.file_path;
     const content = args.content;
-    if (!filePath)
+    if (!rawPath)
         return "Error: file_path is required";
     if (content === undefined)
         return "Error: content is required";
+    const cwd = ctx?.cwd ?? process.cwd();
+    const filePath = isAbsolute(rawPath) ? rawPath : resolve(cwd, rawPath);
     try {
         await mkdir(dirname(filePath), { recursive: true });
         await writeFile(filePath, content, "utf-8");

package/dist/tool-system/context.d.ts

@@ -18,6 +18,8 @@ import type { ToolRegistry } from "./registry.js";
 import type { AgentPresetName } from "../preset/index.js";
 import type { SandboxBackend } from "./sandbox/index.js";
 import type { HookRegistry } from "../hooks/registry.js";
+import type { SessionManager } from "../session/session-manager.js";
+import type { SessionWorkspace } from "../types.js";
 /**
  * Narrow view of the owning Engine that tools are allowed to call back into.
  * Defined here (in the low-level tool-system) rather than importing the
@@ -38,6 +40,14 @@ export interface ToolRuntimeHost {
         linux?: string;
         windows?: string;
     } | undefined;
+    /** Branch prefix used for CodeShell-managed worktree branches. */
+    readWorktreeBranchPrefix?(cwd?: string): string | undefined;
+    /** Resolve a setup-only sandbox for a newly-created worktree root. */
+    resolveWorktreeSetupSandbox?(cwd: string): Promise<SandboxBackend | undefined>;
+    /** Resolve setup-only shell env for a newly-created worktree root. */
+    readWorktreeSetupShellEnv?(cwd?: string): Record<string, string> | undefined;
+    /** Session state store used by session-scoped tools such as worktree switching. */
+    getSessionManager?(): SessionManager;
 }
 /** One choice in a multiple-choice AskUserQuestion. */
 export interface AskUserChoice {
@@ -172,10 +182,24 @@ export interface SubAgentSpawner {
 export interface ToolVisibilityContext {
     cwd: string;
     hasGoal: boolean;
+    settingsScope?: import("../settings/manager.js").SettingsScope;
+}
+export interface ExternalFileChangesRecord {
+    jobId: string;
+    description: string;
+    cli: "claude" | "codex";
+    cwd: string;
+    status: "completed" | "failed" | "cancelled";
+    changedFiles: string[];
+    originClientMessageId?: string;
 }
 export interface ToolContext {
     /** Active working directory for this Engine. */
     cwd: string;
+    /** Mutate the owning live context cwd. Worktree switching intentionally does not use this. */
+    setCwd?(cwd: string): void;
+    /** Mutate the owning live session state after a session workspace switch. */
+    setSessionWorkspace?(workspace: SessionWorkspace): void;
     /** LLM credentials/endpoint for tools that need to make their own calls. */
     llmConfig: LLMConfig;
     /** Active model pool (Arena reads this to pick participants). */
@@ -246,6 +270,15 @@ export interface ToolContext {
      * narrow context, or standalone tool tests. (B2 — Gate 1, standard §S3.)
      */
     sessionId?: string;
+    /** Stable id of the real user turn that owns async work launched here. */
+    originClientMessageId?: string;
+    /**
+     * Persist file attribution from an async external DriveAgent completion in
+     * the owning CodeShell transcript. The callback closes over the live parent
+     * transcript, so a background job can record its files after the run that
+     * launched it has already returned.
+     */
+    recordExternalFileChanges?: (record: ExternalFileChangesRecord) => void;
     /**
      * Skill names the user has hidden from the LLM (full namespaced names
      * for plugin skills, e.g. "docs:pdf"). The skill builtin tool uses
@@ -336,6 +369,13 @@ export interface ToolContext {
      * docs/superpowers/specs/2026-06-16-browser-automation-mvp.md.
      */
     browser?: import("./browser-bridge.js").BrowserBridge;
+    /**
+     * Host-backed workspace switch bridge. Desktop wires this to Electron main so
+     * the model's SwitchSessionWorkspace tool goes through the same path as the UI
+     * switcher. Undefined outside hosts that can switch this conversation's
+     * session workspace.
+     */
+    workspace?: import("./workspace-bridge.js").WorkspaceBridge;
     /**
      * Inject a stored cookie credential into the built-in browser (restore its
      * login state so the AI can drive the page as that account). The host
@@ -347,7 +387,7 @@ export interface ToolContext {
     injectCredentialToBrowser?: InjectCredentialFn;
 }
 /** Inject a cookie credential into the built-in browser (host-implemented). */
-export type InjectCredentialFn = (credentialId: string) => Promise<{
+export type InjectCredentialFn = (credentialId: string, credentialScope?: "full" | "project") => Promise<{
     ok: boolean;
     count?: number;
     error?: string;

package/dist/tool-system/executor.d.ts

@@ -1,7 +1,7 @@
 /**
  * Tool executor — orchestrates permission checks, hooks, and execution.
  */
-import type { ToolCall, ToolResult, Message } from "../types.js";
+import type { ToolCall, ToolResult } from "../types.js";
 import type { HookRegistry } from "../hooks/registry.js";
 import { ToolRegistry } from "./registry.js";
 import { PermissionClassifier } from "./permission.js";
@@ -42,9 +42,5 @@ export declare class ToolExecutor {
     private resolvePolicyOperation;
     private enforceDeclaredPathPolicy;
     private resolvePathPolicyTargets;
-    /**
-     * Convert tool results into Message entries for the transcript.
-     */
-    resultsToMessages(toolCalls: ToolCall[], results: ToolResult[]): Message[];
 }
 export {};