@cjhyy/code-shell-core 0.7.0-beta.1 → 0.7.1

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

@@ -2,6 +2,7 @@ import { readFileSync, existsSync, readdirSync, statSync, openSync, readSync, cl
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { encodeCwd } from "./session-discovery.js";
+import { logger } from "../logging/logger.js";
 /**
  * #6 — attribute file changes made by a background external agent (DriveAgent
  * running `claude` / `codex`). Those Edit/Write calls land in the external CLI's
@@ -143,11 +144,27 @@ export function readCodexChangedFiles(cwd, threadId, codexHome = join(homedir(),
 /** Dispatch by CLI. Unknown cli → []. Never throws. */
 export function readExternalChangedFiles(cli, cwd, sessionId) {
     try {
-        if (cli === "codex")
-            return readCodexChangedFiles(cwd, sessionId);
-        return readClaudeChangedFiles(cwd, sessionId);
-    }
-    catch {
+        const files = cli === "codex"
+            ? readCodexChangedFiles(cwd, sessionId)
+            : readClaudeChangedFiles(cwd, sessionId);
+        logger.debug("changed_files.external.extracted", {
+            cat: "changed_files",
+            cli,
+            cwd,
+            externalSessionId: sessionId,
+            size: files.length,
+            files,
+        });
+        return files;
+    }
+    catch (err) {
+        logger.debug("changed_files.external.extract_failed", {
+            cat: "changed_files",
+            cli,
+            cwd,
+            externalSessionId: sessionId,
+            error: err instanceof Error ? err.message : String(err),
+        });
         return [];
     }
 }

package/dist/cc-orchestrator/external-agent-driver.d.ts

@@ -11,7 +11,7 @@ export declare function runWithLines(adapter: AgentAdapter, lines: string[], exi
 export interface DriverRunOpts extends Omit<BuildArgsOpts, "permissionMode"> {
     permissionMode?: PermissionMode;
 }
-export declare function detectCodexImageInput(command: string, cwd: string): Promise<boolean>;
+export declare function detectCodexImageInput(command: string, cwd: string, signal?: AbortSignal): Promise<boolean>;
 /** Spawn ONE headless agent run, collect stream-json to exit, return result.
  *  No time concept — a single turn. Honors AbortSignal (kills the child). */
 export declare function runAgentOnce(adapter: AgentAdapter, opts: DriverRunOpts & {

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

@@ -1,17 +1,130 @@
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import { pathWithCommonBins } from "./cc-capability.js";
+import { killProcessGroup } from "../runtime/spawn-common.js";
 /** Pure: reduce collected output lines + exit code to a result. Unit-testable. */
 export function runWithLines(adapter, lines, exitCode) {
     const parsed = adapter.parseResult(lines);
     return { ...parsed, exitCode, lines };
 }
 const codexImageFlagCache = new Map();
-export function detectCodexImageInput(command, cwd) {
-    const cached = codexImageFlagCache.get(command);
-    if (cached)
-        return cached;
-    const probe = new Promise((resolve) => {
+const CODEX_IMAGE_PROBE_TIMEOUT_MS = 5_000;
+const AGENT_TERMINATE_GRACE_MS = 500;
+function listPosixProcessTree(rootPid) {
+    return new Promise((resolve) => {
+        execFile("ps", ["-axo", "pid=,ppid="], { encoding: "utf8" }, (err, stdout) => {
+            if (err) {
+                resolve([rootPid]);
+                return;
+            }
+            const childrenByParent = new Map();
+            for (const line of stdout.split("\n")) {
+                const [pidText, parentText] = line.trim().split(/\s+/, 2);
+                const pid = Number(pidText);
+                const parentPid = Number(parentText);
+                if (!Number.isInteger(pid) || !Number.isInteger(parentPid))
+                    continue;
+                const children = childrenByParent.get(parentPid) ?? [];
+                children.push(pid);
+                childrenByParent.set(parentPid, children);
+            }
+            const pids = [];
+            const visit = (pid) => {
+                if (pids.includes(pid))
+                    return;
+                pids.push(pid);
+                for (const childPid of childrenByParent.get(pid) ?? [])
+                    visit(childPid);
+            };
+            visit(rootPid);
+            resolve(pids);
+        });
+    });
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForPidsToExit(pids, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while ([...pids].some(isPidAlive)) {
+        if (Date.now() >= deadline)
+            return false;
+        await delay(25);
+    }
+    return true;
+}
+function signalPids(pids, killSignal) {
+    for (const pid of pids) {
+        try {
+            process.kill(pid, killSignal);
+        }
+        catch {
+            // already gone
+        }
+    }
+}
+async function terminateAttachedProcessTree(child) {
+    const pid = child.pid;
+    if (!pid) {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch {
+            // already gone
+        }
+        return;
+    }
+    if (process.platform === "win32") {
+        // Windows has no POSIX SIGTERM semantics or negative-pid groups. Reap the
+        // tree via taskkill, then use positive-pid process.kill as the fallback the
+        // platform supports when taskkill is unavailable/races.
+        await killProcessGroup(pid, { graceMs: AGENT_TERMINATE_GRACE_MS });
+        if (isPidAlive(pid)) {
+            try {
+                process.kill(pid);
+            }
+            catch {
+                // already gone
+            }
+        }
+        return;
+    }
+    const trackedPids = new Set(await listPosixProcessTree(pid));
+    signalPids(trackedPids, "SIGTERM");
+    if (await waitForPidsToExit(trackedPids, AGENT_TERMINATE_GRACE_MS))
+        return;
+    // Capture descendants created during the grace window while the leader is
+    // still addressable, but retain the first snapshot so reparented stubborn
+    // descendants cannot disappear from the escalation set.
+    for (const treePid of await listPosixProcessTree(pid))
+        trackedPids.add(treePid);
+    signalPids(trackedPids, "SIGKILL");
+    await waitForPidsToExit(trackedPids, 1_000);
+}
+function abortError() {
+    const err = new Error("Agent run aborted");
+    err.name = "AbortError";
+    return err;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortError();
+}
+function createCodexImageProbe(command, cwd, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(abortError());
+            return;
+        }
         const child = spawn(command, ["exec", "--help"], {
             cwd,
             env: { ...process.env, PATH: pathWithCommonBins() },
@@ -20,31 +133,65 @@ export function detectCodexImageInput(command, cwd) {
         });
         let out = "";
         let settled = false;
+        let terminating = false;
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+        };
         const done = (value) => {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timer);
+            cleanup();
             resolve(value);
         };
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(err);
+        };
+        const onAbort = () => {
+            if (settled || terminating)
+                return;
+            terminating = true;
+            cleanup();
+            void terminateAttachedProcessTree(child).then(() => fail(abortError()));
+        };
         const timer = setTimeout(() => {
-            try {
-                child.kill("SIGTERM");
-            }
-            catch {
-                // already gone
-            }
-            done(false);
-        }, 2_000);
+            if (settled || terminating)
+                return;
+            terminating = true;
+            cleanup();
+            void terminateAttachedProcessTree(child).then(() => done(false));
+        }, CODEX_IMAGE_PROBE_TIMEOUT_MS);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
         child.stdout?.on("data", (chunk) => {
             out += chunk.toString("utf8");
         });
         child.stderr?.on("data", (chunk) => {
             out += chunk.toString("utf8");
         });
-        child.on("error", () => done(false));
-        child.on("exit", () => done(/(?:^|\s)-i(?:,|\s)|--image\b/.test(out)));
+        child.on("error", () => {
+            if (!terminating)
+                done(false);
+        });
+        child.on("exit", () => {
+            if (!terminating)
+                done(/(?:^|\s)-i(?:,|\s)|--image\b/.test(out));
+        });
     });
+}
+export function detectCodexImageInput(command, cwd, signal) {
+    if (signal)
+        return createCodexImageProbe(command, cwd, signal);
+    const cached = codexImageFlagCache.get(command);
+    if (cached)
+        return cached;
+    const probe = createCodexImageProbe(command, cwd);
     codexImageFlagCache.set(command, probe);
     return probe;
 }
@@ -53,17 +200,25 @@ export function detectCodexImageInput(command, cwd) {
 export function runAgentOnce(adapter, opts, signal) {
     return new Promise((resolve, reject) => {
         void (async () => {
+            throwIfAborted(signal);
             const codexImageInputSupported = adapter.kind === "codex" && (opts.imagePaths?.length ?? 0) > 0
-                ? await detectCodexImageInput(opts.command, opts.cwd).catch(() => false)
+                ? await detectCodexImageInput(opts.command, opts.cwd, signal).catch((err) => {
+                    if (signal?.aborted || err?.name === "AbortError")
+                        throw err;
+                    return false;
+                })
                 : false;
+            throwIfAborted(signal);
             const args = adapter.buildArgs({
                 prompt: opts.prompt,
                 resumeSessionId: opts.resumeSessionId,
+                model: opts.model,
                 permissionMode: opts.permissionMode ?? "default",
                 cwd: opts.cwd,
                 imagePaths: opts.imagePaths,
                 codexImageInputSupported,
             });
+            throwIfAborted(signal);
             // claude takes the prompt in argv (`-p <prompt>`) and wants stdin closed
             // (verified: avoids a 3s wait). codex `exec` reads the prompt from stdin
             // (argv ends with `-`), so adapters that set promptViaStdin get a piped
@@ -72,14 +227,27 @@ export function runAgentOnce(adapter, opts, signal) {
             const child = spawn(opts.command, args, {
                 cwd: opts.cwd,
                 env: { ...process.env, PATH: pathWithCommonBins() },
-                // NOT detached: this child is owned by the (long-lived) worker that reads
-                // its stdout. Detaching orphaned it across a worker/app restart — the
-                // reader promise then never resolved and the completion notification never
-                // fired (the "后台任务没返回" bug). Bound to the worker, it lives or dies
-                // with the process that's actually listening for its result.
+                // Keep the agent in the owning worker/app process group. If that owner
+                // is force-terminated, the CLI and its descendants must not escape into
+                // a detached group that can keep editing the workspace unseen.
                 detached: false,
                 stdio: [viaStdin ? "pipe" : "ignore", "pipe", "pipe"],
             });
+            let settled = false;
+            let abortRequested = false;
+            let termination;
+            const cleanup = () => {
+                signal?.removeEventListener("abort", onAbort);
+            };
+            const onAbort = () => {
+                if (abortRequested)
+                    return;
+                abortRequested = true;
+                termination = terminateAttachedProcessTree(child);
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            if (signal?.aborted)
+                onAbort();
             if (viaStdin && child.stdin) {
                 child.stdin.end(opts.prompt);
             }
@@ -88,20 +256,11 @@ export function runAgentOnce(adapter, opts, signal) {
                 const rl = createInterface({ input: child.stdout });
                 rl.on("line", (line) => lines.push(line));
             }
-            // Not detached → no own process group, so kill the child directly (a
-            // negative-pid group kill would target the worker's group). claude has no
-            // long-lived child tree of its own here, so a direct SIGTERM is sufficient.
-            const onAbort = () => {
-                try {
-                    child.kill("SIGTERM");
-                }
-                catch {
-                    /* already gone */
-                }
-            };
-            signal?.addEventListener("abort", onAbort, { once: true });
             child.on("error", (err) => {
-                signal?.removeEventListener("abort", onAbort);
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
                 // A missing binary is the most common failure (user hasn't installed the
                 // CLI, or GUI-launched Electron's PATH misses it). Turn the cryptic
                 // "spawn codex ENOENT" into something actionable that names the command.
@@ -112,8 +271,13 @@ export function runAgentOnce(adapter, opts, signal) {
                 reject(err);
             });
             child.on("exit", (code) => {
-                signal?.removeEventListener("abort", onAbort);
-                resolve(runWithLines(adapter, lines, code));
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                void (termination ?? Promise.resolve()).then(() => {
+                    resolve(runWithLines(adapter, lines, code));
+                });
             });
         })().catch(reject);
     });

package/dist/cc-orchestrator/session-history.d.ts

@@ -11,6 +11,41 @@ export interface HistoryMessage {
     }[];
     ts?: number;
 }
+/** One render-relevant event parsed from an appended external-CLI transcript
+ * line. Kept CLI-neutral so the desktop room follower can feed Claude Code and
+ * Codex through the same RoomManager push path. */
+export type SessionTailEvent = {
+    type: "user";
+    text: string;
+} | {
+    type: "assistant";
+    text: string;
+} | {
+    type: "tool";
+    id?: string;
+    name: string;
+    summary: string;
+    args?: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    id?: string;
+    result: string;
+    isError: boolean;
+} | {
+    type: "turn_end";
+    reason: string;
+};
+/** Parse a bounded/raw Claude Code transcript snapshot. Exported so a live
+ * follower can take its initial snapshot and EOF cursor from the same read,
+ * eliminating the snapshot→subscribe race. */
+export declare function parseRecentHistory(raw: string, limit: number): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+    totalCount: number;
+};
+/** Parse one newly-appended Claude Code transcript JSONL line into the compact
+ * event vocabulary consumed by the desktop room follower. */
+export declare function parseClaudeTranscriptLine(line: string): SessionTailEvent[];
 /** Read the last `limit` user/assistant messages from a claude session jsonl. */
 export declare function readRecentHistory(cwd: string, sessionId: string, limit: number, claudeHome?: string): {
     messages: HistoryMessage[];

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

@@ -19,23 +19,28 @@ function toolsOf(content) {
             const inp = p.input ?? {};
             const summary = inp.command ?? inp.file_path ?? inp.path ?? inp.url ?? inp.pattern ?? inp.query ?? "";
             const args = inp && typeof inp === "object" && Object.keys(inp).length > 0 ? inp : undefined;
-            out.push({ name: typeof p.name === "string" ? p.name : "tool", summary: String(summary).slice(0, 120), args });
+            out.push({
+                name: typeof p.name === "string" ? p.name : "tool",
+                summary: String(summary).slice(0, 120),
+                args,
+            });
         }
     }
     return out;
 }
-/** Read the last `limit` user/assistant messages from a claude session jsonl. */
-export function readRecentHistory(cwd, sessionId, limit, claudeHome = join(homedir(), ".claude")) {
-    const file = join(claudeHome, "projects", encodeCwd(cwd), `${sessionId}.jsonl`);
-    if (!existsSync(file))
-        return { messages: [], hasMore: false, totalCount: 0 };
-    let raw;
-    try {
-        raw = readFileSync(file, "utf-8");
-    }
-    catch {
-        return { messages: [], hasMore: false, totalCount: 0 };
-    }
+function toolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => typeof part === "string" ? part : typeof part?.text === "string" ? part.text : "")
+        .join("");
+}
+/** Parse a bounded/raw Claude Code transcript snapshot. Exported so a live
+ * follower can take its initial snapshot and EOF cursor from the same read,
+ * eliminating the snapshot→subscribe race. */
+export function parseRecentHistory(raw, limit) {
     const all = [];
     for (const line of raw.split("\n")) {
         if (!line.trim())
@@ -65,3 +70,81 @@ export function readRecentHistory(cwd, sessionId, limit, claudeHome = join(homed
     const start = Math.max(0, all.length - lim);
     return { messages: all.slice(start), hasMore: start > 0, totalCount: all.length };
 }
+/** Parse one newly-appended Claude Code transcript JSONL line into the compact
+ * event vocabulary consumed by the desktop room follower. */
+export function parseClaudeTranscriptLine(line) {
+    let d;
+    try {
+        d = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    if (d.type === "user") {
+        const content = d.message?.content;
+        if (Array.isArray(content)) {
+            for (const part of content) {
+                if (part?.type !== "tool_result")
+                    continue;
+                out.push({
+                    type: "tool_result",
+                    id: typeof part.tool_use_id === "string" ? part.tool_use_id : undefined,
+                    result: toolResultText(part.content).slice(0, 4000),
+                    isError: Boolean(part.is_error),
+                });
+            }
+        }
+        const text = textOf(content).trim();
+        if (text && !NOISE.some((noise) => text.startsWith(noise))) {
+            out.unshift({ type: "user", text });
+        }
+        return out;
+    }
+    if (d.type === "assistant" && Array.isArray(d.message?.content)) {
+        for (const part of d.message.content) {
+            if (part?.type === "text" && typeof part.text === "string" && part.text) {
+                out.push({ type: "assistant", text: part.text });
+            }
+            else if (part?.type === "tool_use") {
+                const input = part.input && typeof part.input === "object"
+                    ? part.input
+                    : undefined;
+                out.push({
+                    type: "tool",
+                    id: typeof part.id === "string" ? part.id : undefined,
+                    name: typeof part.name === "string" ? part.name : "tool",
+                    summary: toolsOf([part])[0]?.summary ?? "",
+                    args: input,
+                });
+            }
+        }
+        if (d.message.stop_reason === "end_turn") {
+            out.push({ type: "turn_end", reason: "completed" });
+        }
+        return out;
+    }
+    if (d.type === "result") {
+        return [
+            {
+                type: "turn_end",
+                reason: typeof d.subtype === "string" ? d.subtype : "completed",
+            },
+        ];
+    }
+    return [];
+}
+/** Read the last `limit` user/assistant messages from a claude session jsonl. */
+export function readRecentHistory(cwd, sessionId, limit, claudeHome = join(homedir(), ".claude")) {
+    const file = join(claudeHome, "projects", encodeCwd(cwd), `${sessionId}.jsonl`);
+    if (!existsSync(file))
+        return { messages: [], hasMore: false, totalCount: 0 };
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return { messages: [], hasMore: false, totalCount: 0 };
+    }
+    return parseRecentHistory(raw, limit);
+}

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

@@ -33,6 +33,8 @@ import { createRunManager } from "../run/factory.js";
 import { startAutomation } from "../automation/index.js";
 import { CronStore, defaultCronStorePath } from "../automation/store.js";
 import { resolveLLMConfigForTag } from "../engine/resolve-llm-config.js";
+import { randomUUID } from "node:crypto";
+import { getApprovalRouter } from "../tool-system/permission.js";
 const cwd = process.env.AGENT_CWD ?? process.cwd();
 const port = Number(process.env.AGENT_TCP_PORT ?? "4321");
 const host = process.env.AGENT_TCP_HOST ?? "127.0.0.1";
@@ -113,9 +115,18 @@ const automation = startAutomation({
 // ── Serve over TCP ──────────────────────────────────────────────
 // One AgentServer per accepted connection, all sharing the same chatManager.
 const servers = new Set();
-listenTcp({ port, host }, (transport) => {
-    const server = new AgentServer({ chatManager, transport });
+listenTcp({ port, host }, (transport, socket) => {
+    const server = new AgentServer({
+        chatManager,
+        transport,
+        connectionId: randomUUID(),
+        approvalRouter: getApprovalRouter(),
+    });
     servers.add(server);
+    socket.once("close", () => {
+        server.disconnect();
+        servers.delete(server);
+    });
 })
     .then((listener) => {
     process.stderr.write(`[code-shell] automation server listening on ${host}:${listener.port}\n`);

package/dist/context/manager.d.ts

@@ -30,7 +30,7 @@ export interface ContextManagerConfig {
  * Async function type for LLM summarization calls.
  * Injected by the Engine so the ContextManager doesn't depend on LLM directly.
  */
-export type SummarizeFn = (prompt: string) => Promise<string>;
+export type SummarizeFn = (prompt: string, signal?: AbortSignal) => Promise<string>;
 export type CompactStrategy = "micro" | "summary" | "window" | "snip" | "emergency";
 export type OnCompactFn = (info: {
     strategy: CompactStrategy;
@@ -111,7 +111,7 @@ export declare class ContextManager {
      * Async context management — attempts LLM summarization before falling back.
      * Call this when you have access to the LLM (between turns).
      */
-    manageAsync(messages: Message[]): Promise<Message[]>;
+    manageAsync(messages: Message[], signal?: AbortSignal): Promise<Message[]>;
     /**
      * Force maximum compaction, ignoring the ratio gates. This is what a manual
      * `/compact` invokes: the user explicitly asked to shrink NOW, so we don't
@@ -126,7 +126,7 @@ export declare class ContextManager {
      * a long-but-under-threshold text-only conversation (the /compact bug) still
      * gets summarized here.
      */
-    forceSummarize(messages: Message[]): Promise<Message[]>;
+    forceSummarize(messages: Message[], signal?: AbortSignal): Promise<Message[]>;
     /**
      * Persist large tool_result blocks to disk and replace them with a
      * preview + filepath. No-op when transcript path hasn't been set

package/dist/context/manager.js

@@ -162,7 +162,7 @@ export class ContextManager {
     setSummarizeFn(fn) {
         this.summarizeFn = fn;
     }
-    async trySummaryCompact(messages, before, logEvent) {
+    async trySummaryCompact(messages, before, logEvent, signal) {
         if (!this.summarizeFn || this.consecutiveSummaryFailures >= 3) {
             return { messages, tokens: before, compacted: false, noProgress: false };
         }
@@ -178,7 +178,7 @@ export class ContextManager {
             // re-summarizes from scratch.
             const priorSummary = extractAnchoredSummary(messages) ?? this.lastSummary;
             const prompt = buildSummarizationPrompt(messagesToSummarize, priorSummary);
-            const summary = await this.summarizeFn(prompt);
+            const summary = await this.summarizeFn(prompt, signal);
             if (!summary || summary.length <= 50) {
                 this.consecutiveSummaryFailures++;
                 logger.warn("context.summary_failed", {
@@ -358,7 +358,7 @@ export class ContextManager {
      * Async context management — attempts LLM summarization before falling back.
      * Call this when you have access to the LLM (between turns).
      */
-    async manageAsync(messages) {
+    async manageAsync(messages, signal) {
         let result = messages;
         // Tier 0a: Persist large tool_results to disk + replace with preview.
         result = this.persistLargeToolResults(result);
@@ -428,7 +428,7 @@ export class ContextManager {
         // Tier 2: LLM summary if approaching limit, or if micro was the only tier
         // available in the 0.70-0.85 band and it freed nothing.
         if (ratio >= this.config.compactAtRatio || shouldEscalateNoOpMicro) {
-            const summarized = await this.trySummaryCompact(result, tokens, "context.summary_compact");
+            const summarized = await this.trySummaryCompact(result, tokens, "context.summary_compact", signal);
             result = summarized.messages;
             tokens = summarized.tokens;
             if (summarized.compacted) {
@@ -488,7 +488,7 @@ export class ContextManager {
      * a long-but-under-threshold text-only conversation (the /compact bug) still
      * gets summarized here.
      */
-    async forceSummarize(messages) {
+    async forceSummarize(messages, signal) {
         let result = messages;
         // Tier 0: same waste-removal + micro as the automatic path.
         result = this.persistLargeToolResults(result);
@@ -505,7 +505,7 @@ export class ContextManager {
         let tokens = this.estimateTokensHybrid(result);
         // Unconditional LLM summary (no ratio gate).
         {
-            const summarized = await this.trySummaryCompact(result, tokens, "context.force_summary_compact");
+            const summarized = await this.trySummaryCompact(result, tokens, "context.force_summary_compact", signal);
             result = summarized.messages;
             tokens = summarized.tokens;
             if (summarized.compacted)

package/dist/context/token-counter.js

@@ -15,6 +15,9 @@ const RATIOS = {
     mixed: 3.6, // Mixed content (typical for tool results)
     cjk: 1.5, // CJK characters: ~1.5 chars per token
 };
+// Base64 is transport data, not text. A fixed vision estimate prevents large
+// images from spuriously exhausting the text context window.
+const IMAGE_TOKEN_ESTIMATE = 170;
 /**
  * Estimate token count for a string, detecting content type.
  */
@@ -80,12 +83,11 @@ function estimateBlockTokens(block) {
     if (block.name)
         tokens += estimateStringTokens(block.name);
     if (block.source?.data) {
-        tokens += estimateStringTokens(block.source.media_type);
-        tokens += estimateStringTokens(block.source.data);
+        tokens += IMAGE_TOKEN_ESTIMATE;
     }
     const maybeOpenAI = block;
     if (typeof maybeOpenAI.image_url?.url === "string") {
-        tokens += estimateStringTokens(maybeOpenAI.image_url.url);
+        tokens += IMAGE_TOKEN_ESTIMATE;
     }
     return tokens;
 }