@cjhyy/code-shell-core 0.8.7 → 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.7";
+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.7";
+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) ────────────────────────────────────────

package/dist/panel-apps/manifest.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 export declare const PANEL_APP_MANIFEST_FILE = ".codeshell-panel/panel.json";
-export declare const PANEL_APP_PERMISSIONS: readonly ["context.session", "context.workspace", "storage", "external.open", "agent.submitPrompt", "workspace.info", "workspace.read", "workspace.write", "notifications.send", "credentials.cookies", "automations.manage"];
+export declare const PANEL_APP_PERMISSIONS: readonly ["context.session", "context.workspace", "storage", "external.open", "agent.submitPrompt", "workspace.info", "workspace.read", "workspace.write", "notifications.send", "audio.transcribe", "credentials.cookies", "automations.manage"];
 export declare const PANEL_APP_ICONS: readonly ["panel", "activity", "bar-chart-3", "chart", "file-text", "globe", "image", "layout-dashboard", "line-chart", "palette", "pie-chart", "table", "terminal"];
 export declare const PanelAppAgentTool: z.ZodEffects<z.ZodObject<{
     name: z.ZodString;
@@ -116,12 +116,12 @@ export declare const PanelAppManifest: z.ZodEffects<z.ZodDiscriminatedUnion<"sch
     icon: z.ZodDefault<z.ZodEnum<["panel", "activity", "bar-chart-3", "chart", "file-text", "globe", "image", "layout-dashboard", "line-chart", "palette", "pie-chart", "table", "terminal"]>>;
     placement: z.ZodDefault<z.ZodLiteral<"right-dock">>;
     singleton: z.ZodDefault<z.ZodBoolean>;
-    permissions: z.ZodDefault<z.ZodArray<z.ZodEnum<["context.session", "context.workspace", "storage", "external.open", "agent.submitPrompt", "workspace.info", "workspace.read", "workspace.write", "notifications.send", "credentials.cookies", "automations.manage"]>, "many">>;
+    permissions: z.ZodDefault<z.ZodArray<z.ZodEnum<["context.session", "context.workspace", "storage", "external.open", "agent.submitPrompt", "workspace.info", "workspace.read", "workspace.write", "notifications.send", "audio.transcribe", "credentials.cookies", "automations.manage"]>, "many">>;
     schemaVersion: z.ZodLiteral<1>;
 }, "strict", z.ZodTypeAny, {
     id: string;
     version: string;
-    permissions: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "credentials.cookies" | "automations.manage")[];
+    permissions: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "audio.transcribe" | "credentials.cookies" | "automations.manage")[];
     entry: string;
     title: {
         default: string;
@@ -144,7 +144,7 @@ export declare const PanelAppManifest: z.ZodEffects<z.ZodDiscriminatedUnion<"sch
     };
     schemaVersion: 1;
     description?: string | undefined;
-    permissions?: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "credentials.cookies" | "automations.manage")[] | undefined;
+    permissions?: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "audio.transcribe" | "credentials.cookies" | "automations.manage")[] | undefined;
     icon?: "terminal" | "image" | "panel" | "activity" | "bar-chart-3" | "chart" | "file-text" | "globe" | "layout-dashboard" | "line-chart" | "palette" | "pie-chart" | "table" | undefined;
     placement?: "right-dock" | undefined;
     singleton?: boolean | undefined;
@@ -230,12 +230,12 @@ export declare const PanelAppManifest: z.ZodEffects<z.ZodDiscriminatedUnion<"sch
     icon: z.ZodDefault<z.ZodEnum<["panel", "activity", "bar-chart-3", "chart", "file-text", "globe", "image", "layout-dashboard", "line-chart", "palette", "pie-chart", "table", "terminal"]>>;
     placement: z.ZodDefault<z.ZodLiteral<"right-dock">>;
     singleton: z.ZodDefault<z.ZodBoolean>;
-    permissions: z.ZodDefault<z.ZodArray<z.ZodEnum<["context.session", "context.workspace", "storage", "external.open", "agent.submitPrompt", "workspace.info", "workspace.read", "workspace.write", "notifications.send", "credentials.cookies", "automations.manage"]>, "many">>;
+    permissions: z.ZodDefault<z.ZodArray<z.ZodEnum<["context.session", "context.workspace", "storage", "external.open", "agent.submitPrompt", "workspace.info", "workspace.read", "workspace.write", "notifications.send", "audio.transcribe", "credentials.cookies", "automations.manage"]>, "many">>;
     schemaVersion: z.ZodLiteral<2>;
 }, "strict", z.ZodTypeAny, {
     id: string;
     version: string;
-    permissions: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "credentials.cookies" | "automations.manage")[];
+    permissions: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "audio.transcribe" | "credentials.cookies" | "automations.manage")[];
     entry: string;
     title: {
         default: string;
@@ -276,14 +276,14 @@ export declare const PanelAppManifest: z.ZodEffects<z.ZodDiscriminatedUnion<"sch
         }[] | undefined;
     } | undefined;
     description?: string | undefined;
-    permissions?: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "credentials.cookies" | "automations.manage")[] | undefined;
+    permissions?: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "audio.transcribe" | "credentials.cookies" | "automations.manage")[] | undefined;
     icon?: "terminal" | "image" | "panel" | "activity" | "bar-chart-3" | "chart" | "file-text" | "globe" | "layout-dashboard" | "line-chart" | "palette" | "pie-chart" | "table" | undefined;
     placement?: "right-dock" | undefined;
     singleton?: boolean | undefined;
 }>]>, {
     id: string;
     version: string;
-    permissions: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "credentials.cookies" | "automations.manage")[];
+    permissions: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "audio.transcribe" | "credentials.cookies" | "automations.manage")[];
     entry: string;
     title: {
         default: string;
@@ -298,7 +298,7 @@ export declare const PanelAppManifest: z.ZodEffects<z.ZodDiscriminatedUnion<"sch
 } | {
     id: string;
     version: string;
-    permissions: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "credentials.cookies" | "automations.manage")[];
+    permissions: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "audio.transcribe" | "credentials.cookies" | "automations.manage")[];
     entry: string;
     title: {
         default: string;
@@ -330,7 +330,7 @@ export declare const PanelAppManifest: z.ZodEffects<z.ZodDiscriminatedUnion<"sch
     };
     schemaVersion: 1;
     description?: string | undefined;
-    permissions?: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "credentials.cookies" | "automations.manage")[] | undefined;
+    permissions?: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "audio.transcribe" | "credentials.cookies" | "automations.manage")[] | undefined;
     icon?: "terminal" | "image" | "panel" | "activity" | "bar-chart-3" | "chart" | "file-text" | "globe" | "layout-dashboard" | "line-chart" | "palette" | "pie-chart" | "table" | undefined;
     placement?: "right-dock" | undefined;
     singleton?: boolean | undefined;
@@ -354,7 +354,7 @@ export declare const PanelAppManifest: z.ZodEffects<z.ZodDiscriminatedUnion<"sch
         }[] | undefined;
     } | undefined;
     description?: string | undefined;
-    permissions?: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "credentials.cookies" | "automations.manage")[] | undefined;
+    permissions?: ("context.session" | "context.workspace" | "storage" | "external.open" | "agent.submitPrompt" | "workspace.info" | "workspace.read" | "workspace.write" | "notifications.send" | "audio.transcribe" | "credentials.cookies" | "automations.manage")[] | undefined;
     icon?: "terminal" | "image" | "panel" | "activity" | "bar-chart-3" | "chart" | "file-text" | "globe" | "layout-dashboard" | "line-chart" | "palette" | "pie-chart" | "table" | undefined;
     placement?: "right-dock" | undefined;
     singleton?: boolean | undefined;

package/dist/panel-apps/manifest.js

@@ -11,6 +11,7 @@ export const PANEL_APP_PERMISSIONS = [
     "workspace.read",
     "workspace.write",
     "notifications.send",
+    "audio.transcribe",
     "credentials.cookies",
     "automations.manage",
 ];
@@ -180,12 +181,13 @@ export const PanelAppManifest = z
         });
     }
     if ((value.permissions.includes("workspace.read") ||
-        value.permissions.includes("workspace.write")) &&
+        value.permissions.includes("workspace.write") ||
+        value.permissions.includes("audio.transcribe")) &&
         !value.permissions.includes("context.workspace")) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             path: ["permissions"],
-            message: "workspace.read and workspace.write require context.workspace",
+            message: "workspace.read, workspace.write, and audio.transcribe require context.workspace",
         });
     }
     if (value.permissions.includes("automations.manage") &&

package/dist/prompt/composer.d.ts

@@ -89,6 +89,13 @@ export interface ComposerOptions {
      * Undefined/0 → inject all.
      */
     memoriesMaxAgeDays?: number;
+    /**
+     * When true (set from the active behavior profile, e.g. the Pet manager),
+     * the injected memory index keeps only memories relevant to this cwd —
+     * global-layer project/dream records tied to other projects are dropped.
+     * See MemoryManager.buildInjectionIndex(currentProjectOnly).
+     */
+    memoryCurrentProjectOnly?: boolean;
 }
 export declare class PromptComposer {
     private readonly options;

package/dist/prompt/composer.js

@@ -102,18 +102,24 @@ export class PromptComposer {
         });
         const skillsListing = buildSkillListing(skills);
         const declaredSkillGap = this.buildDeclaredSkillGap(skills);
-        const capabilityContext = await this.buildSystemContext();
+        // Capability and sources context are independent I/O — resolve them
+        // concurrently instead of serially.
+        const [capabilityContext, sourcesContext] = await Promise.all([
+            this.buildSystemContext(),
+            (async () => {
+                try {
+                    return (await this.options.sourcesContextProvider?.()) ?? "";
+                }
+                catch {
+                    // Optional metadata context must not make a turn fail.
+                    return "";
+                }
+            })(),
+        ]);
         // Memory rides here (tail, past the cache breakpoint) — not the system
         // prefix — so a memory change (extraction / recall usage++ / approve) never
         // re-bills the cached prefix. See buildUserContextMessage for the rationale.
         const memoryContext = this.getMemoryContext();
-        let sourcesContext = "";
-        try {
-            sourcesContext = (await this.options.sourcesContextProvider?.()) ?? "";
-        }
-        catch {
-            // Optional metadata context must not make a turn fail.
-        }
         const goalToolContext = this.buildGoalToolContext();
         const parts = [
             skillsListing,
@@ -268,6 +274,7 @@ export class PromptComposer {
                 projectDir: this.options.cwd,
                 profileDir: this.options.profileMemoryDir,
                 maxAgeDays: this.options.memoriesMaxAgeDays,
+                currentProjectOnly: this.options.memoryCurrentProjectOnly,
             });
         }
         catch {

package/dist/protocol/server.js

@@ -2240,7 +2240,17 @@ export class AgentServer {
                 if (!archiveEngine)
                     return;
                 try {
-                    const result = await archiveEngine.archiveTurnRange(archiveSessionId, { start, end });
+                    const toClientMessageId = typeof params.toClientMessageId === "string" ? params.toClientMessageId : undefined;
+                    const anchors = toClientMessageId
+                        ? {
+                            toClientMessageId,
+                            ...(typeof params.fromClientMessageId === "string"
+                                ? { fromClientMessageId: params.fromClientMessageId }
+                                : {}),
+                            ...(typeof params.segmentId === "string" ? { segmentId: params.segmentId } : {}),
+                        }
+                        : undefined;
+                    const result = await archiveEngine.archiveTurnRange(archiveSessionId, { start, end }, anchors);
                     if (result.before > result.after) {
                         const event = {
                             type: "context_compact",
@@ -2265,6 +2275,35 @@ export class AgentServer {
                 }
                 break;
             }
+            case "archive_marker": {
+                const markerSessionId = typeof params.sessionId === "string" && params.sessionId.length > 0
+                    ? params.sessionId
+                    : undefined;
+                const summary = typeof params.summary === "string" ? params.summary : undefined;
+                const toClientMessageId = typeof params.toClientMessageId === "string" ? params.toClientMessageId : undefined;
+                if (!markerSessionId || !summary || !toClientMessageId) {
+                    this.transport.send(createErrorResponse(req.id, ErrorCodes.InvalidParams, "archive_marker requires sessionId, summary and toClientMessageId"));
+                    return;
+                }
+                const markerEngine = await this.resolveEngineForSessionQuery(req, markerSessionId, engine, "archive_marker");
+                if (!markerEngine)
+                    return;
+                try {
+                    const appended = await markerEngine.appendArchiveMarker(markerSessionId, {
+                        summary,
+                        toClientMessageId,
+                        ...(typeof params.fromClientMessageId === "string"
+                            ? { fromClientMessageId: params.fromClientMessageId }
+                            : {}),
+                        ...(typeof params.segmentId === "string" ? { segmentId: params.segmentId } : {}),
+                    });
+                    this.transport.send(createResponse(req.id, { type: "archive_marker", data: { appended } }));
+                }
+                catch (err) {
+                    this.transport.send(createErrorResponse(req.id, ErrorCodes.InternalError, err.message));
+                }
+                break;
+            }
             case "models": {
                 if (!engine) {
                     this.transport.send(createErrorResponse(req.id, ErrorCodes.InternalError, "No engine available for models query"));

package/dist/protocol/types.d.ts

@@ -342,6 +342,20 @@ export interface QueryParams {
     start?: unknown;
     /** Used by archive_range: half-open message-index window end (exclusive). */
     end?: unknown;
+    /**
+     * Used by archive_range (optional) and archive_marker (required): the
+     * clientMessageId the archived/marked span ends at. archive_range only
+     * persists a boundary when this anchor is supplied and resolves to a live
+     * message; without it, archive_range behaves exactly as before (in-memory
+     * compaction only, no persisted range_archive event).
+     */
+    toClientMessageId?: string;
+    /** Used by archive_range / archive_marker: optional start-of-span anchor. */
+    fromClientMessageId?: string;
+    /** Used by archive_range / archive_marker: optional idempotency key. */
+    segmentId?: string;
+    /** Used by archive_marker: the summary text to persist without a model call. */
+    summary?: string;
 }
 export interface QueryResult {
     type: string;

package/dist/session/memory.d.ts

@@ -233,6 +233,16 @@ export declare class MemoryManager {
         baseDir?: string;
         maxAgeDays?: number;
         now?: number;
+        /**
+         * Trim the global layer to what is relevant to this run's project:
+         * project-type and dream-scope records are per-project experience, so
+         * they are kept only when their origin metadata ties them to
+         * `projectDir`. General knowledge (user/feedback/reference in user
+         * scope) always stays; the project layer is untouched because it is
+         * already this project's own store. Set by behavior profiles whose runs
+         * never work inside other repos (e.g. a manager/dispatcher session).
+         */
+        currentProjectOnly?: boolean;
     }): string;
     /**
      * Load every entry belonging to the given scope, without changing the

package/dist/session/memory.js

@@ -651,7 +651,13 @@ export class MemoryManager {
         const profile = opts.profileDir ? new MemoryManager({ baseDir: opts.profileDir }) : null;
         const pinnedFirst = (a, b) => Number(b.pinned ?? false) - Number(a.pinned ?? false);
         const collect = (mm) => filterByAge([...mm.loadScope("user"), ...mm.loadScope("dream")], opts.maxAgeDays, opts.now).sort(pinnedFirst);
-        const globalEntries = collect(global);
+        let globalEntries = collect(global);
+        if (opts.currentProjectOnly) {
+            const tiedToProject = (e) => opts.projectDir !== undefined &&
+                (e.originProject === opts.projectDir ||
+                    (e.originProjects?.includes(opts.projectDir) ?? false));
+            globalEntries = globalEntries.filter((e) => (e.type !== "project" && e.scope !== "dream") || tiedToProject(e));
+        }
         const profileEntries = profile ? collect(profile) : [];
         const projectEntries = project ? collect(project) : [];
         if (globalEntries.length === 0 && profileEntries.length === 0 && projectEntries.length === 0) {

package/dist/session/session-manager.js

@@ -154,6 +154,7 @@ const FORK_COPY_EVENT_TYPES = new Set([
     "tool_result",
     "summary",
     "context_transfer",
+    "range_archive",
     "content_replace",
     "subagent",
     "external_file_changes",

package/dist/session/transcript.d.ts

@@ -106,12 +106,48 @@ export declare class Transcript {
      */
     appendTurnStopped(): TranscriptEvent | undefined;
     appendSummary(summary: string, metadata: SummaryAppendMetadata): TranscriptEvent;
+    /**
+     * Persist a range-archival boundary. Span is [fromClientMessageId,
+     * toClientMessageId) over message events; an absent from means "from the
+     * beginning". Idempotent on segmentId so a crash-replayed closure cannot
+     * double-archive.
+     */
+    appendRangeArchive(data: {
+        summary: string;
+        toClientMessageId: string;
+        fromClientMessageId?: string;
+        segmentId?: string;
+    }): TranscriptEvent | undefined;
     appendError(error: string, details?: Record<string, unknown>): TranscriptEvent;
     /**
      * Derive Message[] from transcript events for sending to the LLM.
      * This is the critical boundary: the LLM never sees the event log directly.
      */
     toMessages(): Message[];
+    /**
+     * Marker-aware replay that ALSO reports, for every emitted message event
+     * carrying a clientMessageId, the LIVE index (its position in the returned
+     * messages array) of its FIRST emission. This is how the engine resolves an
+     * anchored archival window: raw transcript indices grow forever and go stale
+     * the moment a range_archive marker trims the replay, so any caller-held
+     * index range is meaningless — only client-message-id anchors resolved over
+     * THIS replay identify the right span.
+     *
+     * Contract details:
+     * - Messages dropped inside an archived span get NO index entry — they are
+     *   not in the live list, so a window anchored on them cannot be built
+     *   (the engine fails open in that case).
+     * - Only the FIRST emission of a duplicated clientMessageId is recorded
+     *   (duplicates replay as plain messages per the one-shot span rule; the
+     *   first index is the meaningful one).
+     * - The clientMessageId is deliberately NOT attached to the Message objects
+     *   themselves: Message[] is exactly what gets serialized into LLM request
+     *   payloads, and transport metadata must not leak into them.
+     */
+    toMessagesWithIndex(): {
+        messages: Message[];
+        liveIndexByClientMessageId: Map<string, number>;
+    };
     getEvents(type?: TranscriptEventType): TranscriptEvent[];
     get turnNumber(): number;
     get eventCount(): number;

package/dist/session/transcript.js

@@ -12,6 +12,7 @@ const CONTEXT_EVENT_TYPES = new Set([
     "tool_result",
     "summary",
     "context_transfer",
+    "range_archive",
 ]);
 const INTERRUPTED_TOOL_RESULT_ERROR = "[Tool result missing due to interrupted session]";
 function isSyntheticInterruptedToolResult(event) {
@@ -212,6 +213,19 @@ export class Transcript {
             },
         });
     }
+    /**
+     * Persist a range-archival boundary. Span is [fromClientMessageId,
+     * toClientMessageId) over message events; an absent from means "from the
+     * beginning". Idempotent on segmentId so a crash-replayed closure cannot
+     * double-archive.
+     */
+    appendRangeArchive(data) {
+        if (data.segmentId &&
+            this.events.some((e) => e.type === "range_archive" && e.data.segmentId === data.segmentId)) {
+            return undefined;
+        }
+        return this.append("range_archive", { ...data });
+    }
     appendError(error, details) {
         return this.append("error", { error, ...details });
     }
@@ -220,12 +234,128 @@ export class Transcript {
      * This is the critical boundary: the LLM never sees the event log directly.
      */
     toMessages() {
+        return this.toMessagesWithIndex().messages;
+    }
+    /**
+     * Marker-aware replay that ALSO reports, for every emitted message event
+     * carrying a clientMessageId, the LIVE index (its position in the returned
+     * messages array) of its FIRST emission. This is how the engine resolves an
+     * anchored archival window: raw transcript indices grow forever and go stale
+     * the moment a range_archive marker trims the replay, so any caller-held
+     * index range is meaningless — only client-message-id anchors resolved over
+     * THIS replay identify the right span.
+     *
+     * Contract details:
+     * - Messages dropped inside an archived span get NO index entry — they are
+     *   not in the live list, so a window anchored on them cannot be built
+     *   (the engine fails open in that case).
+     * - Only the FIRST emission of a duplicated clientMessageId is recorded
+     *   (duplicates replay as plain messages per the one-shot span rule; the
+     *   first index is the meaningful one).
+     * - The clientMessageId is deliberately NOT attached to the Message objects
+     *   themselves: Message[] is exactly what gets serialized into LLM request
+     *   payloads, and transport metadata must not leak into them.
+     */
+    toMessagesWithIndex() {
         const messages = [];
+        const liveIndexByClientMessageId = new Map();
         const selectedToolResults = preferredToolResults(this.events);
+        const hasRangeArchive = this.events.some((e) => e.type === "range_archive");
+        const spansByFromId = new Map();
+        let openingSpan;
+        if (hasRangeArchive) {
+            // First-occurrence event index per client message id, so a marker whose
+            // `to` does not come strictly after its `from` (out of order, or a
+            // degenerate from === to) can be rejected. Without this check the span
+            // opens at `from` but its close condition (`to`) was already passed
+            // while scanning forward, so it would never close — silently swallowing
+            // the rest of the conversation. Fail open instead: ignore the marker.
+            const firstIndexByClientId = new Map();
+            for (const [index, event] of this.events.entries()) {
+                if (event.type === "message" && typeof event.data.clientMessageId === "string") {
+                    if (!firstIndexByClientId.has(event.data.clientMessageId)) {
+                        firstIndexByClientId.set(event.data.clientMessageId, index);
+                    }
+                }
+            }
+            const presentClientIds = new Set(firstIndexByClientId.keys());
+            for (const event of this.events) {
+                if (event.type !== "range_archive")
+                    continue;
+                const { summary, toClientMessageId, fromClientMessageId } = event.data;
+                if (typeof summary !== "string" || !presentClientIds.has(toClientMessageId))
+                    continue;
+                if (fromClientMessageId === undefined) {
+                    // Multiple from-less markers compete for this single opening-span
+                    // slot; the LAST one wins (matching spansByFromId's Map.set
+                    // semantics below). Last-wins is CORRECT by construction, not
+                    // merely a tiebreak: the engine resolves a from-less archival
+                    // window as [0, to) over the LIVE replay, so the window that
+                    // produced a LATER from-less marker began with the EARLIER
+                    // marker's replayed summary message, and summarizeRange merge-fed
+                    // that prior summary (extractAnchoredSummary) into the new one.
+                    // The later summary therefore already contains the earlier one's
+                    // content — dropping the earlier marker here loses nothing. (And
+                    // in production from-less windows only advance: each new marker
+                    // ends at a later boundary, so the surviving span is the widest.)
+                    openingSpan = { summary, toClientMessageId };
+                }
+                else if (presentClientIds.has(fromClientMessageId)) {
+                    const fromIndex = firstIndexByClientId.get(fromClientMessageId);
+                    const toIndex = firstIndexByClientId.get(toClientMessageId);
+                    if (toIndex <= fromIndex)
+                        continue; // out of order or degenerate: fail open
+                    spansByFromId.set(fromClientMessageId, { summary, toClientMessageId });
+                }
+            }
+        }
+        let activeSpan = null;
+        if (openingSpan) {
+            activeSpan = openingSpan;
+            messages.push({ role: "user", content: openingSpan.summary });
+        }
+        // tool_use ids actually emitted into assistant message content blocks so
+        // far. A tool_result whose tool_use_id isn't in this set — e.g. because
+        // its opening tool_use fell inside an archived span while the (later,
+        // preferred) real result landed outside it — would be an orphaned block
+        // that breaks provider validation; skip it instead of emitting it.
+        const emittedToolUseIds = new Set();
         for (const event of this.events) {
+            // Span bookkeeping runs on message events only: exit before entry so
+            // adjacent spans (A.to === B.from) hand over on the boundary message.
+            if (event.type === "message") {
+                const clientMessageId = typeof event.data.clientMessageId === "string" ? event.data.clientMessageId : undefined;
+                if (activeSpan && clientMessageId === activeSpan.toClientMessageId) {
+                    activeSpan = null;
+                }
+                if (!activeSpan && clientMessageId && spansByFromId.has(clientMessageId)) {
+                    activeSpan = spansByFromId.get(clientMessageId);
+                    // One-shot: a duplicate `from` message (e.g. from a torn JSONL
+                    // reload) must not reopen this span a second time — it would have
+                    // no more `to` ahead of it and swallow the rest of the transcript.
+                    spansByFromId.delete(clientMessageId);
+                    messages.push({ role: "user", content: activeSpan.summary });
+                }
+            }
+            if (activeSpan)
+                continue; // archived span: drop every context event inside
             switch (event.type) {
                 case "message": {
-                    const { role, content } = event.data;
+                    const { role, content, clientMessageId } = event.data;
+                    // Record the live index of this message's FIRST emission before
+                    // pushing it (the index it is about to occupy). Dropped-in-span
+                    // messages never reach this point, so they get no entry.
+                    if (typeof clientMessageId === "string" &&
+                        !liveIndexByClientMessageId.has(clientMessageId)) {
+                        liveIndexByClientMessageId.set(clientMessageId, messages.length);
+                    }
+                    if (role === "assistant" && Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === "tool_use" && typeof block.id === "string") {
+                                emittedToolUseIds.add(block.id);
+                            }
+                        }
+                    }
                     messages.push({ role: role, content });
                     break;
                 }
@@ -237,7 +367,8 @@ export class Transcript {
                 case "tool_result": {
                     const eventToolCallId = event.data.toolCallId;
                     if (typeof eventToolCallId !== "string" ||
-                        selectedToolResults.get(eventToolCallId) !== event) {
+                        selectedToolResults.get(eventToolCallId) !== event ||
+                        !emittedToolUseIds.has(eventToolCallId)) {
                         break;
                     }
                     const { toolCallId, result, error, contentBlocks } = event.data;
@@ -280,10 +411,12 @@ export class Transcript {
                     break;
                 }
                 // turn_boundary, run_result, session_meta, file_history, plan_operation, error
-                // are not included in LLM messages
+                // are not included in LLM messages. range_archive is handled entirely
+                // by the pre-pass above (it emits the summary at span entry and drops
+                // events inside the span); it never falls through to this switch.
             }
         }
-        return messages;
+        return { messages, liveIndexByClientMessageId };
     }
     getEvents(type) {
         if (!type)
@@ -448,6 +581,18 @@ export class Transcript {
                     });
                     break;
                 }
+                case "range_archive": {
+                    // A hand-picked context range is an explicit user selection: inject
+                    // the archive summary as context but do NOT replace/drop the
+                    // messages inside its span the way toMessages() does — the caller
+                    // asked for exactly this range and expects to see it in full.
+                    const { summary } = event.data;
+                    messages.push({
+                        role: "user",
+                        content: `<system-reminder>Archived summary for part of this range:\n${summary}</system-reminder>`,
+                    });
+                    break;
+                }
             }
         }
         return messages;

package/dist/types.d.ts

@@ -145,7 +145,7 @@ export interface RegisteredTool {
      */
     timeoutMs?: number;
 }
-export type TranscriptEventType = "message" | "tool_use" | "tool_result" | "summary" | "context_transfer" | "content_replace" | "file_history" | "plan_operation" | "session_meta" | "subagent" | "external_file_changes" | "turn_boundary" | "run_result" | "goal_progress" | "turn_stopped" | "error";
+export type TranscriptEventType = "message" | "tool_use" | "tool_result" | "summary" | "context_transfer" | "range_archive" | "content_replace" | "file_history" | "plan_operation" | "session_meta" | "subagent" | "external_file_changes" | "turn_boundary" | "run_result" | "goal_progress" | "turn_stopped" | "error";
 export interface TranscriptEvent {
     id: string;
     type: TranscriptEventType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-core",
-  "version": "0.8.7",
+  "version": "0.8.8",
   "description": "Core engine for code-shell — agent orchestration, tool execution, hooks, protocol. UI-agnostic.",
   "type": "module",
   "main": "./dist/index.js",