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

package/dist/engine/engine.js

@@ -34,7 +34,7 @@ import { PLAN_MODE_ALLOWED_TOOLS } from "../tool-system/plan-mode-allowlist.js";
 import { PromptComposer } from "../prompt/composer.js";
 import { SessionManager } from "../session/session-manager.js";
 import { ModelFacade } from "./model-facade.js";
-import { logger, setCurrentSid, runWithSid, getCurrentSid } from "../logging/logger.js";
+import { logger, runWithSid, getCurrentSid } from "../logging/logger.js";
 import { recordSessionStart, recordSessionEnd } from "../logging/session-recorder.js";
 import { sanitizeContent, sanitizeTaskString } from "../logging/sanitize-messages.js";
 import { TurnLoop } from "./turn-loop.js";
@@ -129,7 +129,7 @@ export function resolveChildLlm(modelKey, pool, parentLlm) {
  * Names in `disabledAgents` are filtered out so the LLM never sees them.
  */
 /**
- * Resolve the working directory for a run. Precedence:
+ * Resolve the working directory for a run. Precedence for legacy sessions:
  *   options.cwd  >  resumed session's state.cwd  >  config.cwd  >  process.cwd()
  *
  * The session-cwd tier is what stops a project-bound session from being
@@ -735,20 +735,45 @@ export class Engine {
      * Run a task from start to finish.
      */
     async run(task, options) {
-        // When the caller omits cwd but is resuming an existing session, recover
-        // that session's bound cwd from disk so a project-bound session keeps
-        // loading its own agents/settings/memory even if the host's UI repo
-        // selection has drifted to null. Only probe on omission — an explicit cwd
-        // always wins, and a fresh session has nothing to recover.
-        const sessionCwd = options?.cwd === undefined && options?.sessionId
-            ? this.sessionManager.readCwd(options.sessionId)
+        const workspaceResume = options?.sessionId && this.sessionManager.exists(options.sessionId)
+            ? this.sessionManager.resolveSessionWorkspaceForResume(options.sessionId)
             : undefined;
-        const cwd = resolveRunCwd({
-            optionCwd: options?.cwd,
-            sessionCwd,
-            configCwd: this.config.cwd,
-            processCwd: process.cwd(),
-        });
+        if (workspaceResume && !workspaceResume.ok) {
+            return {
+                text: `ERROR: ${workspaceResume.message}`,
+                reason: "completed",
+                sessionId: options.sessionId,
+                turnCount: 0,
+                usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+            };
+        }
+        if (workspaceResume?.ok &&
+            workspaceResume.reason === "worktree_missing_branch_gone" &&
+            workspaceResume.message) {
+            return {
+                text: workspaceResume.message,
+                reason: "completed",
+                sessionId: options.sessionId,
+                turnCount: 0,
+                usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+            };
+        }
+        // Existing P1 sessions resolve cwd from SessionWorkspace, even if the host
+        // passes a stale cwd. Legacy sessions without workspace keep the historical
+        // explicit-cwd precedence for backward compatibility.
+        const workspaceCwd = workspaceResume?.ok && workspaceResume.reason !== "legacy" ? workspaceResume.cwd : undefined;
+        const sessionCwd = workspaceCwd === undefined && options?.cwd === undefined && options?.sessionId
+            ? workspaceResume?.ok
+                ? workspaceResume.cwd
+                : this.sessionManager.readCwd(options.sessionId)
+            : undefined;
+        const cwd = workspaceCwd ??
+            resolveRunCwd({
+                optionCwd: options?.cwd,
+                sessionCwd,
+                configCwd: this.config.cwd,
+                processCwd: process.cwd(),
+            });
         // Wrap the caller's onStream so we can intercept `task_update`
         // events emitted by TodoWrite and keep an in-engine snapshot.
         // TaskGuard reads this snapshot at turn end to decide whether to
@@ -1013,23 +1038,7 @@ export class Engine {
             },
             sessionExists: (sessionId) => this.sessionManager.exists(sessionId),
         };
-        // Priority: config.sandbox → project settings.sandbox → global → per-run
-        // default. Read UNMERGED per-scope (getForScope) so a project that wrote no
-        // sandbox genuinely follows global, rather than inheriting global's mode and
-        // looking like it set one. Fixes "项目级配了不生效" + the scope model.
-        let projectSandbox;
-        let globalSandbox;
-        try {
-            const sm = this.getSettingsManager();
-            if (this.config.isSubAgent !== true) {
-                projectSandbox = sm.getForScope("project", cwd).sandbox;
-            }
-            globalSandbox = sm.getForScope("user").sandbox;
-        }
-        catch {
-            // settings unavailable → fall through to per-run default
-        }
-        const sandboxConfig = resolveSandboxConfig(this.config.sandbox, projectSandbox, globalSandbox, this.config.headless === true);
+        const sandboxConfig = this.resolveSandboxConfigForCwd(cwd);
         // A2: explicit sandbox modes (seatbelt, bwrap) must fail closed
         // per standard §S4. resolveSandboxBackend throws when an explicit
         // mode is unavailable on this host; we let it propagate. The
@@ -1070,12 +1079,16 @@ export class Engine {
                 ? sandboxBackend
                 : { ...sandboxBackend, network: sandboxConfig.network },
             cwd,
+            shellEnv: this.readShellEnv(cwd),
             // TodoWrite reads this to push task_update events independently
             // of its return value, so the UI's pinned task panel refreshes
             // immediately rather than after the LLM next surfaces the
             // snapshot. wrappedOnStream snoops the same channel to keep
             // latestTodos current for TaskGuard.
             streamCallback: options?.onStream,
+            setCwd(nextCwd) {
+                toolCtx.cwd = nextCwd;
+            },
         };
         logger.info("engine.run", {
             task: taskText.slice(0, 200),
@@ -1134,6 +1147,7 @@ export class Engine {
         let session;
         let messages;
         let freshImageMessage;
+        let resumedFromDisk = false;
         const claimedClientMessageIds = new Set();
         const claimClientMessageId = (bundle, clientMessageId, source) => {
             if (!clientMessageId)
@@ -1151,6 +1165,7 @@ export class Engine {
             return true;
         };
         if (options?.sessionId && this.sessionManager.exists(options.sessionId)) {
+            resumedFromDisk = true;
             session = this.sessionManager.resume(options.sessionId);
             const cachedCompacted = this.compactedMessagesBySession.get(options.sessionId);
             messages = cachedCompacted ? [...cachedCompacted] : session.transcript.toMessages();
@@ -1233,21 +1248,6 @@ export class Engine {
         // with this value so `/undo` reverts exactly this turn's file changes.
         // (Both resume and cold-start paths converge here.)
         session.state.turnSeq = (session.state.turnSeq ?? 0) + 1;
-        // Stamp the resolved session id for downstream logging.
-        //
-        // `setCurrentSid` updates the module-level fallback so any code path
-        // running outside an ALS scope (bootstrap, /sid before a run starts)
-        // still sees the latest sid.
-        //
-        // The real isolation comes from wrapping the rest of `run` in
-        // `runWithSid(sid, async () => { ... })`: every `getCurrentSid()`
-        // call inside that closure — including those inside `await`ed child
-        // Engine.run() calls — reads sid from this scope's
-        // AsyncLocalStorage binding, not the module global. Sibling Engines
-        // running concurrently each get their own scope; an `enterSid` inside
-        // a child mutates that child's scope only and doesn't leak back to
-        // the parent's chain after `await child.run(...)` returns.
-        setCurrentSid(session.state.sessionId);
         // B2 / Gate 1: stamp the resolved sid onto the tool context so
         // session-scoped side effects (background-agent completion
         // notifications) attribute to the right session. toolCtx is created
@@ -1255,6 +1255,9 @@ export class Engine {
         // the first point we can set it. After this assignment treat the
         // field as immutable for the rest of the run.
         toolCtx.sessionId = session.state.sessionId;
+        toolCtx.setSessionWorkspace = (workspace) => {
+            session.state.workspace = workspace;
+        };
         return runWithSid(session.state.sessionId, async () => {
             recordSessionStart(session.state.sessionId, {
                 // Strip <codeshell-image> base64 payloads before they reach
@@ -1265,7 +1268,7 @@ export class Engine {
                 model: this.config.llm.model,
                 provider: this.config.llm.provider,
                 permissionMode: this.config.permissionMode ?? "acceptEdits",
-                resumed: !!options?.sessionId,
+                resumed: resumedFromDisk,
             });
             // Session-level hook: fired once per Engine.run() entry, regardless of
             // cold-start vs resume. Handlers can return `messages` to inject a
@@ -1275,7 +1278,8 @@ export class Engine {
             const sessionStartHook = await this.emitHook("on_session_start", {
                 sessionId: session.state.sessionId,
                 cwd,
-                resumed: !!options?.sessionId,
+                resumed: resumedFromDisk,
+                source: resumedFromDisk ? "resume" : "startup",
             });
             // Per-turn hook: fired every time a new user prompt enters the loop.
             // Equivalent to CC's UserPromptSubmit. Handlers can inject lightweight
@@ -1289,7 +1293,7 @@ export class Engine {
                 // and silently leaking attachment bytes through hooks is the kind of
                 // exfiltration risk a curious user-installed shell hook shouldn't carry.
                 prompt: taskText,
-                resumed: !!options?.sessionId,
+                resumed: resumedFromDisk,
             });
             // updatedPrompt: handler rewrote the user's prompt text. Replace the
             // last user message we just pushed (cold-start: line ~511; resume:
@@ -2837,6 +2841,25 @@ export class Engine {
         }
         return cached;
     }
+    resolveSandboxConfigForCwd(cwd) {
+        // Priority: config.sandbox → project settings.sandbox → global → per-run
+        // default. Read UNMERGED per-scope (getForScope) so a project that wrote no
+        // sandbox genuinely follows global, rather than inheriting global's mode and
+        // looking like it set one. Fixes "项目级配了不生效" + the scope model.
+        let projectSandbox;
+        let globalSandbox;
+        try {
+            const sm = this.getSettingsManager();
+            if (this.config.isSubAgent !== true) {
+                projectSandbox = sm.getForScope("project", cwd).sandbox;
+            }
+            globalSandbox = sm.getForScope("user").sandbox;
+        }
+        catch {
+            // settings unavailable → fall through to per-run default
+        }
+        return resolveSandboxConfig(this.config.sandbox, projectSandbox, globalSandbox, this.config.headless === true);
+    }
     /**
      * Build the shell env layered onto the Bash tool / background shells (see
      * mergeShellEnv). Three user-configured sources, merged lowest → highest:
@@ -2931,9 +2954,23 @@ export class Engine {
             return undefined;
         }
     }
+    async resolveWorktreeSetupSandbox(cwd) {
+        if (!cwd)
+            return undefined;
+        const sandboxConfig = this.resolveSandboxConfigForCwd(cwd);
+        const sandboxBackend = this.runtime
+            ? await this.runtime.resolveSandbox(sandboxConfig, cwd)
+            : await this.resolveSandboxWithoutRuntime(sandboxConfig, cwd);
+        return sandboxBackend.name === "off"
+            ? sandboxBackend
+            : { ...sandboxBackend, network: sandboxConfig.network };
+    }
+    readWorktreeSetupShellEnv(cwd) {
+        return this.readShellEnv(cwd);
+    }
     buildToolContext() {
         const { disabledSkills, disabledPlugins } = this.readDisabledLists();
-        return {
+        const ctx = {
             shellEnv: this.readShellEnv(this.config.cwd),
             cwd: this.config.cwd ?? process.cwd(),
             llmConfig: this.config.llm,
@@ -2961,6 +2998,10 @@ export class Engine {
             // opts out via config. Otherwise allowed.
             allowBackgroundShells: this.config.isSubAgent === true ? false : this.config.allowBackgroundShells !== false,
         };
+        ctx.setCwd = (cwd) => {
+            ctx.cwd = cwd;
+        };
+        return ctx;
     }
     /**
      * Read settings.disabledSkills + settings.disabledPlugins in a single

package/dist/engine/turn-loop.js

@@ -553,7 +553,7 @@ export class TurnLoop {
                 // compaction decisions use hybrid (actual + delta) estimation rather than
                 // pure heuristics. Without this the manager falls back to char/4 estimates.
                 if (response.usage?.promptTokens !== undefined) {
-                    this.deps.contextManager.recordActualUsage(response.usage.promptTokens, messages.length);
+                    this.deps.contextManager.recordActualUsage(response.usage.promptTokens, messages.length, messages);
                 }
                 messages = this.markPendingImagesConsumed(messages);
                 // Truncation that cut off a TOOL CALL: the model overflowed

package/dist/git/worktree.d.ts

@@ -2,6 +2,7 @@
  * Git worktree management — create/remove isolated worktrees for agents.
  */
 import type { SandboxBackend } from "../tool-system/sandbox/index.js";
+import type { SessionWorkspace } from "../types.js";
 export interface WorktreeSession {
     originalCwd: string;
     worktreePath: string;
@@ -34,6 +35,12 @@ export declare function validateWorktreeSlug(slug: string): void;
  * Find the canonical git root (resolves worktree → main repo).
  */
 export declare function findGitRoot(cwd: string): string;
+export declare function findMainWorktreeRoot(cwd: string): string;
+export declare function findWorktreeForBranch(cwd: string, branch: string): string | undefined;
+export declare function assertBranchNotCheckedOut(cwd: string, branch: string): void;
+export declare function branchExists(cwd: string, branch: string): boolean;
+export declare function isGitWorktreeRoot(cwd: string): boolean;
+export declare function currentBranch(cwd: string): string | undefined;
 /**
  * Create an isolated git worktree for an agent session.
  */
@@ -70,15 +77,51 @@ export declare function runWorktreeSetup(worktreePath: string, script: string |
     timeoutMs?: number;
     signal?: AbortSignal;
 }): Promise<WorktreeSetupResult>;
+export interface RemoveWorktreeResult {
+    /** True once `git worktree remove` completed and the directory is gone. */
+    dirRemoved: boolean;
+    /** The branch targeted for deletion when removeBranch=true. */
+    branch?: string;
+    /** True when removeBranch=true and branch deletion completed. */
+    branchDeleted?: boolean;
+    /** Non-empty when the worktree directory is gone but branch deletion failed. */
+    branchError?: string;
+}
 /**
  * Remove a worktree and optionally its branch.
  */
-export declare function removeWorktree(worktreePath: string, removeBranch?: boolean): void;
-/**
- * List active worktrees.
- */
-export declare function listWorktrees(cwd: string): Array<{
+export declare function removeWorktree(worktreePath: string, removeBranch?: boolean): RemoveWorktreeResult;
+export declare function worktreeHasUncommittedChanges(worktreePath: string): boolean;
+export declare function worktreeHasUncommittedOrAheadChanges(worktreePath: string, baseRef?: string): boolean;
+export interface WorktreeDiffSummary {
+    /** Best-effort base used for the branch comparison, usually main/master. */
+    baseRef?: string;
+    /** Unique files changed either by commits ahead of base or by uncommitted changes. */
+    changedFiles: number;
+    /** Commits reachable from HEAD but not from baseRef. */
+    aheadCommits: number;
+    /** True when `git status --porcelain` reports local changes. */
+    hasUncommittedChanges: boolean;
+}
+export interface WorktreeWorkspaceOwner {
+    sessionId: string;
+    workspace?: SessionWorkspace;
+}
+export interface ListWorktreesOptions {
+    includeDiffSummary?: boolean;
+    currentSessionId?: string;
+    workspaceOwners?: WorktreeWorkspaceOwner[];
+}
+export interface WorktreeInfo {
     path: string;
     branch: string;
     head: string;
-}>;
+    isMain?: boolean;
+    diff?: WorktreeDiffSummary;
+    occupiedBySessionIds?: string[];
+    occupiedByOtherSession?: boolean;
+}
+/**
+ * List active worktrees.
+ */
+export declare function listWorktrees(cwd: string, opts?: ListWorktreesOptions): WorktreeInfo[];