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

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

@@ -40,7 +40,7 @@ import {
   CronScheduler,
   DEFAULT_RECURRING_MAX_AGE_DAYS,
   normalizeRecurringMaxAge
-} from "./chunk-QTI7SRXI.js";
+} from "./chunk-QPBFRWCP.js";
 import {
   consumeUnread,
   forwardApproval,
@@ -49,13 +49,13 @@ import {
   sendStructuredMessage,
   wrapConfirmWithBadge,
   writeMessage
-} from "./chunk-KT4OWAAZ.js";
+} from "./chunk-JRIVMPD2.js";
 import {
   claimTask,
   listTasks,
   onTasksUpdated,
   unassignTeammateTasks
-} from "./chunk-IX7CFQGA.js";
+} from "./chunk-YILJKX2T.js";
 import {
   assignTeammateColor,
   classifyShutdownResponse,
@@ -63,7 +63,7 @@ import {
   formatAgentId,
   generateUniqueTeammateName,
   writeTeamFile
-} from "./chunk-N7NBMAMW.js";
+} from "./chunk-D2RNVVH6.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
@@ -71,13 +71,13 @@ import {
   RUNTIME_SNAPSHOT_PREFIX,
   buildModelIdContext,
   resolveModelId
-} from "./chunk-I4XSOFH2.js";
+} from "./chunk-I7BT2MME.js";
 import {
   ARTIFACT_TITLE_MAX_LENGTH,
   ARTIFACT_WORKSPACE_PATH_MAX_LENGTH,
   hasControlCharacter,
   hasUnsafeDisplayPayload
-} from "./chunk-NWPO6I7V.js";
+} from "./chunk-DEDESZDL.js";
 import {
   promptIdContext,
   todoWorkChainContext
@@ -86,22 +86,6 @@ import {
   LEADER_NAME,
   MAX_TEAMMATES
 } from "./chunk-CPBF7KYF.js";
-import {
-  APPROVAL_MODES,
-  READ_ONLY_INSPECTION_TOOLS,
-  SUBAGENT_PLAN_LIFECYCLE_TOOLS,
-  buildSubagentPlanToolBlockedResult,
-  getLeaderOnlyToolUnavailableMessage,
-  getPlanRequiredTeammatePreApprovalMessage,
-  getSubagentPlanToolUnavailableMessage,
-  isLeaderOnlyToolUnavailableInSubagent,
-  isPlanLifecycleToolUnavailableInSubagent,
-  isPlanRequiredTeammateAwaitingApproval,
-  isPlanRequiredTeammateContext,
-  isPlanRequiredTeammatePreApprovalAllowedTool,
-  isSubagentLikeExecutionContext,
-  shouldUsePlanOnlyReminderInSubagentContext
-} from "./chunk-6LYDH7VT.js";
 import {
   SKILL_FILE_NAME,
   SKILL_NAME_PATTERN,
@@ -121,7 +105,7 @@ import {
   require_dist as require_dist2,
   stringify,
   validateSkillName
-} from "./chunk-2AZMF6G5.js";
+} from "./chunk-5RUCD4ED.js";
 import {
   require_proper_lockfile
 } from "./chunk-KRXPRVGL.js";
@@ -139,48 +123,74 @@ import {
   createHookOutput,
   getHookKey,
   isToolArtifactLike
-} from "./chunk-GZGDJ4E6.js";
+} from "./chunk-YBVVOSOH.js";
 import {
   BaseTokenStorage,
   KeychainTokenStorage
-} from "./chunk-T6W4KACQ.js";
+} from "./chunk-CPFFU46D.js";
 import {
   normalizeImageGenerationBaseUrl,
   resolveNetworkTarget
-} from "./chunk-MWZYNOCG.js";
+} from "./chunk-ULNWG62W.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-DPTMKFIH.js";
+import {
+  APPROVAL_MODES,
+  READ_ONLY_INSPECTION_TOOLS,
+  SUBAGENT_PLAN_LIFECYCLE_TOOLS,
+  buildSubagentPlanToolBlockedResult,
+  getLeaderOnlyToolUnavailableMessage,
+  getPlanRequiredTeammatePreApprovalMessage,
+  getSubagentPlanToolUnavailableMessage,
+  isLeaderOnlyToolUnavailableInSubagent,
+  isPlanLifecycleToolUnavailableInSubagent,
+  isPlanRequiredTeammateAwaitingApproval,
+  isPlanRequiredTeammateContext,
+  isPlanRequiredTeammatePreApprovalAllowedTool,
+  isSubagentLikeExecutionContext,
+  shouldUsePlanOnlyReminderInSubagentContext
+} from "./chunk-63FNZTWG.js";
 import {
+  AgentOutputMessageCapture,
   DEFAULT_OTLP_ENDPOINT,
   DEFAULT_TELEMETRY_TARGET,
+  addAgentInputMessageAttributes,
+  addDaemonRequestAttribute,
   addToolArgumentsAttributes,
   addToolCallResultAttributes,
   addUserPromptAttributes
-} from "./chunk-O5AZPHYZ.js";
+} from "./chunk-K34GJQOZ.js";
 import {
   supportsOpenAIPrefixCaching
 } from "./chunk-SAH4BD2J.js";
 import {
   DashScopeOpenAICompatibleProvider,
   selectDashScopeThinkingKnob
-} from "./chunk-5PWLQ7SK.js";
+} from "./chunk-KLOMACIR.js";
 import {
   childLaunchDepth,
   getCurrentAgentDepth,
@@ -191,7 +201,7 @@ import {
   runWithAgentContext,
   runWithRuntimeContentGenerator,
   spawnBlockReason
-} from "./chunk-EYS3GGM3.js";
+} from "./chunk-VPV7WBVT.js";
 import {
   getTeammateContext,
   isTeammate,
@@ -201,6 +211,92 @@ import {
   InvalidStreamError,
   getThoughtSummary
 } from "./chunk-2J3OJGTL.js";
+import {
+  BUBBLE_APPROVAL_MODE,
+  FORK_AGENT,
+  FORK_DEFAULT_MAX_TURNS,
+  FORK_PLACEHOLDER_RESULT,
+  FORK_SUBAGENT_TYPE,
+  SubagentError,
+  SubagentErrorCode,
+  buildAvailableSkillsReminder,
+  buildChangedAgentsReminder,
+  buildChangedMcpToolsReminder,
+  buildChangedSkillsReminder,
+  buildChildMessage,
+  buildDeferredToolsReminder,
+  buildForkExecutionAllowlist,
+  buildForkedMessages,
+  buildFunctionResponseParts,
+  buildMcpServerInstructionsReminder,
+  buildPinnedWorktreeNotice,
+  buildWorktreeNotice,
+  formatDateForContext,
+  getDirectoryContextString,
+  getFolderStructure,
+  getInitialChatHistory,
+  getStartupContextLength,
+  isSystemReminderContent,
+  normalizeForkTurns,
+  registerForkDisplayImageForCache,
+  resolveForkExecutionAllowedTools,
+  runInForkContext,
+  selectForkHistory,
+  stripSystemReminderBlocks,
+  validateForkToolList
+} from "./chunk-TTRH3RTQ.js";
+import {
+  collectAvailableSkillEntries,
+  renderAvailableSkillsBlock
+} from "./chunk-K623ENWT.js";
+import {
+  escapeSystemReminderTags,
+  escapeXml
+} from "./chunk-AQ37AY7B.js";
+import {
+  DEFAULT_FILE_FILTERING_OPTIONS,
+  DEFAULT_QWEN_CUSTOM_IGNORE_FILE_NAMES,
+  QwenIgnoreParser,
+  WorkspaceContext,
+  formatQwenIgnoreFileNames,
+  getQwenIgnoreFileNames,
+  isPathWithinRoot,
+  require_ignore
+} from "./chunk-FRHQQC2Z.js";
+import {
+  openBrowserSecurely,
+  shouldAttemptBrowserLaunch
+} from "./chunk-NAVJD2PQ.js";
+import {
+  isUnattendedMode,
+  retryWithBackoff
+} from "./chunk-2ZWH53I4.js";
+import {
+  classifyRetryError,
+  isFallbackEligible
+} from "./chunk-TB4YFWXG.js";
+import {
+  QUOTA_EXHAUSTED_PREFIX,
+  formatQuotaExhaustedMessage,
+  getRateLimitErrorDetails,
+  getRateLimitRetryDelayMs,
+  isApiError,
+  isQuotaExhaustedError,
+  isRateLimitError,
+  isStructuredError
+} from "./chunk-D7QGE3RT.js";
+import {
+  DEFAULT_OPENAI_BASE_URL
+} from "./chunk-AXMWHKXA.js";
+import {
+  getToolCallPreparations,
+  setToolCallPreparations
+} from "./chunk-GLCZKT5V.js";
+import {
+  combineAbortSignals,
+  createAbortController,
+  createChildAbortController
+} from "./chunk-DJ2GSRLV.js";
 import {
   ApiRetryEvent,
   COMBINED_PASS_TOLERANCE_FACTOR,
@@ -318,7 +414,7 @@ import {
   updateMCPServerStatus,
   writeLine,
   writeLineSync
-} from "./chunk-HB6QW4LM.js";
+} from "./chunk-4KM2SYK5.js";
 import {
   defaultModalities,
   isTieredEffortWireModel
@@ -347,65 +443,13 @@ import {
   isManagedMemoryPath,
   isTeamAutoMemPath,
   isUserAutoMemPath
-} from "./chunk-732MOPEM.js";
+} from "./chunk-G6MUFRNI.js";
 import {
   runSideQuery
-} from "./chunk-CTQE2NB2.js";
+} from "./chunk-LSRI3ND3.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-IEP44U2R.js";
-import {
-  BUBBLE_APPROVAL_MODE,
-  FORK_AGENT,
-  FORK_DEFAULT_MAX_TURNS,
-  FORK_PLACEHOLDER_RESULT,
-  FORK_SUBAGENT_TYPE,
-  SubagentError,
-  SubagentErrorCode,
-  buildAvailableSkillsReminder,
-  buildChangedAgentsReminder,
-  buildChangedMcpToolsReminder,
-  buildChangedSkillsReminder,
-  buildChildMessage,
-  buildDeferredToolsReminder,
-  buildForkExecutionAllowlist,
-  buildForkedMessages,
-  buildFunctionResponseParts,
-  buildMcpServerInstructionsReminder,
-  buildPinnedWorktreeNotice,
-  buildWorktreeNotice,
-  formatDateForContext,
-  getDirectoryContextString,
-  getFolderStructure,
-  getInitialChatHistory,
-  getStartupContextLength,
-  isSystemReminderContent,
-  normalizeForkTurns,
-  registerForkDisplayImageForCache,
-  resolveForkExecutionAllowedTools,
-  runInForkContext,
-  selectForkHistory,
-  stripSystemReminderBlocks,
-  validateForkToolList
-} from "./chunk-ZV4XVYL3.js";
-import {
-  collectAvailableSkillEntries,
-  renderAvailableSkillsBlock
-} from "./chunk-K623ENWT.js";
-import {
-  escapeSystemReminderTags,
-  escapeXml
-} from "./chunk-AQ37AY7B.js";
-import {
-  DEFAULT_FILE_FILTERING_OPTIONS,
-  DEFAULT_QWEN_CUSTOM_IGNORE_FILE_NAMES,
-  QwenIgnoreParser,
-  WorkspaceContext,
-  formatQwenIgnoreFileNames,
-  getQwenIgnoreFileNames,
-  isPathWithinRoot,
-  require_ignore
-} from "./chunk-V3LXMASR.js";
+} from "./chunk-PVXEJB66.js";
 import {
   AgentStatistics,
   BaseDeclarativeTool,
@@ -424,29 +468,7 @@ import {
   require_dist,
   require_fast_deep_equal,
   require_fast_uri
-} from "./chunk-XTH2OMDS.js";
-import {
-  openBrowserSecurely,
-  shouldAttemptBrowserLaunch
-} from "./chunk-NAVJD2PQ.js";
-import {
-  isUnattendedMode,
-  retryWithBackoff
-} from "./chunk-EYW54TBD.js";
-import {
-  classifyRetryError,
-  isFallbackEligible
-} from "./chunk-O4BBDP2G.js";
-import {
-  QUOTA_EXHAUSTED_PREFIX,
-  formatQuotaExhaustedMessage,
-  getRateLimitErrorDetails,
-  getRateLimitRetryDelayMs,
-  isApiError,
-  isQuotaExhaustedError,
-  isRateLimitError,
-  isStructuredError
-} from "./chunk-KPVVWKF3.js";
+} from "./chunk-YIGGWOJE.js";
 import {
   AUTH_ENV_MAPPINGS,
   AuthType,
@@ -458,24 +480,11 @@ import {
   createContentGenerator,
   resetPreloadedContentGenerator,
   resolveContentGeneratorConfigWithSources
-} from "./chunk-XWUQ4IH5.js";
+} from "./chunk-KWX56CHZ.js";
 import {
   DEFAULT_QWEN_EMBEDDING_MODEL,
   DEFAULT_QWEN_MODEL
 } from "./chunk-F6WFNA7U.js";
-import {
-  atomicWriteFile,
-  atomicWriteFileSync,
-  atomicWriteJSON,
-  renameWithRetry
-} from "./chunk-F6AOBFUN.js";
-import {
-  DEFAULT_OPENAI_BASE_URL
-} from "./chunk-AXMWHKXA.js";
-import {
-  getToolCallPreparations,
-  setToolCallPreparations
-} from "./chunk-GLCZKT5V.js";
 import {
   normalizeMcpToolName,
   sanitizeToolNameForProvider
@@ -489,18 +498,19 @@ import {
   parsePositiveIntegerEnvValue,
   tokenLimit
 } from "./chunk-FPGTNKCP.js";
-import {
-  combineAbortSignals,
-  createAbortController,
-  createChildAbortController
-} from "./chunk-DJ2GSRLV.js";
 import {
   getOrCreateMcpDispatcher,
   loadUndici,
   preloadRuntimeFetchModule,
   redactProxyError,
   setResolvedProxyUrlForRuntimeFetch
-} from "./chunk-EFIMD5VA.js";
+} from "./chunk-4AOVQPJU.js";
+import {
+  atomicWriteFile,
+  atomicWriteFileSync,
+  atomicWriteJSON,
+  renameWithRetry
+} from "./chunk-YBHUXEC6.js";
 import {
   endHookSpan,
   endInteractionSpan,
@@ -510,10 +520,14 @@ import {
   endToolSpan,
   getActiveInteractionSpan,
   initializeTelemetry,
+  isBinary,
   isPerformanceMonitoringActive,
   isTelemetrySdkInitialized,
+  normalizeContent,
   recordCpuUsage,
+  recordInteractionActivity,
   recordMemoryUsage,
+  redactUrlCredentials,
   refreshSessionContext,
   runInSubagentSpanContext,
   runInToolSpanContext,
@@ -525,8 +539,9 @@ import {
   startToolBlockedOnUserSpan,
   startToolExecutionSpan,
   startToolSpan,
+  stripAnsiAndControl,
   truncateSpanError
-} from "./chunk-E5BWLU5J.js";
+} from "./chunk-N4SVADAV.js";
 import {
   safeJsonStringify
 } from "./chunk-HHJLM3WQ.js";
@@ -546,8 +561,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,
@@ -561,6 +583,7 @@ import {
   formatTraceparent,
   getErrorMessage,
   getErrorStatus,
+  getErrorType,
   getProjectHash,
   getTraceContext,
   isAbortError,
@@ -576,7 +599,7 @@ import {
   tildeifyPath,
   toFriendlyError,
   unescapePath
-} from "./chunk-MPBRV3UU.js";
+} from "./chunk-HOSVOUDK.js";
 import {
   require_src
 } from "./chunk-AMDSOFFV.js";
@@ -21328,6 +21351,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 +26588,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 +26980,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 +27020,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 +27077,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 +27165,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 +28289,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 +28598,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 +28637,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 +28753,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 +28972,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 +29015,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 +29025,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 +29033,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 +29049,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 +29061,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 +29077,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 +29111,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 +29127,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 +29138,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 +29171,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 +29186,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 +29227,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 +29251,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 +29270,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 +29310,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 +29402,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 +29424,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 +29546,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 +29566,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 +29601,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 +29628,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 +29647,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 +29657,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 +29785,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 +30338,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 +30359,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 +32380,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 +32651,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 +33092,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 +33167,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 +33190,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 +33817,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 +33867,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 +33929,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 +34233,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 +34458,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;
   }
@@ -43833,6 +44969,19 @@ function detectCommandSubstitution(command) {
       }
     }
     if (char === "\\" && !inSingleQuotes) {
+      if (nextChar === "\n" && command[i - 1] === "$") {
+        let dollarStart = i - 1;
+        while (dollarStart > 0 && command[dollarStart - 1] === "$") {
+          dollarStart--;
+        }
+        let escapeStart = dollarStart;
+        while (escapeStart > 0 && command[escapeStart - 1] === "\\") {
+          escapeStart--;
+        }
+        if ((i - dollarStart) % 2 === 1 && (dollarStart - escapeStart) % 2 === 0 && command[i + 2] === "(") {
+          return true;
+        }
+      }
       i += 2;
       continue;
     }
@@ -43855,6 +45004,9 @@ function detectCommandSubstitution(command) {
       if (char === "$" && nextChar === "(") {
         return true;
       }
+      if (char === "$" && nextChar === "{" && /^\$\{[A-Za-z_][A-Za-z0-9_]*@P\}/.test(command.slice(i))) {
+        return true;
+      }
       if (char === "<" && nextChar === "(" && !inDoubleQuotes && !inBackticks) {
         return true;
       }
@@ -43870,7 +45022,7 @@ function detectCommandSubstitution(command) {
   return false;
 }
 __name(detectCommandSubstitution, "detectCommandSubstitution");
-var COMMAND_SUBSTITUTION_WARNING = "Contains command substitution ($(...), backticks, <(...), or >(...)).";
+var COMMAND_SUBSTITUTION_WARNING = "Contains command substitution ($(...), backticks, <(...), >(...), or ${parameter@P}).";
 function hasShellSubstitution(rawCommand) {
   if (typeof rawCommand !== "string" || rawCommand.length === 0) return false;
   if (detectCommandSubstitution(rawCommand)) return true;
@@ -43890,7 +45042,7 @@ async function checkCommandPermissions(command, config, sessionAllowlist) {
     return {
       allAllowed: false,
       disallowedCommands: [command],
-      blockReason: "Command substitution using $(), `` ` ``, <(), or >() is not allowed for security reasons",
+      blockReason: "Command substitution using $(), `` ` ``, <(), >(), or ${parameter@P} is not allowed for security reasons",
       isHardDenial: true
     };
   }
@@ -46766,7 +47918,16 @@ function evaluateSubstitutions(node) {
     /* @__PURE__ */ new Set(["command_substitution", "process_substitution"]),
     true
   );
-  if (substitutions.length === 0) return "read-only";
+  if (substitutions.length === 0) {
+    for (const expansion of collectDescendants(node, /* @__PURE__ */ new Set(["expansion"]))) {
+      for (let i = 0; i < expansion.childCount - 1; i++) {
+        if (expansion.child(i)?.type === "@" && expansion.child(i + 1)?.type === "P") {
+          return "unknown";
+        }
+      }
+    }
+    return "read-only";
+  }
   return mergeSafety(
     "unknown",
     ...substitutions.flatMap((substitution) => substitution.namedChildren).map(evaluateStatementSafety)
@@ -46914,6 +48075,13 @@ async function classifyInternal(command, cwd) {
     const safety = mergeSafety(
       ...root.namedChildren.map(evaluateStatementSafety)
     );
+    if (safety === "read-only" && command.includes("\\\n")) {
+      const normalizedSafety = await classifyInternal(
+        command.replaceAll("\\\n", ""),
+        cwd
+      );
+      if (normalizedSafety !== "read-only") return "unknown";
+    }
     if (safety !== "read-only" || !cwd) return safety;
     return localGitConfigMakesCommandUnsafe(root, cwd) ? "unknown" : "read-only";
   } finally {
@@ -58674,7 +59842,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-NKKCUHI2.js");
         const keychainStorage = new KeychainTokenStorage2(this.serviceName);
         const isAvailable = await keychainStorage.isAvailable();
         if (isAvailable) {
@@ -60821,7 +61989,7 @@ function populateMcpServerCommand(mcpServers, mcpServerCommand, cwd) {
 __name(populateMcpServerCommand, "populateMcpServerCommand");
 async function discoverTools(mcpServerName, mcpServerConfig, mcpClient, cliConfig, opts) {
   try {
-    const { mcpToTool } = await import("./node-YSOU44FX.js");
+    const { mcpToTool } = await import("./node-UUDY34IG.js");
     const mcpCallableTool = mcpToTool(mcpClient, {
       timeout: mcpServerConfig.timeout ?? MCP_DEFAULT_TIMEOUT_MSEC
     });
@@ -79292,9 +80460,8 @@ init_esbuild_shims();
 
 // packages/core/src/utils/getPty.ts
 init_esbuild_shims();
-var BUN_FORCE_PTY_ENV_VAR = "QWEN_TUI_FORCE_PTY";
 var getPty = /* @__PURE__ */ __name(async () => {
-  if ("bun" in process.versions && process.env[BUN_FORCE_PTY_ENV_VAR] !== "1") {
+  if ("bun" in process.versions) {
     return null;
   }
   try {
@@ -79317,45 +80484,6 @@ import { spawn as cpSpawn, spawnSync as spawnSync3 } from "node:child_process";
 import { TextDecoder as TextDecoder2 } from "node:util";
 import os11 from "node:os";
 
-// packages/core/src/utils/textUtils.ts
-init_esbuild_shims();
-import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
-var CONTROL_CHARS_RE = /[\u0000-\u001f\u007f-\u009f]/g;
-function stripAnsiAndControl(text) {
-  return stripVTControlCharacters2(text).replace(CONTROL_CHARS_RE, "");
-}
-__name(stripAnsiAndControl, "stripAnsiAndControl");
-function safeLiteralReplace(str, oldString, newString) {
-  if (oldString === "" || !str.includes(oldString)) {
-    return str;
-  }
-  if (!newString.includes("$")) {
-    return str.replaceAll(oldString, newString);
-  }
-  const escapedNewString = newString.replaceAll("$", "$$$$");
-  return str.replaceAll(oldString, escapedNewString);
-}
-__name(safeLiteralReplace, "safeLiteralReplace");
-function isBinary(data, sampleSize = 512) {
-  if (!data) {
-    return false;
-  }
-  const sample = data.length > sampleSize ? data.subarray(0, sampleSize) : data;
-  for (const byte of sample) {
-    if (byte === 0) {
-      return true;
-    }
-  }
-  return false;
-}
-__name(isBinary, "isBinary");
-function normalizeContent(content) {
-  let normalized2 = content.replace(/^\uFEFF/, "");
-  normalized2 = normalized2.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-  return normalized2;
-}
-__name(normalizeContent, "normalizeContent");
-
 // packages/core/src/utils/load-xterm-headless.ts
 init_esbuild_shims();
 var xtermHeadlessModulePromise;
@@ -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);
@@ -82218,8 +83339,8 @@ var BackgroundShellRegistry = class {
   /**
    * Subscribe to new-entry events. Called synchronously inside `register()`.
    * Setting `undefined` clears the existing subscriber. Single-subscriber on
-   * purpose — the UI hook is the only consumer in the codebase, and a list
-   * would invite drift in error-handling.
+   * purpose — each runtime installs one owner callback, and a list would
+   * invite drift in error-handling.
    */
   setRegisterCallback(cb) {
     this.registerCallback = cb;
@@ -82228,14 +83349,19 @@ var BackgroundShellRegistry = class {
     this.notificationCallback = cb;
   }
   /**
-   * Subscribe to status transitions (running → terminal). Called
-   * synchronously inside `complete()` / `fail()` / `cancel()` after the
-   * entry has been mutated. Same single-subscriber rationale as
-   * `setRegisterCallback`.
+   * Subscribe to registration and status transitions (running → terminal).
+   * Called synchronously after the registry has been mutated. Same
+   * single-subscriber rationale as `setRegisterCallback`.
    */
   setStatusChangeCallback(cb) {
     this.statusChangeCallback = cb;
   }
+  /** Retract `cb` only if it is still the installed callback. */
+  clearStatusChangeCallback(cb) {
+    if (this.statusChangeCallback === cb) {
+      this.statusChangeCallback = void 0;
+    }
+  }
   register(registration) {
     const entry = registration;
     entry.id = registration.shellId;
@@ -82491,8 +83617,8 @@ var BackgroundShellRegistry = class {
    * statusChange callback exactly once after the loop. The per-entry
    * `cancel()` path would have triggered both side channels for every
    * running shell — wasteful on shutdown / `/clear` where the only
-   * subscriber (`useBackgroundTaskView`) just re-pulls `getAll()`
-   * regardless of the entry argument.
+   * current subscriber just re-pulls the registry regardless of the entry
+   * argument.
    */
   abortAll() {
     const endTime = Date.now();
@@ -95449,16 +96575,6 @@ import * as fs52 from "node:fs";
 import * as path55 from "node:path";
 import * as os16 from "node:os";
 
-// packages/core/src/extension/redaction.ts
-init_esbuild_shims();
-var REDACTED_URL_CREDENTIAL = "***REDACTED***";
-var URL_CREDENTIALS_PATTERN = /\b([a-z][a-z0-9+.-]*:\/\/)(?:[^/\s]+@)+/gi;
-var UPLOAD_IDENTITY_PATTERN = /\bupload:v1:[0-9a-fA-F-]+:/gu;
-function redactUrlCredentials(source) {
-  return source.replace(UPLOAD_IDENTITY_PATTERN, "upload:").replace(URL_CREDENTIALS_PATTERN, `$1${REDACTED_URL_CREDENTIAL}@`);
-}
-__name(redactUrlCredentials, "redactUrlCredentials");
-
 // packages/core/src/extension/http-client.ts
 init_esbuild_shims();
 import * as http2 from "node:http";
@@ -114211,19 +115327,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",
@@ -115602,6 +116718,8 @@ async function runSpeculativeLoop(config, state, cacheSafe, modelOverride) {
                 toolName: canonicalToolName(name),
                 args: invocation.params,
                 signal: state.abortController.signal,
+                sessionId: config.getSessionId(),
+                cwd: config.getTargetDir(),
                 ...invocationContext ? { invocationContext } : {}
               }
             );
@@ -128755,6 +129873,11 @@ __name(buildReplacement, "buildReplacement");
 
 // packages/core/src/tools/shell.ts
 var debugLogger125 = createDebugLogger("SHELL");
+var DEFAULT_SHELL_OUTPUT_THRESHOLD = 3e4;
+function getShellOutputThreshold(config) {
+  return config.isTruncateToolOutputThresholdExplicit() ? config.getTruncateToolOutputThreshold() : DEFAULT_SHELL_OUTPUT_THRESHOLD;
+}
+__name(getShellOutputThreshold, "getShellOutputThreshold");
 function statusFileGuidance(outputPath) {
   return `status file: ${statusFilePathFor(outputPath)}
 To check whether this process is still running, Read the status file (status: running|completed|failed|cancelled). Do NOT infer liveness from the output file: programs often block-buffer stdout when not attached to a TTY, so an empty output file is normal while the process is alive (for live output, re-run with e.g. \`python -u\` or \`stdbuf -oL\`).`;
@@ -130410,6 +131533,7 @@ ${result.output}` : result.output;
     let persistedOutputFiles;
     if (typeof llmContent === "string") {
       const originalLlmContent = llmContent;
+      const outputThreshold = getShellOutputThreshold(this.config);
       const truncatedResult = await truncateToolOutput(
         this.config,
         ShellTool.Name,
@@ -130420,11 +131544,11 @@ ${result.output}` : result.output;
         // scheduler) so the long-run hint below is appended OUTSIDE the
         // truncation envelope; the scheduler's sentinel makes its later pass a
         // no-op here. lines: Infinity keeps this char-only so the global line
-        // cap can't undercut the declared 30k char budget — many short lines
+        // cap can't undercut the effective Shell char budget — many short lines
         // (e.g. `find /`, `ls -R`) would otherwise truncate while chars remain.
         {
-          threshold: 3e4,
-          previewChars: 4e3,
+          threshold: outputThreshold,
+          previewChars: Math.min(4e3, outputThreshold),
           keep: "both",
           lines: Number.POSITIVE_INFINITY
         }
@@ -130519,12 +131643,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 +131719,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 +132038,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 +132066,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 +132098,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 +132179,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 +132216,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) {
@@ -131618,7 +132746,7 @@ var ShellTool = class _ShellTool extends BaseDeclarativeTool {
   }
   static Name = ToolNames.SHELL;
   get maxOutputChars() {
-    return 3e4;
+    return getShellOutputThreshold(this.config);
   }
   validateToolParamValues(params) {
     if (!params.command.trim()) {
@@ -131767,6 +132895,7 @@ var TRUNCATION_EDIT_REJECTION = "Your previous response was truncated due to max
 function setToolSpanFailure(span, failureKind, message) {
   try {
     span.setAttribute(TOOL_FAILURE_KIND_ATTRIBUTE, failureKind);
+    span.setAttribute("error.type", failureKind);
     span.setAttribute("success", false);
   } catch {
   }
@@ -132606,7 +133735,8 @@ var CoreToolScheduler = class {
    * second call for the same callId is a no-op.
    *
    * No `metadata` parameter: every caller pre-sets span status via
-   * `setToolSpan{Failure,Cancelled,Ok}` before this call (#4321 review).
+   * `setToolSpan{Failure,Cancelled}` or the success path before this call
+   * (#4321 review).
    */
   finalizeToolSpan(callId, force = false) {
     this.bouncedAwaitingApproval.delete(callId);
@@ -134535,6 +135665,8 @@ var CoreToolScheduler = class {
           toolName: canonicalName,
           args: invocation.params,
           signal,
+          sessionId: this.config.getSessionId(),
+          cwd: this.config.getTargetDir(),
           ...invocationContext ? { invocationContext } : {}
         }
       );
@@ -135087,7 +136219,6 @@ ${body}
           return;
         }
         this.setStatusInternal(callId, "success", successResponse);
-        safeSetStatus(span, { code: SpanStatusCode.OK });
         try {
           span.setAttribute("success", true);
         } catch {
@@ -137534,14 +138665,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 +140564,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 +140658,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 +141142,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 +141201,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 +144215,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()
@@ -144384,6 +145512,33 @@ var GeminiClient = class _GeminiClient {
   }
   async *sendMessageStream(request, callerSignal, prompt_id, options2, turns = MAX_TURNS2) {
     const messageType = options2?.type ?? "userQuery" /* UserQuery */;
+    const startsInteraction = messageType === "userQuery" /* UserQuery */ || messageType === "retry" /* Retry */ || messageType === "cron" /* Cron */ || messageType === "notification" /* Notification */ || messageType === "teammate" /* Teammate */ || messageType === "goal" /* Goal */;
+    let interactionOwner = startsInteraction ? void 0 : getActiveInteractionSpan(prompt_id);
+    if (interactionOwner) {
+      recordInteractionActivity(prompt_id, interactionOwner);
+    }
+    const agentOutput = new AgentOutputMessageCapture(this.config);
+    const endCurrentInteraction = /* @__PURE__ */ __name((status, errorMessage, errorType) => {
+      if (!interactionOwner || getActiveInteractionSpan(prompt_id) !== interactionOwner) {
+        return;
+      }
+      if (status === "ok" && this.config.getJsonSchema?.()) {
+        endInteractionSpan("error", {
+          promptId: prompt_id,
+          errorMessage: "model did not produce structured output",
+          errorType: "structured_output_missing"
+        });
+        return;
+      }
+      if (status === "ok") {
+        agentOutput.writeToSpan(interactionOwner);
+      }
+      endInteractionSpan(status, {
+        promptId: prompt_id,
+        ...errorMessage ? { errorMessage } : {},
+        ...errorType ? { errorType } : {}
+      });
+    }, "endCurrentInteraction");
     if (messageType === "userQuery" /* UserQuery */ || messageType === "cron" /* Cron */ || messageType === "notification" /* Notification */ || messageType === "teammate" /* Teammate */) {
       await this.config.assertCanStartTurn();
     }
@@ -144541,6 +145696,23 @@ var GeminiClient = class _GeminiClient {
       pushCountAfterStrip = currentPushCount();
     }
     const preHookUserPromptText = messageType === "userQuery" /* UserQuery */ ? partToString(request) : void 0;
+    if (startsInteraction) {
+      this.loopDetector.reset(prompt_id);
+      this.lastPromptId = prompt_id;
+      startInteractionSpan(this.config, {
+        promptId: prompt_id,
+        model: options2?.modelOverride ?? this.config.getModel(),
+        messageType
+      });
+      interactionOwner = getActiveInteractionSpan(prompt_id);
+      if (interactionOwner && messageType === "userQuery" /* UserQuery */ && typeof options2?.submittedPrompt === "string") {
+        addAgentInputMessageAttributes(
+          this.config,
+          interactionOwner,
+          options2.submittedPrompt
+        );
+      }
+    }
     let userPromptRecordPayload;
     let hooksEnabled;
     let messageBus;
@@ -144581,9 +145753,12 @@ var GeminiClient = class _GeminiClient {
             await runtime.finishTurn(goalPermit);
             goalPermitReleased = true;
             closeGoalStateEvents();
+            endCurrentInteraction("cancelled");
             for (const goalEvent of takePendingGoalEvents()) {
               yield goalEvent;
             }
+          } else {
+            endCurrentInteraction("cancelled");
           }
           yield {
             type: "user_prompt_submit_blocked" /* UserPromptSubmitBlocked */,
@@ -144611,6 +145786,11 @@ var GeminiClient = class _GeminiClient {
         }
       }
     } catch (error) {
+      endCurrentInteraction(
+        signal.aborted ? "cancelled" : "error",
+        signal.aborted ? void 0 : "UserPromptSubmit hook failed",
+        signal.aborted ? void 0 : getErrorType(error)
+      );
       for (const goalEvent of await finalizeInterruptedGoalTurn()) {
         yield goalEvent;
       }
@@ -144660,6 +145840,11 @@ var GeminiClient = class _GeminiClient {
       }
       if (goalRuntime) bindGoalStateEvents(goalRuntime);
     } catch (error) {
+      endCurrentInteraction(
+        signal.aborted ? "cancelled" : "error",
+        signal.aborted ? void 0 : "Goal turn admission failed",
+        signal.aborted ? void 0 : getErrorType(error)
+      );
       for (const goalEvent of await finalizeInterruptedGoalTurn()) {
         yield goalEvent;
       }
@@ -144691,20 +145876,12 @@ var GeminiClient = class _GeminiClient {
       );
       this.activeAutomaticTodoWorkChainPromptIds.add(prompt_id);
     }
-    const isTopLevelInteraction = messageType === "userQuery" /* UserQuery */ || messageType === "cron" /* Cron */ || messageType === "notification" /* Notification */ || messageType === "teammate" /* Teammate */;
     if (messageType === "goal" /* Goal */) {
       this.loopDetector.reset(prompt_id);
       this.lastPromptId = prompt_id;
     }
-    if (isTopLevelInteraction) {
-      this.loopDetector.reset(prompt_id);
-      this.lastPromptId = prompt_id;
-      startInteractionSpan(this.config, {
-        promptId: prompt_id,
-        model: options2?.modelOverride ?? this.config.getModel(),
-        messageType
-      });
-      const interactionSpan = getActiveInteractionSpan();
+    if (startsInteraction) {
+      const interactionSpan = interactionOwner;
       if (interactionSpan && this.config.getTelemetryIncludeSensitiveSpanAttributes?.()) {
         addUserPromptAttributes(
           this.config,
@@ -144838,18 +146015,18 @@ var GeminiClient = class _GeminiClient {
         if (this.config.getMaxSessionTurns() > 0 && this.sessionTurnCount > this.config.getMaxSessionTurns()) {
           this.cancelPendingMemoryPrefetch("no_safe_delivery_point");
           yield { type: "max_session_turns" /* MaxSessionTurns */ };
-          if (isTopLevelInteraction)
-            endInteractionSpan("error", {
-              errorMessage: "max session turns exceeded"
-            });
+          endCurrentInteraction(
+            "error",
+            "max session turns exceeded",
+            "max_session_turns"
+          );
           return new Turn(this.getChat(), prompt_id);
         }
       }
       const boundedTurns = messageType === "goal" /* Goal */ ? MAX_TURNS2 : Math.min(turns, MAX_TURNS2);
       if (!boundedTurns) {
         this.cancelPendingMemoryPrefetch("no_safe_delivery_point");
-        if (isTopLevelInteraction)
-          endInteractionSpan("error", { errorMessage: "max turns exhausted" });
+        endCurrentInteraction("error", "max turns exhausted", "max_turns");
         return new Turn(this.getChat(), prompt_id);
       }
       const takeSteerInput = /* @__PURE__ */ __name(async (nextTurnBudget) => {
@@ -144883,10 +146060,11 @@ var GeminiClient = class _GeminiClient {
               message: `Session token limit exceeded: ${lastPromptTokenCount} tokens > ${sessionTokenLimit} limit. Please start a new session or increase the sessionTokenLimit in your settings.json.`
             }
           };
-          if (isTopLevelInteraction)
-            endInteractionSpan("error", {
-              errorMessage: "session token limit exceeded"
-            });
+          endCurrentInteraction(
+            "error",
+            "session token limit exceeded",
+            "session_token_limit"
+          );
           return new Turn(this.getChat(), prompt_id);
         }
       }
@@ -144920,7 +146098,7 @@ var GeminiClient = class _GeminiClient {
           );
           await arenaAgentClient.reportCancelled();
           this.cancelPendingMemoryPrefetch("abort");
-          if (isTopLevelInteraction) endInteractionSpan("cancelled");
+          endCurrentInteraction("cancelled");
           return new Turn(this.getChat(), prompt_id);
         }
       }
@@ -145055,6 +146233,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
         signal,
         (message) => this.config.getDebugLogger().warn(message)
       ) : null;
+      agentOutput.beginResponse();
       const resultStream = turn.run(model, requestToSend, signal);
       let didUpdateIdeContextState = false;
       let steerInputSettled = false;
@@ -145068,6 +146247,14 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
             hasToolCalls = true;
           } else if (event.type === "retry" /* Retry */ || event.type === "model_fallback" /* ModelFallback */) {
             hasToolCalls = false;
+            agentOutput.restartAttempt(
+              event.type === "retry" /* Retry */ && event.isContinuation === true
+            );
+          }
+          if (event.type === "content" /* Content */) {
+            agentOutput.appendText(event.value);
+          } else if (event.type === "finished" /* Finished */) {
+            agentOutput.observeFinishReason(event.value?.reason);
           }
           if (messageDisplay && event.type === "content" /* Content */) {
             messageDisplay.addChunk(event.value);
@@ -145092,8 +146279,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
               await arenaAgentClient.reportError("Loop detected");
             }
             this.lastApiCompletionTimestamp = Date.now();
-            if (isTopLevelInteraction)
-              endInteractionSpan("error", { errorMessage: "loop detected" });
+            endCurrentInteraction("error", "loop detected", "loop_detected");
             this.cancelPendingMemoryPrefetch("no_safe_delivery_point");
             this.fireLoopDetectedStopFailure(loopType);
             return turn;
@@ -145113,8 +146299,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
               await arenaAgentClient.reportError("Loop detected");
             }
             this.lastApiCompletionTimestamp = Date.now();
-            if (isTopLevelInteraction)
-              endInteractionSpan("error", { errorMessage: "loop detected" });
+            endCurrentInteraction("error", "loop detected", "loop_detected");
             this.cancelPendingMemoryPrefetch("no_safe_delivery_point");
             this.fireLoopDetectedStopFailure(loopType);
             return turn;
@@ -145161,10 +146346,12 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
               await arenaAgentClient.reportError(errorMsg);
             }
             this.lastApiCompletionTimestamp = Date.now();
-            if (isTopLevelInteraction) {
-              const errMsg = event.value instanceof Error ? "[API error]" : "unknown error";
-              endInteractionSpan("error", { errorMessage: errMsg });
-            }
+            const errMsg = event.value instanceof Error ? "[API error]" : "unknown error";
+            endCurrentInteraction(
+              "error",
+              errMsg,
+              event.value instanceof Error ? getErrorType(event.value) : "api_error"
+            );
             this.cancelPendingMemoryPrefetch("no_safe_delivery_point");
             return turn;
           }
@@ -145172,6 +146359,9 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
       } finally {
         await messageDisplay?.finish();
       }
+      agentOutput.commitResponse(
+        hasToolCalls || turn.pendingToolCalls.length > 0
+      );
       for (const goalEvent of signal.aborted ? await finalizeInterruptedGoalTurn() : takePendingGoalEvents()) {
         yield goalEvent;
       }
@@ -145198,9 +146388,10 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
           } finally {
             settleSteerInput(steerInput, pushCountBefore);
           }
-          if (isTopLevelInteraction)
-            endInteractionSpan(signal.aborted ? "cancelled" : "ok");
           hasToolCalls = steeredTurn.pendingToolCalls.length > 0;
+          if (!hasToolCalls) {
+            endCurrentInteraction(signal.aborted ? "cancelled" : "ok");
+          }
           normalCompletion = true;
           return steeredTurn;
         }
@@ -145238,7 +146429,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
           if (activeGoalEvent2) {
             yield activeGoalEvent2;
           }
-          if (isTopLevelInteraction) endInteractionSpan("cancelled");
+          endCurrentInteraction("cancelled");
           return turn;
         }
         const hookOutput = response.output ? createHookOutput("Stop", response.output) : void 0;
@@ -145270,7 +146461,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
             for (const goalEvent of await finalizeInterruptedGoalTurn()) {
               yield goalEvent;
             }
-            if (isTopLevelInteraction) endInteractionSpan("ok");
+            endCurrentInteraction("ok");
             return turn;
           } else {
             for (const goalEvent of takePendingGoalEvents()) {
@@ -145294,7 +146485,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
               for (const goalEvent of await finalizeInterruptedGoalTurn()) {
                 yield goalEvent;
               }
-              if (isTopLevelInteraction) endInteractionSpan("cancelled");
+              endCurrentInteraction("cancelled");
               return turn;
             }
             const continueRequest = [{ text: continueReason }];
@@ -145323,8 +146514,9 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
             } finally {
               settleSteerInput(pendingSteer, pushCountBefore);
             }
-            if (isTopLevelInteraction) {
-              endInteractionSpan(signal.aborted ? "cancelled" : "ok");
+            hasToolCalls = hookTurn.pendingToolCalls.length > 0;
+            if (!hasToolCalls) {
+              endCurrentInteraction(signal.aborted ? "cancelled" : "ok");
             }
             normalCompletion = true;
             return hookTurn;
@@ -145338,7 +146530,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
             if (activeGoalEvent3) {
               yield activeGoalEvent3;
             }
-            if (isTopLevelInteraction) endInteractionSpan("cancelled");
+            endCurrentInteraction("cancelled");
             return turn;
           }
           const continueReason = getStopHookContinuationReason(stopOutput);
@@ -145370,7 +146562,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
               value: warning
             };
             debugLogger136.warn(warning);
-            if (isTopLevelInteraction) endInteractionSpan("ok");
+            endCurrentInteraction("ok");
             return turn;
           }
           const activeGoalEvent2 = maybeEmitActiveGoalChange(
@@ -145405,7 +146597,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
           const discardGoalContinuation = goalContinuationChanged && response.hasNonGoalBlockingStopHook === false;
           const continuationReasonAfterSteer = discardGoalContinuation ? void 0 : goalContinuationChanged && response.hasNonGoalBlockingStopHook === true ? response.nonGoalBlockingStopReason || "No reason provided" : continueReason;
           if (!continuationReasonAfterSteer && !pendingSteer) {
-            if (isTopLevelInteraction) endInteractionSpan("ok");
+            endCurrentInteraction("ok");
             normalCompletion = true;
             return turn;
           }
@@ -145441,9 +146633,10 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
           } finally {
             settleSteerInput(pendingSteer, pushCountBefore);
           }
-          if (isTopLevelInteraction)
-            endInteractionSpan(signal.aborted ? "cancelled" : "ok");
           hasToolCalls = hookTurn.pendingToolCalls.length > 0;
+          if (!hasToolCalls) {
+            endCurrentInteraction(signal.aborted ? "cancelled" : "ok");
+          }
           normalCompletion = true;
           return hookTurn;
         }
@@ -145468,6 +146661,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
         for (const goalEvent of takePendingGoalEvents()) {
           yield goalEvent;
         }
+        endCurrentInteraction("ok");
         normalCompletion = true;
         return turn;
       }
@@ -145497,7 +146691,7 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
           if (arenaAgentClient) {
             await arenaAgentClient.reportCompleted();
           }
-          if (isTopLevelInteraction) endInteractionSpan("ok");
+          endCurrentInteraction("ok");
           return turn;
         }
         const nextSpeakerCheck = await checkNextSpeaker(
@@ -145536,9 +146730,10 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
           } finally {
             settleSteerInput(pendingSteer, pushCountBefore);
           }
-          if (isTopLevelInteraction)
-            endInteractionSpan(signal.aborted ? "cancelled" : "ok");
           hasToolCalls = continueTurn.pendingToolCalls.length > 0;
+          if (!hasToolCalls) {
+            endCurrentInteraction(signal.aborted ? "cancelled" : "ok");
+          }
           normalCompletion = true;
           return continueTurn;
         }
@@ -145552,8 +146747,8 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
       if (signal?.aborted && arenaAgentClient) {
         await arenaAgentClient.reportCancelled();
       }
-      if (isTopLevelInteraction) {
-        endInteractionSpan(signal?.aborted ? "cancelled" : "ok");
+      if (!hasToolCalls) {
+        endCurrentInteraction(signal?.aborted ? "cancelled" : "ok");
       }
       if (!hasToolCalls) {
         this.cancelPendingMemoryPrefetch("no_safe_delivery_point");
@@ -145585,10 +146780,12 @@ The current date is: ${today}. Note: This is the authoritative current date \u20
           signal?.aborted ? "abort" : "no_safe_delivery_point"
         );
       }
-      if (isTopLevelInteraction) {
-        endInteractionSpan(signal?.aborted ? "cancelled" : "error", {
-          errorMessage: "unexpected exit"
-        });
+      if (!normalCompletion) {
+        endCurrentInteraction(
+          signal?.aborted ? "cancelled" : "error",
+          signal?.aborted ? void 0 : "unexpected exit",
+          signal?.aborted ? void 0 : "unexpected_exit"
+        );
       }
     }
   }
@@ -147289,6 +148486,12 @@ var Config = class _Config {
   sessionSourceType;
   sessionSourceId;
   sessionData;
+  pendingSessionRestoreProjection;
+  sessionRestoreRuntime;
+  sessionRestoreProjectionSource;
+  restoredFileHistory = false;
+  goalRestoreActivation;
+  rejectGoalRestoreActivation;
   sessionRuntimeBaseDir;
   sessionProjectDirRegistered = false;
   pendingSessionWriterLease;
@@ -147583,6 +148786,7 @@ var Config = class _Config {
   runtimeStatusWrite = Promise.resolve();
   fileExclusions;
   truncateToolOutputThreshold;
+  truncateToolOutputThresholdExplicit;
   truncateToolOutputLines;
   toolOutputBatchBudget;
   shellDefaultTimeoutMs;
@@ -147642,6 +148846,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;
@@ -147833,6 +149039,7 @@ var Config = class _Config {
       maxBufferedOutputBytes: params.shellExecutionConfig?.maxBufferedOutputBytes
     };
     this.truncateToolOutputThreshold = params.truncateToolOutputThreshold ?? DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD;
+    this.truncateToolOutputThresholdExplicit = params.truncateToolOutputThreshold != null;
     this.truncateToolOutputLines = params.truncateToolOutputLines ?? DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES;
     this.toolOutputBatchBudget = params.toolOutputBatchBudget ?? DEFAULT_TOOL_OUTPUT_BATCH_BUDGET;
     this.shellDefaultTimeoutMs = params.shellDefaultTimeoutMs !== void 0 && Number.isInteger(params.shellDefaultTimeoutMs) && params.shellDefaultTimeoutMs >= 0 && params.shellDefaultTimeoutMs <= 2147483647 ? params.shellDefaultTimeoutMs : void 0;
@@ -147910,7 +149117,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 +149190,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 +149600,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 +149622,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 +150031,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 +150149,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 +151070,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(
@@ -151596,6 +152897,9 @@ var Config = class _Config {
     }
     return this.truncateToolOutputThreshold;
   }
+  isTruncateToolOutputThresholdExplicit() {
+    return this.truncateToolOutputThresholdExplicit;
+  }
   getTruncateToolOutputLines() {
     if (this.truncateToolOutputLines <= 0) {
       return Number.POSITIVE_INFINITY;
@@ -151659,6 +152963,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 +153011,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 +153044,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 +153112,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 +153450,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-YPK2AZT4.js");
       return new ImageGenTool(this);
     });
   }
@@ -152130,36 +153480,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-DVHJMUGV.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-M4UDAZXP.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-M4UDAZXP.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-LOVUSBJC.js");
         return new ReadFileTool(this);
       });
       await registerLazy(ToolNames.EDIT, async () => {
-        const { EditTool } = await import("./edit-WXVZ7FHS.js");
+        const { EditTool } = await import("./edit-X73LA4YO.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-QD4TRKLY.js");
         return new NotebookEditTool(this);
       });
       await registerLazy(ToolNames.SHELL, async () => {
-        const { ShellTool: ShellTool2 } = await import("./shell-C2UP5FF2.js");
+        const { ShellTool: ShellTool2 } = await import("./shell-EGTSUO2P.js");
         return new ShellTool2(this);
       });
       await registerGoalWorkerTools();
@@ -152171,43 +153521,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-QNBLXUGR.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-GWCP23WG.js");
       return new ReadMcpResourceTool(this);
     });
     await registerLazy(ToolNames.AGENT, async () => {
-      const { AgentTool: AgentTool2 } = await import("./agent-FAWBG7PP.js");
+      const { AgentTool: AgentTool2 } = await import("./agent-E6V3VXQR.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-O6WSY4CT.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-YFNATTIM.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-O7FO63UK.js");
       return new SendMessageTool(this);
     });
     await registerLazy(ToolNames.SKILL, async () => {
-      const { SkillTool } = await import("./skill-4XCNK55E.js");
+      const { SkillTool } = await import("./skill-IFUD72GF.js");
       return new SkillTool(this);
     });
     await registerLazy(ToolNames.LS, async () => {
-      const { LSTool } = await import("./ls-FSHISLLA.js");
+      const { LSTool } = await import("./ls-6W2D7TKU.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-LOVUSBJC.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-4MVVVM7E.js");
       return new ZoomImageTool(this);
     });
     if (this.getUseRipgrep()) {
@@ -152222,7 +153572,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-ZJSHKB6H.js");
           return new RipGrepTool2(this);
         });
       } else {
@@ -152235,7 +153585,7 @@ var Config = class _Config {
           )
         );
         await registerLazy(ToolNames.GREP, async () => {
-          const { GrepTool } = await import("./grep-QWBLG564.js");
+          const { GrepTool } = await import("./grep-F4UAR7KX.js");
           return new GrepTool(this);
         });
       }
@@ -152243,77 +153593,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-F4UAR7KX.js");
         return new GrepTool(this);
       });
     }
     await registerLazy(ToolNames.GLOB, async () => {
-      const { GlobTool } = await import("./glob-KJ4A4ZOM.js");
+      const { GlobTool } = await import("./glob-VMEEDDLO.js");
       return new GlobTool(this);
     });
     await registerLazy(ToolNames.EDIT, async () => {
-      const { EditTool } = await import("./edit-WXVZ7FHS.js");
+      const { EditTool } = await import("./edit-X73LA4YO.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-QD4TRKLY.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-JJAY7JSP.js");
       return new WriteFileTool2(this);
     });
     await registerLazy(ToolNames.SHELL, async () => {
-      const { ShellTool: ShellTool2 } = await import("./shell-C2UP5FF2.js");
+      const { ShellTool: ShellTool2 } = await import("./shell-EGTSUO2P.js");
       return new ShellTool2(this);
     });
     await registerLazy(ToolNames.TODO_WRITE, async () => {
-      const { TodoWriteTool } = await import("./todoWrite-WINAZSZI.js");
+      const { TodoWriteTool } = await import("./todoWrite-K5K7NRE5.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-HZJJLR3Z.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-WDURQMIU.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-6BDYUQ5T.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-CLRQTIVN.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-TFFJXCRT.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-MBIVXKPE.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-M2ELAVN4.js");
         return new DisplayImageTool(this);
       });
     }
     if (this.webSearchSettings?.enabled) {
-      const { evaluateWebSearchGate } = await import("./web-search-LVOOV4XZ.js");
+      const { evaluateWebSearchGate } = await import("./web-search-4LBIN6VF.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-4LBIN6VF.js");
           return new WebSearchTool(this);
         });
       } else if (!this.webSearchNoticeEmitted && !options2?.forSubAgent) {
@@ -152324,83 +153674,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-4GCQQDZI.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-IYQDEYMV.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-NJ4KFBI2.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-2JZ2TWTF.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-V44KHAF6.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-CTPD2P26.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-GVQRMUKS.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-XT6DLYOE.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-B6A6MJBT.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-MKYMYBFM.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-5WO3CXXU.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-4NC7PDI4.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-BPLM52GD.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-LBSRMOC7.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-LNMA55HY.js");
         return new WorkflowTool(this);
       });
     }
     if (this.isComputerUseEnabled()) {
-      const { registerComputerUseTools } = await import("./computer-use-S4JEU5P7.js");
+      const { registerComputerUseTools } = await import("./computer-use-F4URV4TU.js");
       await registerComputerUseTools(registerLazy, this);
     }
     await registerLazy(ToolNames.MONITOR, async () => {
-      const { MonitorTool } = await import("./monitor-PY4WDSX3.js");
+      const { MonitorTool } = await import("./monitor-2MM23VDV.js");
       return new MonitorTool(this);
     });
     if (this.pendingMcpBudgetCallback) {
@@ -152871,6 +154221,7 @@ export {
   GROUP_COLOR_OPTIONS,
   SessionOrganizationError,
   SessionOrganizationService,
+  collectSessionTurnState,
   SESSION_TRANSCRIPT_MAX_LIMIT,
   SESSION_TRANSCRIPT_MAX_INDEX_BYTES,
   SESSION_TRANSCRIPT_MAX_PAGE_BYTES,
@@ -152881,8 +154232,6 @@ export {
   SessionTranscriptPageTooLargeError,
   SessionTranscriptCursorCodec,
   encodeSessionTranscriptCursor,
-  isReplayTurnStartType,
-  findBoundaryAtOrBefore,
   SessionTranscriptReader,
   SessionWriterError,
   SESSION_WRITER_RPC_CODES,
@@ -152962,13 +154311,8 @@ export {
   isEditorAvailable,
   createPatchSmart,
   getDiffStat,
-  stripAnsiAndControl,
-  safeLiteralReplace,
-  isBinary,
-  normalizeContent,
   sanitizeChildEnv,
   formatMemoryUsage,
-  sessionIdContext,
   getShellContextEnvVars,
   getShellPagerEnv,
   isSignalTermination,
@@ -153017,6 +154361,8 @@ export {
   getSubagentsRootDir,
   getSubagentSessionDir,
   readAgentMeta,
+  buildAgentTranscriptAttach,
+  attachJsonlTranscriptWriter,
   resolveSubagentApprovalMode,
   TOOL_REGISTRY_REBUILT,
   hasRebuiltToolRegistry,
@@ -153037,8 +154383,6 @@ export {
   MessageDisplayDispatcher,
   collectMemoryDiagnostics,
   MCPOAuthTokenStorage,
-  OAUTH_DISPLAY_MESSAGE_EVENT,
-  OAUTH_AUTH_URL_EVENT,
   MCPOAuthProvider,
   mcpServerRequiresOAuth,
   getMCPDiscoveryState,
@@ -153061,7 +154405,6 @@ export {
   isTerminalWorkflowStatus,
   EXTENSIONS_CONFIG_FILENAME,
   So,
-  redactUrlCredentials,
   require_toml,
   convertTomlToMarkdown,
   normalizeClaudeMcpServer,