@cjhyy/code-shell-core 0.8.1 → 0.8.3

package/dist/engine/engine.js

@@ -1501,7 +1501,9 @@ export class Engine {
         this.lastMessages = messages;
         // Wire up LLM summarization for context compaction
         // Uses a lightweight call without tools
-        contextManager.setTranscriptPath(session.transcript.getFilePath());
+        if (session.transcript.isPersistent()) {
+            contextManager.setTranscriptPath(session.transcript.getFilePath());
+        }
         // Re-derive frozen persistence decisions from the messages we just
         // loaded. Skipped on cold start (messages == [userContextMsg] only).
         // Critical for resume — otherwise a result that was persisted last
@@ -1704,14 +1706,17 @@ export class Engine {
         // capture the persisted total at run start and fold this run's usage onto
         // it (see foldRunUsage). Snapshot now, before any turn boundary fires.
         const usageBaseline = { ...session.state.tokenUsage };
-        const sessionDir = join(this.config.sessionStorageDir ?? sessionsRoot(), session.state.sessionId);
-        const fileHistoryHook = registerFileHistoryHook({
-            hooks: this.hooks,
-            sessionDir,
-            cwd,
-            getTurnSeq: () => session.state.turnSeq,
-            contributions: this.capabilities.flatMap((capability) => [...(capability.fileHistory ?? [])]),
-        });
+        const fileHistoryHook = isEphemeralSessionState(session.state)
+            ? { dispose() { } }
+            : registerFileHistoryHook({
+                hooks: this.hooks,
+                sessionDir: join(this.config.sessionStorageDir ?? sessionsRoot(), session.state.sessionId),
+                cwd,
+                getTurnSeq: () => session.state.turnSeq,
+                contributions: this.capabilities.flatMap((capability) => [
+                    ...(capability.fileHistory ?? []),
+                ]),
+            });
         // Hook: agent start
         await this.emitHook("on_agent_start", {
             sessionId: session.state.sessionId,
@@ -2800,7 +2805,9 @@ export class Engine {
                 maxTokens: this.resolveMaxContextTokens(),
                 ...Object.fromEntries(Object.entries(this.resolveContextRatios()).filter(([, v]) => v !== undefined)),
             });
-            contextManager.setTranscriptPath(session.transcript.getFilePath());
+            if (session.transcript.isPersistent()) {
+                contextManager.setTranscriptPath(session.transcript.getFilePath());
+            }
             contextManager.initReplacementStateFromMessages(sourceMessages);
             this.lastContextManager = contextManager;
         }

package/dist/engine/run-tooling.js

@@ -279,5 +279,9 @@ export function assembleRunToolDefs(args) {
     const toolDefs = args.runPlanMode
         ? profileToolDefs.filter((t) => PLAN_MODE_ALLOWED_TOOLS.has(t.name))
         : profileToolDefs;
+    // ToolSearch shares the worker registry across Sessions, but discovery must
+    // reflect this exact run's filtered and rewritten surface. Keep the context
+    // snapshot in lockstep with the definitions sent to the model.
+    toolCtx.searchableToolDefinitions = toolDefs;
     return toolDefs;
 }

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

@@ -202,6 +202,9 @@ export declare class TurnLoop {
      * loop forces a stop so a stuck goal can't loop forever.
      */
     private stopBlockCount;
+    /** Consecutive identical tool-call/result batches, ignoring provider call ids. */
+    private repeatedToolBatchFingerprint;
+    private repeatedToolBatchCount;
     /**
      * Run-scoped goal budget tracker (Goal mode). Hoisted to an instance field
      * (not a run() local) so extend() can bump its budgets mid-run. Null when no

package/dist/engine/turn-loop.js

@@ -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 { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { buildAgentDirectionMessage } from "../tool-system/builtin/agent-notifications.js";
 import { newTurnId } from "./turn-state.js";
 import { formatFriendlyError } from "./friendly-error.js";
@@ -40,6 +40,39 @@ export function toolResultToBlock(result) {
         block.is_error = true;
     return block;
 }
+const REPEATED_TOOL_BATCH_LIMIT = 3;
+function canonicalToolValue(value) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    if (Array.isArray(value))
+        return `[${value.map(canonicalToolValue).join(",")}]`;
+    if (typeof value === "object") {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => `${JSON.stringify(key)}:${canonicalToolValue(entry)}`)
+            .join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function repeatedToolBatchFingerprint(toolCalls, results) {
+    // Hash immediately and never log the canonical source: tool results may
+    // contain credentials or large media payloads. Call ids are deliberately
+    // omitted because providers generate a fresh id for every identical retry.
+    return createHash("sha256")
+        .update(canonicalToolValue({
+        calls: toolCalls.map((call) => ({ toolName: call.toolName, args: call.args })),
+        results: results.map((result) => ({
+            toolName: result.toolName,
+            isError: result.isError === true || Boolean(result.error),
+            error: result.error,
+            result: result.result,
+            contentBlocks: result.contentBlocks,
+        })),
+    }))
+        .digest("hex");
+}
 export class TurnLoop {
     deps;
     config;
@@ -76,6 +109,9 @@ export class TurnLoop {
      * loop forces a stop so a stuck goal can't loop forever.
      */
     stopBlockCount = 0;
+    /** Consecutive identical tool-call/result batches, ignoring provider call ids. */
+    repeatedToolBatchFingerprint;
+    repeatedToolBatchCount = 0;
     /**
      * Run-scoped goal budget tracker (Goal mode). Hoisted to an instance field
      * (not a run() local) so extend() can bump its budgets mid-run. Null when no
@@ -1409,6 +1445,49 @@ export class TurnLoop {
                         tlog.info("guard.stale_task", { cat: "guard", turn: this.turnCount });
                     }
                 }
+                const toolBatchFingerprint = repeatedToolBatchFingerprint(toolCalls, results);
+                if (toolBatchFingerprint === this.repeatedToolBatchFingerprint) {
+                    this.repeatedToolBatchCount++;
+                }
+                else {
+                    this.repeatedToolBatchFingerprint = toolBatchFingerprint;
+                    this.repeatedToolBatchCount = 1;
+                }
+                if (this.repeatedToolBatchCount >= REPEATED_TOOL_BATCH_LIMIT) {
+                    tlog.warn("turn.repeated_tool_batch_stopped", {
+                        cat: "turn",
+                        repeatedCount: this.repeatedToolBatchCount,
+                        tools: toolCalls.map((call) => call.toolName),
+                    });
+                    await this.emitHook("on_turn_end", {
+                        turnNumber: this.turnCount,
+                        hasToolUse: true,
+                        toolCallCount: toolCalls.length,
+                    });
+                    finalText =
+                        `检测到同一组工具调用及其结果连续重复 ${REPEATED_TOOL_BATCH_LIMIT} 次，` +
+                            "已自动停止，避免继续空转。请调整请求或让 Session 获取新的上下文后再试。";
+                    this.deps.transcript.appendMessage("assistant", finalText);
+                    messages.push({ role: "assistant", content: finalText });
+                    this.config.onStream?.({
+                        type: "assistant_message",
+                        messageId: assistantMessageId,
+                        message: { role: "assistant", content: finalText },
+                    });
+                    this.finalizeModelTurn();
+                    if (await this.consumeQueuedSteer(messages, "finalize_backfill")) {
+                        this.repeatedToolBatchFingerprint = undefined;
+                        this.repeatedToolBatchCount = 0;
+                        continue;
+                    }
+                    messages = this.redactConsumedSensitiveToolResults(messages);
+                    return {
+                        text: finalText,
+                        reason: "completed",
+                        messages,
+                        completionKind: "limit_stop",
+                    };
+                }
                 // Hook: turn end
                 await this.emitHook("on_turn_end", {
                     turnNumber: this.turnCount,

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export declare const VERSION = "0.8.1";
+export declare const VERSION = "0.8.3";
 export type { Message, ContentBlock, ToolDefinition, ToolCall, ToolResult, RegisteredTool, TranscriptEvent, TranscriptEventType, SessionState, SessionKind, SessionWorkspace, SessionForkLineage, ContextUsageAnchor, SessionStatus, TokenUsage, CompiledInput, PermissionDecision, PermissionMode, PermissionRule, TurnPhase, TurnResult, TerminalReason, TurnCompletionKind, StreamEvent, StreamCallback, LLMConfig, ClientDefaults, LLMResponse, Settings, MCPServerConfig, } from "./types.js";
 export type { GoalConfig, GoalLifecycleConfig, GoalLifecyclePhase, GoalLifecycleTerminalReason, GoalLifecycleV1, } from "./goal/lifecycle.js";
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, SandboxUnavailableError, } from "./exceptions.js";

package/dist/index.js

@@ -3,7 +3,7 @@
  *
  * Public API exports.
  */
-export const VERSION = "0.8.1";
+export const VERSION = "0.8.3";
 // ─── Exceptions ──────────────────────────────────────────────────
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, SandboxUnavailableError, } from "./exceptions.js";
 // ─── Engine (primary API) ────────────────────────────────────────

package/dist/llm/providers/openai.js

@@ -145,6 +145,52 @@ export async function runStreamWithWatchdog(stream, opts = {}) {
     }
     return text;
 }
+const MISSING_TOOL_RESULT_WIRE_TEXT = "Error: Tool execution did not complete before the conversation resumed.";
+/**
+ * OpenAI requires each assistant tool_calls batch to be followed immediately
+ * by exactly one role:tool message per id. Normalize at the provider boundary
+ * as a final guard against legacy/corrupt transcripts: keep the latest result
+ * for a duplicate id, synthesize a request-local result for a missing id, and
+ * discard tool messages that were never declared by the preceding assistant.
+ */
+function normalizeOpenAIToolMessagePairs(messages) {
+    const normalized = [];
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        if (message.role === "tool")
+            continue;
+        normalized.push(message);
+        if (message.role !== "assistant")
+            continue;
+        const toolCalls = message.tool_calls;
+        const expectedIds = Array.isArray(toolCalls)
+            ? toolCalls
+                .map((toolCall) => toolCall.id)
+                .filter((id) => typeof id === "string" && id.length > 0)
+            : [];
+        if (expectedIds.length === 0)
+            continue;
+        const expected = new Set(expectedIds);
+        const latestResultById = new Map();
+        let cursor = index + 1;
+        while (cursor < messages.length && messages[cursor]?.role === "tool") {
+            const toolMessage = messages[cursor];
+            if (expected.has(toolMessage.tool_call_id)) {
+                latestResultById.set(toolMessage.tool_call_id, toolMessage);
+            }
+            cursor++;
+        }
+        for (const id of expectedIds) {
+            normalized.push(latestResultById.get(id) ?? {
+                role: "tool",
+                tool_call_id: id,
+                content: MISSING_TOOL_RESULT_WIRE_TEXT,
+            });
+        }
+        index = cursor - 1;
+    }
+    return normalized;
+}
 export class OpenAIClient extends LLMClientBase {
     _client = null;
     // Sticky override: once the endpoint tells us `max_tokens` is rejected for
@@ -839,10 +885,11 @@ export class OpenAIClient extends LLMClientBase {
                 }
             }
         }
+        const normalized = normalizeOpenAIToolMessagePairs(result);
         if (this.isOpenRouterAnthropic) {
-            this.applyAnthropicCacheBreakpoints(result);
+            this.applyAnthropicCacheBreakpoints(normalized);
         }
-        return result;
+        return normalized;
     }
     /**
      * In-place: add prompt-cache breakpoints for Anthropic-over-OpenRouter.

package/dist/protocol/chat-session-manager.js

@@ -190,6 +190,14 @@ export class ChatSessionManager {
             return alreadyClosing;
         const s = this.sessions.get(sessionId);
         if (!s) {
+            if (sessionId.startsWith("qchat-")) {
+                try {
+                    this.engineSessionManager(this.factory({}))?.forgetEphemeralSession?.(sessionId);
+                }
+                catch {
+                    // Closing an already-expired process-local chat is idempotent.
+                }
+            }
             if (markClosed)
                 this.rememberClosedSession(sessionId);
             return Promise.resolve();
@@ -204,6 +212,7 @@ export class ChatSessionManager {
         clearCredentialSessionAllow(sessionId);
         clearInjectCredentialSessionAllow(sessionId);
         const finishClose = () => {
+            sessionManager?.forgetEphemeralSession?.(sessionId);
             this.unregisterMcpOwner(s);
             if (this.sessions.get(sessionId) === s)
                 this.sessions.delete(sessionId);

package/dist/run/EngineRunner.js

@@ -27,10 +27,11 @@ export const AUTOMATION_RUN_SOURCE = "automation";
 export const AUTOMATION_PROMPT_NOTE = "This is an unattended, scheduled automation run. No human is watching, and " +
     "AskUserQuestion will not reach anyone. You ARE the automation — do not ask " +
     "the user questions and do not offer to set up or schedule automation. " +
-    "Produce the requested output directly; when uncertain, state your assumption " +
-    "and proceed." +
-    " When finished, call UpdateAutomationMemory exactly once with a concise " +
-    "summary of this run's key findings/state for the next run.";
+    "When uncertain, state your assumption and proceed. When the work is ready, " +
+    "first call UpdateAutomationMemory exactly once with a concise summary of this " +
+    "run's key findings/state for the next run. After that call succeeds, return the " +
+    "complete requested output as the final assistant message. Do not replace the " +
+    "requested output with a completion acknowledgement or put it in a formatting tool.";
 /** Compose the run's appendSystemPrompt: prepend the automation note when the
  *  run is tagged source "automation", preserving any host-provided append. */
 export function buildAppendSystemPrompt(hostAppend, metadata) {

package/dist/session/session-manager.d.ts

@@ -18,7 +18,7 @@ export interface ForkSessionOptions {
     throughEventId?: string;
     /** `completed` is the interrupted snapshot used by ephemeral side chats. */
     snapshotMode?: "tail" | "completed";
-    /** Hide this temporary fork from ordinary session lists and resume pickers. */
+    /** Keep this temporary fork in process memory only. */
     ephemeral?: boolean;
 }
 export interface ForkSessionResult {
@@ -94,24 +94,22 @@ export declare class SessionManager {
     private readonly registeredCloseEpochs;
     private readonly workspaceCapability?;
     constructor(storageDir?: string, workspaceCapability?: SessionWorkspaceCapability);
+    private processLocalKey;
+    private processLocalBundle;
+    private storeProcessLocalBundle;
+    /** Forget a Quick Chat/side-chat bundle immediately; nothing remains on disk. */
+    forgetEphemeralSession(sessionId: string): boolean;
     private cleanupStaleForkStaging;
     /** Bind one Engine/session pair to the current close epoch without advancing it. */
     registerSessionGeneration(sessionId: string): number;
     /** Advance the close epoch once before close waits for the old run to settle. */
     incrementSessionGeneration(sessionId: string): number;
     /**
-     * Create a new on-disk session. If `explicitSessionId` is passed, use
-     * it verbatim (ChatSessionManager-driven hosts choose a logical sid like
-     * "tui-main" and expect us to honor it). Otherwise generate one with
-     * nanoid. Either way the on-disk directory is materialized and the
-     * state.json + transcript.jsonl files are written before return.
+     * Create a session. `qchat-` sessions stay process-local; ordinary sessions
+     * materialize state.json + transcript.jsonl before return.
      */
     create(cwd: string, model: string, provider: string, explicitSessionId?: string, parentSessionId?: string | null, origin?: import("../types.js").SessionOrigin, kind?: SessionKind): SessionBundle;
-    /**
-     * Whether a session directory exists on disk. Used by ChatSession-driven
-     * cold starts to decide between resume vs create-with-explicit-sid
-     * without catching SessionError.
-     */
+    /** Whether a persisted or process-local session exists. */
     exists(sessionId: string): boolean;
     /**
      * Cheap persisted-main-root probe — reads only state.json, NOT the transcript
@@ -142,10 +140,10 @@ export declare class SessionManager {
     }): string[];
     /** @deprecated Use readSessionMainRoot; retained for public API compatibility. */
     readCwd(sessionId: string): string | undefined;
-    /** Disk-only direct-parent ACL metadata. Undefined means unprovable/corrupt. */
+    /** Direct-parent ACL metadata. Undefined means unprovable/corrupt. */
     readParentSessionId(sessionId: string): string | null | undefined;
     /**
-     * Disk-only workspace pointer reader. Legacy sessions written before
+     * Workspace pointer reader. Legacy sessions written before
      * `workspace` existed are treated as main-workspace sessions rooted at
      * `state.cwd`; the read is intentionally non-mutating.
      */
@@ -306,6 +304,7 @@ export declare class SessionManager {
     /** Publish a summary-only top-level fork after summarization has succeeded. */
     createSummaryFork(sourceSessionId: string, options: SummaryForkOptions): ForkSessionResult;
     private readForkSnapshot;
+    private freezeForkSnapshot;
     private publishSessionAtomically;
     list(limit?: number, opts?: {
         excludeKinds?: readonly string[];