@cjhyy/code-shell-core 0.6.0-rc.12 → 0.6.0-rc.13

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

@@ -1,122 +1,297 @@
 /**
- * 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;
-}
+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 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.",
+    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: "A short identifier for the worktree (alphanumeric, dots, dashes only, max 64 chars). " +
-                    "Example: 'fix-auth-bug', 'refactor-api'",
+                description: "Deprecated alias for target. Prefer target.",
             },
         },
-        required: ["slug"],
+        required: [],
     },
 };
 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.`;
-    }
-    try {
-        validateWorktreeSlug(slug);
-    }
-    catch (err) {
-        return `Error: ${err.message}`;
-    }
+    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;
     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 = resolveWorktreeTarget({
+            target,
+            cwd: ctx?.cwd ?? mainRoot,
+            mainRoot,
+            sessionId,
+            currentWorkspace: fromWorkspace,
+        });
+        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) &&
+        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;
     try {
+        let removal;
+        if (action === "discard" || action === "detach") {
+            const otherOwners = 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);
         }
-        else {
-            removeWorktree(session.worktreePath, false);
-            return (`Worktree removed. Branch ${session.worktreeBranch} preserved.\n` +
-                `To merge: git merge ${session.worktreeBranch}\n` +
-                `Back to ${session.originalCwd}.`);
+        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));
+        }
+        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 };
+}
+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 = 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));
+}
+function resolveWorktreeTarget(opts) {
+    const entries = 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: 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 = createWorktree(opts.mainRoot, opts.target, opts.sessionId);
+    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,12 @@ export interface ToolRuntimeHost {
         linux?: string;
         windows?: 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 {
@@ -176,6 +184,10 @@ export interface ToolVisibilityContext {
 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). */

package/dist/tool-system/mcp-manager.d.ts

@@ -80,6 +80,14 @@ export declare class MCPManager {
      */
     connectAll(servers: Record<string, MCPServerConfig>, owner?: unknown): Promise<void>;
     reconcile(servers: Record<string, MCPServerConfig>, owner?: unknown): Promise<void>;
+    /**
+     * Remove one owner from the shared desired-server pool and disconnect servers
+     * that no remaining owner wants. This is called when a session-owned Engine
+     * is closed; without it project-scoped MCP servers can stay connected until
+     * worker shutdown.
+     */
+    unregisterOwner(owner: unknown): Promise<void>;
+    private enabledServerNames;
     /** Union of every registered owner's desired set; null when none registered. */
     private unionDesired;
     /**

package/dist/tool-system/mcp-manager.js

@@ -247,13 +247,16 @@ export class MCPManager {
      * Connect to all configured MCP servers and register their tools.
      */
     async connectAll(servers, owner) {
+        const enabledNames = this.enabledServerNames(servers);
         // Register this owner's desired set up front (see reconcile's shared-pool
         // note) so a later reconcile from ANOTHER session can't disconnect servers
         // this session connected at run start.
         if (owner !== undefined) {
-            this.desiredByOwner.set(owner, new Set(Object.entries(servers)
-                .filter(([, c]) => c.enabled !== false)
-                .map(([n]) => n)));
+            this.desiredByOwner.set(owner, enabledNames);
+            this.desiredServerNames = this.unionDesired() ?? new Set();
+        }
+        else if (this.desiredByOwner.size === 0) {
+            this.desiredServerNames = enabledNames;
         }
         // Codex-style toggle: skip servers explicitly disabled in settings.
         // Only the literal `false` disables — absent / true / any other value
@@ -279,26 +282,42 @@ export class MCPManager {
         }
     }
     async reconcile(servers, owner) {
-        const enabledNames = new Set(Object.entries(servers)
-            .filter(([, config]) => config.enabled !== false)
-            .map(([name]) => name));
-        this.desiredServerNames = enabledNames;
+        const enabledNames = this.enabledServerNames(servers);
         // Shared-pool semantics: this ONE pool serves every session in the worker,
         // and sessions in different projects legitimately want DIFFERENT server
         // sets (per-project capabilityOverrides). Disconnect only servers that NO
         // registered owner wants — otherwise the per-session hot-reload patches
         // would thrash each other's connections (last reconcile wins, killing a
-        // server another project's session is using). Owners are engines; a
-        // closed session's desires linger (no engine-teardown hook), which merely
-        // over-RETAINS idle connections — per-session tool visibility keeps
-        // correctness regardless.
+        // server another project's session is using). Owners are engines; closed
+        // sessions call unregisterOwner() so their desired sets stop retaining idle
+        // connections.
         if (owner !== undefined)
             this.desiredByOwner.set(owner, enabledNames);
         const union = this.unionDesired() ?? enabledNames;
+        this.desiredServerNames = union;
         const stale = this.listServers().filter((name) => !union.has(name));
         await Promise.all(stale.map((name) => this.disconnect(name)));
         await this.connectAll(servers, owner);
     }
+    /**
+     * Remove one owner from the shared desired-server pool and disconnect servers
+     * that no remaining owner wants. This is called when a session-owned Engine
+     * is closed; without it project-scoped MCP servers can stay connected until
+     * worker shutdown.
+     */
+    async unregisterOwner(owner) {
+        if (!this.desiredByOwner.delete(owner))
+            return;
+        const desired = this.unionDesired() ?? new Set();
+        this.desiredServerNames = desired;
+        const stale = this.listServers().filter((name) => !desired.has(name));
+        await Promise.all(stale.map((name) => this.disconnect(name)));
+    }
+    enabledServerNames(servers) {
+        return new Set(Object.entries(servers)
+            .filter(([, config]) => config.enabled !== false)
+            .map(([name]) => name));
+    }
     /** Union of every registered owner's desired set; null when none registered. */
     unionDesired() {
         if (this.desiredByOwner.size === 0)
@@ -489,6 +508,8 @@ export class MCPManager {
      */
     async disconnectAll() {
         await Promise.all([...this.connections.keys()].map((name) => this.disconnect(name)));
+        this.desiredByOwner.clear();
+        this.desiredServerNames = null;
     }
     async disconnect(name) {
         const conn = this.connections.get(name);

package/dist/types.d.ts

@@ -139,9 +139,21 @@ export type SessionStatus = "active" | "paused" | TerminalReason;
 /** Which host/context created a session — used by the desktop disk-rebuild to
  *  filter the sidebar (only `desktop` + `automation` are shown). */
 export type SessionOrigin = "desktop" | "tui" | "automation" | "subagent";
+export interface SessionWorkspace {
+    root: string;
+    kind: "main" | "worktree";
+    worktree?: {
+        path: string;
+        branch: string;
+        baseRef: string;
+        createdBy: "codeshell";
+    };
+}
 export interface SessionState {
     sessionId: string;
     cwd: string;
+    /** Current session workspace pointer. Absent only on legacy state.json files. */
+    workspace?: SessionWorkspace;
     startedAt: number;
     model: string;
     provider: string;

package/dist/utils/toolDisplay.js

@@ -57,7 +57,7 @@ const TOOL_ARG_KEYS = {
     Agent: ["description"],
     TodoWrite: ["todos"],
     Sleep: ["seconds"],
-    EnterWorktree: ["slug"],
+    EnterWorktree: ["target", "slug"],
     CronCreate: ["name", "schedule"],
     LSP: ["action", "file_path"],
     NotebookEdit: ["action", "file_path"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-core",
-  "version": "0.6.0-rc.12",
+  "version": "0.6.0-rc.13",
   "description": "Core engine for code-shell — agent orchestration, tool execution, hooks, protocol. UI-agnostic.",
   "type": "module",
   "main": "./dist/index.js",