@qwen-code/qwen-code 0.21.12-preview.3 → 0.21.12-preview.4

package/chunks/{chunk-M6HXP2SG.js → chunk-GHOUZ5X4.js}

@@ -40,7 +40,7 @@ import {
   CronScheduler,
   DEFAULT_RECURRING_MAX_AGE_DAYS,
   normalizeRecurringMaxAge
-} from "./chunk-QTI7SRXI.js";
+} from "./chunk-NM33GGOM.js";
 import {
   consumeUnread,
   forwardApproval,
@@ -49,13 +49,13 @@ import {
   sendStructuredMessage,
   wrapConfirmWithBadge,
   writeMessage
-} from "./chunk-KT4OWAAZ.js";
+} from "./chunk-A4BAHMJF.js";
 import {
   claimTask,
   listTasks,
   onTasksUpdated,
   unassignTeammateTasks
-} from "./chunk-IX7CFQGA.js";
+} from "./chunk-ZPZANKVP.js";
 import {
   assignTeammateColor,
   classifyShutdownResponse,
@@ -63,7 +63,7 @@ import {
   formatAgentId,
   generateUniqueTeammateName,
   writeTeamFile
-} from "./chunk-N7NBMAMW.js";
+} from "./chunk-A6GQUQ7I.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
@@ -71,13 +71,13 @@ import {
   RUNTIME_SNAPSHOT_PREFIX,
   buildModelIdContext,
   resolveModelId
-} from "./chunk-I4XSOFH2.js";
+} from "./chunk-JBZYGFIB.js";
 import {
   ARTIFACT_TITLE_MAX_LENGTH,
   ARTIFACT_WORKSPACE_PATH_MAX_LENGTH,
   hasControlCharacter,
   hasUnsafeDisplayPayload
-} from "./chunk-NWPO6I7V.js";
+} from "./chunk-7WUMS2UA.js";
 import {
   promptIdContext,
   todoWorkChainContext
@@ -101,7 +101,7 @@ import {
   isPlanRequiredTeammatePreApprovalAllowedTool,
   isSubagentLikeExecutionContext,
   shouldUsePlanOnlyReminderInSubagentContext
-} from "./chunk-6LYDH7VT.js";
+} from "./chunk-SNHBRO4C.js";
 import {
   SKILL_FILE_NAME,
   SKILL_NAME_PATTERN,
@@ -121,7 +121,7 @@ import {
   require_dist as require_dist2,
   stringify,
   validateSkillName
-} from "./chunk-2AZMF6G5.js";
+} from "./chunk-KTWUFHS4.js";
 import {
   require_proper_lockfile
 } from "./chunk-KRXPRVGL.js";
@@ -139,48 +139,56 @@ import {
   createHookOutput,
   getHookKey,
   isToolArtifactLike
-} from "./chunk-GZGDJ4E6.js";
+} from "./chunk-2ASWIM4A.js";
 import {
   BaseTokenStorage,
   KeychainTokenStorage
-} from "./chunk-T6W4KACQ.js";
+} from "./chunk-67F2BEYW.js";
 import {
   normalizeImageGenerationBaseUrl,
   resolveNetworkTarget
-} from "./chunk-MWZYNOCG.js";
+} from "./chunk-TNETSI2A.js";
 import {
+  EvidenceSourceUnavailableError,
+  GoalEvidenceCheckpointAccumulator,
+  GoalEvidenceRecordIndexAccumulator,
   GoalPersistenceUnavailableError,
+  InvalidGoalEvidenceReferenceError,
   PAUSED_GOAL_SYSTEM_REMINDER,
   aggregateTranscriptRecordFragments,
   createGoalCheckpointVerifier,
   createGoalRuntime,
   goalRequiresExactPermit,
   goalTurnContext,
+  isGoalRecoveryCandidate,
   isTranscriptArtifactRecord,
   isTranscriptConversationRecord,
   isUserPromptSubmitContextPartText,
+  normalizeGoalRecoveryRecord,
   parseGoalStateRecordPayloadV2,
   prepareTranscriptRecords,
   projectUserTranscriptForDisplay,
+  selectGoalRecoveryFromRecords,
   selectTranscriptLeaf,
   validateTranscriptRecord,
   walkTranscriptUuidChain,
   wrapUserPromptSubmitContext
-} from "./chunk-SAQHDAUJ.js";
+} from "./chunk-B66LYK4B.js";
 import {
   DEFAULT_OTLP_ENDPOINT,
   DEFAULT_TELEMETRY_TARGET,
+  addDaemonRequestAttribute,
   addToolArgumentsAttributes,
   addToolCallResultAttributes,
   addUserPromptAttributes
-} from "./chunk-O5AZPHYZ.js";
+} from "./chunk-U5C2GIN2.js";
 import {
   supportsOpenAIPrefixCaching
 } from "./chunk-SAH4BD2J.js";
 import {
   DashScopeOpenAICompatibleProvider,
   selectDashScopeThinkingKnob
-} from "./chunk-5PWLQ7SK.js";
+} from "./chunk-2RTRFLWH.js";
 import {
   childLaunchDepth,
   getCurrentAgentDepth,
@@ -191,7 +199,7 @@ import {
   runWithAgentContext,
   runWithRuntimeContentGenerator,
   spawnBlockReason
-} from "./chunk-EYS3GGM3.js";
+} from "./chunk-SKRHR6N2.js";
 import {
   getTeammateContext,
   isTeammate,
@@ -318,7 +326,7 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-HB6QW4LM.js";
+} from "./chunk-UAAWNTOC.js";
 import {
   defaultModalities,
   isTieredEffortWireModel
@@ -347,13 +355,13 @@ import {
   isManagedMemoryPath,
   isTeamAutoMemPath,
   isUserAutoMemPath
-} from "./chunk-732MOPEM.js";
+} from "./chunk-6OJDN5ZT.js";
 import {
   runSideQuery
-} from "./chunk-CTQE2NB2.js";
+} from "./chunk-JRTJEGSP.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-IEP44U2R.js";
+} from "./chunk-C2DR57L6.js";
 import {
   BUBBLE_APPROVAL_MODE,
   FORK_AGENT,
@@ -387,7 +395,7 @@ import {
   selectForkHistory,
   stripSystemReminderBlocks,
   validateForkToolList
-} from "./chunk-ZV4XVYL3.js";
+} from "./chunk-TROB4PZY.js";
 import {
   collectAvailableSkillEntries,
   renderAvailableSkillsBlock
@@ -405,7 +413,7 @@ import {
   getQwenIgnoreFileNames,
   isPathWithinRoot,
   require_ignore
-} from "./chunk-V3LXMASR.js";
+} from "./chunk-UHF5VBKO.js";
 import {
   AgentStatistics,
   BaseDeclarativeTool,
@@ -424,7 +432,7 @@ import {
   require_dist,
   require_fast_deep_equal,
   require_fast_uri
-} from "./chunk-XTH2OMDS.js";
+} from "./chunk-ZRT36RSF.js";
 import {
   openBrowserSecurely,
   shouldAttemptBrowserLaunch
@@ -432,11 +440,11 @@ import {
 import {
   isUnattendedMode,
   retryWithBackoff
-} from "./chunk-EYW54TBD.js";
+} from "./chunk-QEWAHAW2.js";
 import {
   classifyRetryError,
   isFallbackEligible
-} from "./chunk-O4BBDP2G.js";
+} from "./chunk-FTGU6G45.js";
 import {
   QUOTA_EXHAUSTED_PREFIX,
   formatQuotaExhaustedMessage,
@@ -446,7 +454,7 @@ import {
   isQuotaExhaustedError,
   isRateLimitError,
   isStructuredError
-} from "./chunk-KPVVWKF3.js";
+} from "./chunk-PSTHNTHF.js";
 import {
   AUTH_ENV_MAPPINGS,
   AuthType,
@@ -458,7 +466,7 @@ import {
   createContentGenerator,
   resetPreloadedContentGenerator,
   resolveContentGeneratorConfigWithSources
-} from "./chunk-XWUQ4IH5.js";
+} from "./chunk-XJ6IMYUS.js";
 import {
   DEFAULT_QWEN_EMBEDDING_MODEL,
   DEFAULT_QWEN_MODEL
@@ -468,7 +476,7 @@ import {
   atomicWriteFileSync,
   atomicWriteJSON,
   renameWithRetry
-} from "./chunk-F6AOBFUN.js";
+} from "./chunk-NW7SPXVG.js";
 import {
   DEFAULT_OPENAI_BASE_URL
 } from "./chunk-AXMWHKXA.js";
@@ -500,7 +508,7 @@ import {
   preloadRuntimeFetchModule,
   redactProxyError,
   setResolvedProxyUrlForRuntimeFetch
-} from "./chunk-EFIMD5VA.js";
+} from "./chunk-H6BFLALJ.js";
 import {
   endHookSpan,
   endInteractionSpan,
@@ -526,7 +534,7 @@ import {
   startToolExecutionSpan,
   startToolSpan,
   truncateSpanError
-} from "./chunk-E5BWLU5J.js";
+} from "./chunk-3MJ44LNC.js";
 import {
   safeJsonStringify
 } from "./chunk-HHJLM3WQ.js";
@@ -546,8 +554,15 @@ import {
   TOOL_FAILURE_KIND_TIMEOUT,
   TOOL_FAILURE_KIND_TOOL_ERROR,
   TOOL_FAILURE_KIND_TOOL_EXCEPTION,
-  isValidSensitiveSpanAttributeMaxLength
-} from "./chunk-L2GTEEEU.js";
+  getSessionModel,
+  getSessionProjectDir,
+  isValidSensitiveSpanAttributeMaxLength,
+  registerSessionModel,
+  registerSessionProjectDir,
+  sessionIdContext,
+  unregisterSessionModel,
+  unregisterSessionProjectDir
+} from "./chunk-K5IDV3PC.js";
 import {
   FatalConfigError,
   PATH_ARG_KEYS,
@@ -576,7 +591,7 @@ import {
   tildeifyPath,
   toFriendlyError,
   unescapePath
-} from "./chunk-MPBRV3UU.js";
+} from "./chunk-YMB77M76.js";
 import {
   require_src
 } from "./chunk-AMDSOFFV.js";
@@ -21328,6 +21343,13 @@ var getGitBranch = /* @__PURE__ */ __name((cwd) => {
     return void 0;
   }
 }, "getGitBranch");
+var gitBranchCache = /* @__PURE__ */ new Map();
+var getCachedGitBranch = /* @__PURE__ */ __name((cwd) => {
+  if (gitBranchCache.has(cwd)) return gitBranchCache.get(cwd);
+  const branch = getGitBranch(cwd);
+  gitBranchCache.set(cwd, branch);
+  return branch;
+}, "getCachedGitBranch");
 var getGitRepoName = /* @__PURE__ */ __name((cwd) => {
   try {
     const remoteUrl = execSync("git remote get-url origin", {
@@ -26558,6 +26580,46 @@ var FileHistoryService = class {
   }
 };
 
+// packages/core/src/services/session-file-history-state.ts
+init_esbuild_shims();
+var SessionFileHistoryAccumulator = class {
+  static {
+    __name(this, "SessionFileHistoryAccumulator");
+  }
+  seenPromptIds = /* @__PURE__ */ new Set();
+  retainedPromptIds = [];
+  snapshotsByPromptId = /* @__PURE__ */ new Map();
+  add(record2) {
+    if (record2.type !== "system" || record2.subtype !== "file_history_snapshot" || !record2.systemPayload) {
+      return;
+    }
+    const payload = record2.systemPayload;
+    if (!Array.isArray(payload.snapshots)) return;
+    const deserialized = deserializeSnapshots(payload.snapshots);
+    for (const snapshot of deserialized) {
+      if (this.seenPromptIds.has(snapshot.promptId)) {
+        if (this.snapshotsByPromptId.has(snapshot.promptId)) {
+          this.snapshotsByPromptId.set(snapshot.promptId, snapshot);
+        }
+        continue;
+      }
+      this.seenPromptIds.add(snapshot.promptId);
+      this.retainedPromptIds.push(snapshot.promptId);
+      this.snapshotsByPromptId.set(snapshot.promptId, snapshot);
+      if (this.retainedPromptIds.length > MAX_SNAPSHOTS) {
+        const evictedPromptId = this.retainedPromptIds.shift();
+        this.snapshotsByPromptId.delete(evictedPromptId);
+      }
+    }
+  }
+  finish() {
+    const snapshots = this.retainedPromptIds.map(
+      (promptId) => this.snapshotsByPromptId.get(promptId)
+    );
+    return snapshots.length > 0 ? snapshots : void 0;
+  }
+};
+
 // packages/core/src/utils/runtimeStatus.ts
 init_esbuild_shims();
 import * as fs7 from "node:fs/promises";
@@ -26910,42 +26972,21 @@ function readLastJsonStringFieldsSync(filePath, primaryKey, otherKeys, lineConta
   }
 }
 __name(readLastJsonStringFieldsSync, "readLastJsonStringFieldsSync");
-
-// packages/core/src/services/tokenEstimation.ts
-init_esbuild_shims();
-var CHARS_PER_TOKEN = TOKEN_TO_CHAR_RATIO;
-function estimateContentTokens(contents, imageTokenEstimate = DEFAULT_IMAGE_TOKEN_ESTIMATE) {
-  let totalChars = 0;
-  for (const content of contents) {
-    totalChars += estimateContentChars(content, imageTokenEstimate);
-  }
-  return Math.ceil(totalChars / CHARS_PER_TOKEN);
-}
-__name(estimateContentTokens, "estimateContentTokens");
-var CONSERVATIVE_NEW_CONTENT_SAFETY_FACTOR = 1.5;
-function estimatePromptTokens(history, userMessage, lastPromptTokenCount, lastOutputTokenCount = 0, imageTokenEstimate = DEFAULT_IMAGE_TOKEN_ESTIMATE, conservative = false) {
-  if (lastPromptTokenCount > 0) {
-    const newContentTokens = estimateContentTokens(
-      [userMessage],
-      imageTokenEstimate
-    );
-    return lastPromptTokenCount + lastOutputTokenCount + (conservative ? Math.ceil(newContentTokens * CONSERVATIVE_NEW_CONTENT_SAFETY_FACTOR) : newContentTokens);
-  }
-  return estimateContentTokens([...history, userMessage], imageTokenEstimate);
-}
-__name(estimatePromptTokens, "estimatePromptTokens");
-function getUsageOutputTokenCountForPromptEstimate(usage) {
-  if (usage?.promptTokenCount === void 0) {
-    return 0;
-  }
-  if (usage.totalTokenCount !== void 0) {
-    return Math.max(0, usage.totalTokenCount - usage.promptTokenCount);
-  }
-  const candidates = Math.max(0, usage.candidatesTokenCount ?? 0);
-  const thoughts = Math.max(0, usage.thoughtsTokenCount ?? 0);
-  return candidates > thoughts ? candidates : candidates + thoughts;
+function readSessionTitleInfoFromFileSync(filePath, scratchBuffer) {
+  const hit = readLastJsonStringFieldsSync(
+    filePath,
+    "customTitle",
+    ["titleSource"],
+    '"subtype":"custom_title"',
+    scratchBuffer
+  );
+  const title = hit["customTitle"];
+  if (!title) return {};
+  const rawSource = hit["titleSource"];
+  const source = rawSource === "auto" || rawSource === "manual" ? rawSource : void 0;
+  return { title, source };
 }
-__name(getUsageOutputTokenCountForPromptEstimate, "getUsageOutputTokenCountForPromptEstimate");
+__name(readSessionTitleInfoFromFileSync, "readSessionTitleInfoFromFileSync");
 
 // packages/core/src/services/session-artifact-persistence.ts
 init_esbuild_shims();
@@ -26971,6 +27012,52 @@ function isSessionArtifactRecord(record2) {
   return isTranscriptArtifactRecord(record2);
 }
 __name(isSessionArtifactRecord, "isSessionArtifactRecord");
+function selectActiveSideArtifactRecordUuids(records, activeRecordUuids) {
+  const activeUuids = new Set(activeRecordUuids);
+  const firstActiveUuid = activeRecordUuids[0];
+  const firstActiveIndex = firstActiveUuid === void 0 ? -1 : records.findIndex((record2) => record2.uuid === firstActiveUuid);
+  const nextActiveUuidByIndex = /* @__PURE__ */ new Map();
+  const nextBlockingUuidByIndex = /* @__PURE__ */ new Map();
+  let nextActiveUuid;
+  let nextBlockingUuid;
+  for (let index = records.length - 1; index >= 0; index--) {
+    if (nextActiveUuid !== void 0) {
+      nextActiveUuidByIndex.set(index, nextActiveUuid);
+    }
+    if (nextBlockingUuid !== void 0) {
+      nextBlockingUuidByIndex.set(index, nextBlockingUuid);
+    }
+    const record2 = records[index];
+    if (activeUuids.has(record2.uuid)) {
+      nextActiveUuid = record2.uuid;
+      nextBlockingUuid = void 0;
+    } else if (!isSessionArtifactRecord(record2) && !(record2.type === "system" && record2.subtype === "custom_title")) {
+      nextBlockingUuid = record2.uuid;
+    }
+  }
+  const selected = [];
+  const includedSideArtifactUuids = /* @__PURE__ */ new Set();
+  let previousActiveUuid;
+  for (let index = 0; index < records.length; index++) {
+    const record2 = records[index];
+    if (activeUuids.has(record2.uuid)) {
+      previousActiveUuid = record2.uuid;
+      continue;
+    }
+    if (!isSessionArtifactRecord(record2)) continue;
+    const nextUuid = nextActiveUuidByIndex.get(index);
+    const isInActiveSegment = !nextBlockingUuidByIndex.has(index) && (nextUuid !== void 0 ? activeUuids.has(nextUuid) : previousActiveUuid !== void 0 && activeUuids.has(previousActiveUuid));
+    if (record2.parentUuid !== null && (activeUuids.has(record2.parentUuid) || includedSideArtifactUuids.has(record2.parentUuid)) && isInActiveSegment && (record2.parentUuid === previousActiveUuid || includedSideArtifactUuids.has(record2.parentUuid))) {
+      selected.push(record2.uuid);
+      includedSideArtifactUuids.add(record2.uuid);
+    } else if (record2.parentUuid === null && index < firstActiveIndex && isInActiveSegment) {
+      selected.push(record2.uuid);
+      includedSideArtifactUuids.add(record2.uuid);
+    }
+  }
+  return selected;
+}
+__name(selectActiveSideArtifactRecordUuids, "selectActiveSideArtifactRecordUuids");
 function stableSessionArtifactId(sessionId, identityKey) {
   return createHash2("sha256").update(`${sessionId}:${identityKey}`).digest("hex").slice(0, 16);
 }
@@ -26982,75 +27069,87 @@ function sessionArtifactIdentityKey(artifact) {
   return void 0;
 }
 __name(sessionArtifactIdentityKey, "sessionArtifactIdentityKey");
-function rebuildSessionArtifactSnapshot(records, fallbackSessionId) {
-  const artifacts = /* @__PURE__ */ new Map();
-  const tombstonedIds = /* @__PURE__ */ new Set();
-  const stickyEphemeralIds = /* @__PURE__ */ new Set();
-  const markerArtifacts = /* @__PURE__ */ new Map();
-  const warnings = [];
-  let sequence = 0;
-  let lastSnapshotSequence = 0;
-  let sessionId = fallbackSessionId;
-  let sawRecord = false;
-  for (const record2 of records) {
-    if (!isSessionArtifactRecord(record2)) continue;
+var SessionArtifactSnapshotAccumulator = class {
+  static {
+    __name(this, "SessionArtifactSnapshotAccumulator");
+  }
+  artifacts = /* @__PURE__ */ new Map();
+  tombstonedIds = /* @__PURE__ */ new Set();
+  stickyEphemeralIds = /* @__PURE__ */ new Set();
+  markerArtifacts = /* @__PURE__ */ new Map();
+  warnings = [];
+  sequence = 0;
+  lastSnapshotSequence = 0;
+  sessionId;
+  sawRecord = false;
+  constructor(fallbackSessionId) {
+    this.sessionId = fallbackSessionId;
+  }
+  add(record2) {
+    if (!isSessionArtifactRecord(record2)) return;
     if (record2.subtype === "session_artifact_snapshot") {
-      const payload2 = normalizeSnapshotPayload(record2.systemPayload, warnings);
-      if (!payload2) continue;
-      sawRecord = true;
-      sessionId = payload2.sessionId;
-      sequence = Math.max(sequence, payload2.sequence);
-      lastSnapshotSequence = payload2.sequence;
-      artifacts.clear();
-      tombstonedIds.clear();
-      stickyEphemeralIds.clear();
-      markerArtifacts.clear();
-      for (const id of payload2.tombstonedIds ?? []) tombstonedIds.add(id);
+      const payload2 = normalizeSnapshotPayload(
+        record2.systemPayload,
+        this.warnings
+      );
+      if (!payload2) return;
+      this.sawRecord = true;
+      this.sessionId = payload2.sessionId;
+      this.sequence = Math.max(this.sequence, payload2.sequence);
+      this.lastSnapshotSequence = payload2.sequence;
+      this.artifacts.clear();
+      this.tombstonedIds.clear();
+      this.stickyEphemeralIds.clear();
+      this.markerArtifacts.clear();
+      for (const id of payload2.tombstonedIds ?? []) this.tombstonedIds.add(id);
       for (const id of payload2.stickyEphemeralIds ?? []) {
-        stickyEphemeralIds.add(id);
+        this.stickyEphemeralIds.add(id);
       }
-      const markerIds = /* @__PURE__ */ new Set([...tombstonedIds, ...stickyEphemeralIds]);
+      const markerIds = /* @__PURE__ */ new Set([
+        ...this.tombstonedIds,
+        ...this.stickyEphemeralIds
+      ]);
       for (const artifact of payload2.markerArtifacts ?? []) {
         if (markerIds.has(artifact.id)) {
-          markerArtifacts.set(artifact.id, artifact);
+          this.markerArtifacts.set(artifact.id, artifact);
         }
       }
       for (const artifact of payload2.artifacts) {
         if (artifact.retention === "ephemeral") continue;
-        artifacts.set(artifact.id, artifact);
-        markerArtifacts.delete(artifact.id);
+        this.artifacts.set(artifact.id, artifact);
+        this.markerArtifacts.delete(artifact.id);
       }
-      continue;
+      return;
     }
-    const payload = normalizeEventPayload(record2.systemPayload, warnings);
-    if (!payload) continue;
-    sawRecord = true;
-    sessionId = payload.sessionId;
-    if (payload.sequence <= lastSnapshotSequence) {
-      warnings.push(
-        `skipped stale event sequence ${payload.sequence} at or before snapshot sequence ${lastSnapshotSequence}`
+    const payload = normalizeEventPayload(record2.systemPayload, this.warnings);
+    if (!payload) return;
+    this.sawRecord = true;
+    this.sessionId = payload.sessionId;
+    if (payload.sequence <= this.lastSnapshotSequence) {
+      this.warnings.push(
+        `skipped stale event sequence ${payload.sequence} at or before snapshot sequence ${this.lastSnapshotSequence}`
       );
-      continue;
+      return;
     }
-    sequence = Math.max(sequence, payload.sequence);
+    this.sequence = Math.max(this.sequence, payload.sequence);
     for (const change of payload.changes) {
       if (change.action === "removed") {
-        artifacts.delete(change.artifactId);
+        this.artifacts.delete(change.artifactId);
         if (change.reason === "explicit") {
-          tombstonedIds.add(change.artifactId);
-          stickyEphemeralIds.delete(change.artifactId);
+          this.tombstonedIds.add(change.artifactId);
+          this.stickyEphemeralIds.delete(change.artifactId);
           if (change.artifact) {
-            markerArtifacts.set(change.artifactId, change.artifact);
+            this.markerArtifacts.set(change.artifactId, change.artifact);
           }
         }
         if (change.reason === "eviction") {
-          stickyEphemeralIds.delete(change.artifactId);
-          markerArtifacts.delete(change.artifactId);
+          this.stickyEphemeralIds.delete(change.artifactId);
+          this.markerArtifacts.delete(change.artifactId);
         }
         if (change.reason === "unpin_to_ephemeral") {
-          stickyEphemeralIds.add(change.artifactId);
+          this.stickyEphemeralIds.add(change.artifactId);
           if (change.artifact) {
-            markerArtifacts.set(change.artifactId, change.artifact);
+            this.markerArtifacts.set(change.artifactId, change.artifact);
           }
         }
         continue;
@@ -27058,25 +27157,30 @@ function rebuildSessionArtifactSnapshot(records, fallbackSessionId) {
       if (!change.artifact || change.artifact.retention === "ephemeral") {
         continue;
       }
-      artifacts.set(change.artifact.id, change.artifact);
-      tombstonedIds.delete(change.artifact.id);
-      stickyEphemeralIds.delete(change.artifact.id);
-      markerArtifacts.delete(change.artifact.id);
+      this.artifacts.set(change.artifact.id, change.artifact);
+      this.tombstonedIds.delete(change.artifact.id);
+      this.stickyEphemeralIds.delete(change.artifact.id);
+      this.markerArtifacts.delete(change.artifact.id);
     }
   }
-  if (!sawRecord || !sessionId) {
-    return void 0;
+  finish() {
+    if (!this.sawRecord || !this.sessionId) return void 0;
+    return {
+      v: SESSION_ARTIFACT_PERSISTENCE_VERSION,
+      sessionId: this.sessionId,
+      sequence: this.sequence,
+      artifacts: Array.from(this.artifacts.values()),
+      tombstonedIds: Array.from(this.tombstonedIds),
+      stickyEphemeralIds: Array.from(this.stickyEphemeralIds),
+      ...this.markerArtifacts.size > 0 ? { markerArtifacts: Array.from(this.markerArtifacts.values()) } : {},
+      warnings: this.warnings
+    };
   }
-  return {
-    v: SESSION_ARTIFACT_PERSISTENCE_VERSION,
-    sessionId,
-    sequence,
-    artifacts: Array.from(artifacts.values()),
-    tombstonedIds: Array.from(tombstonedIds),
-    stickyEphemeralIds: Array.from(stickyEphemeralIds),
-    ...markerArtifacts.size > 0 ? { markerArtifacts: Array.from(markerArtifacts.values()) } : {},
-    warnings
-  };
+};
+function rebuildSessionArtifactSnapshot(records, fallbackSessionId) {
+  const accumulator = new SessionArtifactSnapshotAccumulator(fallbackSessionId);
+  for (const record2 of records) accumulator.add(record2);
+  return accumulator.finish();
 }
 __name(rebuildSessionArtifactSnapshot, "rebuildSessionArtifactSnapshot");
 function remapSessionArtifactPayloadForFork(payload, sourceSessionId, newSessionId, remappedArtifactIds = /* @__PURE__ */ new Map()) {
@@ -28177,6 +28281,291 @@ import * as crypto from "node:crypto";
 import * as fs10 from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as path10 from "node:path";
+import { performance as performance3 } from "node:perf_hooks";
+
+// packages/core/src/services/session-api-history.ts
+init_esbuild_shims();
+function stripThoughtsFromContent(content) {
+  if (!content.parts) return content;
+  const filteredParts = content.parts.filter((part) => !part.thought);
+  if (filteredParts.length === 0) return null;
+  return { ...content, parts: filteredParts };
+}
+__name(stripThoughtsFromContent, "stripThoughtsFromContent");
+function copyContentForApiHistory(content) {
+  return {
+    ...content,
+    parts: content.parts?.map((part) => {
+      if ("functionCall" in part && part.functionCall) {
+        return {
+          ...part,
+          functionCall: {
+            ...part.functionCall,
+            args: part.functionCall.args ? { ...part.functionCall.args } : part.functionCall.args
+          }
+        };
+      }
+      if ("functionResponse" in part && part.functionResponse) {
+        return {
+          ...part,
+          functionResponse: { ...part.functionResponse }
+        };
+      }
+      return { ...part };
+    })
+  };
+}
+__name(copyContentForApiHistory, "copyContentForApiHistory");
+function appendApiHistoryRecord(history, record2) {
+  if (!record2.message || record2.subtype === "realtime_message") return;
+  const message = copyContentForApiHistory(record2.message);
+  if (record2.subtype === "mid_turn_user_message") {
+    const previous = history.at(-1);
+    if (previous?.role === "user") {
+      previous.parts = [...previous.parts ?? [], ...message.parts ?? []];
+      return;
+    }
+  }
+  history.push(message);
+}
+__name(appendApiHistoryRecord, "appendApiHistoryRecord");
+var SessionApiHistoryAccumulator = class {
+  static {
+    __name(this, "SessionApiHistoryAccumulator");
+  }
+  history = [];
+  compressionCandidate;
+  add(record2) {
+    if (record2.type === "system") {
+      if (!isApiHistoryCompressionCandidate(record2)) return;
+      const payload = record2.systemPayload;
+      this.compressionCandidate = payload.compressedHistory;
+      this.history = Array.isArray(payload.compressedHistory) ? payload.compressedHistory.map(copyContentForApiHistory) : [];
+      return;
+    }
+    if (this.compressionCandidate !== void 0 && !Array.isArray(this.compressionCandidate)) {
+      return;
+    }
+    appendApiHistoryRecord(this.history, record2);
+  }
+  finish(options2 = {}) {
+    if (this.compressionCandidate !== void 0 && !Array.isArray(this.compressionCandidate)) {
+      return this.compressionCandidate.map(
+        copyContentForApiHistory
+      );
+    }
+    if (!options2.stripThoughtsFromHistory) return this.history;
+    return this.history.map(stripThoughtsFromContent).filter((content) => content !== null);
+  }
+};
+function isApiHistoryCompressionCandidate(record2) {
+  if (record2.type !== "system" || record2.subtype !== "chat_compression") {
+    return false;
+  }
+  const payload = record2.systemPayload;
+  return Boolean(payload?.compressedHistory);
+}
+__name(isApiHistoryCompressionCandidate, "isApiHistoryCompressionCandidate");
+function buildApiHistoryFromConversation(conversation, options2 = {}) {
+  const accumulator = new SessionApiHistoryAccumulator();
+  for (const record2 of conversation.messages) accumulator.add(record2);
+  return accumulator.finish(options2);
+}
+__name(buildApiHistoryFromConversation, "buildApiHistoryFromConversation");
+
+// packages/core/src/services/session-resume-token-counts.ts
+init_esbuild_shims();
+
+// packages/core/src/services/tokenEstimation.ts
+init_esbuild_shims();
+var CHARS_PER_TOKEN = TOKEN_TO_CHAR_RATIO;
+function estimateContentTokens(contents, imageTokenEstimate = DEFAULT_IMAGE_TOKEN_ESTIMATE) {
+  let totalChars = 0;
+  for (const content of contents) {
+    totalChars += estimateContentChars(content, imageTokenEstimate);
+  }
+  return Math.ceil(totalChars / CHARS_PER_TOKEN);
+}
+__name(estimateContentTokens, "estimateContentTokens");
+var CONSERVATIVE_NEW_CONTENT_SAFETY_FACTOR = 1.5;
+function estimatePromptTokens(history, userMessage, lastPromptTokenCount, lastOutputTokenCount = 0, imageTokenEstimate = DEFAULT_IMAGE_TOKEN_ESTIMATE, conservative = false) {
+  if (lastPromptTokenCount > 0) {
+    const newContentTokens = estimateContentTokens(
+      [userMessage],
+      imageTokenEstimate
+    );
+    return lastPromptTokenCount + lastOutputTokenCount + (conservative ? Math.ceil(newContentTokens * CONSERVATIVE_NEW_CONTENT_SAFETY_FACTOR) : newContentTokens);
+  }
+  return estimateContentTokens([...history, userMessage], imageTokenEstimate);
+}
+__name(estimatePromptTokens, "estimatePromptTokens");
+function getUsageOutputTokenCountForPromptEstimate(usage) {
+  if (usage?.promptTokenCount === void 0) {
+    return 0;
+  }
+  if (usage.totalTokenCount !== void 0) {
+    return Math.max(0, usage.totalTokenCount - usage.promptTokenCount);
+  }
+  const candidates = Math.max(0, usage.candidatesTokenCount ?? 0);
+  const thoughts = Math.max(0, usage.thoughtsTokenCount ?? 0);
+  return candidates > thoughts ? candidates : candidates + thoughts;
+}
+__name(getUsageOutputTokenCountForPromptEstimate, "getUsageOutputTokenCountForPromptEstimate");
+
+// packages/core/src/services/session-resume-token-counts.ts
+var ResumeTokenCountsAccumulator = class {
+  static {
+    __name(this, "ResumeTokenCountsAccumulator");
+  }
+  value;
+  add(record2) {
+    if (record2.type === "assistant") {
+      const usage = record2.usageMetadata;
+      const candidate = usage?.promptTokenCount ?? usage?.totalTokenCount;
+      if (candidate) {
+        this.value = {
+          promptTokenCount: candidate,
+          outputTokenCount: getUsageOutputTokenCountForPromptEstimate(usage),
+          isEstimated: false
+        };
+      }
+      return;
+    }
+    if (record2.type === "system" && record2.subtype === "chat_compression") {
+      const payload = record2.systemPayload;
+      if (payload?.info) {
+        this.value = {
+          promptTokenCount: payload.info.newTokenCount,
+          outputTokenCount: 0,
+          isEstimated: payload.info.newTokenCountIsEstimated ?? true
+        };
+      }
+    }
+  }
+  finish() {
+    return this.value;
+  }
+};
+function isResumeTokenCountsCandidate(record2) {
+  if (record2.type === "assistant") {
+    const usage = record2.usageMetadata;
+    return Boolean(usage?.promptTokenCount ?? usage?.totalTokenCount);
+  }
+  if (record2.type !== "system" || record2.subtype !== "chat_compression") {
+    return false;
+  }
+  const payload = record2.systemPayload;
+  return payload?.info !== void 0;
+}
+__name(isResumeTokenCountsCandidate, "isResumeTokenCountsCandidate");
+function getResumeTokenCounts(conversation) {
+  const accumulator = new ResumeTokenCountsAccumulator();
+  for (const record2 of conversation.messages) accumulator.add(record2);
+  return accumulator.finish();
+}
+__name(getResumeTokenCounts, "getResumeTokenCounts");
+
+// packages/core/src/services/session-turn-state.ts
+init_esbuild_shims();
+var SessionTurnStateAccumulator = class {
+  constructor(sessionId) {
+    this.sessionId = sessionId;
+  }
+  static {
+    __name(this, "SessionTurnStateAccumulator");
+  }
+  maxPromptTurn = 0;
+  userMessageCount = 0;
+  turnParentUuids = [];
+  backgroundNotificationTaskIds = /* @__PURE__ */ new Set();
+  add(record2) {
+    this.addHint(getSessionTurnRecordHint(record2, this.sessionId));
+  }
+  addHint(hint) {
+    if (hint.countsAsUserPrompt) {
+      this.userMessageCount += 1;
+    }
+    if (hint.promptTurn !== void 0) {
+      this.maxPromptTurn = Math.max(this.maxPromptTurn, hint.promptTurn);
+    }
+    if (hint.turnParentUuid !== void 0) {
+      this.turnParentUuids.push(hint.turnParentUuid);
+    }
+    if (hint.backgroundNotificationTaskId !== void 0) {
+      this.backgroundNotificationTaskIds.add(hint.backgroundNotificationTaskId);
+    }
+  }
+  finish() {
+    return {
+      initialTurn: this.maxPromptTurn > 0 ? this.maxPromptTurn : this.userMessageCount,
+      turnParentUuids: [...this.turnParentUuids],
+      backgroundNotificationTaskIds: [...this.backgroundNotificationTaskIds]
+    };
+  }
+};
+function getSessionTurnRecordHint(record2, sessionId) {
+  let promptTurn;
+  for (const promptId of getRecordPromptIds(record2)) {
+    const candidate = parseSessionPromptTurn(promptId, sessionId);
+    if (candidate !== void 0) {
+      promptTurn = Math.max(promptTurn ?? 0, candidate);
+    }
+  }
+  const turnParentUuid = record2.type === "user" && record2.subtype !== "goal_runtime" && record2.subtype !== "notification" && record2.subtype !== "cron" && record2.subtype !== "mid_turn_user_message" && record2.subtype !== "realtime_message" ? record2.parentUuid ?? null : void 0;
+  const backgroundTask = record2.subtype === "notification" ? record2.systemPayload?.backgroundTask : void 0;
+  return {
+    ...promptTurn !== void 0 ? { promptTurn } : {},
+    countsAsUserPrompt: record2.sessionId === sessionId && isUserPromptRecord(record2),
+    ...turnParentUuid !== void 0 ? { turnParentUuid } : {},
+    ...typeof backgroundTask?.taskId === "string" ? { backgroundNotificationTaskId: backgroundTask.taskId } : {}
+  };
+}
+__name(getSessionTurnRecordHint, "getSessionTurnRecordHint");
+function collectSessionTurnState(records, sessionId) {
+  const accumulator = new SessionTurnStateAccumulator(sessionId);
+  for (const record2 of records) accumulator.add(record2);
+  return accumulator.finish();
+}
+__name(collectSessionTurnState, "collectSessionTurnState");
+function getRecordPromptIds(record2) {
+  const promptIds = [];
+  const recordPromptId = record2.promptId;
+  if (typeof recordPromptId === "string") promptIds.push(recordPromptId);
+  const telemetryPromptId = readTelemetryPromptId(record2.systemPayload);
+  if (telemetryPromptId) promptIds.push(telemetryPromptId);
+  return promptIds;
+}
+__name(getRecordPromptIds, "getRecordPromptIds");
+function readTelemetryPromptId(payload) {
+  if (!payload || typeof payload !== "object" || !("uiEvent" in payload)) {
+    return void 0;
+  }
+  const uiEvent = payload.uiEvent;
+  if (!uiEvent || typeof uiEvent !== "object" || !("prompt_id" in uiEvent)) {
+    return void 0;
+  }
+  const promptId = uiEvent.prompt_id;
+  return typeof promptId === "string" ? promptId : void 0;
+}
+__name(readTelemetryPromptId, "readTelemetryPromptId");
+function parseSessionPromptTurn(promptId, sessionId) {
+  const promptIdPrefix = `${sessionId}########`;
+  if (!promptId.startsWith(promptIdPrefix)) return void 0;
+  const suffix = promptId.slice(promptIdPrefix.length);
+  return /^\d+$/.test(suffix) ? Number(suffix) : void 0;
+}
+__name(parseSessionPromptTurn, "parseSessionPromptTurn");
+function isUserPromptRecord(record2) {
+  if (record2.type !== "user" || record2.subtype === "realtime_message") {
+    return false;
+  }
+  return record2.message?.parts?.some(
+    (part) => typeof part.text === "string" && part.text.trim().length > 0
+  ) ?? false;
+}
+__name(isUserPromptRecord, "isUserPromptRecord");
+
+// packages/core/src/services/session-transcript-reader.ts
 var SESSION_TRANSCRIPT_DEFAULT_LIMIT = 100;
 var SESSION_TRANSCRIPT_MAX_LIMIT = 500;
 var SESSION_TRANSCRIPT_CURSOR_VERSION = 1;
@@ -28201,6 +28590,11 @@ var SessionTranscriptSnapshotUnavailableError = class extends Error {
     this.name = "SessionTranscriptSnapshotUnavailableError";
   }
 };
+var EmptySessionTranscriptError = class extends SessionTranscriptSnapshotUnavailableError {
+  static {
+    __name(this, "EmptySessionTranscriptError");
+  }
+};
 var SessionTranscriptTooLargeError = class extends Error {
   constructor(sessionId, snapshotSize, maxBytes) {
     super(
@@ -28235,15 +28629,104 @@ var INDEX_CACHE_TTL_MS = 5 * 60 * 1e3;
 var INDEX_ENTRY_BASE_BYTES = 256;
 var INDEX_SEGMENT_BYTES = 64;
 var INDEX_STRING_BYTES = 2;
+var INDEX_HINT_BASE_BYTES = 64;
+var INDEX_CONTAINER_BASE_BYTES = 64;
+var INDEX_CONTAINER_SLOT_BYTES = 8;
+var INDEX_MAP_ENTRY_BYTES = 48;
 var READ_CHUNK_SIZE = 64 * 1024;
+var COOPERATIVE_READ_BYTE_BUDGET = 2 * 1024 * 1024;
+var COOPERATIVE_READ_TIME_BUDGET_MS = 8;
 var CURSOR_HMAC_KEY_BYTES = 32;
 var CURSOR_HMAC_KEY_FILENAME = "session-transcript-cursor-key";
 var SESSION_TRANSCRIPT_SESSION_ID_PATTERN = /^[0-9a-fA-F-]{32,36}$/;
 var debugLogger14 = createDebugLogger("SESSION_TRANSCRIPT");
+function recordRestoreStage(stage, startedAt) {
+  const durationMs = Math.round((performance3.now() - startedAt) * 100) / 100;
+  if (Number.isFinite(durationMs) && durationMs >= 0) {
+    addDaemonRequestAttribute(
+      `qwen-code.daemon.session_restore.${stage}_ms`,
+      durationMs
+    );
+  }
+}
+__name(recordRestoreStage, "recordRestoreStage");
+function recordRestoreIndexAttributes(index) {
+  addDaemonRequestAttribute(
+    "qwen-code.daemon.session_restore.transcript_bytes",
+    index.snapshotSize
+  );
+  addDaemonRequestAttribute(
+    "qwen-code.daemon.session_restore.records_indexed",
+    index.byUuid.size
+  );
+  addDaemonRequestAttribute(
+    "qwen-code.daemon.session_restore.active_records",
+    index.runtimeUuids.length
+  );
+}
+__name(recordRestoreIndexAttributes, "recordRestoreIndexAttributes");
+function selectedRecordBytes(index, uuids) {
+  const offsets = /* @__PURE__ */ new Set();
+  let bytes = 0;
+  for (const uuid of uuids) {
+    const entry = index.byUuid.get(uuid);
+    if (!entry) continue;
+    for (const segment of entry.segments) {
+      if (offsets.has(segment.offset)) continue;
+      offsets.add(segment.offset);
+      bytes += segment.length;
+    }
+  }
+  return bytes;
+}
+__name(selectedRecordBytes, "selectedRecordBytes");
+function recordRestoreSelectionAttributes(index, selectedUuids, replayUuids) {
+  addDaemonRequestAttribute(
+    "qwen-code.daemon.session_restore.selected_records",
+    selectedUuids.size
+  );
+  addDaemonRequestAttribute(
+    "qwen-code.daemon.session_restore.selected_bytes",
+    selectedRecordBytes(index, selectedUuids)
+  );
+  addDaemonRequestAttribute(
+    "qwen-code.daemon.session_restore.replay_records",
+    replayUuids.size
+  );
+  addDaemonRequestAttribute(
+    "qwen-code.daemon.session_restore.replay_bytes",
+    selectedRecordBytes(index, replayUuids)
+  );
+}
+__name(recordRestoreSelectionAttributes, "recordRestoreSelectionAttributes");
 var indexCache = /* @__PURE__ */ new Map();
 var cursorHmacKeys = /* @__PURE__ */ new Map();
 var indexCacheMaxBytesForTest;
 var expandedPageBytesForTest;
+var cooperativeReadByteBudgetForTest;
+var cooperativeReadTimeBudgetMsForTest;
+var cooperativeYieldHookForTest;
+var selectedLineReadHookForTest;
+var indexBuildCompleteHookForTest;
+var CooperativeReadScheduler = class {
+  static {
+    __name(this, "CooperativeReadScheduler");
+  }
+  processedBytes = 0;
+  startedAt = performance3.now();
+  async afterUnit(sourceBytes) {
+    this.processedBytes += sourceBytes;
+    const byteBudget = cooperativeReadByteBudgetForTest ?? COOPERATIVE_READ_BYTE_BUDGET;
+    const timeBudgetMs = cooperativeReadTimeBudgetMsForTest ?? COOPERATIVE_READ_TIME_BUDGET_MS;
+    if (this.processedBytes < byteBudget && performance3.now() - this.startedAt < timeBudgetMs) {
+      return;
+    }
+    cooperativeYieldHookForTest?.();
+    await new Promise((resolve41) => setImmediate(resolve41));
+    this.processedBytes = 0;
+    this.startedAt = performance3.now();
+  }
+};
 function getExpandedPageBytes() {
   return expandedPageBytesForTest ?? SESSION_TRANSCRIPT_MAX_EXPANDED_PAGE_BYTES;
 }
@@ -28262,6 +28745,14 @@ function isObjectRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 __name(isObjectRecord, "isObjectRecord");
+function isFileMissingError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+__name(isFileMissingError, "isFileMissingError");
+function isAttributionSnapshotCandidate(record2) {
+  return record2.subtype === "attribution_snapshot" && isObjectRecord(record2.systemPayload) && "snapshot" in record2.systemPayload;
+}
+__name(isAttributionSnapshotCandidate, "isAttributionSnapshotCandidate");
 function isFiniteNonNegativeInteger(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
@@ -28473,7 +28964,7 @@ function recordSegmentBytes(index, uuid) {
 }
 __name(recordSegmentBytes, "recordSegmentBytes");
 function selectPageUuids(index, position, limit, maxBytes) {
-  const candidates = index.activeUuids.slice(position, position + limit);
+  const candidates = index.replayUuids.slice(position, position + limit);
   if (maxBytes === void 0) return candidates;
   const selected = [];
   let selectedBytes = 0;
@@ -28516,7 +29007,7 @@ function findBoundaryAtOrBefore(items, from, floor, isBoundary) {
 __name(findBoundaryAtOrBefore, "findBoundaryAtOrBefore");
 function findReplayBoundaryAtOrBefore(index, from, floor, isBoundary) {
   return findBoundaryAtOrBefore(
-    index.activeUuids,
+    index.replayUuids,
     from,
     floor,
     (uuid) => isBoundary(index, uuid)
@@ -28526,7 +29017,7 @@ __name(findReplayBoundaryAtOrBefore, "findReplayBoundaryAtOrBefore");
 function backwardPageBytesFit(index, start, end, budget) {
   let total = 0;
   for (let i = start; i < end; i++) {
-    total += recordSegmentBytes(index, index.activeUuids[i]);
+    total += recordSegmentBytes(index, index.replayUuids[i]);
     if (total > budget) return false;
   }
   return true;
@@ -28534,11 +29025,11 @@ function backwardPageBytesFit(index, start, end, budget) {
 __name(backwardPageBytesFit, "backwardPageBytesFit");
 function selectionOrphansToolResult(index, start, end) {
   for (let i = start; i < end; i++) {
-    if (index.byUuid.get(index.activeUuids[i])?.type !== "tool_result") {
+    if (index.byUuid.get(index.replayUuids[i])?.type !== "tool_result") {
       continue;
     }
     for (let owner = i - 1; owner >= start; owner--) {
-      if (isReplayPageStart(index, index.activeUuids[owner])) return false;
+      if (isReplayPageStart(index, index.replayUuids[owner])) return false;
     }
     return true;
   }
@@ -28550,7 +29041,7 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
   const expansionByteBudget = maxBytes === void 0 ? getExpandedPageBytes() : Math.min(2 * maxBytes, getExpandedPageBytes());
   let start = Math.max(0, position - limit);
   for (let i = start; i < position; i++) {
-    if (isReplayTurnStart(index, index.activeUuids[i])) {
+    if (isReplayTurnStart(index, index.replayUuids[i])) {
       start = i;
       break;
     }
@@ -28562,13 +29053,13 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
     expansionFloor,
     isReplayTurnStart
   );
-  if (isReplayTurnStart(index, index.activeUuids[expandedStart])) {
+  if (isReplayTurnStart(index, index.replayUuids[expandedStart])) {
     start = expandedStart;
   }
   let selectedStart = position;
   let selectedBytes = 0;
   for (let i = position - 1; i >= start; i--) {
-    const uuid = index.activeUuids[i];
+    const uuid = index.replayUuids[i];
     const bytes = recordSegmentBytes(index, uuid);
     if (selectedStart < position && maxBytes !== void 0 && selectedBytes + bytes > maxBytes) {
       break;
@@ -28578,12 +29069,12 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
   }
   const logTurnExpansionSkipped = /* @__PURE__ */ __name((reason) => {
     debugLogger14.debug(
-      `backward turn expansion skipped session=${sessionId} start=${index.activeUuids[selectedStart]} reason=${reason}`
+      `backward turn expansion skipped session=${sessionId} start=${index.replayUuids[selectedStart]} reason=${reason}`
     );
   }, "logTurnExpansionSkipped");
   let alignedToReplayBoundary = false;
   for (let i = selectedStart; i < position; i++) {
-    if (isReplayTurnStart(index, index.activeUuids[i])) {
+    if (isReplayTurnStart(index, index.replayUuids[i])) {
       selectedStart = i;
       alignedToReplayBoundary = true;
       break;
@@ -28612,7 +29103,7 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
       expansionFloor,
       isReplayTurnStart
     );
-    if (isReplayTurnStart(index, index.activeUuids[candidate])) {
+    if (isReplayTurnStart(index, index.replayUuids[candidate])) {
       if (backwardPageBytesFit(index, candidate, position, expansionByteBudget)) {
         selectedStart = candidate;
       } else {
@@ -28628,9 +29119,9 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
       pairFloor,
       isReplayPageStart
     );
-    if (!isReplayPageStart(index, index.activeUuids[pairStart])) {
+    if (!isReplayPageStart(index, index.replayUuids[pairStart])) {
       debugLogger14.debug(
-        `backward pair extension skipped session=${sessionId} start=${index.activeUuids[selectedStart]} reason=record-budget`
+        `backward pair extension skipped session=${sessionId} start=${index.replayUuids[selectedStart]} reason=record-budget`
       );
     } else if (!backwardPageBytesFit(
       index,
@@ -28639,14 +29130,14 @@ function selectBackwardPageUuids(index, sessionId, position, limit, maxBytes) {
       expansionByteBudget
     )) {
       debugLogger14.debug(
-        `backward pair extension skipped session=${sessionId} start=${index.activeUuids[selectedStart]} reason=byte-budget`
+        `backward pair extension skipped session=${sessionId} start=${index.replayUuids[selectedStart]} reason=byte-budget`
       );
     } else {
       selectedStart = pairStart;
     }
   }
   return {
-    uuids: index.activeUuids.slice(selectedStart, position),
+    uuids: index.replayUuids.slice(selectedStart, position),
     nextPosition: selectedStart
   };
 }
@@ -28672,8 +29163,14 @@ function estimateStringBytes(value) {
 }
 __name(estimateStringBytes, "estimateStringBytes");
 function estimateIndexCacheBytes(index) {
-  let total = INDEX_ENTRY_BASE_BYTES + estimateStringBytes(index.filePath) + estimateStringBytes(index.leafUuid) + estimateStringBytes(index.startTime) + estimateStringBytes(index.lastUpdated);
-  for (const uuid of index.activeUuids) {
+  let total = INDEX_ENTRY_BASE_BYTES + INDEX_CONTAINER_BASE_BYTES * 6 + (index.physicalRecords.length + index.runtimeUuids.length + index.replayUuids.length + index.goalStatePositions.length + index.gaps.length) * INDEX_CONTAINER_SLOT_BYTES + estimateStringBytes(index.filePath) + estimateStringBytes(index.leafUuid) + estimateStringBytes(index.firstRecordUuid) + estimateStringBytes(index.restoreStartTime) + estimateStringBytes(index.startTime) + estimateStringBytes(index.lastUpdated);
+  for (const record2 of index.physicalRecords) {
+    total += INDEX_HINT_BASE_BYTES + estimateStringBytes(record2.uuid) + estimateStringBytes(record2.parentUuid) + estimateStringBytes(record2.type) + estimateStringBytes(record2.subtype);
+  }
+  for (const uuid of index.runtimeUuids) {
+    total += estimateStringBytes(uuid);
+  }
+  for (const uuid of index.replayUuids) {
     total += estimateStringBytes(uuid);
   }
   total += index.goalStatePositions.length * 8;
@@ -28681,7 +29178,7 @@ function estimateIndexCacheBytes(index) {
     total += INDEX_ENTRY_BASE_BYTES + estimateStringBytes(gap.childUuid) + estimateStringBytes(gap.missingParentUuid);
   }
   for (const [uuid, entry] of index.byUuid) {
-    total += INDEX_ENTRY_BASE_BYTES + estimateStringBytes(uuid) + estimateStringBytes(entry.parentUuid) + entry.segments.length * INDEX_SEGMENT_BYTES;
+    total += INDEX_ENTRY_BASE_BYTES + INDEX_HINT_BASE_BYTES * 2 + (entry.goalEvidenceHint.parsedGoalContext ? INDEX_HINT_BASE_BYTES : 0) + INDEX_MAP_ENTRY_BYTES + INDEX_CONTAINER_BASE_BYTES + entry.segments.length * INDEX_CONTAINER_SLOT_BYTES + estimateStringBytes(uuid) + estimateStringBytes(entry.parentUuid) + estimateStringBytes(entry.type) + estimateStringBytes(entry.subtype) + estimateStringBytes(entry.turnHint.turnParentUuid) + estimateStringBytes(entry.turnHint.backgroundNotificationTaskId) + estimateStringBytes(entry.goalEvidenceHint.parsedGoalContext?.goalId) + estimateStringBytes(entry.goalEvidenceHint.parsedGoalContext?.turnId) + estimateStringBytes(entry.goalEvidenceHint.claimedGoalId) + estimateStringBytes(entry.goalEvidenceHint.provenance) + entry.segments.length * INDEX_SEGMENT_BYTES;
   }
   return total;
 }
@@ -28722,6 +29219,7 @@ function pruneCache(now = Date.now()) {
 __name(pruneCache, "pruneCache");
 async function forEachLineInSnapshot(filePath, snapshotSize, onLine) {
   if (snapshotSize === 0) return;
+  const scheduler = new CooperativeReadScheduler();
   let pending = [];
   let pendingLength = 0;
   let pendingOffset = 0;
@@ -28745,7 +29243,8 @@ async function forEachLineInSnapshot(filePath, snapshotSize, onLine) {
         pendingLength + currentLine.length
       ) : currentLine;
       const line = rawLine.length > 0 && rawLine[rawLine.length - 1] === 13 ? rawLine.subarray(0, rawLine.length - 1) : rawLine;
-      onLine(line, lineOffset, line.length);
+      await onLine(line, lineOffset, line.length);
+      await scheduler.afterUnit(line.length);
       pending = [];
       pendingLength = 0;
       lineStart = lineEnd + 1;
@@ -28763,20 +29262,32 @@ async function forEachLineInSnapshot(filePath, snapshotSize, onLine) {
   if (pendingLength > 0) {
     const rawLine = makePendingLine();
     const line = rawLine[rawLine.length - 1] === 13 ? rawLine.subarray(0, rawLine.length - 1) : rawLine;
-    onLine(line, pendingOffset, line.length);
+    await onLine(line, pendingOffset, line.length);
+    await scheduler.afterUnit(line.length);
   }
 }
 __name(forEachLineInSnapshot, "forEachLineInSnapshot");
-async function readSegmentRecords(handle, filePath, segment, uuid) {
+async function readSegmentRecords(handle, filePath, segment, uuid, lineCache) {
   if (segment.length === 0) return [];
-  const buffer = Buffer.alloc(segment.length);
-  await handle.read(buffer, 0, segment.length, segment.offset);
-  const line = buffer.toString("utf8").trim();
-  if (line.length === 0) return [];
-  const records = parseLineTolerant(line, filePath).flatMap((value) => {
-    const record3 = validateTranscriptRecord(value).record;
-    return record3 && isTranscriptConversationRecord(record3) ? [record3] : [];
-  });
+  let records;
+  if (lineCache.value?.offset === segment.offset && lineCache.value.length === segment.length) {
+    records = lineCache.value.records;
+  } else {
+    selectedLineReadHookForTest?.(segment.offset, segment.length);
+    const buffer = Buffer.alloc(segment.length);
+    await handle.read(buffer, 0, segment.length, segment.offset);
+    const line = buffer.toString("utf8").trim();
+    if (line.length === 0) return [];
+    records = parseLineTolerant(line, filePath).flatMap((value) => {
+      const record3 = validateTranscriptRecord(value).record;
+      return record3 ? [record3] : [];
+    });
+    lineCache.value = {
+      offset: segment.offset,
+      length: segment.length,
+      records
+    };
+  }
   const anomalySessionId = path10.basename(filePath, ".jsonl");
   const record2 = records[segment.fragmentIndex];
   if (!record2) {
@@ -28791,31 +29302,84 @@ async function readSegmentRecords(handle, filePath, segment, uuid) {
     );
     throw new SessionTranscriptSnapshotUnavailableError(anomalySessionId);
   }
+  if (record2.sessionId !== anomalySessionId) {
+    debugLogger14.warn(
+      `segment read anomaly: session mismatch session=${anomalySessionId} recordSession=${record2.sessionId} uuid=${uuid} offset=${segment.offset}`
+    );
+    throw new SessionTranscriptSnapshotUnavailableError(anomalySessionId);
+  }
   return [record2];
 }
 __name(readSegmentRecords, "readSegmentRecords");
-async function readAggregatedRecords(index, uuids) {
-  const handle = await fsp.open(index.filePath, "r");
+async function forEachAggregatedRecord(index, uuids, onRecord, context2) {
+  if (!context2) {
+    await withAggregatedRecordReadContext(
+      index,
+      (readContext) => forEachAggregatedRecord(index, uuids, onRecord, readContext)
+    );
+    return;
+  }
+  for (const uuid of uuids) {
+    const entry = index.byUuid.get(uuid);
+    if (!entry) continue;
+    const preloadedRecord = context2.preloadedRecords?.get(uuid);
+    if (preloadedRecord) {
+      context2.preloadedRecords?.delete(uuid);
+      await onRecord(preloadedRecord);
+      continue;
+    }
+    const physicalRecords = [];
+    for (const segment of entry.segments) {
+      physicalRecords.push(
+        ...await readSegmentRecords(
+          context2.handle,
+          index.filePath,
+          segment,
+          uuid,
+          context2.lineCache
+        )
+      );
+    }
+    if (physicalRecords.length > 0) {
+      await onRecord(aggregateTranscriptRecordFragments(physicalRecords));
+    }
+    await context2.scheduler.afterUnit(
+      entry.segments.reduce((total, segment) => total + segment.length, 0)
+    );
+  }
+}
+__name(forEachAggregatedRecord, "forEachAggregatedRecord");
+async function withAggregatedRecordReadContext(index, callback) {
+  let handle;
   try {
-    const records = [];
-    for (const uuid of uuids) {
-      const entry = index.byUuid.get(uuid);
-      if (!entry) continue;
-      const physicalRecords = [];
-      for (const segment of entry.segments) {
-        physicalRecords.push(
-          ...await readSegmentRecords(handle, index.filePath, segment, uuid)
-        );
-      }
-      if (physicalRecords.length > 0) {
-        records.push(aggregateTranscriptRecordFragments(physicalRecords));
-      }
+    handle = await fsp.open(index.filePath, "r");
+  } catch (error) {
+    if (isFileMissingError(error)) {
+      throw new SessionTranscriptSnapshotUnavailableError(
+        path10.basename(index.filePath, ".jsonl")
+      );
     }
-    return records;
+    throw error;
+  }
+  const context2 = {
+    handle,
+    scheduler: new CooperativeReadScheduler(),
+    lineCache: {}
+  };
+  try {
+    return await callback(context2);
   } finally {
-    await handle.close();
+    await context2.handle.close();
   }
 }
+__name(withAggregatedRecordReadContext, "withAggregatedRecordReadContext");
+async function readAggregatedRecords(index, uuids) {
+  const records = [];
+  await forEachAggregatedRecord(index, uuids, (record2) => {
+    records.push(record2);
+  });
+  return records;
+}
 __name(readAggregatedRecords, "readAggregatedRecords");
 async function readGoalStatePayloadBeforePosition(index, position) {
   let low = 0;
@@ -28830,7 +29394,7 @@ async function readGoalStatePayloadBeforePosition(index, position) {
   }
   const goalStatePosition = index.goalStatePositions[low - 1];
   if (goalStatePosition === void 0) return void 0;
-  const uuid = index.activeUuids[goalStatePosition];
+  const uuid = index.replayUuids[goalStatePosition];
   const [record2] = await readAggregatedRecords(index, [uuid]);
   return parseGoalStateRecordPayloadV2(record2?.systemPayload);
 }
@@ -28852,59 +29416,121 @@ async function buildIndex(params) {
     `index build start session=${sessionId} snapshotSize=${snapshotSize}`
   );
   const byUuid = /* @__PURE__ */ new Map();
+  const goalEvidenceAccumulators = /* @__PURE__ */ new Map();
   let sequence = 0;
+  const physicalRecords = [];
   let leafUuid;
+  let firstRecordUuid;
+  let firstRecordTimestamp;
   let startTime;
-  let sideTaskSourceUuid;
-  await forEachLineInSnapshot(
-    filePath,
-    snapshotSize,
-    (line, offset, length) => {
-      const text = line.toString("utf8").trim();
-      if (text.length === 0) return;
-      let fragmentIndex = 0;
-      for (const value of parseLineTolerant(text, filePath)) {
-        const record2 = validateTranscriptRecord(value).record;
-        if (!record2 || !isTranscriptConversationRecord(record2)) {
-          continue;
-        }
-        if (record2.type === "system" && record2.subtype === "session_source" && isObjectRecord(record2.systemPayload) && record2.systemPayload["sourceType"] === "side_task") {
-          sideTaskSourceUuid = record2.uuid;
-        }
-        if (record2.timestamp) startTime ??= record2.timestamp;
-        leafUuid = record2.uuid;
-        const existing = byUuid.get(record2.uuid);
-        const segment = {
-          offset,
-          length,
-          sequence: sequence++,
-          fragmentIndex
-        };
-        fragmentIndex++;
-        if (existing) {
-          existing.segments.push(segment);
-        } else {
-          byUuid.set(record2.uuid, {
+  try {
+    await forEachLineInSnapshot(
+      filePath,
+      snapshotSize,
+      (line, offset, length) => {
+        const text = line.toString("utf8").trim();
+        if (text.length === 0) return;
+        let fragmentIndex = 0;
+        for (const value of parseLineTolerant(text, filePath)) {
+          const record2 = validateTranscriptRecord(value).record;
+          if (!record2) {
+            continue;
+          }
+          if (firstRecordUuid === void 0) {
+            firstRecordUuid = record2.uuid;
+            firstRecordTimestamp = record2.timestamp;
+          }
+          const sideTaskSource = record2.type === "system" && record2.subtype === "session_source" && isObjectRecord(record2.systemPayload) && record2.systemPayload["sourceType"] === "side_task";
+          if (isTranscriptConversationRecord(record2)) {
+            if (record2.timestamp) startTime ??= record2.timestamp;
+            leafUuid = record2.uuid;
+          }
+          const existing = byUuid.get(record2.uuid);
+          physicalRecords.push({
+            uuid: record2.uuid,
             parentUuid: record2.parentUuid,
             type: record2.type,
-            ...record2.subtype !== void 0 ? { subtype: record2.subtype } : {},
-            inherited: record2.forkedFrom !== void 0,
-            segments: [segment]
+            ...record2.subtype !== void 0 ? { subtype: record2.subtype } : {}
           });
+          const segment = {
+            offset,
+            length,
+            sequence: sequence++,
+            fragmentIndex
+          };
+          fragmentIndex++;
+          if (existing) {
+            existing.segments.push(segment);
+            existing.sessionIdMatchesFile &&= record2.sessionId === sessionId;
+            if (existing.type === "assistant" && record2.usageMetadata) {
+              existing.resumeTokenCountsCandidate = isResumeTokenCountsCandidate({
+                ...record2,
+                type: existing.type,
+                subtype: existing.subtype
+              });
+            }
+            existing.turnHint.countsAsUserPrompt ||= getSessionTurnRecordHint(
+              record2,
+              sessionId
+            ).countsAsUserPrompt;
+            goalEvidenceAccumulators.get(record2.uuid)?.addFragment(record2);
+          } else {
+            const chatRecord = record2;
+            const goalEvidenceAccumulator = new GoalEvidenceRecordIndexAccumulator(chatRecord);
+            const goalEvidenceHint = goalEvidenceAccumulator.finish();
+            if (goalEvidenceHint.provenance) {
+              goalEvidenceAccumulators.set(
+                record2.uuid,
+                goalEvidenceAccumulator
+              );
+            }
+            byUuid.set(record2.uuid, {
+              parentUuid: record2.parentUuid,
+              sessionIdMatchesFile: record2.sessionId === sessionId,
+              type: record2.type,
+              ...record2.subtype !== void 0 ? { subtype: record2.subtype } : {},
+              inherited: record2.forkedFrom !== void 0,
+              sideTaskSource,
+              apiHistoryCompressionCandidate: isApiHistoryCompressionCandidate(chatRecord),
+              resumeTokenCountsCandidate: isResumeTokenCountsCandidate(chatRecord),
+              attributionSnapshotCandidate: isAttributionSnapshotCandidate(chatRecord),
+              goalRecoveryCandidate: isGoalRecoveryCandidate(chatRecord),
+              goalEvidenceHint,
+              turnHint: getSessionTurnRecordHint(chatRecord, sessionId),
+              segments: [segment]
+            });
+          }
         }
       }
+    );
+  } catch (error) {
+    if (isFileMissingError(error)) {
+      throw new SessionTranscriptSnapshotUnavailableError(sessionId);
     }
-  );
-  if (!leafUuid) {
+    throw error;
+  }
+  for (const [uuid, accumulator] of goalEvidenceAccumulators) {
+    byUuid.get(uuid).goalEvidenceHint = accumulator.finish();
+  }
+  for (const [uuid, entry] of byUuid) {
+    if (!entry.sessionIdMatchesFile) {
+      debugLogger14.warn(
+        `transcript session mismatch session=${sessionId} uuid=${uuid}`
+      );
+      throw new SessionTranscriptSnapshotUnavailableError(sessionId);
+    }
+  }
+  if (!leafUuid || !firstRecordUuid) {
     debugLogger14.warn(
-      `index build failed: no transcript records session=${sessionId}`
+      `index build failed: no active transcript records session=${sessionId}`
     );
-    throw new SessionTranscriptSnapshotUnavailableError(sessionId);
+    throw new EmptySessionTranscriptError(sessionId);
   }
   startTime ??= lastUpdated;
+  const restoreStartTime = firstRecordTimestamp ?? startTime;
   const chain = walkTranscriptUuidChain(leafUuid, (uuid) => {
     const entry = byUuid.get(uuid);
-    return entry ? {
+    return entry && isTranscriptConversationRecord(entry) ? {
       uuid,
       parentUuid: entry.parentUuid,
       sessionId,
@@ -28912,11 +29538,14 @@ async function buildIndex(params) {
       type: "system"
     } : void 0;
   });
-  const sourceBoundary = sideTaskSourceUuid ? chain.uuids.indexOf(sideTaskSourceUuid) : -1;
-  const activeUuids = sourceBoundary >= 0 ? chain.uuids.slice(sourceBoundary).filter((uuid) => byUuid.get(uuid)?.inherited !== true) : [...chain.uuids];
+  const runtimeUuids = [...chain.uuids];
+  const sourceBoundary = runtimeUuids.findIndex(
+    (uuid) => byUuid.get(uuid)?.sideTaskSource === true
+  );
+  const replayUuids = sourceBoundary >= 0 ? runtimeUuids.slice(sourceBoundary).filter((uuid) => byUuid.get(uuid)?.inherited !== true) : [...runtimeUuids];
   const goalStatePositions = [];
-  for (let position = 0; position < activeUuids.length; position++) {
-    const uuid = activeUuids[position];
+  for (let position = 0; position < replayUuids.length; position++) {
+    const uuid = replayUuids[position];
     const entry = byUuid.get(uuid);
     if (entry?.type === "system" && entry.subtype === "goal_state") {
       goalStatePositions.push(position);
@@ -28929,16 +29558,21 @@ async function buildIndex(params) {
     );
   }
   debugLogger14.debug(
-    `index build complete session=${sessionId} records=${byUuid.size} active=${activeUuids.length} gaps=${gaps.length}`
+    `index build complete session=${sessionId} records=${byUuid.size} runtime=${runtimeUuids.length} replay=${replayUuids.length} gaps=${gaps.length}`
   );
+  await indexBuildCompleteHookForTest?.(filePath);
   return {
     filePath,
     fileIdentity,
     snapshotSize,
     leafUuid,
-    activeUuids,
+    firstRecordUuid,
+    physicalRecords,
+    runtimeUuids,
+    replayUuids,
     goalStatePositions,
     gaps,
+    restoreStartTime,
     startTime,
     lastUpdated,
     byUuid
@@ -28959,13 +29593,16 @@ async function getCachedIndex(params) {
     indexCache.delete(key);
     indexCache.set(key, cached);
     debugLogger14.debug(`index cache hit ${key}`);
+    params.onCacheState?.("hit");
     return cached.value;
   }
   if (cached?.pending && cached.expiresAt > now) {
     debugLogger14.debug(`index cache pending hit ${key}`);
+    params.onCacheState?.("pending");
     return cached.pending;
   }
   debugLogger14.debug(`index cache miss ${key}`);
+  params.onCacheState?.("miss");
   const pending = buildIndex(params);
   indexCache.set(key, {
     pending,
@@ -28983,6 +29620,17 @@ async function getCachedIndex(params) {
       );
       return value;
     }
+    if (indexCache.get(key)?.pending !== pending) {
+      debugLogger14.debug(`index cache skipped stale completion ${key}`);
+      return value;
+    }
+    if (getIndexCacheBytes() + byteSize > getIndexCacheMaxBytes()) {
+      indexCache.delete(key);
+      debugLogger14.debug(
+        `index cache skipped byte-budget admission ${key} byteSize=${byteSize}`
+      );
+      return value;
+    }
     indexCache.set(key, {
       value,
       byteSize,
@@ -28991,7 +29639,9 @@ async function getCachedIndex(params) {
     pruneCache();
     return value;
   } catch (error) {
-    indexCache.delete(key);
+    if (indexCache.get(key)?.pending === pending) {
+      indexCache.delete(key);
+    }
     debugLogger14.debug(
       `index cache build failed ${key}: ${error instanceof Error ? error.message : String(error)}`
     );
@@ -28999,11 +29649,118 @@ async function getCachedIndex(params) {
   }
 }
 __name(getCachedIndex, "getCachedIndex");
+function makeReplayIndex(index, hideInheritedHistory) {
+  const replayUuids = hideInheritedHistory ? index.replayUuids.filter(
+    (uuid) => index.byUuid.get(uuid)?.inherited !== true
+  ) : index.replayUuids;
+  if (replayUuids === index.replayUuids) return index;
+  const goalStatePositions = [];
+  for (let position = 0; position < replayUuids.length; position++) {
+    const entry = index.byUuid.get(replayUuids[position]);
+    if (entry?.type === "system" && entry.subtype === "goal_state") {
+      goalStatePositions.push(position);
+    }
+  }
+  return { ...index, replayUuids, goalStatePositions };
+}
+__name(makeReplayIndex, "makeReplayIndex");
+function selectRestoreReplayUuids(index, sessionId, replay) {
+  if (replay.kind === "none") return void 0;
+  const replayIndex = makeReplayIndex(index, replay.hideInheritedHistory);
+  if (replay.kind === "all") {
+    return {
+      index: replayIndex,
+      uuids: replayIndex.replayUuids,
+      hasMore: false,
+      nextPosition: 0
+    };
+  }
+  const limit = normalizeLimit(replay.limit);
+  const selected = selectBackwardPageUuids(
+    replayIndex,
+    sessionId,
+    replayIndex.replayUuids.length,
+    limit,
+    SESSION_TRANSCRIPT_MAX_PAGE_BYTES
+  );
+  return {
+    index: replayIndex,
+    uuids: selected.uuids,
+    hasMore: selected.nextPosition > 0,
+    nextPosition: selected.nextPosition
+  };
+}
+__name(selectRestoreReplayUuids, "selectRestoreReplayUuids");
+function validateRestoreReplaySelection(replay) {
+  if (replay.kind === "recent") normalizeLimit(replay.limit);
+}
+__name(validateRestoreReplaySelection, "validateRestoreReplaySelection");
+async function assertIndexSnapshotUnchanged(index, sessionId) {
+  if (!await hasSnapshotSignature(
+    index.filePath,
+    index.fileIdentity,
+    index.snapshotSize,
+    index.lastUpdated
+  )) {
+    throw new SessionTranscriptSnapshotUnavailableError(sessionId);
+  }
+}
+__name(assertIndexSnapshotUnchanged, "assertIndexSnapshotUnchanged");
+async function hasSnapshotSignature(filePath, fileIdentity, snapshotSize, lastUpdated) {
+  let stats;
+  try {
+    stats = await fsp.stat(filePath);
+  } catch (error) {
+    if (isFileMissingError(error)) return false;
+    throw error;
+  }
+  return stats.size === snapshotSize && sameFileIdentity(fileIdentityFromStats(stats), fileIdentity) && new Date(stats.mtimeMs).toISOString() === lastUpdated;
+}
+__name(hasSnapshotSignature, "hasSnapshotSignature");
+function offerFreshIndexToCache(index) {
+  pruneCache();
+  const key = makeCacheKey(
+    index.filePath,
+    index.fileIdentity,
+    index.snapshotSize,
+    index.lastUpdated
+  );
+  if (indexCache.has(key)) return;
+  const byteSize = estimateIndexCacheBytes(index);
+  if (byteSize > getIndexCacheMaxBytes() || getIndexCacheBytes() + byteSize > getIndexCacheMaxBytes() || indexCache.size >= INDEX_CACHE_MAX_ENTRIES) {
+    debugLogger14.debug(
+      `fresh index cache offer skipped ${key} byteSize=${byteSize}`
+    );
+    return;
+  }
+  indexCache.set(key, {
+    value: index,
+    byteSize,
+    expiresAt: Date.now() + INDEX_CACHE_TTL_MS
+  });
+}
+__name(offerFreshIndexToCache, "offerFreshIndexToCache");
+function lastUuidMatching(index, predicate) {
+  for (let position = index.runtimeUuids.length - 1; position >= 0; position--) {
+    const uuid = index.runtimeUuids[position];
+    const entry = index.byUuid.get(uuid);
+    if (entry && predicate(entry)) return uuid;
+  }
+  return void 0;
+}
+__name(lastUuidMatching, "lastUuidMatching");
+function selectArtifactUuids(index) {
+  return selectActiveSideArtifactRecordUuids(
+    index.physicalRecords,
+    index.runtimeUuids
+  );
+}
+__name(selectArtifactUuids, "selectArtifactUuids");
 var SessionTranscriptReader = class {
-  constructor(workspaceCwd, cursorCodec) {
+  constructor(workspaceCwd, cursorCodec, runtimeBaseDir) {
     this.workspaceCwd = workspaceCwd;
     this.cursorCodec = cursorCodec;
-    this.storage = new Storage(workspaceCwd);
+    this.storage = new Storage(workspaceCwd, runtimeBaseDir);
   }
   static {
     __name(this, "SessionTranscriptReader");
@@ -29020,6 +29777,522 @@ var SessionTranscriptReader = class {
       `${sessionId}.jsonl`
     );
   }
+  async readRestoreProjection(sessionId, options2, readOptions = {}) {
+    const filePath = this.getSessionFilePath(sessionId);
+    validateRestoreReplaySelection(options2.replay);
+    addDaemonRequestAttribute(
+      "qwen-code.daemon.session_restore.replay_mode",
+      options2.replay.kind
+    );
+    addDaemonRequestAttribute(
+      "qwen-code.daemon.session_restore.index_cache_state",
+      "fresh"
+    );
+    let stats;
+    try {
+      stats = await fsp.stat(filePath);
+    } catch (error) {
+      if (isFileMissingError(error)) {
+        throw new SessionTranscriptSnapshotUnavailableError(sessionId);
+      }
+      throw error;
+    }
+    const fileIdentity = fileIdentityFromStats(stats);
+    const lastUpdated = new Date(stats.mtimeMs).toISOString();
+    let index;
+    const indexStartedAt = performance3.now();
+    try {
+      index = await buildIndex({
+        filePath,
+        fileIdentity,
+        snapshotSize: stats.size,
+        lastUpdated
+      });
+    } catch (error) {
+      if (error instanceof EmptySessionTranscriptError) {
+        if (await hasSnapshotSignature(
+          filePath,
+          fileIdentity,
+          stats.size,
+          lastUpdated
+        )) {
+          return void 0;
+        }
+      }
+      throw error;
+    } finally {
+      recordRestoreStage("transcript_index", indexStartedAt);
+    }
+    recordRestoreIndexAttributes(index);
+    const selectionStartedAt = performance3.now();
+    let replaySelection;
+    try {
+      replaySelection = selectRestoreReplayUuids(
+        index,
+        sessionId,
+        options2.replay
+      );
+    } finally {
+      recordRestoreStage("resume_state_select", selectionStartedAt);
+    }
+    const replaySet = new Set(replaySelection?.uuids ?? []);
+    const modelSet = /* @__PURE__ */ new Set();
+    let compressionPosition = -1;
+    for (let position = 0; position < index.runtimeUuids.length; position++) {
+      const entry = index.byUuid.get(index.runtimeUuids[position]);
+      if (entry?.apiHistoryCompressionCandidate) {
+        compressionPosition = position;
+      }
+    }
+    for (let position = 0; position < index.runtimeUuids.length; position++) {
+      const uuid = index.runtimeUuids[position];
+      const entry = index.byUuid.get(uuid);
+      if (position === compressionPosition || entry?.type !== "system" && (compressionPosition < 0 || position > compressionPosition)) {
+        modelSet.add(uuid);
+      }
+    }
+    addDaemonRequestAttribute(
+      "qwen-code.daemon.session_restore.compression_selected",
+      compressionPosition >= 0
+    );
+    addDaemonRequestAttribute(
+      "qwen-code.daemon.session_restore.legacy_full_model_history",
+      compressionPosition < 0
+    );
+    const tokenUuid = lastUuidMatching(
+      index,
+      (entry) => entry.resumeTokenCountsCandidate
+    );
+    const attributionUuid = lastUuidMatching(
+      index,
+      (entry) => entry.attributionSnapshotCandidate
+    );
+    const parentSessionUuid = lastUuidMatching(
+      index,
+      (entry) => entry.type === "system" && entry.subtype === "parent_session"
+    );
+    const sessionSourceUuid = lastUuidMatching(
+      index,
+      (entry) => entry.type === "system" && entry.subtype === "session_source"
+    );
+    const uiTelemetrySet = new Set(
+      index.runtimeUuids.filter((uuid) => {
+        const entry = index.byUuid.get(uuid);
+        return entry?.type === "system" && entry.subtype === "ui_telemetry";
+      })
+    );
+    const fileHistorySet = new Set(
+      index.runtimeUuids.filter((uuid) => {
+        const entry = index.byUuid.get(uuid);
+        return entry?.type === "system" && entry.subtype === "file_history_snapshot";
+      })
+    );
+    const goalSet = new Set(
+      index.runtimeUuids.filter(
+        (uuid) => index.byUuid.get(uuid)?.goalRecoveryCandidate === true
+      )
+    );
+    const replayGoalSet = new Set(
+      replaySelection ? replaySelection.index.replayUuids.filter(
+        (uuid) => index.byUuid.get(uuid)?.goalRecoveryCandidate === true
+      ) : []
+    );
+    const artifactUuids = selectArtifactUuids(index);
+    const artifactSet = new Set(artifactUuids);
+    const metadataSet = new Set(
+      [parentSessionUuid, sessionSourceUuid].filter(
+        (uuid) => uuid !== void 0
+      )
+    );
+    const apiHistory = new SessionApiHistoryAccumulator();
+    const resumeTokenCounts = new ResumeTokenCountsAccumulator();
+    const turnState = new SessionTurnStateAccumulator(sessionId);
+    for (const uuid of index.runtimeUuids) {
+      const hint = index.byUuid.get(uuid)?.turnHint;
+      if (hint) turnState.addHint(hint);
+    }
+    const uiTelemetryEvents = [];
+    const fileHistory = new SessionFileHistoryAccumulator();
+    const artifacts = new SessionArtifactSnapshotAccumulator(sessionId);
+    const goalRecords = [];
+    const goalStatePayloads = /* @__PURE__ */ new Map();
+    const replayRecordsByUuid = /* @__PURE__ */ new Map();
+    let attributionSnapshot;
+    let parentSessionId;
+    let sourceType;
+    let sourceId;
+    let firstRecord;
+    let firstRecordSeen = false;
+    let goalCheckpointAccumulator;
+    let goalEvidenceSet = /* @__PURE__ */ new Set();
+    const deferredPreReadRecords = /* @__PURE__ */ new Map();
+    const dispatchRecord = /* @__PURE__ */ __name((record2) => {
+      if (modelSet.has(record2.uuid)) apiHistory.add(record2);
+      if (record2.uuid === tokenUuid) resumeTokenCounts.add(record2);
+      if (uiTelemetrySet.has(record2.uuid)) {
+        const uiEvent = record2.systemPayload?.uiEvent;
+        if (uiEvent) uiTelemetryEvents.push(uiEvent);
+      }
+      if (record2.uuid === attributionUuid) {
+        const snapshot = record2.systemPayload?.snapshot;
+        if (snapshot && typeof snapshot === "object") {
+          attributionSnapshot = snapshot;
+        }
+      }
+      if (record2.uuid === parentSessionUuid) {
+        parentSessionId = record2.systemPayload?.parentSessionId;
+      } else if (record2.uuid === sessionSourceUuid) {
+        const payload = record2.systemPayload;
+        sourceType = payload?.sourceType;
+        sourceId = payload?.sourceId;
+      }
+      if (fileHistorySet.has(record2.uuid)) {
+        try {
+          fileHistory.add(record2);
+        } catch (error) {
+          debugLogger14.warn(
+            `restore projection: skipping malformed file_history_snapshot: ${error}`
+          );
+        }
+      }
+      if (artifactSet.has(record2.uuid)) artifacts.add(record2);
+      if (goalEvidenceSet.has(record2.uuid)) {
+        goalCheckpointAccumulator?.capture(record2);
+      }
+      if (replaySet.has(record2.uuid)) {
+        replayRecordsByUuid.set(record2.uuid, record2);
+      }
+    }, "dispatchRecord");
+    const preReadUuids = Array.from(
+      /* @__PURE__ */ new Set([
+        index.firstRecordUuid,
+        ...index.runtimeUuids.filter((uuid) => goalSet.has(uuid))
+      ])
+    );
+    const selectedReadsStartedAt = performance3.now();
+    const selectedReadSet = new Set(preReadUuids);
+    let goalRecovery;
+    try {
+      goalRecovery = await withAggregatedRecordReadContext(
+        index,
+        async (readContext) => {
+          await forEachAggregatedRecord(
+            index,
+            preReadUuids,
+            async (record2) => {
+              if (record2.uuid === index.firstRecordUuid) {
+                if (readOptions.validateFirstRecord && !await readOptions.validateFirstRecord(record2)) {
+                  throw new SessionTranscriptSnapshotUnavailableError(
+                    sessionId
+                  );
+                }
+                firstRecordSeen = true;
+                if (!goalSet.has(record2.uuid)) firstRecord = record2;
+              }
+              if (goalSet.has(record2.uuid)) {
+                const normalized2 = normalizeGoalRecoveryRecord(record2);
+                if (normalized2) {
+                  goalRecords.push(normalized2);
+                  if (record2.subtype === "goal_state") {
+                    goalStatePayloads.set(
+                      record2.uuid,
+                      parseGoalStateRecordPayloadV2(normalized2.systemPayload)
+                    );
+                  }
+                }
+              }
+              if (replaySet.has(record2.uuid)) {
+                replayRecordsByUuid.set(record2.uuid, record2);
+              }
+              const needsDeferredDispatch = modelSet.has(record2.uuid) || record2.uuid === tokenUuid || record2.uuid === attributionUuid || metadataSet.has(record2.uuid) || uiTelemetrySet.has(record2.uuid) || fileHistorySet.has(record2.uuid) || artifactSet.has(record2.uuid);
+              if (needsDeferredDispatch) {
+                if (record2.uuid === index.firstRecordUuid && artifactSet.has(record2.uuid)) {
+                  artifacts.add(record2);
+                } else {
+                  deferredPreReadRecords.set(record2.uuid, record2);
+                }
+              }
+            },
+            readContext
+          );
+          if (!firstRecordSeen) {
+            throw new SessionTranscriptSnapshotUnavailableError(sessionId);
+          }
+          const selectedGoalRecovery = selectGoalRecoveryFromRecords(goalRecords);
+          const pendingGoal = selectedGoalRecovery.recovery.kind === "v2" ? selectedGoalRecovery.recovery.payload : void 0;
+          const pendingCheckpoint = pendingGoal?.checkpointPending;
+          if (pendingCheckpoint && pendingGoal.snapshot.goal) {
+            try {
+              goalCheckpointAccumulator = new GoalEvidenceCheckpointAccumulator(
+                index.runtimeUuids.map(
+                  (uuid) => index.byUuid.get(uuid).goalEvidenceHint
+                ),
+                pendingGoal.snapshot.goal,
+                pendingCheckpoint.permit
+              );
+            } catch (error) {
+              if (!(error instanceof EvidenceSourceUnavailableError)) {
+                throw error;
+              }
+              debugLogger14.warn(
+                `restore projection: deferring unavailable Goal checkpoint evidence: ${error.message}`
+              );
+            }
+          }
+          goalEvidenceSet = new Set(
+            goalCheckpointAccumulator?.getCandidateUuids() ?? []
+          );
+          if (firstRecord && goalEvidenceSet.has(firstRecord.uuid)) {
+            goalCheckpointAccumulator?.capture(firstRecord);
+          }
+          firstRecord = void 0;
+          const selectedRuntimeUuids = index.runtimeUuids.filter(
+            (uuid) => modelSet.has(uuid) || uuid === tokenUuid || uuid === attributionUuid || metadataSet.has(uuid) || uiTelemetrySet.has(uuid) || fileHistorySet.has(uuid) || replaySet.has(uuid) || goalEvidenceSet.has(uuid)
+          );
+          const preReadSet = new Set(preReadUuids);
+          readContext.preloadedRecords = deferredPreReadRecords;
+          const remainingUuids = Array.from(
+            /* @__PURE__ */ new Set([...selectedRuntimeUuids, ...artifactUuids])
+          ).filter(
+            (uuid) => !preReadSet.has(uuid) || deferredPreReadRecords.has(uuid)
+          );
+          for (const uuid of remainingUuids) selectedReadSet.add(uuid);
+          await forEachAggregatedRecord(
+            index,
+            remainingUuids,
+            dispatchRecord,
+            readContext
+          );
+          let goalCheckpointWindow;
+          try {
+            goalCheckpointWindow = goalCheckpointAccumulator?.finish();
+          } catch (error) {
+            if (!(error instanceof InvalidGoalEvidenceReferenceError)) {
+              throw error;
+            }
+            debugLogger14.warn(
+              `restore projection: deferring invalid Goal checkpoint evidence: ${error.message}`
+            );
+          }
+          return { selectedGoalRecovery, goalCheckpointWindow };
+        }
+      );
+    } finally {
+      recordRestoreStage("selected_record_read", selectedReadsStartedAt);
+    }
+    recordRestoreSelectionAttributes(index, selectedReadSet, replaySet);
+    let persistedTitle;
+    try {
+      persistedTitle = readSessionTitleInfoFromFileSync(index.filePath);
+    } catch (error) {
+      if (isFileMissingError(error)) {
+        throw new SessionTranscriptSnapshotUnavailableError(sessionId);
+      }
+      throw error;
+    }
+    const customTitle = persistedTitle.title;
+    const titleSource = persistedTitle.source;
+    const turnStateValue = turnState.finish();
+    const replayRecords = replaySelection ? replaySelection.uuids.map((uuid) => replayRecordsByUuid.get(uuid)).filter((record2) => record2 !== void 0) : [];
+    const replayGoalRecords = replaySelection ? goalRecords.filter((record2) => replayGoalSet.has(record2.uuid)) : [];
+    const replayGoalRecoverySourceUuid = replaySelection ? selectGoalRecoveryFromRecords(replayGoalRecords).sourceUuid : goalRecovery.selectedGoalRecovery.sourceUuid;
+    let replay;
+    if (replaySelection) {
+      const goalStatePosition = replaySelection.index.goalStatePositions.findLast(
+        (position) => position < replaySelection.nextPosition
+      );
+      const goalStateUuid = goalStatePosition === void 0 ? void 0 : replaySelection.index.replayUuids[goalStatePosition];
+      const goalState = goalStateUuid ? goalStatePayloads.get(goalStateUuid) : void 0;
+      replay = {
+        records: replayRecords,
+        gaps: index.gaps,
+        hasMore: replaySelection.hasMore,
+        ...replaySelection.hasMore && replayRecords[0] ? { anchorRecordId: replayRecords[0].uuid } : {},
+        ...replayGoalRecoverySourceUuid && !replaySet.has(replayGoalRecoverySourceUuid) ? { goalBootstrapRecords: replayGoalRecords } : {},
+        ...replayGoalRecoverySourceUuid ? { goalRecoverySourceUuid: replayGoalRecoverySourceUuid } : {},
+        ...goalState ? {
+          replay: {
+            goalState: goalState.snapshot,
+            goalCause: goalState.cause
+          }
+        } : {}
+      };
+    }
+    const restoredTokenCounts = resumeTokenCounts.finish();
+    const restoredFileHistory = fileHistory.finish();
+    const artifactSnapshot = artifacts.finish();
+    const runtime = {
+      apiHistory: apiHistory.finish(),
+      ...restoredTokenCounts ? { resumeTokenCounts: restoredTokenCounts } : {},
+      uiTelemetryEvents,
+      ...attributionSnapshot ? { attributionSnapshot } : {},
+      ...index.gaps.length > 0 ? { historyGaps: index.gaps } : {},
+      recording: {
+        lastCompletedUuid: index.leafUuid,
+        turnParentUuids: turnStateValue.turnParentUuids,
+        ...customTitle !== void 0 ? { customTitle } : {},
+        ...titleSource !== void 0 ? { titleSource } : {},
+        ...parentSessionId !== void 0 ? { parentSessionId } : {},
+        ...sourceType !== void 0 ? { sourceType } : {},
+        ...sourceId !== void 0 ? { sourceId } : {}
+      },
+      ...restoredFileHistory ? { fileHistorySnapshots: restoredFileHistory } : {},
+      ...artifactSnapshot ? { artifactSnapshot } : {},
+      goalRecords,
+      ...goalRecovery.selectedGoalRecovery.sourceUuid ? {
+        goalRecoverySourceUuid: goalRecovery.selectedGoalRecovery.sourceUuid
+      } : {},
+      ...goalRecovery.goalCheckpointWindow ? { goalCheckpointWindow: goalRecovery.goalCheckpointWindow } : {},
+      initialTurn: turnStateValue.initialTurn,
+      backgroundNotificationTaskIds: turnStateValue.backgroundNotificationTaskIds
+    };
+    await assertIndexSnapshotUnchanged(index, sessionId);
+    offerFreshIndexToCache(index);
+    return {
+      sessionId,
+      filePath,
+      startTime: index.restoreStartTime,
+      lastUpdated: index.lastUpdated,
+      runtime,
+      ...replay ? { replay } : {}
+    };
+  }
+  async readLiveRestoreProjection(sessionId, options2, readOptions = {}) {
+    const filePath = this.getSessionFilePath(sessionId);
+    validateRestoreReplaySelection(options2.replay);
+    addDaemonRequestAttribute(
+      "qwen-code.daemon.session_restore.replay_mode",
+      options2.replay.kind
+    );
+    let stats;
+    try {
+      stats = await fsp.stat(filePath);
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
+      throw error;
+    }
+    let index;
+    const fileIdentity = fileIdentityFromStats(stats);
+    const lastUpdated = new Date(stats.mtimeMs).toISOString();
+    const indexStartedAt = performance3.now();
+    try {
+      index = await getCachedIndex({
+        filePath,
+        fileIdentity,
+        snapshotSize: stats.size,
+        lastUpdated,
+        onCacheState: /* @__PURE__ */ __name((state) => addDaemonRequestAttribute(
+          "qwen-code.daemon.session_restore.index_cache_state",
+          state
+        ), "onCacheState")
+      });
+    } catch (error) {
+      if (error instanceof EmptySessionTranscriptError) {
+        if (await hasSnapshotSignature(
+          filePath,
+          fileIdentity,
+          stats.size,
+          lastUpdated
+        )) {
+          return void 0;
+        }
+      }
+      throw error;
+    } finally {
+      recordRestoreStage("transcript_index", indexStartedAt);
+    }
+    recordRestoreIndexAttributes(index);
+    const selectionStartedAt = performance3.now();
+    const replaySelection = selectRestoreReplayUuids(
+      index,
+      sessionId,
+      options2.replay
+    );
+    const replaySet = new Set(replaySelection?.uuids ?? []);
+    const goalSet = new Set(
+      replaySelection ? replaySelection.index.replayUuids.filter(
+        (uuid) => index.byUuid.get(uuid)?.goalRecoveryCandidate === true
+      ) : []
+    );
+    const goalStatePosition = replaySelection ? replaySelection.index.goalStatePositions.findLast(
+      (position) => position < replaySelection.nextPosition
+    ) : void 0;
+    const goalStateUuid = goalStatePosition === void 0 || !replaySelection ? void 0 : replaySelection.index.replayUuids[goalStatePosition];
+    const goalStateSet = new Set(goalStateUuid ? [goalStateUuid] : []);
+    const artifactUuids = selectArtifactUuids(index);
+    const artifactSet = new Set(artifactUuids);
+    const selectedRuntimeUuids = index.runtimeUuids.filter(
+      (uuid) => replaySet.has(uuid) || goalStateSet.has(uuid) || goalSet.has(uuid)
+    );
+    if (!selectedRuntimeUuids.includes(index.firstRecordUuid)) {
+      selectedRuntimeUuids.unshift(index.firstRecordUuid);
+    }
+    const replayRecords = [];
+    const goalRecords = [];
+    const goalStatePayloads = /* @__PURE__ */ new Map();
+    const artifacts = new SessionArtifactSnapshotAccumulator(sessionId);
+    recordRestoreStage("resume_state_select", selectionStartedAt);
+    const selectedReadSet = /* @__PURE__ */ new Set([
+      ...selectedRuntimeUuids,
+      ...artifactUuids
+    ]);
+    const selectedReadsStartedAt = performance3.now();
+    try {
+      await forEachAggregatedRecord(
+        index,
+        [...selectedReadSet],
+        async (record2) => {
+          if (record2.uuid === index.firstRecordUuid && readOptions.validateFirstRecord && !await readOptions.validateFirstRecord(record2)) {
+            throw new SessionTranscriptSnapshotUnavailableError(sessionId);
+          }
+          if (replaySet.has(record2.uuid)) replayRecords.push(record2);
+          if (goalStateSet.has(record2.uuid)) {
+            goalStatePayloads.set(
+              record2.uuid,
+              parseGoalStateRecordPayloadV2(record2.systemPayload)
+            );
+          }
+          if (goalSet.has(record2.uuid)) {
+            const normalized2 = normalizeGoalRecoveryRecord(record2);
+            if (normalized2) goalRecords.push(normalized2);
+          }
+          if (artifactSet.has(record2.uuid)) artifacts.add(record2);
+        }
+      );
+    } finally {
+      recordRestoreStage("selected_record_read", selectedReadsStartedAt);
+    }
+    recordRestoreSelectionAttributes(index, selectedReadSet, replaySet);
+    let replay;
+    if (replaySelection) {
+      const goalState = goalStateUuid ? goalStatePayloads.get(goalStateUuid) : void 0;
+      replay = {
+        records: replayRecords,
+        gaps: index.gaps,
+        hasMore: replaySelection.hasMore,
+        ...replaySelection.hasMore && replayRecords[0] ? { anchorRecordId: replayRecords[0].uuid } : {},
+        ...goalState ? {
+          replay: {
+            goalState: goalState.snapshot,
+            goalCause: goalState.cause
+          }
+        } : {}
+      };
+    }
+    const artifactSnapshot = artifacts.finish();
+    const goalRecovery = selectGoalRecoveryFromRecords(goalRecords);
+    const replayGoalRecoverySourceUuid = goalRecovery.sourceUuid && replaySelection?.index.replayUuids.includes(goalRecovery.sourceUuid) ? goalRecovery.sourceUuid : void 0;
+    await assertIndexSnapshotUnchanged(index, sessionId);
+    return {
+      sessionId,
+      startTime: index.restoreStartTime,
+      lastUpdated: index.lastUpdated,
+      ...replay ? { replay } : {},
+      ...artifactSnapshot ? { artifactSnapshot } : {},
+      ...goalRecords.length > 0 ? { goalRecords } : {},
+      ...replayGoalRecoverySourceUuid ? { goalRecoverySourceUuid: replayGoalRecoverySourceUuid } : {}
+    };
+  }
   async readPage(sessionId, options2 = {}) {
     const limit = normalizeLimit(options2.limit);
     const maxBytes = normalizeMaxBytes(options2.maxBytes);
@@ -29057,19 +30330,19 @@ var SessionTranscriptReader = class {
       throw new SessionTranscriptSnapshotUnavailableError(sessionId);
     }
     const direction = cursor?.direction ?? options2.direction ?? (options2.beforeRecordId !== void 0 ? "backward" : "forward");
-    let position = cursor?.position ?? (direction === "backward" ? index.activeUuids.length : 0);
+    let position = cursor?.position ?? (direction === "backward" ? index.replayUuids.length : 0);
     if (!cursor && options2.beforeRecordId !== void 0) {
       if (options2.beforeRecordId.length === 0) {
         throw new InvalidSessionTranscriptCursorError();
       }
-      position = index.activeUuids.indexOf(options2.beforeRecordId);
+      position = index.replayUuids.indexOf(options2.beforeRecordId);
       if (position < 0) {
         throw new InvalidSessionTranscriptCursorError();
       }
     }
-    if (position > index.activeUuids.length) {
+    if (position > index.replayUuids.length) {
       debugLogger14.debug(
-        `cursor position out of range session=${sessionId} position=${position} active=${index.activeUuids.length}`
+        `cursor position out of range session=${sessionId} position=${position} replay=${index.replayUuids.length}`
       );
       throw new InvalidSessionTranscriptCursorError();
     }
@@ -29078,7 +30351,7 @@ var SessionTranscriptReader = class {
     const nextPosition = backwardPage?.nextPosition ?? position + pageUuids.length;
     const records = await readAggregatedRecords(index, pageUuids);
     const backwardGoalState = direction === "backward" ? await readGoalStatePayloadBeforePosition(index, nextPosition) : void 0;
-    const hasMore = direction === "backward" ? nextPosition > 0 : nextPosition < index.activeUuids.length;
+    const hasMore = direction === "backward" ? nextPosition > 0 : nextPosition < index.replayUuids.length;
     const nextCursorState = hasMore ? {
       v: SESSION_TRANSCRIPT_CURSOR_VERSION,
       sessionId,
@@ -31099,11 +32372,17 @@ var SessionService = class {
   projectHash;
   projectRoot;
   onWarning;
+  transcriptReader;
   constructor(cwd, options2 = {}) {
     this.storage = new Storage(cwd, options2.runtimeBaseDir);
     this.projectRoot = cwd;
     this.projectHash = getProjectHash(cwd);
     this.onWarning = options2.onWarning;
+    this.transcriptReader = new SessionTranscriptReader(
+      cwd,
+      void 0,
+      options2.runtimeBaseDir
+    );
   }
   /** The workspace root this service is bound to (the cwd it was constructed
    * with). Lets callers that already hold a service — e.g. the session
@@ -31364,18 +32643,7 @@ var SessionService = class {
    * user's pre-upgrade rename is never displayed as if it were auto-generated.
    */
   readSessionTitleInfoFromFile(filePath, tailBuffer) {
-    const hit = readLastJsonStringFieldsSync(
-      filePath,
-      "customTitle",
-      ["titleSource"],
-      '"subtype":"custom_title"',
-      tailBuffer
-    );
-    const title = hit["customTitle"];
-    if (!title) return {};
-    const rawSource = hit["titleSource"];
-    const source = rawSource === "auto" || rawSource === "manual" ? rawSource : void 0;
-    return { title, source };
+    return readSessionTitleInfoFromFileSync(filePath, tailBuffer);
   }
   /**
    * Extracts the `parent_session` record's `parentSessionId` from records
@@ -31816,6 +33084,16 @@ var SessionService = class {
   async loadSession(sessionId) {
     return this.loadSessionFromState(sessionId, "active");
   }
+  async readRestoreProjection(sessionId, options2) {
+    return this.transcriptReader.readRestoreProjection(sessionId, options2, {
+      validateFirstRecord: /* @__PURE__ */ __name((record2) => this.sessionBelongsToCurrentProject(record2.sessionId, record2.cwd), "validateFirstRecord")
+    });
+  }
+  async readLiveRestoreProjection(sessionId, options2) {
+    return this.transcriptReader.readLiveRestoreProjection(sessionId, options2, {
+      validateFirstRecord: /* @__PURE__ */ __name((record2) => this.sessionBelongsToCurrentProject(record2.sessionId, record2.cwd), "validateFirstRecord")
+    });
+  }
   /**
    * Reads an archived session without changing its archive state.
    * Daemon load/resume paths must continue to use {@link loadSession}.
@@ -31881,33 +33159,17 @@ var SessionService = class {
       lastUpdated: new Date(stats.mtimeMs).toISOString(),
       messages
     };
-    const fileHistorySnapshots = [];
-    const seenPromptIds = /* @__PURE__ */ new Map();
+    const fileHistoryAccumulator = new SessionFileHistoryAccumulator();
     for (const msg of messages) {
-      if (msg.type === "system" && msg.subtype === "file_history_snapshot" && msg.systemPayload) {
-        const payload = msg.systemPayload;
-        if (!Array.isArray(payload?.snapshots)) continue;
-        let deserialized;
-        try {
-          deserialized = deserializeSnapshots(payload.snapshots);
-        } catch (e) {
-          debugLogger16.warn(
-            `loadSession: skipping malformed file_history_snapshot: ${e}`
-          );
-          continue;
-        }
-        for (const s3 of deserialized) {
-          const existingIdx = seenPromptIds.get(s3.promptId);
-          if (existingIdx !== void 0) {
-            fileHistorySnapshots[existingIdx] = s3;
-          } else {
-            seenPromptIds.set(s3.promptId, fileHistorySnapshots.length);
-            fileHistorySnapshots.push(s3);
-          }
-        }
+      try {
+        fileHistoryAccumulator.add(msg);
+      } catch (e) {
+        debugLogger16.warn(
+          `loadSession: skipping malformed file_history_snapshot: ${e}`
+        );
       }
     }
-    const cappedSnapshots = fileHistorySnapshots.length > MAX_SNAPSHOTS ? fileHistorySnapshots.slice(-MAX_SNAPSHOTS) : fileHistorySnapshots;
+    const fileHistorySnapshots = fileHistoryAccumulator.finish();
     const activeBranchRecords = includeActiveSideArtifactRecords(
       records,
       messages
@@ -31920,7 +33182,7 @@ var SessionService = class {
       conversation,
       filePath,
       lastCompletedUuid: lastMessage.uuid,
-      fileHistorySnapshots: cappedSnapshots.length > 0 ? cappedSnapshots : void 0,
+      fileHistorySnapshots,
       ...artifactSnapshot ? { artifactSnapshot } : {},
       historyGaps: gaps.length > 0 ? gaps : void 0
     };
@@ -32547,95 +33809,6 @@ var SessionService = class {
     }
   }
 };
-function stripThoughtsFromContent(content) {
-  if (!content.parts) return content;
-  const filteredParts = content.parts.filter((part) => !part.thought);
-  if (filteredParts.length === 0) {
-    return null;
-  }
-  return {
-    ...content,
-    parts: filteredParts
-  };
-}
-__name(stripThoughtsFromContent, "stripThoughtsFromContent");
-function copyContentForApiHistory(content) {
-  return {
-    ...content,
-    parts: content.parts?.map((part) => {
-      if ("functionCall" in part && part.functionCall) {
-        return {
-          ...part,
-          functionCall: {
-            ...part.functionCall,
-            args: part.functionCall.args ? { ...part.functionCall.args } : part.functionCall.args
-          }
-        };
-      }
-      if ("functionResponse" in part && part.functionResponse) {
-        return {
-          ...part,
-          functionResponse: {
-            ...part.functionResponse
-          }
-        };
-      }
-      return { ...part };
-    })
-  };
-}
-__name(copyContentForApiHistory, "copyContentForApiHistory");
-function appendApiHistoryRecord(history, record2) {
-  if (!record2.message || record2.subtype === "realtime_message") return;
-  const message = copyContentForApiHistory(record2.message);
-  if (record2.subtype === "mid_turn_user_message") {
-    const previous = history.at(-1);
-    if (previous?.role === "user") {
-      previous.parts = [...previous.parts ?? [], ...message.parts ?? []];
-      return;
-    }
-  }
-  history.push(message);
-}
-__name(appendApiHistoryRecord, "appendApiHistoryRecord");
-function buildApiHistoryFromConversation(conversation, options2 = {}) {
-  const { stripThoughtsFromHistory = false } = options2;
-  const { messages } = conversation;
-  let lastCompressionIndex = -1;
-  let compressedHistory;
-  messages.forEach((record2, index) => {
-    if (record2.type === "system" && record2.subtype === "chat_compression") {
-      const payload = record2.systemPayload;
-      if (payload?.compressedHistory) {
-        lastCompressionIndex = index;
-        compressedHistory = payload.compressedHistory;
-      }
-    }
-  });
-  if (compressedHistory && lastCompressionIndex >= 0) {
-    const baseHistory = compressedHistory.map(
-      copyContentForApiHistory
-    );
-    for (let i = lastCompressionIndex + 1; i < messages.length; i++) {
-      const record2 = messages[i];
-      if (record2.type === "system") continue;
-      appendApiHistoryRecord(baseHistory, record2);
-    }
-    if (stripThoughtsFromHistory) {
-      return baseHistory.map(stripThoughtsFromContent).filter((content) => content !== null);
-    }
-    return baseHistory;
-  }
-  const result = [];
-  for (const record2 of messages) {
-    appendApiHistoryRecord(result, record2);
-  }
-  if (stripThoughtsFromHistory) {
-    return result.map(stripThoughtsFromContent).filter((content) => content !== null);
-  }
-  return result;
-}
-__name(buildApiHistoryFromConversation, "buildApiHistoryFromConversation");
 function remapSnapshotPromptId(snapshot, sourceSessionId, newSessionId) {
   const sourcePrefix = `${sourceSessionId}########`;
   if (!snapshot.promptId.startsWith(sourcePrefix)) {
@@ -32686,60 +33859,25 @@ function includeActiveSideArtifactRecords(records, activeRecords) {
   const activeByUuid = new Map(
     activeRecords.map((record2) => [record2.uuid, record2])
   );
-  const activeUuids = new Set(activeByUuid.keys());
-  const firstActiveUuid = activeRecords[0]?.uuid;
-  const firstActiveIndex = firstActiveUuid === void 0 ? -1 : records.findIndex((record2) => record2.uuid === firstActiveUuid);
-  const nextActiveUuidByIndex = /* @__PURE__ */ new Map();
-  const nextBlockingUuidByIndex = /* @__PURE__ */ new Map();
-  let nextActiveUuid;
-  let nextBlockingUuid;
-  for (let index = records.length - 1; index >= 0; index--) {
-    if (nextActiveUuid !== void 0) {
-      nextActiveUuidByIndex.set(index, nextActiveUuid);
-    }
-    if (nextBlockingUuid !== void 0) {
-      nextBlockingUuidByIndex.set(index, nextBlockingUuid);
-    }
-    if (activeUuids.has(records[index].uuid)) {
-      nextActiveUuid = records[index].uuid;
-      nextBlockingUuid = void 0;
-    } else if (!isSessionArtifactRecord(records[index]) && !isTailNeutralSideRecord(records[index])) {
-      nextBlockingUuid = records[index].uuid;
-    }
-  }
+  const artifactUuids = new Set(
+    selectActiveSideArtifactRecordUuids(
+      records,
+      activeRecords.map((record2) => record2.uuid)
+    )
+  );
   const selected = [];
-  const includedSideArtifactUuids = /* @__PURE__ */ new Set();
-  let previousActiveUuid;
-  for (let index = 0; index < records.length; index++) {
-    const record2 = records[index];
+  for (const record2 of records) {
     const activeRecord = activeByUuid.get(record2.uuid);
     if (activeRecord) {
       selected.push(activeRecord);
       activeByUuid.delete(record2.uuid);
-      previousActiveUuid = record2.uuid;
-      continue;
-    }
-    if (!isSessionArtifactRecord(record2)) {
       continue;
     }
-    const nextUuid = nextActiveUuidByIndex.get(index);
-    const hasBlockingRecordBeforeNextActive = nextBlockingUuidByIndex.has(index);
-    const isInActiveSegment = !hasBlockingRecordBeforeNextActive && (nextUuid !== void 0 ? activeUuids.has(nextUuid) : previousActiveUuid !== void 0 && activeUuids.has(previousActiveUuid));
-    if (record2.parentUuid !== null && (activeUuids.has(record2.parentUuid) || includedSideArtifactUuids.has(record2.parentUuid)) && isInActiveSegment && (record2.parentUuid === previousActiveUuid || includedSideArtifactUuids.has(record2.parentUuid))) {
-      selected.push(record2);
-      includedSideArtifactUuids.add(record2.uuid);
-    } else if (record2.parentUuid === null && index < firstActiveIndex && isInActiveSegment) {
-      selected.push(record2);
-      includedSideArtifactUuids.add(record2.uuid);
-    }
+    if (artifactUuids.has(record2.uuid)) selected.push(record2);
   }
   return selected;
 }
 __name(includeActiveSideArtifactRecords, "includeActiveSideArtifactRecords");
-function isTailNeutralSideRecord(record2) {
-  return record2.type === "system" && record2.subtype === "custom_title";
-}
-__name(isTailNeutralSideRecord, "isTailNeutralSideRecord");
 function collectFileHistorySnapshotPromptIds(records) {
   const ids = /* @__PURE__ */ new Set();
   for (const record2 of records) {
@@ -32783,37 +33921,6 @@ function replayUiTelemetryFromConversation(conversation, sessionId) {
   return resumeTokenCounts;
 }
 __name(replayUiTelemetryFromConversation, "replayUiTelemetryFromConversation");
-function getResumeTokenCounts(conversation) {
-  for (let i = conversation.messages.length - 1; i >= 0; i--) {
-    const record2 = conversation.messages[i];
-    if (record2.type === "assistant") {
-      const usage = record2.usageMetadata;
-      const candidate = usage?.promptTokenCount ?? usage?.totalTokenCount;
-      if (candidate) {
-        return {
-          promptTokenCount: candidate,
-          outputTokenCount: getUsageOutputTokenCountForPromptEstimate(usage),
-          isEstimated: false
-        };
-      }
-    }
-    if (record2.type === "system" && record2.subtype === "chat_compression") {
-      const payload = record2.systemPayload;
-      if (payload?.info) {
-        return {
-          promptTokenCount: payload.info.newTokenCount,
-          outputTokenCount: 0,
-          // Checkpoints created before provenance was persisted are safest to
-          // treat as estimates: this keeps the output clamp's overhead pad on
-          // and prevents an optimistic resume from overflowing the window.
-          isEstimated: payload.info.newTokenCountIsEstimated ?? true
-        };
-      }
-    }
-  }
-  return void 0;
-}
-__name(getResumeTokenCounts, "getResumeTokenCounts");
 var MAX_BRANCH_COLLISION_SCAN = 99;
 async function computeUniqueBranchTitle(baseName, sessionService) {
   const maxSuffixLen = " (Branch 1234567890123)".length;
@@ -33118,24 +34225,28 @@ function copyGoalContext(goalContext) {
 }
 __name(copyGoalContext, "copyGoalContext");
 var ChatRecordingService = class {
-  constructor(config, onWriteFailure, writerLeaseRequired = config.isSessionWriterLeaseEnabled?.() ?? config.getExperimentalZedIntegration?.() ?? true) {
+  constructor(config, onWriteFailure, writerLeaseRequired = config.isSessionWriterLeaseEnabled?.() ?? config.getExperimentalZedIntegration?.() ?? true, restoreState) {
     this.onWriteFailure = onWriteFailure;
     this.config = config;
     this.writerLeaseRequired = writerLeaseRequired;
     const resumed = config.getResumedSessionData();
     if (writerLeaseRequired) {
-      this.lastRecordUuid = resumed?.lastCompletedUuid ?? null;
+      this.lastRecordUuid = restoreState?.lastCompletedUuid ?? resumed?.lastCompletedUuid ?? null;
       this.lastPersistedRecordUuid = this.lastRecordUuid;
     } else {
       this.state = "active";
       this.acceptingWrites = true;
-      this.restoreSessionState(
-        resumed ? {
-          conversation: resumed.conversation ?? { messages: [] },
-          lastCompletedUuid: resumed.lastCompletedUuid
-        } : void 0,
-        resumed ? this.readPersistedTitleInfo() : void 0
-      );
+      if (restoreState) {
+        this.restoreProjectedState(restoreState);
+      } else {
+        this.restoreSessionState(
+          resumed ? {
+            conversation: resumed.conversation ?? { messages: [] },
+            lastCompletedUuid: resumed.lastCompletedUuid
+          } : void 0,
+          resumed ? this.readPersistedTitleInfo() : void 0
+        );
+      }
     }
   }
   static {
@@ -33339,12 +34450,29 @@ var ChatRecordingService = class {
       this.userDisplayTextsForTitle.shift();
     }
   }
-  activate(lease, sessionData, persistedTitleInfo) {
+  restoreProjectedState(state) {
+    this.lastRecordUuid = state.lastCompletedUuid;
+    this.lastPersistedRecordUuid = state.lastCompletedUuid;
+    this.turnParentUuids = [...state.turnParentUuids];
+    this.currentCustomTitle = state.customTitle;
+    this.currentTitleSource = state.titleSource;
+    this.currentParentSessionId = state.parentSessionId;
+    this.currentSourceType = state.sourceType;
+    this.currentSourceId = state.sourceId;
+    if (this.currentCustomTitle) {
+      this.bytesSinceTitleAnchor = TITLE_REANCHOR_BYTES;
+    }
+  }
+  activate(lease, sessionData, persistedTitleInfo, restoreState) {
     if (!this.writerLeaseRequired || this.state !== "inactive" || lease.sessionId !== this.config.getSessionId()) {
       throw new SessionWriterUnavailableError();
     }
     this.binding = { sessionId: lease.sessionId, lease };
-    this.restoreSessionState(sessionData, persistedTitleInfo);
+    if (restoreState) {
+      this.restoreProjectedState(restoreState);
+    } else {
+      this.restoreSessionState(sessionData, persistedTitleInfo);
+    }
     this.state = "active";
     this.acceptingWrites = true;
   }
@@ -58674,7 +59802,7 @@ var HybridTokenStorage = class extends BaseTokenStorage {
     const forceFileStorage = process.env[FORCE_FILE_STORAGE_ENV_VAR] === "true";
     if (!forceFileStorage) {
       try {
-        const { KeychainTokenStorage: KeychainTokenStorage2 } = await import("./keychain-token-storage-JTWUYFU7.js");
+        const { KeychainTokenStorage: KeychainTokenStorage2 } = await import("./keychain-token-storage-GU75J2T2.js");
         const keychainStorage = new KeychainTokenStorage2(this.serviceName);
         const isAvailable = await keychainStorage.isAvailable();
         if (isAvailable) {
@@ -79833,39 +80961,6 @@ var formatMemoryUsage = /* @__PURE__ */ __name((bytes) => {
 // packages/core/src/utils/shellContextEnv.ts
 init_esbuild_shims();
 import { accessSync as accessSync2, closeSync as closeSync3, constants as constants4, openSync as openSync3, readSync } from "node:fs";
-
-// packages/core/src/utils/sessionIdContext.ts
-init_esbuild_shims();
-import { AsyncLocalStorage } from "node:async_hooks";
-var sessionIdContext = new AsyncLocalStorage();
-var projectDirBySession = /* @__PURE__ */ new Map();
-function registerSessionProjectDir(sessionId, projectDir) {
-  if (sessionId && projectDir) projectDirBySession.set(sessionId, projectDir);
-}
-__name(registerSessionProjectDir, "registerSessionProjectDir");
-function getSessionProjectDir(sessionId) {
-  return projectDirBySession.get(sessionId);
-}
-__name(getSessionProjectDir, "getSessionProjectDir");
-function unregisterSessionProjectDir(sessionId) {
-  projectDirBySession.delete(sessionId);
-}
-__name(unregisterSessionProjectDir, "unregisterSessionProjectDir");
-var modelBySession = /* @__PURE__ */ new Map();
-function registerSessionModel(sessionId, model) {
-  if (sessionId && model) modelBySession.set(sessionId, model);
-}
-__name(registerSessionModel, "registerSessionModel");
-function getSessionModel(sessionId) {
-  return modelBySession.get(sessionId);
-}
-__name(getSessionModel, "getSessionModel");
-function unregisterSessionModel(sessionId) {
-  modelBySession.delete(sessionId);
-}
-__name(unregisterSessionModel, "unregisterSessionModel");
-
-// packages/core/src/utils/shellContextEnv.ts
 var unusableCache = /* @__PURE__ */ new Map();
 function isUnusableScriptEntry(path103) {
   if (!/\.(?:mjs|cjs|js)$/i.test(path103)) return false;
@@ -80114,10 +81209,11 @@ var serializePlainViewportToAnsiOutput = /* @__PURE__ */ __name((terminal, unwra
   return lines;
 }, "serializePlainViewportToAnsiOutput");
 var WINDOWS_TASKKILL = `${process.env["SystemRoot"] || "C:\\Windows"}\\System32\\taskkill.exe`;
+var WINDOWS_TASKKILL_OPTIONS = { windowsHide: true };
 var windowsKillPid = /* @__PURE__ */ __name((pid, tree) => {
   try {
     const args = tree ? ["/f", "/t", "/pid", pid.toString()] : ["/f", "/pid", pid.toString()];
-    const killer = cpSpawn(WINDOWS_TASKKILL, args);
+    const killer = cpSpawn(WINDOWS_TASKKILL, args, WINDOWS_TASKKILL_OPTIONS);
     killer.on("error", (e) => {
       debugLogger58.warn(
         `windowsKillPid: taskkill failed to launch for pid ${pid}: ${e.message}`
@@ -80139,7 +81235,11 @@ var windowsKillPid = /* @__PURE__ */ __name((pid, tree) => {
 var windowsStrategy = {
   killPty: /* @__PURE__ */ __name((pid, pty) => {
     try {
-      spawnSync3(WINDOWS_TASKKILL, ["/f", "/t", "/pid", pid.toString()]);
+      spawnSync3(
+        WINDOWS_TASKKILL,
+        ["/f", "/t", "/pid", pid.toString()],
+        WINDOWS_TASKKILL_OPTIONS
+      );
     } catch {
     }
     try {
@@ -80154,7 +81254,7 @@ var windowsStrategy = {
         for (const pid of pids) {
           args.push("/pid", pid.toString());
         }
-        spawnSync3(WINDOWS_TASKKILL, args);
+        spawnSync3(WINDOWS_TASKKILL, args, WINDOWS_TASKKILL_OPTIONS);
       } catch {
       }
     }
@@ -80615,12 +81715,11 @@ var ShellExecutionService = class _ShellExecutionService {
         const performCancelKill = /* @__PURE__ */ __name(async () => {
           if (!child.pid || exited) return;
           if (isWindows3) {
-            const killer = cpSpawn(WINDOWS_TASKKILL, [
-              "/f",
-              "/t",
-              "/pid",
-              child.pid.toString()
-            ]);
+            const killer = cpSpawn(
+              WINDOWS_TASKKILL,
+              ["/f", "/t", "/pid", child.pid.toString()],
+              WINDOWS_TASKKILL_OPTIONS
+            );
             const killChildFallback = /* @__PURE__ */ __name((why) => {
               debugLogger58.warn(
                 `performCancelKill (child_process): taskkill ${why} for pid ${child.pid}; falling back to child.kill`
@@ -81260,12 +82359,11 @@ var ShellExecutionService = class _ShellExecutionService {
           cancelKillDispatched = true;
           if (os11.platform() === "win32") {
             try {
-              const r = spawnSync3(WINDOWS_TASKKILL, [
-                "/f",
-                "/t",
-                "/pid",
-                ptyProcess.pid.toString()
-              ]);
+              const r = spawnSync3(
+                WINDOWS_TASKKILL,
+                ["/f", "/t", "/pid", ptyProcess.pid.toString()],
+                WINDOWS_TASKKILL_OPTIONS
+              );
               if (r.error || typeof r.status === "number" && r.status !== 0) {
                 debugLogger58.warn(
                   `performCancelKill: taskkill failed for pid ${ptyProcess.pid}: ${r.error?.message ?? `exit ${r.status}`}`
@@ -81547,6 +82645,26 @@ function readLastTranscriptRecordUuidSync(jsonlPath) {
   return null;
 }
 __name(readLastTranscriptRecordUuidSync, "readLastTranscriptRecordUuidSync");
+function buildAgentTranscriptAttach(config, agentId, extras) {
+  const projectRoot = config.getProjectRoot();
+  const options2 = {
+    agentId,
+    sessionId: config.getSessionId(),
+    cwd: projectRoot,
+    version: config.getCliVersion() || "unknown",
+    gitBranch: getCachedGitBranch(projectRoot),
+    ...extras
+  };
+  return {
+    jsonlPath: getAgentJsonlPath(
+      config.storage.getProjectDir(),
+      options2.sessionId,
+      options2.agentId
+    ),
+    options: options2
+  };
+}
+__name(buildAgentTranscriptAttach, "buildAgentTranscriptAttach");
 function attachJsonlTranscriptWriter(emitter, jsonlPath, options2) {
   let lastUuid = options2.initialParentUuid !== void 0 ? options2.initialParentUuid : options2.appendToExisting ? readLastTranscriptRecordUuidSync(jsonlPath) : null;
   let fd = null;
@@ -81721,6 +82839,9 @@ function attachJsonlTranscriptWriter(emitter, jsonlPath, options2) {
       displayText: options2.launchTaskPrompt
     });
   }
+  if (options2.retryAttempt !== void 0) {
+    recordSystem("agent_retry", { attempt: options2.retryAttempt });
+  }
   emitter.on("round_text" /* ROUND_TEXT */, onRoundText);
   emitter.on("stream_text" /* STREAM_TEXT */, appendStreamText);
   emitter.on("tool_call" /* TOOL_CALL */, onToolCall);
@@ -114211,19 +115332,19 @@ var BackgroundAgentResumeService = class {
         subagent = result.subagent;
         subagentDispose = result.dispose;
       }
-      const projectRoot = this.config.getProjectRoot();
-      cleanupJsonl = attachJsonlTranscriptWriter(bgEventEmitter, outputFile, {
-        agentId: meta.agentId,
+      const { jsonlPath, options: transcriptAttachOptions } = buildAgentTranscriptAttach(this.config, meta.agentId, {
+        sessionId: meta.parentSessionId,
         agentName: target.agentName,
         agentColor: target.subagentConfig?.color ?? meta.agentColor,
-        sessionId: meta.parentSessionId,
-        cwd: projectRoot,
-        version: this.config.getCliVersion() || "unknown",
-        gitBranch: getGitBranch(projectRoot),
         initialUserPrompt: writerInitialPrompt,
         appendToExisting: true,
         initialParentUuid: recovery.lastStableUuid
-      }).cleanup;
+      });
+      cleanupJsonl = attachJsonlTranscriptWriter(
+        bgEventEmitter,
+        jsonlPath,
+        transcriptAttachOptions
+      ).cleanup;
       const nextResumeCount = (meta.resumeCount ?? 0) + 1;
       patchAgentMeta(metaPath, {
         status: "running",
@@ -130519,12 +131640,13 @@ ${longRunHint}` : ""),
       if (pid !== void 0) {
         if (os23.platform() === "win32") {
           try {
-            const taskkillChild = childProcess.spawn("taskkill", [
-              "/pid",
-              String(pid),
-              "/f",
-              "/t"
-            ]);
+            const taskkillChild = childProcess.spawn(
+              "taskkill",
+              ["/pid", String(pid), "/f", "/t"],
+              // The desktop runtime daemon has no console; without this
+              // flag each console-app child allocates a visible window.
+              { windowsHide: true }
+            );
             taskkillChild.on("error", () => {
             });
           } catch {
@@ -130594,12 +131716,13 @@ ${longRunHint}` : ""),
       if (pid !== void 0) {
         if (os23.platform() === "win32") {
           try {
-            const taskkillChild = childProcess.spawn("taskkill", [
-              "/pid",
-              String(pid),
-              "/f",
-              "/t"
-            ]);
+            const taskkillChild = childProcess.spawn(
+              "taskkill",
+              ["/pid", String(pid), "/f", "/t"],
+              // The desktop runtime daemon has no console; without this
+              // flag each console-app child allocates a visible window.
+              { windowsHide: true }
+            );
             taskkillChild.on("error", (err) => {
               debugLogger125.warn(
                 `promote: taskkill spawn failed for pid=${pid}: ${err.message}`
@@ -130912,7 +132035,7 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
       const child = childProcess.execFile(
         "git",
         args,
-        { cwd, timeout: 2e3 },
+        { cwd, timeout: 2e3, windowsHide: true },
         (error, stdout) => {
           if (error) {
             resolve41(0);
@@ -130940,7 +132063,7 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
       const child = childProcess.execFile(
         "git",
         ["rev-parse", "HEAD"],
-        { cwd, timeout: 2e3 },
+        { cwd, timeout: 2e3, windowsHide: true },
         (error, stdout) => {
           if (error) {
             resolve41(null);
@@ -130972,6 +132095,7 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
       const stdout = childProcess.execFileSync("git", ["rev-parse", "HEAD"], {
         cwd,
         timeout: 2e3,
+        windowsHide: true,
         // Discard stderr noise (e.g. "fatal: not a git repository") —
         // the catch-or-empty-output path already covers failure.
         stdio: ["ignore", "pipe", "ignore"]
@@ -131052,6 +132176,7 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
           return childProcess.execFileSync("git", ["show", `${postHead}:${rel}`], {
             cwd,
             timeout: 2e3,
+            windowsHide: true,
             stdio: ["ignore", "pipe", "ignore"],
             maxBuffer: 16 * 1024 * 1024
           }).toString("utf-8");
@@ -131088,7 +132213,7 @@ To inspect: /tasks (text) or the interactive Background tasks dialog (focus the
         const child = childProcess.execFile(
           notesCommand.command,
           notesCommand.args,
-          { cwd, timeout: 5e3 },
+          { cwd, timeout: 5e3, windowsHide: true },
           (error, stdout, stderr) => {
             const merged = (stdout || "") + (stderr || "");
             if (error) {
@@ -137534,14 +138659,6 @@ __name(loadForkProfile, "loadForkProfile");
 
 // packages/core/src/tools/agent/agent.ts
 init_esm();
-var gitBranchCache = /* @__PURE__ */ new Map();
-function getCachedGitBranch(cwd) {
-  if (gitBranchCache.has(cwd)) return gitBranchCache.get(cwd);
-  const branch = getGitBranch(cwd);
-  gitBranchCache.set(cwd, branch);
-  return branch;
-}
-__name(getCachedGitBranch, "getCachedGitBranch");
 function persistBackgroundCancellation2(metaPath, persistedStatus) {
   patchAgentMeta(metaPath, {
     status: persistedStatus,
@@ -139441,17 +140558,21 @@ ${taskPrompt}`;
         const registry2 = this.config.getBackgroundTaskRegistry();
         const projectDir = this.config.storage.getProjectDir();
         const sessionId = this.config.getSessionId();
-        const jsonlPath = getAgentJsonlPath(
-          projectDir,
-          sessionId,
-          hookOpts.agentId
-        );
+        const { jsonlPath, options: transcriptAttachOptions } = buildAgentTranscriptAttach(this.config, hookOpts.agentId, {
+          agentName: subagentConfig.name,
+          agentColor: subagentConfig.color,
+          // Seed the JSONL with the launching prompt so the transcript is
+          // self-describing — readers don't need to consult .meta.json to
+          // know what the agent was asked to do.
+          initialUserPrompt: this.params.prompt,
+          bootstrapHistory: isFork ? bgInitialMessages : void 0,
+          launchTaskPrompt: isFork ? bgTaskPrompt : void 0
+        });
         const metaPath = getAgentMetaPath(
           projectDir,
           sessionId,
           hookOpts.agentId
         );
-        const projectRoot = this.config.getProjectRoot();
         try {
           const registerOptions = backgroundSlotReservation ? { slotReservation: backgroundSlotReservation } : {};
           registry2.register(
@@ -139531,21 +140652,7 @@ ${taskPrompt}`;
         const { cleanup: cleanupJsonl } = attachJsonlTranscriptWriter(
           bgEventEmitter,
           jsonlPath,
-          {
-            agentId: hookOpts.agentId,
-            agentName: subagentConfig.name,
-            agentColor: subagentConfig.color,
-            sessionId,
-            cwd: projectRoot,
-            version: this.config.getCliVersion() || "unknown",
-            gitBranch: getCachedGitBranch(projectRoot),
-            // Seed the JSONL with the launching prompt so the transcript is
-            // self-describing — readers don't need to consult .meta.json to
-            // know what the agent was asked to do.
-            initialUserPrompt: this.params.prompt,
-            bootstrapHistory: isFork ? bgInitialMessages : void 0,
-            launchTaskPrompt: isFork ? bgTaskPrompt : void 0
-          }
+          transcriptAttachOptions
         );
         writeAgentMeta(metaPath, {
           agentId: hookOpts.agentId,
@@ -140029,17 +141136,19 @@ If asked, you can check progress before completion by using ${ToolNames.READ_FIL
       const registry = this.config.getBackgroundTaskRegistry();
       const fgProjectDir = this.config.storage.getProjectDir();
       const fgSessionId = this.config.getSessionId();
-      const fgJsonlPath = getAgentJsonlPath(
-        fgProjectDir,
-        fgSessionId,
-        hookOpts.agentId
-      );
+      const { jsonlPath: fgJsonlPath, options: fgTranscriptAttachOptions } = buildAgentTranscriptAttach(this.config, hookOpts.agentId, {
+        agentName: subagentConfig.name,
+        agentColor: subagentConfig.color,
+        // Seed the JSONL with the launching prompt so the transcript
+        // is self-describing — readers don't need the meta sidecar to
+        // know what the agent was asked to do.
+        initialUserPrompt: this.params.prompt
+      });
       const fgMetaPath = getAgentMetaPath(
         fgProjectDir,
         fgSessionId,
         hookOpts.agentId
       );
-      const fgProjectRoot = this.config.getProjectRoot();
       let cleanupFgJsonl;
       const cleanupOwnedMonitorNotifications = this.registerOwnedMonitorNotifications(
         hookOpts.agentId,
@@ -140086,19 +141195,7 @@ If asked, you can check progress before completion by using ${ToolNames.READ_FIL
         ({ cleanup: cleanupFgJsonl } = attachJsonlTranscriptWriter(
           this.eventEmitter,
           fgJsonlPath,
-          {
-            agentId: hookOpts.agentId,
-            agentName: subagentConfig.name,
-            agentColor: subagentConfig.color,
-            sessionId: fgSessionId,
-            cwd: fgProjectRoot,
-            version: this.config.getCliVersion() || "unknown",
-            gitBranch: getCachedGitBranch(fgProjectRoot),
-            // Seed the JSONL with the launching prompt so the transcript
-            // is self-describing — readers don't need the meta sidecar to
-            // know what the agent was asked to do.
-            initialUserPrompt: this.params.prompt
-          }
+          fgTranscriptAttachOptions
         ));
         registry.register({
           agentId: hookOpts.agentId,
@@ -143112,7 +144209,32 @@ var GeminiClient = class _GeminiClient {
       return;
     }
     const resumedSessionData = this.config.getResumedSessionData();
-    if (resumedSessionData) {
+    const restoreRuntime = this.config.getSessionRestoreRuntime?.();
+    if (restoreRuntime) {
+      uiTelemetryService.resetSession(sessionId);
+      for (const event of restoreRuntime.uiTelemetryEvents) {
+        uiTelemetryService.addEvent(event, sessionId);
+      }
+      this.seedRecentCompletedToolNamesFromHistory(restoreRuntime.apiHistory);
+      await this.startChat(
+        restoreRuntime.apiHistory,
+        sessionStartSource ?? "resume" /* Resume */
+      );
+      const chat = this.getChat();
+      if (restoreRuntime.resumeTokenCounts) {
+        const counts = restoreRuntime.resumeTokenCounts;
+        uiTelemetryService.setLastPromptTokenCount(counts.promptTokenCount);
+        chat.seedResumeTokenCounts(
+          counts.promptTokenCount,
+          counts.outputTokenCount,
+          counts.isEstimated
+        );
+      } else {
+        chat.setLastPromptTokenCount(
+          uiTelemetryService.getLastPromptTokenCount()
+        );
+      }
+    } else if (resumedSessionData) {
       const resumeTokenCounts = replayUiTelemetryFromConversation(
         resumedSessionData.conversation,
         this.config.getSessionId()
@@ -147289,6 +148411,12 @@ var Config = class _Config {
   sessionSourceType;
   sessionSourceId;
   sessionData;
+  pendingSessionRestoreProjection;
+  sessionRestoreRuntime;
+  sessionRestoreProjectionSource;
+  restoredFileHistory = false;
+  goalRestoreActivation;
+  rejectGoalRestoreActivation;
   sessionRuntimeBaseDir;
   sessionProjectDirRegistered = false;
   pendingSessionWriterLease;
@@ -147642,6 +148770,8 @@ var Config = class _Config {
       sessionEnvClaimed = true;
     }
     this.sessionData = params.sessionData;
+    this.sessionRestoreProjectionSource = params.sessionRestoreProjectionSource;
+    this.setSessionRestoreProjection(params.sessionRestoreProjection);
     setDebugLogSession(this);
     this.debugLogger = createDebugLogger();
     this.embeddingModel = params.embeddingModel ?? DEFAULT_QWEN_EMBEDDING_MODEL;
@@ -147910,7 +149040,12 @@ var Config = class _Config {
     }
     this.geminiClient = new GeminiClient(this);
     this.chatRecordingService = this.chatRecordingEnabled ? this.createChatRecordingService() : void 0;
-    this.initializeGoalRuntime(this.sessionData?.conversation.messages);
+    if (!this.sessionRestoreProjectionSource || this.sessionRestoreRuntime || !this.sessionWriterLeaseEnabled) {
+      this.initializeGoalRuntime(
+        this.sessionRestoreRuntime?.goalRecords ?? this.sessionData?.conversation.messages,
+        this.sessionRestoreRuntime
+      );
+    }
     this.extensionManager = new ExtensionManager({
       workspaceDir: this.targetDir,
       enabledExtensionOverrides: this.overrideExtensions,
@@ -147978,6 +149113,7 @@ var Config = class _Config {
       this.sessionProjectDirRegistered = true;
       await this.initializeInternal(options2);
     } catch (error) {
+      this.clearSessionRestoreProjection();
       if (this.sessionProjectDirRegistered) {
         unregisterSessionProjectDir(this.sessionId);
         this.sessionProjectDirRegistered = false;
@@ -148387,7 +149523,15 @@ var Config = class _Config {
         throw new SessionTranscriptChangedError();
       }
       let authoritative;
-      if (this.sessionData || lease.transcriptExistedAtAcquire) {
+      let projection;
+      if (this.sessionRestoreProjectionSource) {
+        addDaemonRequestAttribute(
+          "qwen-code.daemon.session_restore.projection_acquisition",
+          "after_writer_lease"
+        );
+        projection = await this.sessionRestoreProjectionSource();
+        this.setSessionRestoreProjection(projection);
+      } else if (this.sessionData || lease.transcriptExistedAtAcquire) {
         authoritative = await this.getSessionService().loadSession(
           this.sessionId
         );
@@ -148401,7 +149545,18 @@ var Config = class _Config {
         throw new SessionWriterShutdownError();
       }
       this.sessionData = authoritative;
-      recorder.activate(lease, authoritative, persistedTitleInfo);
+      recorder.activate(
+        lease,
+        authoritative,
+        persistedTitleInfo,
+        projection?.runtime.recording
+      );
+      if (this.sessionRestoreProjectionSource) {
+        this.initializeGoalRuntime(
+          projection?.runtime.goalRecords,
+          projection?.runtime
+        );
+      }
       this.pendingSessionWriterLease = void 0;
       lease = void 0;
       this.startPendingGoalRestore();
@@ -148799,6 +149954,68 @@ var Config = class _Config {
   getSessionId() {
     return this.sessionId;
   }
+  getSessionRestoreRuntime() {
+    return this.sessionRestoreRuntime;
+  }
+  consumeSessionRestoreProjection() {
+    const projection = this.pendingSessionRestoreProjection;
+    this.pendingSessionRestoreProjection = void 0;
+    return projection;
+  }
+  hydrateSessionRestoreFileHistory() {
+    if (this.restoredFileHistory) return;
+    const snapshots = this.sessionRestoreRuntime?.fileHistorySnapshots;
+    if (!snapshots?.length) return;
+    const service = this.getFileHistoryService();
+    if (!service.isEnabled()) return;
+    service.restoreFromSnapshots(snapshots);
+    this.restoredFileHistory = true;
+  }
+  finalizeSessionRestore() {
+    const runtime = this.sessionRestoreRuntime;
+    if (!runtime) return;
+    this.sessionRestoreRuntime = void 0;
+    if (runtime.attributionSnapshot) {
+      try {
+        CommitAttributionService.getInstance().restoreFromSnapshot(
+          runtime.attributionSnapshot
+        );
+      } catch (error) {
+        this.debugLogger.error(
+          `Session restore attribution activation failed: ${error}`
+        );
+      }
+    }
+    const activateGoal = this.goalRestoreActivation;
+    this.goalRestoreActivation = void 0;
+    this.rejectGoalRestoreActivation = void 0;
+    if (activateGoal) {
+      try {
+        void activateGoal().catch((error) => {
+          this.debugLogger.error(
+            `Session restore goal activation failed: ${error}`
+          );
+        });
+      } catch (error) {
+        this.debugLogger.error(
+          `Session restore goal activation failed: ${error}`
+        );
+      }
+    }
+    if (this.restoredFileHistory && this.fileHistoryService) {
+      try {
+        void this.fileHistoryService.validateRestoredSnapshots().catch((error) => {
+          this.debugLogger.error(
+            `FileHistory: validateRestoredSnapshots failed: ${error}`
+          );
+        });
+      } catch (error) {
+        this.debugLogger.error(
+          `FileHistory: validateRestoredSnapshots failed: ${error}`
+        );
+      }
+    }
+  }
   setSessionSource(sourceType, sourceId) {
     this.sessionSourceType = sourceType;
     this.sessionSourceId = sourceId;
@@ -148855,6 +150072,7 @@ var Config = class _Config {
     unregisterSessionModel(previousSessionId);
     this.publishModelEnv();
     this.sessionData = sessionData;
+    this.clearSessionRestoreProjection();
     this.pendingRecoveredAgentsNotice = null;
     this.getOwnActiveTodoReminders().clear();
     this.getOwnActiveTodoWorkChainOwners().clear();
@@ -149775,12 +150993,18 @@ var Config = class _Config {
   }
   async shutdownResourcesOnce() {
     try {
+      this.clearSessionRestoreProjection();
       if (this.sessionProjectDirRegistered) {
         unregisterSessionProjectDir(this.sessionId);
         this.sessionProjectDirRegistered = false;
       }
       unregisterSessionModel(this.sessionId);
       if (Object.hasOwn(this, "goalRuntime")) {
+        this.rejectGoalRestoreActivation?.(
+          new GoalPersistenceUnavailableError("Goal runtime disposed")
+        );
+        this.goalRestoreActivation = void 0;
+        this.rejectGoalRestoreActivation = void 0;
         this.goalTurnHostUnbind?.();
         this.goalTurnHostUnbind = void 0;
         this.settlePendingGoalRestore(
@@ -151659,6 +152883,11 @@ var Config = class _Config {
     }
     return this.goalRuntimeReady.then(() => runtime);
   }
+  getGoalRuntimePrepared() {
+    const runtime = this.getGoalRuntime();
+    if (!this.sessionRestoreRuntime) return this.getGoalRuntimeReady();
+    return runtime.getPreparedRestore().then(() => runtime);
+  }
   async rebaseGoalRuntimeFromActiveTranscript() {
     const runtime = this.getGoalRuntime();
     const recordingService = this.chatRecordingService;
@@ -151702,10 +152931,16 @@ var Config = class _Config {
       (event) => {
         this.notifyChatRecordingFailure(event);
       },
-      this.sessionWriterLeaseEnabled
+      this.sessionWriterLeaseEnabled,
+      this.sessionRestoreRuntime?.recording
     );
   }
-  initializeGoalRuntime(records) {
+  initializeGoalRuntime(records, restoreRuntime) {
+    this.rejectGoalRestoreActivation?.(
+      new GoalPersistenceUnavailableError("Goal runtime replaced")
+    );
+    this.goalRestoreActivation = void 0;
+    this.rejectGoalRestoreActivation = void 0;
     this.goalTurnHostUnbind?.();
     this.goalTurnHostUnbind = void 0;
     this.settlePendingGoalRestore(
@@ -151729,7 +152964,27 @@ var Config = class _Config {
     if (this.goalTurnHost) {
       this.goalTurnHostUnbind = runtime.bindHost(this.goalTurnHost);
     }
-    if (this.sessionWriterLeaseEnabled && !recorder.hasWriteOwnership()) {
+    if (restoreRuntime) {
+      const preparation = runtime.prepareRestore(
+        records ?? [],
+        restoreRuntime.goalCheckpointWindow
+      );
+      let resolveActivation;
+      let rejectActivation;
+      const activation = new Promise((resolve41, reject) => {
+        resolveActivation = resolve41;
+        rejectActivation = reject;
+      });
+      this.rejectGoalRestoreActivation = rejectActivation;
+      this.goalRestoreActivation = () => {
+        const started = runtime.activateRestoredWork();
+        void started.then(resolveActivation, rejectActivation);
+        return started;
+      };
+      this.goalRuntimeReady = Promise.all([preparation, activation]).then(
+        () => runtime
+      );
+    } else if (this.sessionWriterLeaseEnabled && !recorder.hasWriteOwnership()) {
       const ready = new Promise((resolve41, reject) => {
         this.pendingGoalRestore = { runtime, resolve: resolve41, reject };
       });
@@ -151777,6 +153032,21 @@ var Config = class _Config {
     this.pendingGoalRestore = void 0;
     pending.reject(error);
   }
+  setSessionRestoreProjection(projection) {
+    this.pendingSessionRestoreProjection = projection;
+    this.sessionRestoreRuntime = projection?.runtime;
+    this.restoredFileHistory = false;
+  }
+  clearSessionRestoreProjection() {
+    this.pendingSessionRestoreProjection = void 0;
+    this.sessionRestoreRuntime = void 0;
+    this.restoredFileHistory = false;
+    this.rejectGoalRestoreActivation?.(
+      new GoalPersistenceUnavailableError("Session restore was abandoned")
+    );
+    this.goalRestoreActivation = void 0;
+    this.rejectGoalRestoreActivation = void 0;
+  }
   notifyChatRecordingFailure(event) {
     for (const listener of [...this.chatRecordingFailureListeners]) {
       try {
@@ -152100,7 +153370,7 @@ var Config = class _Config {
     }
     if (!enabled) return;
     registry.registerFactory(ToolNames.IMAGE_GEN, async () => {
-      const { ImageGenTool } = await import("./image-gen-OTFC2S7L.js");
+      const { ImageGenTool } = await import("./image-gen-DC2IQZ73.js");
       return new ImageGenTool(this);
     });
   }
@@ -152130,36 +153400,36 @@ var Config = class _Config {
       if (options2?.forSubAgent) return;
       const schema = this.jsonSchema;
       await registerLazy(ToolNames.STRUCTURED_OUTPUT, async () => {
-        const { SyntheticOutputTool } = await import("./syntheticOutput-D3Z64LJC.js");
+        const { SyntheticOutputTool } = await import("./syntheticOutput-SEW4NA47.js");
         return new SyntheticOutputTool(schema);
       });
     }, "registerStructuredOutputIfRequested");
     const registerGoalWorkerTools = /* @__PURE__ */ __name(async () => {
       if (options2?.forSubAgent) return;
       await registerLazy(ToolNames.GET_GOAL, async () => {
-        const { GetGoalTool } = await import("./goal-tools-JDK2SNMV.js");
+        const { GetGoalTool } = await import("./goal-tools-LQFO4BRY.js");
         return new GetGoalTool(this);
       });
       await registerLazy(ToolNames.UPDATE_GOAL, async () => {
-        const { UpdateGoalTool } = await import("./goal-tools-JDK2SNMV.js");
+        const { UpdateGoalTool } = await import("./goal-tools-LQFO4BRY.js");
         return new UpdateGoalTool(this);
       });
     }, "registerGoalWorkerTools");
     if (this.getBareMode()) {
       await registerLazy(ToolNames.READ_FILE, async () => {
-        const { ReadFileTool } = await import("./read-file-GORBXJTS.js");
+        const { ReadFileTool } = await import("./read-file-IYEBTQT5.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-WXVZ7FHS.js");
+        const { EditTool } = await import("./edit-OXBMFY5B.js");
         return new EditTool(this);
       });
       await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-        const { NotebookEditTool } = await import("./notebook-edit-GEPL33NO.js");
+        const { NotebookEditTool } = await import("./notebook-edit-STSSB5KQ.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-C2UP5FF2.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-AR7XFLHA.js");
         return new ShellTool2(this);
       });
       await registerGoalWorkerTools();
@@ -152171,43 +153441,43 @@ var Config = class _Config {
     }
     await registerGoalWorkerTools();
     await registerLazy(ToolNames.TOOL_SEARCH, async () => {
-      const { ToolSearchTool } = await import("./tool-search-B6F3MPUZ.js");
+      const { ToolSearchTool } = await import("./tool-search-4UVNFYWU.js");
       return new ToolSearchTool(this);
     });
     await registerLazy(ToolNames.READ_MCP_RESOURCE, async () => {
-      const { ReadMcpResourceTool } = await import("./read-mcp-resource-TJSJRH4F.js");
+      const { ReadMcpResourceTool } = await import("./read-mcp-resource-THCSZHXO.js");
       return new ReadMcpResourceTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-FAWBG7PP.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-43KVQSB5.js");
       return new AgentTool2(this);
     });
     await registerLazy(ToolNames.LIST_AGENTS, async () => {
-      const { ListAgentsTool } = await import("./list-agents-4GQ2XNEU.js");
+      const { ListAgentsTool } = await import("./list-agents-5PNMK2AM.js");
       return new ListAgentsTool(this);
     });
     await registerLazy(ToolNames.TASK_STOP, async () => {
-      const { TaskStopTool } = await import("./task-stop-HHUGCD25.js");
+      const { TaskStopTool } = await import("./task-stop-MAYQJ42I.js");
       return new TaskStopTool(this);
     });
     await registerLazy(ToolNames.SEND_MESSAGE, async () => {
-      const { SendMessageTool } = await import("./send-message-RBYLV5NY.js");
+      const { SendMessageTool } = await import("./send-message-P5SLP57G.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-4XCNK55E.js");
+      const { SkillTool } = await import("./skill-K6NOUUYM.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
-      const { LSTool } = await import("./ls-FSHISLLA.js");
+      const { LSTool } = await import("./ls-RPRSX26R.js");
       return new LSTool(this);
     });
     await registerLazy(ToolNames.READ_FILE, async () => {
-      const { ReadFileTool } = await import("./read-file-GORBXJTS.js");
+      const { ReadFileTool } = await import("./read-file-IYEBTQT5.js");
       return new ReadFileTool(this);
     });
     await registerLazy(ToolNames.ZOOM_IMAGE, async () => {
-      const { ZoomImageTool } = await import("./zoom-image-RS6MU26F.js");
+      const { ZoomImageTool } = await import("./zoom-image-4TQA5GHG.js");
       return new ZoomImageTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -152222,7 +153492,7 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       if (useRipgrep) {
         await registerLazy(ToolNames.GREP, async () => {
-          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-RNLIZGCY.js");
+          const { RipGrepTool: RipGrepTool2 } = await import("./ripGrep-VV2CRCL2.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -152235,7 +153505,7 @@ var Config = class _Config {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-QWBLG564.js");
+          const { GrepTool } = await import("./grep-6CN23ZPS.js");
           return new GrepTool(this);
         });
       }
@@ -152243,77 +153513,77 @@ var Config = class _Config {
       recordStartupEvent("config_initialize_ripgrep_probe_start");
       recordStartupEvent("config_initialize_ripgrep_probe_end");
       await registerLazy(ToolNames.GREP, async () => {
-        const { GrepTool } = await import("./grep-QWBLG564.js");
+        const { GrepTool } = await import("./grep-6CN23ZPS.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-KJ4A4ZOM.js");
+      const { GlobTool } = await import("./glob-JKVAHWL5.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-WXVZ7FHS.js");
+      const { EditTool } = await import("./edit-OXBMFY5B.js");
       return new EditTool(this);
     });
     await registerLazy(ToolNames.NOTEBOOK_EDIT, async () => {
-      const { NotebookEditTool } = await import("./notebook-edit-GEPL33NO.js");
+      const { NotebookEditTool } = await import("./notebook-edit-STSSB5KQ.js");
       return new NotebookEditTool(this);
     });
     await registerLazy(ToolNames.WRITE_FILE, async () => {
-      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-PYL3JCCD.js");
+      const { WriteFileTool: WriteFileTool2 } = await import("./write-file-MSFRVUZB.js");
       return new WriteFileTool2(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-C2UP5FF2.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-AR7XFLHA.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
-      const { TodoWriteTool } = await import("./todoWrite-WINAZSZI.js");
+      const { TodoWriteTool } = await import("./todoWrite-IE2YTCK7.js");
       return new TodoWriteTool(this);
     });
     const supportsUserInteraction = resolveInteractionMode(this) !== "headless";
     if (supportsUserInteraction) {
       await registerLazy(ToolNames.ASK_USER_QUESTION, async () => {
-        const { AskUserQuestionTool } = await import("./askUserQuestion-7G3LI3IZ.js");
+        const { AskUserQuestionTool } = await import("./askUserQuestion-IQCA2SOX.js");
         return new AskUserQuestionTool(this);
       });
     }
     if (!this.sdkMode && (supportsUserInteraction || options2?.forSubAgent)) {
       await registerLazy(ToolNames.EXIT_PLAN_MODE, async () => {
-        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-MBPAPBBV.js");
+        const { ExitPlanModeTool: ExitPlanModeTool2 } = await import("./exitPlanMode-QQL27HU4.js");
         return new ExitPlanModeTool2(this);
       });
     }
     if (!this.sdkMode && supportsUserInteraction) {
       await registerLazy(ToolNames.ENTER_PLAN_MODE, async () => {
-        const { EnterPlanModeTool } = await import("./enterPlanMode-FT4MRU5N.js");
+        const { EnterPlanModeTool } = await import("./enterPlanMode-J6PDPFFT.js");
         return new EnterPlanModeTool(this);
       });
     }
     await registerLazy(ToolNames.ENTER_WORKTREE, async () => {
-      const { EnterWorktreeTool } = await import("./enter-worktree-TYMVXFLA.js");
+      const { EnterWorktreeTool } = await import("./enter-worktree-XS4JX4PO.js");
       return new EnterWorktreeTool(this);
     });
     await registerLazy(ToolNames.EXIT_WORKTREE, async () => {
-      const { ExitWorktreeTool } = await import("./exit-worktree-ODZUQLGJ.js");
+      const { ExitWorktreeTool } = await import("./exit-worktree-2RIE6DAO.js");
       return new ExitWorktreeTool(this);
     });
     await registerLazy(ToolNames.WEB_FETCH, async () => {
-      const { WebFetchTool } = await import("./web-fetch-NUOLHXPN.js");
+      const { WebFetchTool } = await import("./web-fetch-5ANX6FSM.js");
       return new WebFetchTool(this);
     });
     if (resolveInteractionMode(this) === "interactive" && !this.sdkMode && !this.getScreenReader() && !options2?.forSubAgent) {
       await registerLazy(ToolNames.DISPLAY_IMAGE, async () => {
-        const { DisplayImageTool } = await import("./display-image-ZE3GZNIK.js");
+        const { DisplayImageTool } = await import("./display-image-CAD7RAUM.js");
         return new DisplayImageTool(this);
       });
     }
     if (this.webSearchSettings?.enabled) {
-      const { evaluateWebSearchGate } = await import("./web-search-LVOOV4XZ.js");
+      const { evaluateWebSearchGate } = await import("./web-search-KQJWWRHW.js");
       const gate = evaluateWebSearchGate(this);
       if (gate.ok) {
         await registerLazy(ToolNames.WEB_SEARCH, async () => {
-          const { WebSearchTool } = await import("./web-search-LVOOV4XZ.js");
+          const { WebSearchTool } = await import("./web-search-KQJWWRHW.js");
           return new WebSearchTool(this);
         });
       } else if (!this.webSearchNoticeEmitted && !options2?.forSubAgent) {
@@ -152324,83 +153594,83 @@ var Config = class _Config {
     await this.registerImageGenerationTool(registry);
     if (this.isArtifactEnabled()) {
       await registerLazy(ToolNames.ARTIFACT, async () => {
-        const { ArtifactTool } = await import("./artifact-tool-FRMBPDPB.js");
+        const { ArtifactTool } = await import("./artifact-tool-RWJAKYBZ.js");
         return new ArtifactTool(this);
       });
     }
     if (this.isRecordArtifactEnabled()) {
       await registerLazy(ToolNames.RECORD_ARTIFACT, async () => {
-        const { RecordArtifactTool } = await import("./record-artifact-FXF5LHPE.js");
+        const { RecordArtifactTool } = await import("./record-artifact-76YYQA5F.js");
         return new RecordArtifactTool();
       });
     }
     if (this.isLspEnabled() && this.getLspClient()) {
       await registerLazy(ToolNames.LSP, async () => {
-        const { LspTool } = await import("./lsp-APQJ5ZEZ.js");
+        const { LspTool } = await import("./lsp-IWTJWFLT.js");
         return new LspTool(this);
       });
     }
     await registerStructuredOutputIfRequested();
     if (this.isCronEnabled()) {
       await registerLazy(ToolNames.CRON_CREATE, async () => {
-        const { CronCreateTool } = await import("./cron-create-ZOVA3CC2.js");
+        const { CronCreateTool } = await import("./cron-create-5WUTNKNF.js");
         return new CronCreateTool(this);
       });
       await registerLazy(ToolNames.CRON_LIST, async () => {
-        const { CronListTool } = await import("./cron-list-UHGX3IQG.js");
+        const { CronListTool } = await import("./cron-list-IXGCA7UR.js");
         return new CronListTool(this);
       });
       await registerLazy(ToolNames.CRON_DELETE, async () => {
-        const { CronDeleteTool } = await import("./cron-delete-7Z3H4LJY.js");
+        const { CronDeleteTool } = await import("./cron-delete-JEQ27YPS.js");
         return new CronDeleteTool(this);
       });
       await registerLazy(ToolNames.LOOP_WAKEUP, async () => {
-        const { LoopWakeupTool } = await import("./loop-wakeup-HOQI3K5D.js");
+        const { LoopWakeupTool } = await import("./loop-wakeup-OV65FEGR.js");
         return new LoopWakeupTool(this);
       });
     }
     await registerLazy(ToolNames.CREATE_SUB_SESSION, async () => {
-      const { CreateSubSessionTool } = await import("./create-sub-session-Y4WYDZGC.js");
+      const { CreateSubSessionTool } = await import("./create-sub-session-23ULO5PO.js");
       return new CreateSubSessionTool(this);
     });
     if (this.isAgentTeamEnabled()) {
       await registerLazy(ToolNames.TEAM_CREATE, async () => {
-        const { TeamCreateTool } = await import("./team-create-WZWH2NJI.js");
+        const { TeamCreateTool } = await import("./team-create-IEEEBLE2.js");
         return new TeamCreateTool(this);
       });
       await registerLazy(ToolNames.TEAM_DELETE, async () => {
-        const { TeamDeleteTool } = await import("./team-delete-PZGGBQLM.js");
+        const { TeamDeleteTool } = await import("./team-delete-3XVRPQBP.js");
         return new TeamDeleteTool(this);
       });
       await registerLazy(ToolNames.TEAM_PLAN_APPROVAL, async () => {
-        const { TeamPlanApprovalTool } = await import("./team-plan-approval-SUZQJCWJ.js");
+        const { TeamPlanApprovalTool } = await import("./team-plan-approval-SJGNS5JL.js");
         return new TeamPlanApprovalTool(this);
       });
       await registerLazy(ToolNames.TASK_CREATE, async () => {
-        const { TaskCreateTool } = await import("./task-create-URFZ5EUX.js");
+        const { TaskCreateTool } = await import("./task-create-247EAVF7.js");
         return new TaskCreateTool(this);
       });
       await registerLazy(ToolNames.TASK_UPDATE, async () => {
-        const { TaskUpdateTool } = await import("./task-update-DVV6CUGI.js");
+        const { TaskUpdateTool } = await import("./task-update-SU5TMZGG.js");
         return new TaskUpdateTool(this);
       });
       await registerLazy(ToolNames.TASK_LIST, async () => {
-        const { TaskListTool } = await import("./task-list-6JDFMPUW.js");
+        const { TaskListTool } = await import("./task-list-ZJN4QHLK.js");
         return new TaskListTool(this);
       });
     }
     if (this.isWorkflowsEnabled()) {
       await registerLazy(ToolNames.WORKFLOW, async () => {
-        const { WorkflowTool } = await import("./workflow-JSTYTG3K.js");
+        const { WorkflowTool } = await import("./workflow-C57ZKFUF.js");
         return new WorkflowTool(this);
       });
     }
     if (this.isComputerUseEnabled()) {
-      const { registerComputerUseTools } = await import("./computer-use-S4JEU5P7.js");
+      const { registerComputerUseTools } = await import("./computer-use-J5VUY257.js");
       await registerComputerUseTools(registerLazy, this);
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-PY4WDSX3.js");
+      const { MonitorTool } = await import("./monitor-SLGY7CYB.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -152871,6 +154141,7 @@ export {
   GROUP_COLOR_OPTIONS,
   SessionOrganizationError,
   SessionOrganizationService,
+  collectSessionTurnState,
   SESSION_TRANSCRIPT_MAX_LIMIT,
   SESSION_TRANSCRIPT_MAX_INDEX_BYTES,
   SESSION_TRANSCRIPT_MAX_PAGE_BYTES,
@@ -152881,8 +154152,6 @@ export {
   SessionTranscriptPageTooLargeError,
   SessionTranscriptCursorCodec,
   encodeSessionTranscriptCursor,
-  isReplayTurnStartType,
-  findBoundaryAtOrBefore,
   SessionTranscriptReader,
   SessionWriterError,
   SESSION_WRITER_RPC_CODES,
@@ -152968,7 +154237,6 @@ export {
   normalizeContent,
   sanitizeChildEnv,
   formatMemoryUsage,
-  sessionIdContext,
   getShellContextEnvVars,
   getShellPagerEnv,
   isSignalTermination,
@@ -153017,6 +154285,8 @@ export {
   getSubagentsRootDir,
   getSubagentSessionDir,
   readAgentMeta,
+  buildAgentTranscriptAttach,
+  attachJsonlTranscriptWriter,
   resolveSubagentApprovalMode,
   TOOL_REGISTRY_REBUILT,
   hasRebuiltToolRegistry,