@cjhyy/code-shell-core 0.8.6 → 0.8.8

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

@@ -215,11 +215,13 @@ function freshSettings() {
 }
 const chatManager = new ChatSessionManager({
     runtime,
-    // resolvedLlmConfig is the bootstrap-time snapshot. When the user
-    // hot-switches models via configure() the modelPool.activeKey moves
-    // ahead of it, so newly-created sessions must re-resolve from the pool
-    // each time the factory fires; fall back to the snapshot only when the
-    // pool can't resolve (no active key — shouldn't happen in practice).
+    // resolvedLlmConfig is the bootstrap-time snapshot. Explicit global model
+    // changes can move modelPool.activeKey ahead of it, so newly-created
+    // sessions re-resolve from the pool each time the factory fires. A
+    // per-session configure intentionally does NOT move that shared key; this
+    // keeps one Session's selected model from leaking into the next Session.
+    // Fall back to the snapshot only when the pool can't resolve (no active key
+    // — shouldn't happen in practice).
     engineFactory: (slice) => {
         // Effective cwd for THIS session: explicit slice.cwd → that project; absent
         // → the no-repo sandbox (NOT the worker's stale boot cwd). See

package/dist/context/manager.js

@@ -547,8 +547,16 @@ export class ContextManager {
         const window = messages.slice(start, end);
         // Feed a prior anchored summary back so the LLM merge-updates rather than
         // re-summarizes from scratch, matching the rolling-summary behavior of
-        // trySummaryCompact().
-        const priorSummary = extractAnchoredSummary(messages) ?? this.lastSummary;
+        // trySummaryCompact() — but ONLY when that anchored summary sits inside
+        // the window being replaced. A summary inside [start, end) is about to be
+        // overwritten by this call, so it must be merged in or its content is
+        // lost. A summary OUTSIDE the window belongs to a different, untouched
+        // span and must NOT be merged in: doing so (via `?? this.lastSummary`,
+        // which is a single most-recent-summary carryover with no span
+        // awareness) made every subsequent range archive fold in the text of
+        // every prior one, so N archived spans produced N copies of the same
+        // growing summary instead of N independent summaries.
+        const priorSummary = extractAnchoredSummary(window);
         const prompt = buildSummarizationPrompt(window, priorSummary);
         const summary = await this.summarizeFn(prompt, opts.signal);
         if (!summary || summary.length <= 50)

package/dist/engine/engine.d.ts

@@ -457,6 +457,13 @@ export declare class Engine {
      * Switch the active model by pool key. Takes effect on the next run() call.
      * Returns the new model entry.
      *
+     * Per-session switches (`persist:false`) must not mutate the shared
+     * ModelPool active key. Every desktop ChatSession owns an Engine, but those
+     * Engines share one runtime pool; changing the pool selection here made the
+     * next newly-created Session inherit whichever model another Session had
+     * just selected (for example a Mimi manager model leaking into its delegated
+     * Work Session).
+     *
      * Persists settings.defaults.text (= the connection id / pool key) so the
      * next process startup defaults to the same model — without this, switches
      * only live in memory and every restart reverts to the previously persisted
@@ -623,22 +630,67 @@ export declare class Engine {
      */
     private prepareContextManagerForSession;
     /**
-     * Archive a caller-chosen contiguous message-index window `[range.start,
-     * range.end)` of a session into a single anchored summary, leaving everything
-     * outside the window untouched, and cache the result so a later
-     * forceCompact/resume reads the archived history. This is a generic
-     * range-archival facade over ContextManager.summarizeRange — the caller
-     * decides which span to collapse (the range is a half-open message-index
-     * window, matching summarizeRange). Returns token stats before/after; equal
-     * before/after means the window was empty or the summary was rejected.
+     * Archive a contiguous message window of a session into a single anchored
+     * summary, leaving everything outside the window untouched, and cache the
+     * result so a later forceCompact/resume reads the archived history. This is
+     * a generic range-archival facade over ContextManager.summarizeRange.
+     * Returns token stats before/after; equal before/after means the window was
+     * empty/unresolvable or the summary was rejected.
+     *
+     * Window resolution depends on whether the caller supplied anchors:
+     * - With `anchors`, the caller's `range` is IGNORED and the window is
+     *   resolved from the client-message-id anchors over a fresh, marker-aware
+     *   transcript replay. Callers (the pet segment closure) compute index
+     *   ranges over the RAW transcript message list, whose indices grow
+     *   forever — but the live list is trimmed by every persisted marker
+     *   (replay after restart) and by each in-process archival, so a raw index
+     *   range clamps to an empty window or, worse, onto the WRONG tail
+     *   messages, which would then be persistently mis-summarized against
+     *   correct anchors. Anchors are the only stable coordinates.
+     * - Without `anchors`, legacy behavior: `range` is a half-open index window
+     *   over the cached/in-process message list, and nothing is persisted.
      */
     archiveTurnRange(sessionId: string, range: {
         start: number;
         end: number;
+    }, anchors?: {
+        toClientMessageId: string;
+        fromClientMessageId?: string;
+        segmentId?: string;
     }): Promise<{
         before: number;
         after: number;
     }>;
+    /**
+     * Guard against writing a marker anchored to a client message id the
+     * transcript doesn't actually contain. toMessages()'s replay silently
+     * ignores a range_archive event whose anchor doesn't resolve (fail open),
+     * so a bad anchor wouldn't corrupt anything on its own — but if the marker
+     * carries a segmentId, appendRangeArchive's idempotency check treats that
+     * segmentId as "already recorded" forever, with no retry path (e.g. a
+     * one-time migration keyed "migration-v1" would be permanently burned on
+     * its first, failed attempt). Reject before writing so the caller can
+     * retry with a corrected anchor. fromClientMessageId is optional in the
+     * data model (absent means "from the beginning"), so only validate it when
+     * present; missing it is fail-open by design, same as the replay path.
+     */
+    private hasLiveArchiveAnchors;
+    /**
+     * Persist an archive boundary WITHOUT a summarization call — the caller
+     * already has the summary text (e.g. the one-time migration built from
+     * pet journal entries). Wraps the plain text in the anchored-summary
+     * envelope so replay and rolling-merge treat it like a real archive.
+     * Returns false when the segmentId was already recorded (idempotent) OR
+     * when the anchors don't resolve to real messages in this transcript —
+     * see hasLiveArchiveAnchors for why a dead anchor must be rejected before
+     * the (potentially one-shot) segmentId gets burned.
+     */
+    appendArchiveMarker(sessionId: string, marker: {
+        summary: string;
+        toClientMessageId: string;
+        fromClientMessageId?: string;
+        segmentId?: string;
+    }): Promise<boolean>;
     private recordCacheReadDiagnostics;
     private getSettingsManager;
     /**

package/dist/engine/engine.js

@@ -12,6 +12,7 @@ import { enqueueSteerItem, consumeSteerItems, removeSteerItem, } from "./steer-q
 import { RunEnvironmentResolver } from "./run-environment.js";
 import { BUILTIN_TOOLS, } from "../tool-system/builtin/index.js";
 import { asyncAgentRegistry } from "../tool-system/builtin/agent-registry.js";
+import { skillToolDef } from "../tool-system/builtin/skill.js";
 import { backgroundShellManager } from "../runtime/background-shell.js";
 import { notificationQueue } from "../tool-system/builtin/agent-notifications.js";
 import { HookRegistry } from "../hooks/registry.js";
@@ -20,7 +21,7 @@ import { loadPluginHooks } from "../plugins/loadPluginHooks.js";
 import { pluginAgentDirs } from "../plugins/installer/loadPluginAgents.js";
 import { runShellHook, shellHookMatches } from "../hooks/shell-runner.js";
 import { ContextManager } from "../context/manager.js";
-import { CONTEXT_PACKAGE_MAX_OUTPUT_TOKENS, buildContextPackagePromptFromSerialized, estimateTokens, groupMessagesByApiRound, serializeContextPackageMessages, clampContextRatios as clampContextRatiosImpl, } from "../context/compaction.js";
+import { CONTEXT_PACKAGE_MAX_OUTPUT_TOKENS, buildAnchoredSummaryMessage, buildContextPackagePromptFromSerialized, estimateTokens, groupMessagesByApiRound, serializeContextPackageMessages, clampContextRatios as clampContextRatiosImpl, } from "../context/compaction.js";
 import { PromptComposer } from "../prompt/composer.js";
 import { SessionManager, assertSafeSessionId, isEphemeralSessionState, sessionsRoot, } from "../session/session-manager.js";
 import { createRunUsageAccounting, wireRunModelFacade } from "./run-accounting.js";
@@ -1935,6 +1936,10 @@ export class Engine {
                 (visibilityStoredGoal !== undefined && visibilityStoredGoal.paused !== true) ||
                 (visibilityDefaultGoal !== undefined && visibilityDefaultGoal.paused !== true));
         const { disabledSkills, disabledPlugins } = this.readDisabledLists(cwd, sessionProfileOverrides);
+        // A profile whose tool allowlist excludes the Skill tool can never invoke
+        // a skill, so the full skills listing would be dead context for every one
+        // of its turns (e.g. the Pet manager) — inject none via an empty allowlist.
+        const profileCanUseSkills = !profile?.allowedToolNames || profile.allowedToolNames.has(skillToolDef.name);
         const promptComposer = new PromptComposer(buildPromptComposerConfig({
             cwd,
             model: this.config.llm.model,
@@ -1954,8 +1959,9 @@ export class Engine {
             instructionBoundaryFinder: (scanCwd) => resolveInstructionBoundary(scanCwd, this.capabilities),
             disabledSkills,
             disabledPlugins,
-            skillAllowlist: this.config.skillAllowlist,
+            skillAllowlist: profileCanUseSkills ? this.config.skillAllowlist : [],
             memoriesMaxAgeDays: this.readMemoriesConfig()?.maxAge,
+            memoryCurrentProjectOnly: profile?.memoryCurrentProjectOnly,
             goalToolState: !profile?.allowedToolNames ||
                 profile.allowedToolNames.has("complete_goal") ||
                 profile.allowedToolNames.has("cancel_goal")
@@ -2228,13 +2234,28 @@ export class Engine {
      * Switch the active model by pool key. Takes effect on the next run() call.
      * Returns the new model entry.
      *
+     * Per-session switches (`persist:false`) must not mutate the shared
+     * ModelPool active key. Every desktop ChatSession owns an Engine, but those
+     * Engines share one runtime pool; changing the pool selection here made the
+     * next newly-created Session inherit whichever model another Session had
+     * just selected (for example a Mimi manager model leaking into its delegated
+     * Work Session).
+     *
      * Persists settings.defaults.text (= the connection id / pool key) so the
      * next process startup defaults to the same model — without this, switches
      * only live in memory and every restart reverts to the previously persisted
      * defaults.text.
      */
     switchModel(key, opts) {
-        const entry = this.modelPool.switch(key);
+        const perSession = opts?.persist === false;
+        const entry = perSession ? this.modelPool.get(key) : this.modelPool.switch(key);
+        if (!entry) {
+            const available = this.modelPool
+                .list()
+                .map((candidate) => candidate.key)
+                .join(", ");
+            throw new Error(`Model "${key}" not found. Available: ${available}`);
+        }
         // LLMConfig is pure model identity now — rotate it wholesale. Cross-model
         // runtime knobs (temperature/timeout/retryMaxAttempts/imageDetail) live on
         // this.config.clientDefaults and survive the switch untouched.
@@ -2243,7 +2264,7 @@ export class Engine {
         // persist: false is the per-session path (ChatSession) — switching one
         // session's model must not rewrite settings.defaults.text, the boot
         // default every future session inherits.
-        if (opts?.persist !== false)
+        if (!perSession)
             this.persistActiveModel(entry);
         return entry;
     }
@@ -2839,33 +2860,149 @@ export class Engine {
         return contextManager;
     }
     /**
-     * Archive a caller-chosen contiguous message-index window `[range.start,
-     * range.end)` of a session into a single anchored summary, leaving everything
-     * outside the window untouched, and cache the result so a later
-     * forceCompact/resume reads the archived history. This is a generic
-     * range-archival facade over ContextManager.summarizeRange — the caller
-     * decides which span to collapse (the range is a half-open message-index
-     * window, matching summarizeRange). Returns token stats before/after; equal
-     * before/after means the window was empty or the summary was rejected.
-     */
-    async archiveTurnRange(sessionId, range) {
+     * Archive a contiguous message window of a session into a single anchored
+     * summary, leaving everything outside the window untouched, and cache the
+     * result so a later forceCompact/resume reads the archived history. This is
+     * a generic range-archival facade over ContextManager.summarizeRange.
+     * Returns token stats before/after; equal before/after means the window was
+     * empty/unresolvable or the summary was rejected.
+     *
+     * Window resolution depends on whether the caller supplied anchors:
+     * - With `anchors`, the caller's `range` is IGNORED and the window is
+     *   resolved from the client-message-id anchors over a fresh, marker-aware
+     *   transcript replay. Callers (the pet segment closure) compute index
+     *   ranges over the RAW transcript message list, whose indices grow
+     *   forever — but the live list is trimmed by every persisted marker
+     *   (replay after restart) and by each in-process archival, so a raw index
+     *   range clamps to an empty window or, worse, onto the WRONG tail
+     *   messages, which would then be persistently mis-summarized against
+     *   correct anchors. Anchors are the only stable coordinates.
+     * - Without `anchors`, legacy behavior: `range` is a half-open index window
+     *   over the cached/in-process message list, and nothing is persisted.
+     */
+    async archiveTurnRange(sessionId, range, anchors) {
         const effectiveSessionId = sessionId || this.lastSessionId;
         if (!effectiveSessionId)
             return { before: 0, after: 0 };
         const session = this.sessionManager.resume(effectiveSessionId);
-        const sourceMessages = this.compactedMessagesBySession.get(effectiveSessionId) ?? session.transcript.toMessages();
+        let sourceMessages;
+        let window;
+        if (anchors) {
+            const { messages: liveMessages, liveIndexByClientMessageId } = session.transcript.toMessagesWithIndex();
+            sourceMessages = liveMessages;
+            // An absent from-anchor means "from the beginning" — over the live
+            // list that is index 0, which includes any previously replayed
+            // from-less summary at the head, so summarizeRange merge-feeds it
+            // (extractAnchoredSummary) instead of losing it.
+            const start = anchors.fromClientMessageId !== undefined
+                ? liveIndexByClientMessageId.get(anchors.fromClientMessageId)
+                : 0;
+            const end = liveIndexByClientMessageId.get(anchors.toClientMessageId);
+            if (start === undefined || end === undefined || end <= start) {
+                // Fail open: no summarization, no persistence. Falling back to the
+                // caller's raw range is exactly the bug this path exists to fix —
+                // it would summarize the wrong messages and persist that against
+                // the (correct) anchors, with segmentId dedupe blocking correction.
+                logger.warn("engine.archive_range.anchor_window_unresolved", {
+                    sessionId: effectiveSessionId,
+                    segmentId: anchors.segmentId,
+                    fromClientMessageId: anchors.fromClientMessageId,
+                    toClientMessageId: anchors.toClientMessageId,
+                });
+                const before = estimateTokens(sourceMessages);
+                return { before, after: before };
+            }
+            window = { start, end };
+        }
+        else {
+            sourceMessages =
+                this.compactedMessagesBySession.get(effectiveSessionId) ?? session.transcript.toMessages();
+            window = range;
+        }
         const before = estimateTokens(sourceMessages);
         const contextManager = await this.prepareContextManagerForSession(effectiveSessionId, session, sourceMessages, "archive_range");
         // Range archival is initiated deliberately, not by a pressure heuristic;
         // don't let a stale run callback retained on lastContextManager double-emit.
         contextManager.setOnCompact(() => { });
-        const archived = await contextManager.summarizeRange(sourceMessages, range);
+        const archived = await contextManager.summarizeRange(sourceMessages, window);
         const after = estimateTokens(archived);
+        // Persist the boundary so a restart replays the trimmed context. Only when
+        // summarizeRange actually replaced the span (identity return means empty
+        // window / rejected summary / no summarizer available) and the caller
+        // supplied stable anchors to record it against.
+        if (anchors && archived !== sourceMessages) {
+            const clampedStart = Math.max(0, Math.min(window.start, archived.length - 1));
+            const summaryMessage = archived[clampedStart];
+            const summaryText = typeof summaryMessage?.content === "string" ? summaryMessage.content : undefined;
+            if (summaryText && this.hasLiveArchiveAnchors(session, anchors)) {
+                session.transcript.appendRangeArchive({ summary: summaryText, ...anchors });
+            }
+        }
+        // In the anchored path this replaces any in-process-only cache state with
+        // the fresh-replay-based result — safe, because the transcript is the
+        // superset of the cache and pressure compaction re-runs if needed.
         this.compactedMessagesBySession.set(effectiveSessionId, archived);
         this.lastSessionId = effectiveSessionId;
         this.lastMessages = archived;
         return { before, after };
     }
+    /**
+     * Guard against writing a marker anchored to a client message id the
+     * transcript doesn't actually contain. toMessages()'s replay silently
+     * ignores a range_archive event whose anchor doesn't resolve (fail open),
+     * so a bad anchor wouldn't corrupt anything on its own — but if the marker
+     * carries a segmentId, appendRangeArchive's idempotency check treats that
+     * segmentId as "already recorded" forever, with no retry path (e.g. a
+     * one-time migration keyed "migration-v1" would be permanently burned on
+     * its first, failed attempt). Reject before writing so the caller can
+     * retry with a corrected anchor. fromClientMessageId is optional in the
+     * data model (absent means "from the beginning"), so only validate it when
+     * present; missing it is fail-open by design, same as the replay path.
+     */
+    hasLiveArchiveAnchors(session, anchors) {
+        if (!session.transcript.hasClientMessageId(anchors.toClientMessageId))
+            return false;
+        if (anchors.fromClientMessageId !== undefined &&
+            !session.transcript.hasClientMessageId(anchors.fromClientMessageId)) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Persist an archive boundary WITHOUT a summarization call — the caller
+     * already has the summary text (e.g. the one-time migration built from
+     * pet journal entries). Wraps the plain text in the anchored-summary
+     * envelope so replay and rolling-merge treat it like a real archive.
+     * Returns false when the segmentId was already recorded (idempotent) OR
+     * when the anchors don't resolve to real messages in this transcript —
+     * see hasLiveArchiveAnchors for why a dead anchor must be rejected before
+     * the (potentially one-shot) segmentId gets burned.
+     */
+    async appendArchiveMarker(sessionId, marker) {
+        const session = this.sessionManager.resume(sessionId);
+        if (!this.hasLiveArchiveAnchors(session, marker)) {
+            logger.warn("engine.archive_marker.dead_anchor", {
+                sessionId,
+                segmentId: marker.segmentId,
+                toClientMessageId: marker.toClientMessageId,
+                fromClientMessageId: marker.fromClientMessageId,
+            });
+            return false;
+        }
+        const wrapped = buildAnchoredSummaryMessage(marker.summary, {
+            ...(session.transcript.isPersistent()
+                ? { transcriptPath: session.transcript.getFilePath() }
+                : {}),
+        });
+        const content = typeof wrapped.content === "string" ? wrapped.content : marker.summary;
+        const appended = session.transcript.appendRangeArchive({ ...marker, summary: content });
+        if (!appended)
+            return false;
+        // The in-memory cache (if any) predates the marker; drop it so the next
+        // run rebuilds from the trimmed transcript replay.
+        this.compactedMessagesBySession.delete(sessionId);
+        return true;
+    }
     recordCacheReadDiagnostics(sessionId, sample) {
         const result = this.promptCacheDiagnostics.record(sessionId, sample);
         if (result.kind === "scope_changed") {

package/dist/engine/run-setup.d.ts

@@ -32,6 +32,7 @@ export interface RunPromptComposerConfigInput {
     disabledPlugins: ComposerOptions["disabledPlugins"];
     skillAllowlist: ComposerOptions["skillAllowlist"];
     memoriesMaxAgeDays: ComposerOptions["memoriesMaxAgeDays"];
+    memoryCurrentProjectOnly?: ComposerOptions["memoryCurrentProjectOnly"];
     goalToolState: ComposerOptions["goalToolState"];
     capabilityPromptSections: ComposerOptions["capabilityPromptSections"];
     dynamicContextProviders: ComposerOptions["dynamicContextProviders"];

package/dist/engine/run-setup.js

@@ -23,7 +23,7 @@ export function resolveRunProfileState(args) {
 }
 /** Build the prompt-composer options for a run without capturing the Engine facade. */
 export function buildPromptComposerConfig(args) {
-    const { cwd, model, preset, customSystemPrompt, appendSystemPrompt, responseLanguage, userProfile, workspaceProfile, sessionBrief, profileMemoryDir, instructionCompatFileNames, instructionBoundaryFinder, disabledSkills, disabledPlugins, skillAllowlist, memoriesMaxAgeDays, goalToolState, capabilityPromptSections, dynamicContextProviders, getSettingsManager, toolCatalog, } = args;
+    const { cwd, model, preset, customSystemPrompt, appendSystemPrompt, responseLanguage, userProfile, workspaceProfile, sessionBrief, profileMemoryDir, instructionCompatFileNames, instructionBoundaryFinder, disabledSkills, disabledPlugins, skillAllowlist, memoriesMaxAgeDays, memoryCurrentProjectOnly, goalToolState, capabilityPromptSections, dynamicContextProviders, getSettingsManager, toolCatalog, } = args;
     return {
         cwd,
         model,
@@ -49,6 +49,7 @@ export function buildPromptComposerConfig(args) {
         disabledPlugins,
         skillAllowlist,
         memoriesMaxAgeDays,
+        memoryCurrentProjectOnly,
         goalToolState,
         capabilityPromptSections,
         dynamicContextProviders,

package/dist/engine/run-types.d.ts

@@ -32,6 +32,13 @@ export interface RunBehaviorProfile {
     disablePlanMode?: boolean;
     /** When true, MCP servers are neither connected nor exposed for the run. */
     disableMcp?: boolean;
+    /**
+     * When true, the injected persistent-memory index is trimmed to this run's
+     * project: global-layer project-type / dream-scope records tied to other
+     * projects are dropped. Meant for manager-style profiles whose runs never
+     * work inside other repos.
+     */
+    memoryCurrentProjectOnly?: boolean;
     /**
      * Wrapper tag for host-provided runtime context injected at the system
      * prompt tail (e.g. "pet-world"). Injection happens only when both this tag

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

@@ -202,9 +202,6 @@ 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 { createHash, randomUUID } from "node:crypto";
+import { 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,39 +40,6 @@ 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;
@@ -109,9 +76,6 @@ 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
@@ -1445,49 +1409,6 @@ 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.6";
+export declare const VERSION = "0.8.8";
 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.6";
+export const VERSION = "0.8.8";
 // ─── Exceptions ──────────────────────────────────────────────────
 export { FrameworkError, LLMError, LLMRateLimitError, ContextLimitError, ToolError, ToolNotFoundError, ToolExecutionError, ToolTimeoutError, PermissionDeniedError, SessionError, TranscriptError, ConfigError, SandboxUnavailableError, } from "./exceptions.js";
 // ─── Engine (primary API) ────────────────────────────────────────