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

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, PromptTokenConfidence, PromptTokenSource } 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,11 +70,18 @@ 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.
      */
+    private estimateTokensHybridInfo;
     private estimateTokensHybrid;
     /**
      * Set the summarize function (injected by Engine).
@@ -141,5 +151,7 @@ export declare class ContextManager {
         ratio: number;
         needsCompact: boolean;
         needsEmergency: boolean;
+        promptTokensSource: PromptTokenSource;
+        promptTokensConfidence: PromptTokenConfidence;
     };
 }

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,28 +78,83 @@ 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,
      * plus estimation for messages added since the last API call.
      */
-    estimateTokensHybrid(messages) {
+    estimateTokensHybridInfo(messages) {
         const currentEstimate = estimateTokens(messages);
         if (this.lastActualTokens !== undefined &&
             this.lastActualAtMessageCount !== undefined) {
             if (this.lastActualAtMessageCount < messages.length) {
                 const newMessages = messages.slice(this.lastActualAtMessageCount);
                 const newTokens = estimateTokens(newMessages);
-                return this.lastActualTokens + newTokens;
+                return {
+                    tokens: this.lastActualTokens + newTokens,
+                    source: "anchor_delta",
+                    confidence: "medium",
+                };
             }
             if (this.lastActualAnchorEstimate !== undefined && this.lastActualAnchorEstimate > 0) {
-                return Math.round(this.lastActualTokens * (currentEstimate / this.lastActualAnchorEstimate));
+                return {
+                    tokens: Math.round(this.lastActualTokens * (currentEstimate / this.lastActualAnchorEstimate)),
+                    source: "anchor_rescale",
+                    confidence: "medium",
+                };
             }
         }
-        return currentEstimate;
+        return { tokens: currentEstimate, source: "heuristic_estimate", confidence: "low" };
+    }
+    estimateTokensHybrid(messages) {
+        return this.estimateTokensHybridInfo(messages).tokens;
     }
     /**
      * Set the summarize function (injected by Engine).
@@ -306,6 +367,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;
@@ -516,13 +588,16 @@ export class ContextManager {
      * Check if context is approaching limits.
      */
     checkLimits(messages) {
-        const tokens = this.estimateTokensHybrid(messages);
+        const estimate = this.estimateTokensHybridInfo(messages);
+        const tokens = estimate.tokens;
         const ratio = tokens / this.config.maxTokens;
         return {
             tokens,
             ratio,
             needsCompact: ratio >= this.config.compactAtRatio,
             needsEmergency: ratio >= this.config.summarizeAtRatio,
+            promptTokensSource: estimate.source,
+            promptTokensConfidence: estimate.confidence,
         };
     }
 }

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;