@cjhyy/code-shell-core 0.7.0 → 0.7.1

package/dist/arena/arena.d.ts

@@ -19,6 +19,8 @@ export declare class Arena {
     private config;
     private strategy;
     private limits;
+    private usage;
+    private readonly recordUsage;
     constructor(config: ArenaConfig);
     /**
      * Run a full arena session.

package/dist/arena/arena.js

@@ -28,6 +28,7 @@ import { runDetailExpansion } from "./phases/planning-detail-expansion.js";
 import { withLanguage } from "./strategies/language-wrapper.js";
 import { ArenaLedger } from "./ledger.js";
 import { registerClaims } from "./phases/claim-registry.js";
+import { addTokenUsage } from "../engine/session-usage.js";
 /** Bucket claims by status. Shared by the two consensus phases. */
 function summarizeClaims(all) {
     return {
@@ -41,6 +42,17 @@ export class Arena {
     config;
     strategy;
     limits;
+    usage = {
+        promptTokens: 0,
+        completionTokens: 0,
+        totalTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+    };
+    recordUsage = (usage) => {
+        if (usage)
+            this.usage = addTokenUsage(this.usage, usage);
+    };
     constructor(config) {
         if (config.participants.length < 2) {
             throw new Error("Arena requires at least 2 participants");
@@ -63,13 +75,20 @@ export class Arena {
      * @param flags  - Optional explicit overrides (mode, base, head)
      */
     async run(topic, flags) {
+        this.usage = {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+        };
         const participantNames = this.config.participants.map((p) => p.name);
         const signal = this.config.signal;
         logger.info("arena.start", { mode: this.config.mode, participants: participantNames });
         signal?.throwIfAborted();
         // ─── Phase 0: Plan ────────────────────────────────────────
         const llmConfig = this.config.participants[0].llm;
-        const plan = await planArena(topic, llmConfig, flags, signal);
+        const plan = await planArena(topic, llmConfig, flags, signal, this.recordUsage);
         this.config.onProgress?.({ type: "plan_resolved", plan });
         logger.info("arena.plan", {
             mode: plan.mode,
@@ -129,6 +148,7 @@ export class Arena {
             contextTools,
             signal,
             onProgress: this.config.onProgress,
+            onUsage: this.recordUsage,
         });
         const reports = researchResults.map((r) => r.report);
         const dossiers = researchResults.map((r) => r.dossier);
@@ -197,6 +217,7 @@ export class Arena {
             mode: "planning",
             signal,
             onProgress: this.config.onProgress,
+            onUsage: this.recordUsage,
         });
         signal?.throwIfAborted();
         // ─── Roadmap Consensus ───────────────────────────────────
@@ -212,6 +233,7 @@ export class Arena {
             claimSummary,
             signal,
             onProgress: this.config.onProgress,
+            onUsage: this.recordUsage,
         });
         signal?.throwIfAborted();
         // ─── Detail Expansion ────────────────────────────────────
@@ -229,6 +251,7 @@ export class Arena {
                     contextTools,
                     signal,
                     onProgress: this.config.onProgress,
+                    onUsage: this.recordUsage,
                 });
                 consensus.roadmapDetails = details;
             }
@@ -251,6 +274,7 @@ export class Arena {
             claims: allClaims,
             reviews,
             consensus,
+            usage: { ...this.usage },
         };
     }
     /**
@@ -271,6 +295,7 @@ export class Arena {
             limits: this.limits,
             signal,
             onProgress: this.config.onProgress,
+            onUsage: this.recordUsage,
         });
         signal?.throwIfAborted();
         // ─── Debate Rounds ───────────────────────────────────────
@@ -284,6 +309,7 @@ export class Arena {
             maxRounds: this.config.maxDiscussionRounds,
             signal,
             onProgress: this.config.onProgress,
+            onUsage: this.recordUsage,
         });
         signal?.throwIfAborted();
         // ─── Adjudication ────────────────────────────────────────
@@ -295,6 +321,7 @@ export class Arena {
             ledger,
             signal,
             onProgress: this.config.onProgress,
+            onUsage: this.recordUsage,
         });
         signal?.throwIfAborted();
         // ─── Consensus (claim-aware) ─────────────────────────────
@@ -314,6 +341,7 @@ export class Arena {
             claimSummary,
             signal,
             onProgress: this.config.onProgress,
+            onUsage: this.recordUsage,
         });
         return {
             topic,
@@ -328,6 +356,7 @@ export class Arena {
             debateRounds,
             adjudications,
             consensus,
+            usage: { ...this.usage },
         };
     }
 }

package/dist/arena/phases/adjudication.d.ts

@@ -6,7 +6,7 @@
  *
  * Claims that were verified without contest get synthetic adjudication records.
  */
-import type { ArenaParticipant, ArenaStrategy, ClaimAdjudication, ArenaProgressEvent } from "../types.js";
+import type { ArenaParticipant, ArenaStrategy, ClaimAdjudication, ArenaProgressEvent, ArenaUsageRecorder } from "../types.js";
 import type { ArenaLedger } from "../ledger.js";
 interface AdjudicationOptions {
     concluder: ArenaParticipant;
@@ -15,6 +15,7 @@ interface AdjudicationOptions {
     ledger: ArenaLedger;
     signal?: AbortSignal;
     onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
 }
 /**
  * Run adjudication phase. The moderator rules on contested claims.

package/dist/arena/phases/adjudication.js

@@ -17,7 +17,7 @@ import { logger } from "../../logging/logger.js";
  * Verified claims get synthetic adjudications.
  */
 export async function runAdjudication(options) {
-    const { concluder, strategy, topic, ledger, signal, onProgress } = options;
+    const { concluder, strategy, topic, ledger, signal, onProgress, onUsage } = options;
     const allAdjudications = [];
     const v2 = isStrategyV2(strategy);
     // Claims that need moderator adjudication: contested or those with debate rounds
@@ -54,6 +54,7 @@ export async function runAdjudication(options) {
             messages: [{ role: "user", content: userContent }],
             signal,
         });
+        onUsage?.(response.usage);
         logger.info("arena.adjudication_response", {
             claimId: claim.claimId,
             stopReason: response.stopReason,

package/dist/arena/phases/build-consensus.d.ts

@@ -8,7 +8,7 @@
  * In both paths, the moderator must faithfully reflect aggregated results
  * (no new unsourced conclusions).
  */
-import type { ArenaParticipant, ArenaStrategy, ParticipantReport, FindingReview, ArenaConsensus, ClaimStatusSummary, ArenaProgressEvent } from "../types.js";
+import type { ArenaParticipant, ArenaStrategy, ParticipantReport, FindingReview, ArenaConsensus, ClaimStatusSummary, ArenaProgressEvent, ArenaUsageRecorder } from "../types.js";
 interface ConsensusOptions {
     /** The participant that acts as moderator/concluder */
     concluder: ArenaParticipant;
@@ -20,6 +20,7 @@ interface ConsensusOptions {
     claimSummary?: ClaimStatusSummary;
     signal?: AbortSignal;
     onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
 }
 /**
  * Build structured consensus from participant reports, cross-reviews,

package/dist/arena/phases/build-consensus.js

@@ -16,7 +16,7 @@ import { isStrategyV2 } from "../types.js";
  * and optionally adjudicated claim data.
  */
 export async function buildConsensus(options) {
-    const { concluder, strategy, topic, reports, reviews, claimSummary, signal, onProgress } = options;
+    const { concluder, strategy, topic, reports, reviews, claimSummary, signal, onProgress, onUsage } = options;
     onProgress?.({ type: "consensus_start" });
     const client = await createLLMClient(concluder.llm, concluder.clientDefaults);
     const systemPrompt = strategy.consensusSystemPrompt();
@@ -41,6 +41,7 @@ export async function buildConsensus(options) {
         messages: [{ role: "user", content: userContent }],
         signal,
     });
+    onUsage?.(response.usage);
     logger.info("arena.consensus_raw_response", {
         text: response.text,
         stopReason: response.stopReason,
@@ -64,6 +65,7 @@ export async function buildConsensus(options) {
             ],
             signal,
         });
+        onUsage?.(retryResponse.usage);
         logger.info("arena.consensus_retry_response", {
             textLen: retryResponse.text?.length ?? 0,
             stopReason: retryResponse.stopReason,

package/dist/arena/phases/cross-review.d.ts

@@ -7,7 +7,7 @@
  * V2 (VerificationReview): Reviewers get claim + evidence packet + digest data,
  * and produce ClaimChallenge records that feed into the claim state machine.
  */
-import type { ArenaParticipant, ArenaStrategy, ParticipantReport, FindingReview, ClaimChallenge, ArenaProgressEvent, ArenaExecutionLimits } from "../types.js";
+import type { ArenaParticipant, ArenaStrategy, ParticipantReport, FindingReview, ClaimChallenge, ArenaProgressEvent, ArenaExecutionLimits, ArenaUsageRecorder } from "../types.js";
 import type { ArenaLedger } from "../ledger.js";
 interface CrossReviewOptions {
     participants: ArenaParticipant[];
@@ -16,6 +16,7 @@ interface CrossReviewOptions {
     reports: ParticipantReport[];
     signal?: AbortSignal;
     onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
 }
 /**
  * Run cross-review phase (V1). Each participant reviews the others' findings.
@@ -32,6 +33,7 @@ interface VerificationReviewOptions {
     mode?: "review" | "discussion" | "planning";
     signal?: AbortSignal;
     onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
 }
 interface VerificationReviewResult {
     reviews: FindingReview[];

package/dist/arena/phases/cross-review.js

@@ -17,7 +17,7 @@ import { logger } from "../../logging/logger.js";
  * Run cross-review phase (V1). Each participant reviews the others' findings.
  */
 export async function runCrossReview(options) {
-    const { participants, strategy, topic, reports, signal, onProgress } = options;
+    const { participants, strategy, topic, reports, signal, onProgress, onUsage } = options;
     onProgress?.({ type: "cross_review_start", round: 1 });
     const allReviews = [];
     const tasks = participants.map(async (p) => {
@@ -36,6 +36,7 @@ export async function runCrossReview(options) {
             messages: [{ role: "user", content: userContent }],
             signal,
         });
+        onUsage?.(response.usage);
         logger.info("arena.cross_review_raw_response", {
             participant: p.name,
             text: response.text,
@@ -56,6 +57,7 @@ export async function runCrossReview(options) {
                 ],
                 signal,
             });
+            onUsage?.(retryResponse.usage);
             logger.info("arena.cross_review_retry", {
                 participant: p.name,
                 stopReason: retryResponse.stopReason,
@@ -76,7 +78,7 @@ export async function runCrossReview(options) {
  * Falls back to V1 cross-review if strategy doesn't implement V2.
  */
 export async function runVerificationReview(options) {
-    const { participants, strategy, topic, reports, ledger, limits, mode, signal, onProgress } = options;
+    const { participants, strategy, topic, reports, ledger, limits, mode, signal, onProgress, onUsage } = options;
     // Select claims to review, prioritized by severity + confidence
     const allClaims = ledger.getAllClaims();
     const claimsToReview = selectClaimsForReview(allClaims, limits.maxClaimsForReview);
@@ -120,6 +122,7 @@ export async function runVerificationReview(options) {
                 messages: [{ role: "user", content: userContent }],
                 signal,
             });
+            onUsage?.(response.usage);
             logger.info("arena.verification_review_raw", {
                 participant: p.name,
                 stopReason: response.stopReason,
@@ -134,6 +137,7 @@ export async function runVerificationReview(options) {
                     ],
                     signal,
                 });
+                onUsage?.(retryResponse.usage);
                 response = retryResponse;
             }
             const challenges = isPlanningMerge
@@ -163,6 +167,7 @@ export async function runVerificationReview(options) {
                 messages: [{ role: "user", content: userContent }],
                 signal,
             });
+            onUsage?.(response.usage);
             if (response.stopReason === "length") {
                 const retryResponse = await client.createMessage({
                     systemPrompt,
@@ -173,6 +178,7 @@ export async function runVerificationReview(options) {
                     ],
                     signal,
                 });
+                onUsage?.(retryResponse.usage);
                 response = retryResponse;
             }
             const reviews = strategy.parseCrossReviewResponse(p.name, response.text);

package/dist/arena/phases/debate-rounds.d.ts

@@ -7,7 +7,7 @@
  *   2. Convergence check: all stances are "support" or "narrow" → resolved
  *   3. If max rounds exhausted → stays contested for adjudication
  */
-import type { ArenaParticipant, ArenaStrategy, DebateRound, ArenaExecutionLimits, ArenaProgressEvent } from "../types.js";
+import type { ArenaParticipant, ArenaStrategy, DebateRound, ArenaExecutionLimits, ArenaProgressEvent, ArenaUsageRecorder } from "../types.js";
 import type { ArenaLedger } from "../ledger.js";
 interface DebateOptions {
     participants: ArenaParticipant[];
@@ -18,6 +18,7 @@ interface DebateOptions {
     maxRounds: number;
     signal?: AbortSignal;
     onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
 }
 /**
  * Run debate rounds for all contested claims.

package/dist/arena/phases/debate-rounds.js

@@ -17,7 +17,7 @@ import { logger } from "../../logging/logger.js";
  * Returns empty array if no contested claims exist.
  */
 export async function runDebateRounds(options) {
-    const { participants, strategy, topic, ledger, limits, maxRounds, signal, onProgress } = options;
+    const { participants, strategy, topic, ledger, limits, maxRounds, signal, onProgress, onUsage } = options;
     // Select contested claims, capped
     const contested = ledger.getClaimsByStatus("contested")
         .slice(0, limits.maxContestedClaimsForDebate);
@@ -44,6 +44,7 @@ export async function runDebateRounds(options) {
             maxRounds,
             signal,
             onProgress,
+            onUsage,
         });
         allDebateRounds.push(...claimDebateRounds);
         // Attach debate rounds to claim record
@@ -52,7 +53,7 @@ export async function runDebateRounds(options) {
     return allDebateRounds;
 }
 async function debateClaim(options) {
-    const { claim, participants, strategy, v2, topic, ledger, maxRounds, signal, onProgress } = options;
+    const { claim, participants, strategy, v2, topic, ledger, maxRounds, signal, onProgress, onUsage } = options;
     // Identify debaters: claim owner + primary challenger
     const owner = participants.find((p) => p.name === claim.owner);
     const primaryChallenger = findPrimaryChallenger(claim, participants);
@@ -91,6 +92,7 @@ async function debateClaim(options) {
                 messages: [{ role: "user", content: userContent }],
                 signal,
             });
+            onUsage?.(response.usage);
             logger.info("arena.debate_turn", {
                 participant: p.name,
                 claimId: claim.claimId,

package/dist/arena/phases/participant-research.d.ts

@@ -5,7 +5,7 @@
  * Phase 3 upgrade: now captures ToolTrace and builds EvidencePackets,
  * outputting a full ResearchDossier alongside the ParticipantReport.
  */
-import type { ArenaBaseContext, ArenaParticipant, ArenaStrategy, ParticipantReport, ResearchDossier, ArenaProgressEvent } from "../types.js";
+import type { ArenaBaseContext, ArenaParticipant, ArenaStrategy, ParticipantReport, ResearchDossier, ArenaProgressEvent, ArenaUsageRecorder } from "../types.js";
 import type { ToolDefinition } from "../../types.js";
 /** Result of a single participant's research — includes both report and dossier */
 export interface ResearchResult {
@@ -23,6 +23,7 @@ interface ResearchOptions {
     /** AbortSignal — cancels in-flight LLM calls */
     signal?: AbortSignal;
     onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
 }
 /**
  * Run participant research phase in parallel.

package/dist/arena/phases/participant-research.js

@@ -23,7 +23,7 @@ export async function runParticipantResearch(options) {
  * Returns both reports (backward compat) and dossiers (evidence trail).
  */
 export async function runParticipantResearchWithDossiers(options) {
-    const { participants, strategy, topic, baseContext, enableContextTools, contextTools, signal, onProgress } = options;
+    const { participants, strategy, topic, baseContext, enableContextTools, contextTools, signal, onProgress, onUsage } = options;
     const tools = enableContextTools ? (contextTools ?? CONTEXT_TOOLS) : undefined;
     const tasks = participants.map(async (p) => {
         onProgress?.({ type: "research_start", participant: p.name });
@@ -57,6 +57,7 @@ export async function runParticipantResearchWithDossiers(options) {
                 tools,
                 signal,
             });
+            onUsage?.(response.usage);
             const toolNames = (response.toolCalls ?? []).map((tc) => tc.toolName);
             const hasTools = response.toolCalls && response.toolCalls.length > 0;
             logger.info("arena.research_round", {
@@ -158,6 +159,7 @@ export async function runParticipantResearchWithDossiers(options) {
                     },
                 ],
             });
+            onUsage?.(forceResponse.usage);
             logger.info("arena.research_force_conclude_response", {
                 participant: p.name,
                 textLen: forceResponse.text?.length ?? 0,

package/dist/arena/phases/planning-detail-expansion.d.ts

@@ -9,7 +9,7 @@
  *
  * Tool access is available so the LLM can verify file paths and interfaces.
  */
-import type { ArenaParticipant, ArenaRoadmapPhase, ArenaRoadmapPhaseDetail, ArenaProgressEvent, ArenaExecutionLimits, ArenaStrategyPlanning } from "../types.js";
+import type { ArenaParticipant, ArenaRoadmapPhase, ArenaRoadmapPhaseDetail, ArenaProgressEvent, ArenaExecutionLimits, ArenaStrategyPlanning, ArenaUsageRecorder } from "../types.js";
 import type { ToolDefinition } from "../../types.js";
 import type { ArenaLedger } from "../ledger.js";
 interface DetailExpansionOptions {
@@ -27,6 +27,7 @@ interface DetailExpansionOptions {
     contextTools?: ToolDefinition[];
     signal?: AbortSignal;
     onProgress?: (event: ArenaProgressEvent) => void;
+    onUsage?: ArenaUsageRecorder;
 }
 /**
  * Expand each roadmap phase into a repo-level implementation plan.

package/dist/arena/phases/planning-detail-expansion.js

@@ -22,7 +22,7 @@ const MAX_EXPANSION_TOOL_ROUNDS = 3;
  * The number of phases expanded is capped by limits.maxExpandedPhasesPerRun.
  */
 export async function runDetailExpansion(options) {
-    const { concluder, strategy, topic, phases, ledger, limits, signal, onProgress } = options;
+    const { concluder, strategy, topic, phases, ledger, limits, signal, onProgress, onUsage } = options;
     const tools = options.enableContextTools !== false
         ? (options.contextTools ?? CONTEXT_TOOLS)
         : undefined;
@@ -56,6 +56,7 @@ export async function runDetailExpansion(options) {
                 tools: offerTools,
                 signal,
             });
+            onUsage?.(response.usage);
             const hasTools = response.toolCalls && response.toolCalls.length > 0;
             logger.info("arena.detail_expansion_round", {
                 phase: phase.title,

package/dist/arena/planner.d.ts

@@ -12,6 +12,7 @@
  * LLM call that outputs a holistic execution plan.
  */
 import type { LLMConfig } from "../types.js";
+import type { ArenaUsageRecorder } from "./types.js";
 import type { ArenaPlan, ArenaMode } from "./types.js";
 /** Explicit flags the user may pass via CLI or tool args */
 export interface PlannerFlags {
@@ -24,4 +25,4 @@ export interface PlannerFlags {
  *
  * Priority: explicit flags > LLM plan > safe defaults.
  */
-export declare function planArena(topic: string, llmConfig: LLMConfig, flags?: PlannerFlags, signal?: AbortSignal): Promise<ArenaPlan>;
+export declare function planArena(topic: string, llmConfig: LLMConfig, flags?: PlannerFlags, signal?: AbortSignal, onUsage?: ArenaUsageRecorder): Promise<ArenaPlan>;

package/dist/arena/planner.js

@@ -58,7 +58,7 @@ Respond ONLY with JSON, no markdown fences:
  *
  * Priority: explicit flags > LLM plan > safe defaults.
  */
-export async function planArena(topic, llmConfig, flags, signal) {
+export async function planArena(topic, llmConfig, flags, signal, onUsage) {
     // If mode and base are both explicit, we can skip the LLM call
     if (flags?.mode && flags?.base) {
         return buildExplicitPlan(topic, flags);
@@ -75,6 +75,7 @@ export async function planArena(topic, llmConfig, flags, signal) {
             maxTokens: 1024,
             signal,
         });
+        onUsage?.(response.usage);
         const plan = parsePlanResponse(response.text, topic);
         // Explicit flags override LLM output
         if (flags?.mode)

package/dist/arena/types.d.ts

@@ -3,7 +3,9 @@
  *
  * V2 architecture: shared facts → independent research → findings → cross-review → consensus.
  */
-import type { ClientDefaults, LLMConfig } from "../types.js";
+import type { ClientDefaults, LLMConfig, TokenUsage } from "../types.js";
+/** Receives usage for each completed Arena provider request. */
+export type ArenaUsageRecorder = (usage: TokenUsage | undefined) => void;
 /** Arena operating mode — determines prompts, output format, and default rounds */
 export type ArenaMode = "review" | "discussion" | "planning";
 /** Analysis lens — the perspective from which participants analyze */
@@ -337,6 +339,8 @@ export interface ArenaResultV2 {
     /** Claim adjudications (Phase 3+) */
     adjudications?: ClaimAdjudication[];
     consensus: ArenaConsensus;
+    /** Aggregate of every provider request made by this Arena run. */
+    usage: TokenUsage;
 }
 /**
  * ArenaStrategy — encapsulates mode-specific behavior for prompts and parsing.

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;
 }

package/dist/context/tool-result-storage.d.ts

@@ -55,6 +55,12 @@ export declare function reconstructContentReplacementState(messages: Message[]):
  * transcript path. Layout:  <transcriptDir>/tool-results/
  */
 export declare function resolveToolResultsDir(transcriptPath: string): string;
+/**
+ * Convert an externally supplied tool_use_id to a bounded internal filename.
+ * The original id remains the key in ContentReplacementState/onPersist; it is
+ * never used as a path component.
+ */
+export declare function safeToolResultFilename(toolUseId: string): string;
 interface PersistOptions {
     /** Per-result threshold; default DEFAULT_PERSIST_THRESHOLD. */
     perResultThreshold?: number;