@cjhyy/code-shell-core 0.6.0-rc.14 → 0.6.0-rc.15

package/dist/capability-control/service.d.ts

@@ -31,9 +31,11 @@ export interface CapabilityServiceDeps {
     readInstalledPlugins: () => InstalledPluginsV2;
     resolveBuiltinToolNames: (o?: {
         preset?: string;
+        host?: "desktop";
         enabledBuiltinTools?: string[];
         disabledBuiltinTools?: string[];
     }) => string[];
+    builtinToolHost?: "desktop";
 }
 export declare class CapabilityService {
     private readonly deps;

package/dist/capability-control/service.js

@@ -13,7 +13,7 @@
  */
 import { CapabilityNotFoundError } from "./types.js";
 import { projectBuiltin, projectMcp, projectSkills, projectPlugins, projectAgents, } from "./project.js";
-import { applyOverride, bucketForKind, overrideTokenForId, overrideFor, } from "./overlay.js";
+import { applyOverride, bucketForKind, overrideTokenForId, overrideFor } from "./overlay.js";
 export class CapabilityService {
     deps;
     constructor(deps) {
@@ -30,12 +30,14 @@ export class CapabilityService {
         const agent = (s.agent ?? {});
         const tools = this.deps.registry.listToolsDetailed();
         const preset = agent.preset;
+        const host = this.deps.builtinToolHost;
         const base = [
             ...projectBuiltin({
                 tools: tools.filter((t) => t.source === "builtin"),
-                presetDefaults: this.deps.resolveBuiltinToolNames({ preset }),
+                presetDefaults: this.deps.resolveBuiltinToolNames({ preset, host }),
                 effective: this.deps.resolveBuiltinToolNames({
                     preset,
+                    host,
                     enabledBuiltinTools: agent.enabledBuiltinTools ?? [],
                     disabledBuiltinTools: agent.disabledBuiltinTools ?? [],
                 }),

package/dist/cc-orchestrator/codex-session-history.js

@@ -52,7 +52,7 @@ export function readCodexRecentHistory(cwd, threadId, limit, codexHome = join(ho
             const t = textOf(p.content).trim();
             if (!t || t.startsWith("<environment_context>"))
                 continue;
-            all.push({ role: p.role, text: t.slice(0, 4000) });
+            all.push({ role: p.role, text: t });
         }
         else if (p.type === "function_call" || p.type === "custom_tool_call") {
             const tool = { name: typeof p.name === "string" ? p.name : "tool", summary: summaryOf(p), args: argsOf(p) };

package/dist/cc-orchestrator/external-agent-bindings.js

@@ -43,7 +43,7 @@ export class ExternalAgentBindingStore {
         }
         catch (err) {
             if (opts.failOnCorrupt) {
-                throw new Error(`external agent bindings file is corrupt or unreadable: ${err instanceof Error ? err.message : String(err)}`);
+                throw new Error(`external agent bindings file is corrupt or unreadable: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
             }
             return { bindings: {} };
         }

package/dist/cc-orchestrator/external-agent-session-store.js

@@ -90,7 +90,9 @@ export class ExternalAgentSessionStore {
                 if (removeStaleLock(lockDir))
                     continue;
                 if (Date.now() >= deadline) {
-                    throw new Error(`timed out waiting for external agent session store lock: ${lockDir}`);
+                    throw new Error(`timed out waiting for external agent session store lock: ${lockDir}`, {
+                        cause: err,
+                    });
                 }
                 sleepSync(LOCK_POLL_MS);
             }

package/dist/cc-orchestrator/session-history.js

@@ -51,14 +51,14 @@ export function readRecentHistory(cwd, sessionId, limit, claudeHome = join(homed
             const t = textOf(d.message?.content).trim();
             if (!t || NOISE.some((n) => t.startsWith(n)))
                 continue;
-            all.push({ role: "user", text: t.slice(0, 4000) });
+            all.push({ role: "user", text: t });
         }
         else if (d.type === "assistant") {
             const t = textOf(d.message?.content).trim();
             const tools = toolsOf(d.message?.content);
             if (!t && tools.length === 0)
                 continue;
-            all.push({ role: "assistant", text: t.slice(0, 4000), tools: tools.length ? tools : undefined });
+            all.push({ role: "assistant", text: t, tools: tools.length ? tools : undefined });
         }
     }
     const lim = limit > 0 ? limit : 20;

package/dist/cli/agent-server-stdio.js

@@ -106,8 +106,7 @@ catch (err) {
 // knob; imageDetail from settings.images.detail).
 const seedLlm = resolveLLMConfigForTag(settings, "text", settings.defaults?.text);
 if (!seedLlm) {
-    console.error(`[agent-server] 没有可用的文本模型连接(defaults.text=${settings.defaults?.text ?? "未设置"})。` +
-        `请在「连接」页添加并填写凭证。`);
+    console.error(`[agent-server] 没有可用的文本模型连接(defaults.text=${settings.defaults?.text ?? "未设置"})。` + `请在「连接」页添加并填写凭证。`);
     process.exit(1);
 }
 const llmConfig = seedLlm;
@@ -115,6 +114,10 @@ const llmConfig = seedLlm;
 const seedEngine = new Engine({
     llm: llmConfig,
     cwd,
+    preset: settings.agent.preset,
+    enabledBuiltinTools: settings.agent.enabledBuiltinTools,
+    disabledBuiltinTools: settings.agent.disabledBuiltinTools,
+    builtinToolHost: "desktop",
     settingsScope: "full",
     // No runtime — Engine.populateModelPoolFromSettings() runs in ctor.
 });
@@ -217,6 +220,7 @@ const chatManager = new ChatSessionManager({
             // This stdio worker exists only to serve the desktop app, so every
             // session it creates is a desktop-origin session.
             origin: "desktop",
+            builtinToolHost: "desktop",
             // Inherit full scope so spawned subagents read user config too.
             settingsScope: "full",
             // MCP servers from settings — the worker reads the full disk
@@ -286,6 +290,7 @@ const goalDiskReader = new SessionManager();
 const agentServer = new AgentServer({
     chatManager,
     transport: stdioTransport,
+    workspaceBridge: true,
     // Config hot-reload (layer 2) reads disk through the SAME closure the
     // engineFactory uses for new sessions, so a reloaded running session and a
     // newly-created session converge on identical disk config (no divergence).

package/dist/context/manager.d.ts

@@ -5,7 +5,7 @@
  * Tier 2: LLM summary (async) — generate summary of older messages via model call
  * Tier 3: window compact (sync, emergency) — aggressive truncation fallback
  */
-import type { Message } from "../types.js";
+import type { Message, ContextUsageAnchor } from "../types.js";
 export interface ContextManagerConfig {
     maxTokens: number;
     compactAtRatio: number;
@@ -50,6 +50,9 @@ export declare class ContextManager {
     private lastActualAtMessageCount;
     /** Heuristic token estimate for the same messages as lastActualTokens. */
     private lastActualAnchorEstimate;
+    private lastActualRecordedAt;
+    private lastActualProvider;
+    private lastActualModel;
     /** Path to session transcript — passed to summary compaction for on-demand access. */
     private transcriptPath;
     /** Notified whenever any compaction tier fires, including microcompact. */
@@ -67,7 +70,13 @@ export declare class ContextManager {
      * Record actual token usage from API response.
      * Used for hybrid estimation: actual + estimate for new messages.
      */
-    recordActualUsage(inputTokens: number, messageCount: number, messages?: Message[]): void;
+    recordActualUsage(inputTokens: number, messageCount: number, messages?: Message[]): ContextUsageAnchor | undefined;
+    /**
+     * Seed actual prompt-token usage from persisted session state.
+     * Returns the normalized anchor when accepted; invalid legacy/tampered data is ignored.
+     */
+    seedActualUsage(anchor: ContextUsageAnchor | undefined): ContextUsageAnchor | undefined;
+    getActualUsageAnchor(): ContextUsageAnchor | undefined;
     /**
      * Best-effort token estimate: uses actual API usage as base if available,
      * plus estimation for messages added since the last API call.

package/dist/context/manager.js

@@ -37,6 +37,9 @@ const DEFAULT_CONFIG = {
 function defaultKeepRecent(maxTokens) {
     return Math.max(5, Math.floor(maxTokens / 100_000));
 }
+function positiveFinite(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
 export class ContextManager {
     config;
     summarizeFn;
@@ -50,6 +53,9 @@ export class ContextManager {
     lastActualAtMessageCount;
     /** Heuristic token estimate for the same messages as lastActualTokens. */
     lastActualAnchorEstimate;
+    lastActualRecordedAt;
+    lastActualProvider;
+    lastActualModel;
     /** Path to session transcript — passed to summary compaction for on-demand access. */
     transcriptPath;
     /** Notified whenever any compaction tier fires, including microcompact. */
@@ -72,9 +78,53 @@ export class ContextManager {
      * Used for hybrid estimation: actual + estimate for new messages.
      */
     recordActualUsage(inputTokens, messageCount, messages) {
-        this.lastActualTokens = inputTokens;
-        this.lastActualAtMessageCount = messageCount;
-        this.lastActualAnchorEstimate = messages ? estimateTokens(messages) : undefined;
+        const estimateAtAnchor = messages ? estimateTokens(messages) : undefined;
+        return this.seedActualUsage({
+            promptTokens: inputTokens,
+            messageCount,
+            ...(estimateAtAnchor !== undefined ? { estimateAtAnchor } : {}),
+            recordedAt: Date.now(),
+        });
+    }
+    /**
+     * Seed actual prompt-token usage from persisted session state.
+     * Returns the normalized anchor when accepted; invalid legacy/tampered data is ignored.
+     */
+    seedActualUsage(anchor) {
+        if (!anchor)
+            return undefined;
+        if (!positiveFinite(anchor.promptTokens))
+            return undefined;
+        if (!Number.isSafeInteger(anchor.messageCount) || anchor.messageCount <= 0) {
+            return undefined;
+        }
+        if (anchor.estimateAtAnchor !== undefined && !positiveFinite(anchor.estimateAtAnchor)) {
+            return undefined;
+        }
+        this.lastActualTokens = anchor.promptTokens;
+        this.lastActualAtMessageCount = anchor.messageCount;
+        this.lastActualAnchorEstimate = anchor.estimateAtAnchor;
+        this.lastActualRecordedAt = positiveFinite(anchor.recordedAt) ? anchor.recordedAt : Date.now();
+        this.lastActualProvider = anchor.provider;
+        this.lastActualModel = anchor.model;
+        return this.getActualUsageAnchor();
+    }
+    getActualUsageAnchor() {
+        if (this.lastActualTokens === undefined ||
+            this.lastActualAtMessageCount === undefined ||
+            this.lastActualRecordedAt === undefined) {
+            return undefined;
+        }
+        return {
+            promptTokens: this.lastActualTokens,
+            messageCount: this.lastActualAtMessageCount,
+            ...(this.lastActualAnchorEstimate !== undefined
+                ? { estimateAtAnchor: this.lastActualAnchorEstimate }
+                : {}),
+            recordedAt: this.lastActualRecordedAt,
+            ...(this.lastActualProvider ? { provider: this.lastActualProvider } : {}),
+            ...(this.lastActualModel ? { model: this.lastActualModel } : {}),
+        };
     }
     /**
      * Best-effort token estimate: uses actual API usage as base if available,
@@ -306,6 +356,17 @@ export class ContextManager {
         result = this.truncateToolResults(result);
         // Tier 0c: Aggregate tool result budget (per-message)
         result = applyToolResultBudget(result);
+        // Tier 0d: same always-on waste-removal passes as manage().
+        const dedup = dedupeFileReads(result);
+        if (dedup.clearedCount > 0) {
+            result = dedup.messages;
+            logger.info("context.dedupe_file_reads", { cleared: dedup.clearedCount });
+        }
+        const masked = maskOldObservations(result);
+        if (masked.maskedCount > 0) {
+            result = masked.messages;
+            logger.info("context.mask_browser_snapshots", { masked: masked.maskedCount });
+        }
         // Tier 1: microcompact — see manage() for the rationale on the floor.
         const preTier1Tokens = this.estimateTokensHybrid(result);
         const microFloorGate = this.config.maxTokens * this.config.microcompactFloorRatio;

package/dist/credentials/inject-credential-tool.d.ts

@@ -12,9 +12,11 @@
  */
 import type { ToolDefinition } from "../types.js";
 import type { ToolContext } from "../tool-system/context.js";
+import { type SettingsScope } from "../settings/manager.js";
 export declare const injectCredentialToolDef: ToolDefinition;
 /** 该工具仅在有 cookie 凭证 且 宿主接了注入回调时才可见(BUILTIN_TOOL_GUARDS)。 */
-export declare function isInjectCredentialAvailable(cwd: string): boolean;
+export declare function isInjectCredentialAvailable(cwd: string, settingsScope?: SettingsScope): boolean;
 export declare function injectCredentialTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 /** 测试钩子:清空会话 allow 集。 */
 export declare function __resetInjectCredentialSessionAllowForTests(): void;
+export declare function clearInjectCredentialSessionAllow(sessionId: string): void;

package/dist/credentials/inject-credential-tool.js

@@ -62,9 +62,14 @@ function sessionAllowFor(ctx) {
     }
     return set;
 }
-function readAutoApprove(cwd) {
+// CredentialStore only distinguishes full user+project from project-only.
+// Isolated engines must be at least as restrictive as project-scoped engines.
+function credentialScope(scope) {
+    return scope === "full" || scope === undefined ? "full" : "project";
+}
+function readAutoApprove(cwd, scope) {
     try {
-        const s = new SettingsManager(cwd, "full").get();
+        const s = new SettingsManager(cwd, scope === "full" ? "full" : "project").get();
         return s.credentialUse?.autoApprove === true;
     }
     catch {
@@ -72,9 +77,11 @@ function readAutoApprove(cwd) {
     }
 }
 /** 该工具仅在有 cookie 凭证 且 宿主接了注入回调时才可见(BUILTIN_TOOL_GUARDS)。 */
-export function isInjectCredentialAvailable(cwd) {
+export function isInjectCredentialAvailable(cwd, settingsScope) {
     try {
-        return new CredentialStore(cwd).listMasked().some((c) => c.type === "cookie");
+        return new CredentialStore(cwd)
+            .listMasked(credentialScope(settingsScope))
+            .some((c) => c.type === "cookie");
     }
     catch {
         return false;
@@ -82,10 +89,14 @@ export function isInjectCredentialAvailable(cwd) {
 }
 export async function injectCredentialTool(args, ctx) {
     const cwd = ctx?.cwd ?? process.cwd();
+    const scope = credentialScope(ctx?.settingsScope);
     const id = typeof args.id === "string" ? args.id.trim() : "";
     const purpose = typeof args.purpose === "string" ? args.purpose : undefined;
     if (!id) {
-        return json({ kind: "error", error: "缺少 id。先用 UseCredential(无参)列出凭证,再用 cookie 凭证的 id 调本工具。" });
+        return json({
+            kind: "error",
+            error: "缺少 id。先用 UseCredential(无参)列出凭证,再用 cookie 凭证的 id 调本工具。",
+        });
     }
     if (!ctx?.injectCredentialToBrowser) {
         return json({
@@ -93,17 +104,22 @@ export async function injectCredentialTool(args, ctx) {
             error: "当前环境无内置浏览器(headless/无面板),无法注入。请改用 UseCredential 取 cookie 走 HTTP 请求。",
         });
     }
-    const cred = new CredentialStore(cwd).resolve(id);
+    const cred = new CredentialStore(cwd).resolve(id, scope);
     if (!cred) {
-        return json({ kind: "error", error: `凭证不存在: "${id}"。调用 UseCredential(无参)可列出可用凭证。` });
+        return json({
+            kind: "error",
+            error: `凭证不存在: "${id}"。调用 UseCredential(无参)可列出可用凭证。`,
+        });
     }
     if (cred.type !== "cookie") {
         return json({ kind: "error", error: `凭证「${cred.label}」不是 cookie 类型,不能注入浏览器。` });
     }
     // 过门:复用三档,但用该凭证的 autoInjectByAI(不是 autoUseByAI)。
-    const ask = ctx.askUser ? (q, opts) => ctx.askUser(q, opts) : undefined;
+    const ask = ctx.askUser
+        ? (q, opts) => ctx.askUser(q, opts)
+        : undefined;
     const decision = await credentialUseGate({ id: cred.id, label: cred.label, purpose }, {
-        autoApprove: readAutoApprove(cwd),
+        autoApprove: readAutoApprove(cwd, scope),
         credentialAutoUse: cred.autoInjectByAI === true,
         sessionAllow: sessionAllowFor(ctx),
         ask,
@@ -115,7 +131,7 @@ export async function injectCredentialTool(args, ctx) {
         return json({ kind: "error", error: msg });
     }
     // 跨进程触发宿主注入。
-    const res = await ctx.injectCredentialToBrowser(cred.id);
+    const res = await ctx.injectCredentialToBrowser(cred.id, scope);
     if (!res.ok) {
         return json({ kind: "error", error: res.error ?? "注入浏览器失败(宿主未返回成功)。" });
     }
@@ -128,3 +144,6 @@ function json(r) {
 export function __resetInjectCredentialSessionAllowForTests() {
     injectSessionAllowByEngine.clear();
 }
+export function clearInjectCredentialSessionAllow(sessionId) {
+    injectSessionAllowByEngine.delete(sessionId);
+}

package/dist/credentials/use-credential-tool.d.ts

@@ -27,3 +27,4 @@ export declare function sweepStaleCredentialCookies(now?: number): void;
 export declare function useCredentialTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
 /** 测试钩子:清空会话 allow 集(避免跨用例污染)。 */
 export declare function __resetCredentialSessionAllowForTests(): void;
+export declare function clearCredentialSessionAllow(sessionId: string): void;

package/dist/credentials/use-credential-tool.js

@@ -203,3 +203,6 @@ function json(r) {
 export function __resetCredentialSessionAllowForTests() {
     sessionAllowByEngine.clear();
 }
+export function clearCredentialSessionAllow(sessionId) {
+    sessionAllowByEngine.delete(sessionId);
+}

package/dist/engine/engine.d.ts

@@ -262,6 +262,8 @@ export declare class Engine {
      * clear "no browser panel" error.
      */
     setBrowserBridge(bridge: import("../tool-system/browser-bridge.js").BrowserBridge | undefined): void;
+    /** Inject the host-backed workspace bridge after construction. */
+    setWorkspaceBridge(bridge: import("../tool-system/workspace-bridge.js").WorkspaceBridge | undefined): void;
     /**
      * Queue a user message to be spliced into the in-flight run for `sessionId`
      * at the next turn-loop step boundary — the 不打断 steering path (vs cancel +
@@ -461,6 +463,12 @@ export declare class Engine {
      * session with no active goal is a no-op returning false.
      */
     clearGoal(sessionId: string): boolean;
+    /**
+     * Reset a session's workspace pointer back to its main root. If the session is
+     * actively running, mutate that live SessionBundle first so the run's next
+     * saveState cannot resurrect a stale worktree pointer.
+     */
+    releaseSessionWorkspace(sessionId: string): import("../types.js").SessionWorkspace | null;
     injectContext(sessionId: string, content: string): void;
     /**
      * Force context compaction on a session.
@@ -624,6 +632,7 @@ export declare class Engine {
         linux?: string;
         windows?: string;
     } | undefined;
+    readWorktreeBranchPrefix(cwd?: string): string | undefined;
     resolveWorktreeSetupSandbox(cwd: string): Promise<SandboxBackend | undefined>;
     readWorktreeSetupShellEnv(cwd?: string): Record<string, string> | undefined;
     buildToolContext(): ToolContext;

package/dist/engine/engine.js

@@ -42,12 +42,12 @@ import { MCPManager } from "../tool-system/mcp-manager.js";
 import { SettingsManager, userHome } from "../settings/manager.js";
 import { CredentialStore } from "../credentials/store.js";
 import { isFeatureEnabled, resolveFeatureFlags, } from "../settings/feature-flags.js";
-import { effectiveDisabledList, effectiveBuiltinLists, } from "../capability-control/overlay.js";
+import { effectiveDisabledList, effectiveBuiltinLists } from "../capability-control/overlay.js";
 import { computeEffectiveDisabledLists } from "../capability-control/disabled-lists.js";
 import { FileHistory } from "../session/file-history.js";
 import { patchBackupTargets } from "../tool-system/builtin/apply-patch/backup-targets.js";
 import { resolveSandboxBackend, } from "../tool-system/sandbox/index.js";
-import { resolveAgentPreset, resolveBuiltinToolNames, } from "../preset/index.js";
+import { resolveAgentPreset, resolveBuiltinToolNames } from "../preset/index.js";
 import { ModelPool } from "../llm/model-pool.js";
 import { AgentDefinitionRegistry } from "../agent/agent-definition-registry.js";
 import { defaultCacheDir } from "../llm/model-cache.js";
@@ -445,6 +445,7 @@ export class Engine {
                 new ToolRegistry({
                     builtinTools: resolveBuiltinToolNames({
                         preset: this.preset.name,
+                        host: config.builtinToolHost,
                         enabledBuiltinTools: builtinLists.enabledBuiltinTools,
                         disabledBuiltinTools: builtinLists.disabledBuiltinTools,
                     }),
@@ -635,6 +636,10 @@ export class Engine {
     setBrowserBridge(bridge) {
         this.config.browserBridge = bridge;
     }
+    /** Inject the host-backed workspace bridge after construction. */
+    setWorkspaceBridge(bridge) {
+        this.config.workspaceBridge = bridge;
+    }
     /**
      * Queue a user message to be spliced into the in-flight run for `sessionId`
      * at the next turn-loop step boundary — the 不打断 steering path (vs cancel +
@@ -736,7 +741,7 @@ export class Engine {
      */
     async run(task, options) {
         const workspaceResume = options?.sessionId && this.sessionManager.exists(options.sessionId)
-            ? this.sessionManager.resolveSessionWorkspaceForResume(options.sessionId)
+            ? await this.sessionManager.resolveSessionWorkspaceForResume(options.sessionId)
             : undefined;
         if (workspaceResume && !workspaceResume.ok) {
             return {
@@ -971,6 +976,7 @@ export class Engine {
                     preset: this.preset.name,
                     enabledBuiltinTools: childEnabled,
                     disabledBuiltinTools: childDisabled,
+                    builtinToolHost: this.config.builtinToolHost,
                     customSystemPrompt: this.config.customSystemPrompt,
                     appendSystemPrompt: [this.config.appendSystemPrompt, req.appendSystemPrompt].filter(Boolean).join("\n\n") ||
                         undefined,
@@ -1311,6 +1317,24 @@ export class Engine {
                     messages[lastIdx] = { role: "user", content: promptSubmitHook.updatedPrompt };
                 }
             }
+            const contextManager = new ContextManager({
+                maxTokens: this.resolveMaxContextTokens(),
+                // Drop undefined fields so they don't clobber ContextManager defaults
+                // (spread of `{x: undefined}` would override the default with undefined).
+                ...Object.fromEntries(Object.entries(this.resolveContextRatios()).filter(([, v]) => v !== undefined)),
+            });
+            this.lastContextManager = contextManager;
+            const persistedContextAnchor = session.state.contextUsageAnchor;
+            const contextAnchorCompatible = persistedContextAnchor !== undefined &&
+                (persistedContextAnchor.provider === undefined ||
+                    persistedContextAnchor.provider === this.config.llm.provider) &&
+                (persistedContextAnchor.model === undefined ||
+                    persistedContextAnchor.model === this.config.llm.model) &&
+                (persistedContextAnchor.messageCount <= messages.length ||
+                    persistedContextAnchor.estimateAtAnchor !== undefined);
+            const seededContextAnchor = contextAnchorCompatible
+                ? contextManager.seedActualUsage(persistedContextAnchor)
+                : undefined;
             // Rough token estimate of the full prompt so the UI's ctx bar isn't 0%
             // before the first real usage_update arrives. The authoritative count
             // comes from `usage.promptTokens` after the first LLM response — this is
@@ -1322,10 +1346,12 @@ export class Engine {
             const sid = session.state.sessionId;
             const needsCtxSeed = !this.ctxSeedSent.has(sid);
             const roughPromptTokens = needsCtxSeed
-                ? messages.reduce((sum, m) => {
-                    const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
-                    return sum + Math.ceil(text.length / 4);
-                }, 0)
+                ? seededContextAnchor
+                    ? contextManager.checkLimits(messages).tokens
+                    : messages.reduce((sum, m) => {
+                        const text = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+                        return sum + Math.ceil(text.length / 4);
+                    }, 0)
                 : 0;
             if (needsCtxSeed)
                 this.ctxSeedSent.add(sid);
@@ -1383,13 +1409,6 @@ export class Engine {
             // Wire abort signal for cascading cancellation + per-Engine ToolContext
             toolExecutor.setSignal(options?.signal);
             toolExecutor.setContext(toolCtx);
-            const contextManager = new ContextManager({
-                maxTokens: this.resolveMaxContextTokens(),
-                // Drop undefined fields so they don't clobber ContextManager defaults
-                // (spread of `{x: undefined}` would override the default with undefined).
-                ...Object.fromEntries(Object.entries(this.resolveContextRatios()).filter(([, v]) => v !== undefined)),
-            });
-            this.lastContextManager = contextManager;
             const { disabledSkills, disabledPlugins } = this.readDisabledLists();
             const promptComposer = new PromptComposer({
                 cwd,
@@ -1451,6 +1470,7 @@ export class Engine {
                     (normalizeGoal(options?.goal) !== undefined ||
                         session.state.activeGoal !== undefined ||
                         normalizeGoal(this.config.goal) !== undefined),
+                settingsScope: this.config.settingsScope ?? "project",
             };
             toolCtx.toolVisibility = toolVisibility;
             // #7: per-turn project builtin override. The toolRegistry's builtin tool
@@ -1761,6 +1781,13 @@ export class Engine {
                 consumeSteer: (source) => this.consumeSteer(sid, source),
                 claimClientMessageId: (clientMessageId, source) => claimClientMessageId(session, clientMessageId, source),
                 recordCumulativeUsage,
+                recordContextUsageAnchor: (anchor) => {
+                    session.state.contextUsageAnchor = {
+                        ...anchor,
+                        provider: this.config.llm.provider,
+                        model: this.config.llm.model,
+                    };
+                },
                 // Clear the persisted goal for a self-reported completion / confirmed
                 // cancel. Clears the in-RAM session's activeGoal (so THIS run's later
                 // turns don't re-arm) AND persists it, and drops the in-flight stop
@@ -2359,7 +2386,6 @@ export class Engine {
     refreshRuntimeConfig(patch, version) {
         if (version <= this.lastAppliedConfigVersion)
             return;
-        const prevServers = this.config.mcpServers ?? {};
         const prevPresetName = this.preset.name;
         this.config = { ...this.config, ...patch };
         // #2: re-resolve the prompt-affecting preset so the next-turn PromptComposer
@@ -2370,11 +2396,17 @@ export class Engine {
             // The builtin tool SET is ctor-frozen and may be shared via runtime — we
             // do NOT rebuild it here. If the new preset implies a different builtin
             // tool set, that part of the change only lands on session restart.
-            const prevTools = resolveBuiltinToolNames({ preset: prevPresetName })
+            const prevTools = resolveBuiltinToolNames({
+                preset: prevPresetName,
+                host: this.config.builtinToolHost,
+            })
                 .slice()
                 .sort()
                 .join(",");
-            const nextTools = resolveBuiltinToolNames({ preset: nextPreset.name })
+            const nextTools = resolveBuiltinToolNames({
+                preset: nextPreset.name,
+                host: this.config.builtinToolHost,
+            })
                 .slice()
                 .sort()
                 .join(",");
@@ -2461,6 +2493,41 @@ export class Engine {
         }
         return had;
     }
+    /**
+     * Reset a session's workspace pointer back to its main root. If the session is
+     * actively running, mutate that live SessionBundle first so the run's next
+     * saveState cannot resurrect a stale worktree pointer.
+     */
+    releaseSessionWorkspace(sessionId) {
+        if (!sessionId || !this.sessionManager.exists(sessionId))
+            return null;
+        const mainRoot = this.sessionManager.readCwd(sessionId) ??
+            (this.activeRunSession?.state.sessionId === sessionId
+                ? this.activeRunSession.state.cwd
+                : undefined);
+        if (!mainRoot)
+            return null;
+        const workspace = { root: mainRoot, kind: "main" };
+        if (this.activeRunSession?.state.sessionId === sessionId) {
+            this.activeRunSession.state.workspace = workspace;
+        }
+        try {
+            const bundle = this.activeRunSession?.state.sessionId === sessionId
+                ? this.activeRunSession
+                : this.sessionManager.resume(sessionId);
+            bundle.state.workspace = workspace;
+            this.sessionManager.saveState(bundle.state);
+        }
+        catch {
+            try {
+                this.sessionManager.setSessionWorkspace(sessionId, workspace);
+            }
+            catch {
+                return null;
+            }
+        }
+        return workspace;
+    }
     injectContext(sessionId, content) {
         const session = this.sessionManager.resume(sessionId);
         session.transcript.appendMessage("assistant", content);
@@ -2954,6 +3021,17 @@ export class Engine {
             return undefined;
         }
     }
+    readWorktreeBranchPrefix(cwd) {
+        if (this.config.isSubAgent === true || !cwd)
+            return undefined;
+        try {
+            const settings = this.getSettingsManager().get();
+            return settings.worktree?.branchPrefix;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async resolveWorktreeSetupSandbox(cwd) {
         if (!cwd)
             return undefined;
@@ -2978,6 +3056,7 @@ export class Engine {
             toolRegistry: this.toolRegistry,
             askUser: this.config.askUser,
             browser: this.config.browserBridge,
+            workspace: this.config.workspaceBridge,
             injectCredentialToBrowser: this.config.injectCredentialToBrowser,
             isSubAgent: this.config.isSubAgent === true,
             // Credential tools narrow their disk reads to this scope: a project/

package/dist/engine/turn-loop.d.ts

@@ -4,7 +4,7 @@
  * Following Claude Code's po_() pattern:
  * pre_check → model_call → post_check → tool_exec → context_mgmt → hook_notify → next turn
  */
-import type { Message, StreamCallback, TerminalReason, ContentBlock, ToolResult, TokenUsage } from "../types.js";
+import type { Message, StreamCallback, TerminalReason, ContentBlock, ToolResult, TokenUsage, ContextUsageAnchor } from "../types.js";
 import type { SteerItem } from "./steer-queue.js";
 import { ModelFacade } from "./model-facade.js";
 import { ToolExecutor } from "../tool-system/executor.js";
@@ -88,6 +88,8 @@ export interface TurnLoopDeps {
      * Returns the updated counters so usage_update can carry both metric scopes.
      */
     recordCumulativeUsage?: (usage: TokenUsage) => CumulativeUsageCounters;
+    /** Persist the latest context-estimation anchor derived from provider usage. */
+    recordContextUsageAnchor?: (anchor: ContextUsageAnchor) => void;
     /**
      * Reads/clears any user messages queued for THIS session via the steering
      * channel (Engine.enqueueSteer) while a run is in flight. Consumed at the top

package/dist/engine/turn-loop.js

@@ -553,7 +553,9 @@ 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, messages);
+                    const anchor = this.deps.contextManager.recordActualUsage(response.usage.promptTokens, messages.length, messages);
+                    if (anchor)
+                        this.deps.recordContextUsageAnchor?.(anchor);
                 }
                 messages = this.markPendingImagesConsumed(messages);
                 // Truncation that cut off a TOOL CALL: the model overflowed