@alan-ai-hq/agent-manager-darwin-arm64 0.1.138 → 0.1.140

package/alan-agent.cjs

@@ -20782,7 +20782,11 @@ var init_github_proxy = __esm({
     ];
     gitHubProxyUpstreamSchema = external_exports.enum(GITHUB_PROXY_UPSTREAMS);
     GITHUB_PROXY_PLACEHOLDER_TOKEN = "proxy-injected";
-    GITHUB_PROXY_REFUSAL_CODES = ["host_not_proxied", "machine_not_allowed"];
+    GITHUB_PROXY_REFUSAL_CODES = [
+      "host_not_proxied",
+      "machine_not_allowed",
+      "github_not_connected"
+    ];
     gitHubProxyErrorSchema = external_exports.object({
       message: external_exports.string().min(1),
       documentation_url: external_exports.string(),
@@ -22071,13 +22075,9 @@ So when a turn depends on something the repository cannot tell you \u2014 a valu
 What comes back is the answer, not a step towards it. Carry its specifics into what you write or change \u2014 the value, the constraint, the reason, the person \u2014 and say plainly when the evidence contradicts what was asked for. Retrieving a decision and then producing work that ignores it is worse than never having searched, because it looks informed.
 
 Skip it when nothing team-specific is at stake: source-code questions, general knowledge, mechanical work fully specified in the request, or an exact ID already in hand.`;
-    ALAN_PLATFORM_TOOL_ROUTING_PROMPT = `## Alan platform tools
-
-Use the matching Alan MCP tool to retrieve or change canonical Alan records \u2014 tasks, sessions, documents, artifacts, and their relationships \u2014 to perform Alan platform actions such as managing runs or machines, or to act through a provider identity connected to Alan. This applies whether the agent runs locally or in the cloud. Do not use a shell CLI, browser, raw HTTP, or local files to bypass an unavailable or unauthorized Alan MCP action; those paths bypass Alan's identity, authorization, audit trail, and task linkage.
-
-Use computer use and browser tools for authorized product debugging and QA, including inspecting the authenticated Alan app, its transient DOM and CSS state, and exercising UI flows in development or test environments. These tools are also available for ordinary browser and computer tasks outside Alan. Use local tools for repository, process, and log diagnostics. Exercising a UI for QA is not a substitute for carrying out a blocked platform record action.
+    ALAN_PLATFORM_TOOL_ROUTING_PROMPT = `## Alan platform and GitHub
 
-A tool missing from the currently offered set is not proof that it is unavailable. Use the host's tool-discovery mechanism once. If the tool is still not exposed, or its call reports unavailable or unauthorized, name the blocked capability and stop that platform action only; continue independent debugging and testing. Do not bypass a workflow or role tool allowlist.`;
+Use Alan MCP tools for canonical Alan records and platform actions: tasks, sessions, documents, artifacts, runs, and machines. Use the available repository tools for GitHub work, including git and gh when useful. If a cloud GitHub request reports github_not_connected, call request_github_connection in the current conversation and end the turn. The chat will offer GitHub authorization and resume after the user connects. Continue other independent work when possible.`;
     ALAN_IDENTITY_PROMPT = `You are Alan, the software factory agent. Alan ships software end to end \u2014 plan, write, review, test, deploy.
 
 ## How Alan is structured
@@ -22115,10 +22115,10 @@ Team
 
 ${ALAN_PLATFORM_TOOL_ROUTING_PROMPT}
 
-## Record & Entity Resolution (Tasks, PRs, Docs, Epics)
+## Record & Entity Resolution (Tasks, Docs, Epics)
 
-When the user refers to a specific task, pull request, document, or epic by human identifier (e.g. \`AL-2980\`, \`2980\`, \`#45\`), title, or topic phrase:
-- **Always resolve it with \`find_records\` first** (pass \`kinds: ["task"]\`, \`["document"]\`, \`["pull_request"]\`, or \`["epic"]\`).
+When the user refers to a specific task, document, or epic by human identifier (e.g. \`AL-2980\`, \`2980\`), title, or topic phrase:
+- **Always resolve it with \`find_records\` first** (pass \`kinds: ["task"]\`, \`["document"]\`, or \`["epic"]\`).
 - **Never scan with \`list_tasks\` or \`list_epics\`** to locate a specific item whose number or title you were already given \u2014 list tools are strictly for paginating browsable boards of work, not for lookup.
 - Once \`find_records\` returns the entity, call \`get_task\` / \`get_epic\` / \`get_document\` with the resolved identifier or UUID if full relational details, comments, or subtasks are required.
 
@@ -22610,8 +22610,8 @@ function decode3(bytes, start, end) {
 }
 async function linuxStartTicks(pid) {
   try {
-    const stat21 = await (0, import_promises9.readFile)(`/proc/${pid}/stat`, "utf8");
-    const fields = stat21.slice(stat21.lastIndexOf(")") + 2).split(" ");
+    const stat22 = await (0, import_promises9.readFile)(`/proc/${pid}/stat`, "utf8");
+    const fields = stat22.slice(stat22.lastIndexOf(")") + 2).split(" ");
     return fields[19];
   } catch {
     return void 0;
@@ -24658,35 +24658,99 @@ var init_reduce = __esm({
 });
 
 // ../shared/dist/agent/acp/conversation-messages.js
+function hasProviderCopy(meta3) {
+  return Object.keys(meta3).some((key) => PROVIDER_COPY_META_KEYS.has(key));
+}
+function withoutProviderCopies(meta3) {
+  return Object.fromEntries(Object.entries(meta3).filter(([key]) => !PROVIDER_COPY_META_KEYS.has(key)));
+}
+function toolContentText(content) {
+  if (!Array.isArray(content))
+    return null;
+  const parts4 = [];
+  for (const block of content) {
+    const inner = isRecord8(block) && block.type === "content" ? block.content : block;
+    if (!isRecord8(inner) || typeof inner.text !== "string")
+      return null;
+    parts4.push(inner.text);
+  }
+  return parts4.join("\n");
+}
+function parsedFromRawOutput(update) {
+  const name = typeof update.name === "string" ? update.name : typeof update.title === "string" ? update.title : "";
+  if (isAskUserQuestionTool(name, update.rawInput))
+    return true;
+  const input2 = typeof update.rawInput === "string" ? update.rawInput : JSON.stringify(update.rawInput ?? null);
+  return /search_?context/i.test(`${name} ${input2}`.replace(/search_?code_?context/gi, ""));
+}
+function repeatsContent(update) {
+  const output2 = update.rawOutput;
+  if (typeof output2 !== "string" || output2.length === 0)
+    return false;
+  return output2 === toolContentText(update.content) && !parsedFromRawOutput(update);
+}
+function withoutProviderCopiesOf(value2) {
+  if (!value2._meta || !hasProviderCopy(value2._meta))
+    return value2;
+  return { ...value2, _meta: withoutProviderCopies(value2._meta) };
+}
+function pageUpdate(update) {
+  const meta3 = isRecord8(update._meta) ? update._meta : void 0;
+  const dropPayload = meta3 !== void 0 && hasProviderCopy(meta3);
+  const dropOutput = repeatsContent(update);
+  if (!dropPayload && !dropOutput)
+    return update;
+  const entries = Object.entries(update).filter(([key]) => !(dropOutput && key === "rawOutput") && !(dropPayload && key === "_meta"));
+  const slim = {
+    ...Object.fromEntries(entries),
+    sessionUpdate: update.sessionUpdate
+  };
+  if (dropPayload && meta3 !== void 0) {
+    slim._meta = withoutProviderCopies(meta3);
+  }
+  return slim;
+}
+function pageNode(node2) {
+  return {
+    ...node2,
+    event: { ...node2.event, update: pageUpdate(node2.event.update) },
+    children: node2.children.map(pageNode)
+  };
+}
 function compactConversationMessageTurns(turns, keepNewestEntries) {
   return turns.map((turn, index) => ({
     ...turn,
     display: turn.display.map((displayTurn) => {
+      const working = displayTurn.working.map(pageNode);
       if (!displayTurn.final)
-        return displayTurn;
+        return { ...displayTurn, working };
       return {
         ...displayTurn,
-        working: displayTurn.working.map((node2) => node2.key === displayTurn.final?.key ? {
+        working: working.map((node2) => node2.key === displayTurn.final?.key ? {
           ...node2,
           children: [],
           event: {
             ...node2.event,
             update: { ...node2.event.update, content: [] }
           }
-        } : node2)
+        } : node2),
+        final: pageNode(displayTurn.final)
       };
     }),
     state: {
       ...turn.state,
+      // Readers use only media updates from `unknown`; a provider's command list alone was 77 KB.
+      unknown: turn.state.unknown.filter((update) => MEDIA_SESSION_UPDATE_KINDS.has(update.sessionUpdate)),
       entries: index === 0 && keepNewestEntries ? turn.state.entries.map((entry) => {
-        if (entry.kind === "message")
-          return entry.role === "user" ? entry : { ...entry, content: [] };
-        const ask = isAskUserQuestionTool(entry.title || entry.toolKind, entry.rawInput);
+        const kept = withoutProviderCopiesOf(entry);
+        if (kept.kind === "message")
+          return kept.role === "user" ? kept : { ...kept, content: [] };
+        const ask = isAskUserQuestionTool(kept.title || kept.toolKind, kept.rawInput);
         return {
-          ...entry,
+          ...kept,
           content: [],
           locations: [],
-          rawInput: ask ? entry.rawInput : void 0,
+          rawInput: ask ? kept.rawInput : void 0,
           rawOutput: void 0
         };
       }) : []
@@ -24779,12 +24843,58 @@ function conversationTurnView(ordinal, state, previousDisplay = []) {
     read: prepareConversationTurnRead(state)
   };
 }
+function diffArray(previous, next) {
+  const changes = [];
+  for (const [index, value2] of next.entries()) {
+    if (previous[index] !== value2)
+      changes.push({ index, value: value2 });
+  }
+  return { length: next.length, changes };
+}
+function stateFields(state) {
+  const { entries: _entries, unknown: _unknown2, presentation: _presentation, ...fields } = state;
+  return fields;
+}
+function diffTranscriptState(previous, next) {
+  return {
+    entries: diffArray(previous.entries, next.entries),
+    unknown: diffArray(previous.unknown, next.unknown),
+    fields: stateFields(next)
+  };
+}
+function createLiveTurnFrameEncoder() {
+  const sent = /* @__PURE__ */ new Map();
+  return (ordinal, state) => {
+    const previous = sent.get(ordinal);
+    sent.delete(ordinal);
+    sent.set(ordinal, state);
+    for (const oldest of sent.keys()) {
+      if (sent.size <= SENT_LIVE_TURNS)
+        break;
+      sent.delete(oldest);
+    }
+    return previous ? { kind: "patch", ordinal, patch: diffTranscriptState(previous, state) } : { kind: "snapshot", ordinal, state };
+  };
+}
 function isRecord8(value2) {
   return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
 function isTranscriptState(value2) {
   return isRecord8(value2) && typeof value2.state === "string" && Array.isArray(value2.entries) && Array.isArray(value2.notices) && Array.isArray(value2.unknown);
 }
+function isArrayPatch(value2) {
+  return isRecord8(value2) && Number.isSafeInteger(value2.length) && Array.isArray(value2.changes) && value2.changes.every((change) => isRecord8(change) && Number.isSafeInteger(change.index) && "value" in change);
+}
+function isTranscriptStatePatch(value2) {
+  return isRecord8(value2) && isArrayPatch(value2.entries) && isArrayPatch(value2.unknown) && isRecord8(value2.fields) && typeof value2.fields.state === "string" && Array.isArray(value2.fields.notices);
+}
+function isLiveTurnFrame(value2) {
+  if (!isRecord8(value2) || !Number.isSafeInteger(value2.ordinal))
+    return false;
+  if (value2.kind === "snapshot")
+    return isTranscriptState(value2.state);
+  return value2.kind === "patch" && isTranscriptStatePatch(value2.patch);
+}
 function isPendingAsk(value2) {
   return value2 === null || isRecord8(value2) && typeof value2.toolCallId === "string" && isRecord8(value2.rawInput) && Array.isArray(value2.questions) && value2.questions.every((question) => isRecord8(question) && typeof question.question === "string" && (question.header === void 0 || typeof question.header === "string") && typeof question.multiSelect === "boolean" && Array.isArray(question.options) && question.options.every((option2) => isRecord8(option2) && typeof option2.label === "string" && (option2.description === void 0 || typeof option2.description === "string")));
 }
@@ -24800,6 +24910,7 @@ function isConversationMessageTurn(value2) {
 function isConversationMessagesPage(value2) {
   return isRecord8(value2) && typeof value2.revision === "string" && typeof value2.streamCursor === "string" && (value2.before === null || typeof value2.before === "string") && Array.isArray(value2.turns) && value2.turns.every(isConversationMessageTurn);
 }
+var PROVIDER_PAYLOAD_META_KEY, PROVIDER_EVENT_META_KEY, PROVIDER_COPY_META_KEYS, LIVE_TURN_FRAMES, LIVE_TURN_EVENT, SENT_LIVE_TURNS;
 var init_conversation_messages = __esm({
   "../shared/dist/agent/acp/conversation-messages.js"() {
     "use strict";
@@ -24810,6 +24921,16 @@ var init_conversation_messages = __esm({
     init_prepare_conversation_turns();
     init_reduce();
     init_transcript_http();
+    init_types2();
+    PROVIDER_PAYLOAD_META_KEY = "alan.dev/providerPayload";
+    PROVIDER_EVENT_META_KEY = "alan.dev/providerEvent";
+    PROVIDER_COPY_META_KEYS = /* @__PURE__ */ new Set([
+      PROVIDER_PAYLOAD_META_KEY,
+      PROVIDER_EVENT_META_KEY
+    ]);
+    LIVE_TURN_FRAMES = "patch";
+    LIVE_TURN_EVENT = "live_turn";
+    SENT_LIVE_TURNS = 8;
   }
 });
 
@@ -24835,15 +24956,6 @@ var init_transcript_byte_decoder = __esm({
 });
 
 // ../shared/dist/agent/acp/transcript-fold.js
-function snapshotTranscriptState(state) {
-  return {
-    ...state,
-    entries: state.entries.map((entry) => entry.kind === "message" ? { ...entry, content: [...entry.content] } : { ...entry, content: [...entry.content], locations: [...entry.locations] }),
-    notices: [...state.notices],
-    unknown: [...state.unknown],
-    ...state.activities ? { activities: state.activities.map((activity) => ({ ...activity })) } : {}
-  };
-}
 function isRecord9(value2) {
   return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
 }
@@ -24884,9 +24996,130 @@ function scopeTranscriptEvent(value2) {
     scoped.content = scopedContent(update.content, turnId);
   return { ...event, update: scoped };
 }
+function placeMessage(cache2, message2, updateOffset, entryOffset, startsWithPrompt) {
+  const cached2 = cache2.get(message2.messageId);
+  const source = message2.state;
+  const sameSource = cached2?.source === source;
+  if (sameSource && cached2.updateCount === source.updateCount && cached2.updateOffset === updateOffset && cached2.entryOffset === entryOffset && cached2.startsWithPrompt === startsWithPrompt)
+    return cached2.state;
+  const replacedEntries = cached2 && !sameSource ? cached2.source.entries : void 0;
+  const entries = source.entries.map((entry, index) => {
+    const previous = cached2?.state.entries[index];
+    const lastUpdateIndex = entry.lastUpdateIndex === void 0 ? void 0 : entry.lastUpdateIndex + updateOffset;
+    if (previous && cached2.updateOffset === updateOffset && previous.id === entry.id && previous.kind === entry.kind && (sameSource ? entry.lastUpdateIndex !== void 0 && previous.lastUpdateIndex === lastUpdateIndex : replacedEntries?.[index] === entry))
+      return previous;
+    return entry.kind === "message" ? { ...entry, lastUpdateIndex, content: [...entry.content] } : {
+      ...entry,
+      lastUpdateIndex,
+      content: [...entry.content],
+      locations: [...entry.locations]
+    };
+  });
+  const state = {
+    ...source,
+    entries,
+    notices: [...source.notices],
+    unknown: [...source.unknown],
+    ...source.activities ? {
+      activities: source.activities.map((activity) => ({
+        ...activity,
+        firstEntryIndex: entryOffset + activity.firstEntryIndex - (startsWithPrompt && activity.firstEntryIndex === 0 ? 1 : 0)
+      }))
+    } : {}
+  };
+  cache2.set(message2.messageId, {
+    source,
+    updateCount: source.updateCount,
+    updateOffset,
+    entryOffset,
+    startsWithPrompt,
+    state
+  });
+  return state;
+}
+function anchoredUpdateOffset(ordered, cache2) {
+  let natural = 0;
+  for (const message2 of ordered) {
+    const placed = cache2.get(message2.messageId);
+    if (placed)
+      return natural - placed.updateOffset;
+    natural += message2.state.updateCount ?? 0;
+  }
+  return 0;
+}
+function mergeTranscriptMessages(messages, cache2) {
+  const merged = emptyTranscript();
+  const ordered = [...messages].sort((left, right) => (left.turnOrdinal ?? 0) - (right.turnOrdinal ?? 0) || left.messageId.localeCompare(right.messageId));
+  let updateOffset = -anchoredUpdateOffset(ordered, cache2);
+  const seenToolIds = /* @__PURE__ */ new Set();
+  const seenNotices = /* @__PURE__ */ new Set();
+  for (const message2 of ordered) {
+    const entryOffset = merged.entries.length;
+    const previous = merged.entries.at(-1);
+    const startsWithPrompt = message2.role !== "user" && previous?.kind === "message" && previous.role === "user";
+    const state = placeMessage(cache2, message2, updateOffset, entryOffset, startsWithPrompt);
+    const removedBefore = [0];
+    const duplicateToolIds = /* @__PURE__ */ new Set();
+    for (const entry of state.entries) {
+      const parentId = entry._meta?.["alan.dev/parentToolCallId"];
+      const rawId = entry._meta?.[TRANSCRIPT_TOOL_RESPONSE_ID_META];
+      const providerEvent = entry._meta?.["alan.dev/providerEvent"];
+      const providerEventId = providerEvent && typeof providerEvent === "object" && "id" in providerEvent ? providerEvent.id : void 0;
+      const toolId = entry.kind === "tool_call" && typeof rawId === "string" && typeof providerEventId === "string" ? `${rawId}:${providerEventId}` : void 0;
+      const duplicate = toolId !== void 0 && seenToolIds.has(toolId) || typeof parentId === "string" && duplicateToolIds.has(parentId);
+      if (!duplicate) {
+        merged.entries.push(entry);
+        if (toolId)
+          seenToolIds.add(toolId);
+      }
+      if (duplicate && toolId)
+        duplicateToolIds.add(entry.id);
+      removedBefore.push((removedBefore.at(-1) ?? 0) + Number(duplicate));
+    }
+    if (state.activities?.length) {
+      merged.activities ??= [];
+      merged.activities.push(...state.activities.map((activity, index) => ({
+        ...activity,
+        firstEntryIndex: activity.firstEntryIndex - (removedBefore[message2.state.activities?.[index]?.firstEntryIndex ?? 0] ?? 0)
+      })));
+    }
+    for (const notice2 of state.notices) {
+      const key = JSON.stringify([notice2.level, notice2.message]);
+      if (seenNotices.has(key))
+        continue;
+      seenNotices.add(key);
+      merged.notices.push({
+        ...notice2,
+        firstEntryIndex: startsWithPrompt ? entryOffset - 1 : entryOffset
+      });
+    }
+    merged.unknown.push(...state.unknown);
+    if (state.userMessageAt !== void 0)
+      merged.userMessageAt = Math.max(merged.userMessageAt ?? state.userMessageAt, state.userMessageAt);
+    if (message2.role !== "user") {
+      merged.state = state.state;
+      merged.stopReason = state.stopReason;
+      merged.thinkingTokens = state.thinkingTokens;
+      if (state.awaitingToolCallIds)
+        merged.awaitingToolCallIds = state.awaitingToolCallIds;
+      else
+        delete merged.awaitingToolCallIds;
+    }
+    if (state.plan)
+      merged.plan = state.plan;
+    if (state.usage)
+      merged.usage = state.usage;
+    if (state.title)
+      merged.title = state.title;
+    updateOffset += state.updateCount ?? 0;
+  }
+  merged.updateCount = updateOffset;
+  return merged;
+}
 var init_transcript_fold = __esm({
   "../shared/dist/agent/acp/transcript-fold.js"() {
     "use strict";
+    init_reduce();
     init_transcript_http();
     init_types2();
   }
@@ -24925,7 +25158,7 @@ var init_acp = __esm({
   }
 });
 
-// ../agent-core/dist/chunk-UGRKZTAD.js
+// ../agent-core/dist/chunk-XC5676SG.js
 function textBlock(text2) {
   return { type: "text", text: text2 };
 }
@@ -25156,13 +25389,13 @@ function withoutInlineMedia(update) {
   };
 }
 var PROVIDER_PAYLOAD_META, TOOL_RESULT_ONLY_META, PARENT_TOOL_CALL_META, SUBAGENT_LAUNCHER_META, SUBAGENT_TASK_ID_META, SUBAGENT_OUTPUT_FILE_META, USAGE_META, TODOS_META, NOTICE_KIND_META, ASK_USER_QUESTIONS_META, USER_ANSWER_META, AWAITING_TOOL_CALLS_META2, EXIT_PLAN_MODE_INPUT_META, BACKGROUND_TASK_META, TASK_PROGRESS_META, RATE_LIMIT_META, MODEL_META, TOOLS_META, SLASH_COMMANDS_META, TOOL_KIND_RULES, ANSWER_PREFIX, ACCEPT_WORDS, MIN_INLINE_MEDIA_CHARS, DATA_URL_PREFIX, BASE64_BODY;
-var init_chunk_UGRKZTAD = __esm({
-  "../agent-core/dist/chunk-UGRKZTAD.js"() {
+var init_chunk_XC5676SG = __esm({
+  "../agent-core/dist/chunk-XC5676SG.js"() {
     "use strict";
     init_chunk_YXWJW7I5();
     init_constants();
     init_acp();
-    PROVIDER_PAYLOAD_META = "alan.dev/providerPayload";
+    PROVIDER_PAYLOAD_META = PROVIDER_PAYLOAD_META_KEY;
     TOOL_RESULT_ONLY_META = "alan.dev/toolResultOnly";
     PARENT_TOOL_CALL_META = "alan.dev/parentToolCallId";
     SUBAGENT_LAUNCHER_META = "alan.dev/subagentLauncher";
@@ -25207,12 +25440,12 @@ var init_chunk_UGRKZTAD = __esm({
 var init_acp2 = __esm({
   "../agent-core/dist/acp.js"() {
     "use strict";
-    init_chunk_UGRKZTAD();
+    init_chunk_XC5676SG();
     init_chunk_YXWJW7I5();
   }
 });
 
-// ../agent-core/dist/chunk-DALFHI4B.js
+// ../agent-core/dist/chunk-SBT5W7L4.js
 function isRecordValue(value2) {
   return value2 !== null;
 }
@@ -25391,10 +25624,10 @@ function readTranscriptTurns(transcript, chunk, baseOffset, skipped = []) {
   return { turns, consumedBytes: consumedEnd - baseOffset };
 }
 var import_fs3, NEWLINE2, TranscriptCursor, TranscriptLineLookup, CONTENT_UPDATES;
-var init_chunk_DALFHI4B = __esm({
-  "../agent-core/dist/chunk-DALFHI4B.js"() {
+var init_chunk_SBT5W7L4 = __esm({
+  "../agent-core/dist/chunk-SBT5W7L4.js"() {
     "use strict";
-    init_chunk_UGRKZTAD();
+    init_chunk_XC5676SG();
     init_chunk_YXWJW7I5();
     import_fs3 = require("fs");
     NEWLINE2 = 10;
@@ -25947,7 +26180,7 @@ var init_chunk_54ZRJOQP = __esm({
   }
 });
 
-// ../agent-core/dist/chunk-KHYYC5IN.js
+// ../agent-core/dist/chunk-VMGVHPBB.js
 function collectStrings(value2, out) {
   if (typeof value2 === "string") out.push(value2);
   else if (Array.isArray(value2)) for (const item of value2) collectStrings(item, out);
@@ -26039,8 +26272,8 @@ function readMediaFiles(candidates2, cwd, mimeByExt, maxBytes) {
     seen.add(path4);
     const mimeType = mimeByExt[(0, import_path3.extname)(path4).toLowerCase()];
     if (!mimeType) continue;
-    const stat21 = (0, import_fs4.statSync)(path4);
-    if (!stat21.isFile() || stat21.size <= 0 || stat21.size > maxBytes) continue;
+    const stat22 = (0, import_fs4.statSync)(path4);
+    if (!stat22.isFile() || stat22.size <= 0 || stat22.size > maxBytes) continue;
     files.push({ path: path4, mimeType, buffer: (0, import_fs4.readFileSync)(path4) });
   }
   return files;
@@ -26317,10 +26550,10 @@ function silentStartError(name, timeoutMs) {
   };
 }
 var import_crypto3, import_fs4, import_path3, IMAGE_MIME_BY_EXT, VIDEO_MIME_BY_EXT, IMAGE_EXTENSIONS, VIDEO_EXTENSIONS, MAX_IMAGE_BYTES, MAX_VIDEO_BYTES, AGENT_BROWSER_MENTION, LocalMediaReader, SessionOpenRefusal, JsonRpcError, ACP_PROTOCOL_VERSION, ACP_ERROR, STDERR_TAIL_LINES, RESULT_EXIT_GRACE_MS, PerTurnSession;
-var init_chunk_KHYYC5IN = __esm({
-  "../agent-core/dist/chunk-KHYYC5IN.js"() {
+var init_chunk_VMGVHPBB = __esm({
+  "../agent-core/dist/chunk-VMGVHPBB.js"() {
     "use strict";
-    init_chunk_UGRKZTAD();
+    init_chunk_XC5676SG();
     init_chunk_54ZRJOQP();
     init_chunk_M6YHY2EZ();
     init_chunk_YXWJW7I5();
@@ -27985,6 +28218,9 @@ function classifyResultError(event, context) {
   if (classified.errorKind !== "unknown_cli_error" || !isApiError) return classified;
   return { ...specForErrorKind("provider_error"), message: classified.message };
 }
+function isIdleUpdate(update) {
+  return isUpdate(update, "state_update") && update.state === "idle";
+}
 function isSettled22(update) {
   return update.status === "completed" || update.status === "failed" || update.status === "cancelled";
 }
@@ -28412,9 +28648,9 @@ var import_crypto6, import_fs5, import_path5, import_crypto7, import_promises31,
 var init_claude = __esm({
   "../agent-core/dist/providers/claude.js"() {
     "use strict";
-    init_chunk_DALFHI4B();
-    init_chunk_KHYYC5IN();
-    init_chunk_UGRKZTAD();
+    init_chunk_SBT5W7L4();
+    init_chunk_VMGVHPBB();
+    init_chunk_XC5676SG();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
@@ -28721,6 +28957,7 @@ var init_claude = __esm({
       #failure;
       #authFailure;
       #resultSeen = false;
+      #heldIdle;
       constructor(options = {}) {
         this.#options = options;
         this.taskRecords = options.taskRecords ?? new TaskRecords(options.now ?? (() => systemClock2.now()));
@@ -28768,7 +29005,17 @@ var init_claude = __esm({
       readEvent(event) {
         const parsed = this.#revise(parseClaudeEvent(event, this.grammar), event);
         parsed.push(...this.#handle(event));
-        const updates = parsed.map((update) => this.taskRecords.stamp(update));
+        const kept = parsed.filter((update) => {
+          if (!isIdleUpdate(update)) return true;
+          if (this.#finalized) return true;
+          this.#heldIdle = update;
+          return false;
+        });
+        if (this.#finalized && this.#heldIdle !== void 0) {
+          if (!kept.some(isIdleUpdate)) kept.push(this.#heldIdle);
+          this.#heldIdle = void 0;
+        }
+        const updates = kept.map((update) => this.taskRecords.stamp(update));
         for (const update of updates) this.#applyRunState(update);
         return updates;
       }
@@ -31189,9 +31436,9 @@ var import_fs6, import_path6, import_crypto8, import_crypto9, import_crypto10, T
 var init_codex = __esm({
   "../agent-core/dist/providers/codex.js"() {
     "use strict";
-    init_chunk_DALFHI4B();
-    init_chunk_KHYYC5IN();
-    init_chunk_UGRKZTAD();
+    init_chunk_SBT5W7L4();
+    init_chunk_VMGVHPBB();
+    init_chunk_XC5676SG();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
@@ -42460,8 +42707,8 @@ var require_tar_stream = __commonJS({
 var init_dist = __esm({
   "../agent-core/dist/index.js"() {
     "use strict";
-    init_chunk_KHYYC5IN();
-    init_chunk_UGRKZTAD();
+    init_chunk_VMGVHPBB();
+    init_chunk_XC5676SG();
     init_chunk_54ZRJOQP();
     init_chunk_M6YHY2EZ();
     init_chunk_YXWJW7I5();
@@ -43207,8 +43454,8 @@ var import_promises48, import_path9, import_crypto12, import_promises49, CURSOR_
 var init_acp3 = __esm({
   "../agent-core/dist/providers/acp.js"() {
     "use strict";
-    init_chunk_KHYYC5IN();
-    init_chunk_UGRKZTAD();
+    init_chunk_VMGVHPBB();
+    init_chunk_XC5676SG();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
@@ -44092,15 +44339,16 @@ function createPersistentDriver(provider4, options) {
     return void 0;
   };
   const resumeNotice = (spec, session, sink) => {
+    if (spec.resumeFallbackContext) {
+      log.info("holder.session_resume_fallback", { harness: provider4.harness, runId: spec.runId });
+      return { session, contextPrefix: spec.resumeFallbackContext };
+    }
     sink.onEvent({
       seq: 0,
       at: clock.now(),
       update: noticeUpdate("warning", "session_resume_failed", RESUME_UNAVAILABLE)
     });
-    return {
-      session,
-      ...spec.resumeFallbackContext ? { contextPrefix: spec.resumeFallbackContext } : {}
-    };
+    return { session };
   };
   const managedMcpAccess = async (signal) => {
     const managed = options.managedMcp;
@@ -44175,6 +44423,7 @@ function createPersistentDriver(provider4, options) {
       };
       const _events = __using(_stack, session.onEvent(forward));
       live.turn = turn;
+      record2({ sessionUpdate: "state_update", state: "running" });
       if (session.pid !== void 0) sink.onSpawned(session.pid);
       const onAbort = () => {
         void session.cancel();
@@ -44911,8 +45160,8 @@ var import_http10, import_crypto13, import_promises50, import_path10, import_pat
 var init_opencode = __esm({
   "../agent-core/dist/providers/opencode.js"() {
     "use strict";
-    init_chunk_KHYYC5IN();
-    init_chunk_UGRKZTAD();
+    init_chunk_VMGVHPBB();
+    init_chunk_XC5676SG();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
@@ -44927,6 +45176,7 @@ var init_opencode = __esm({
     import_path11 = require("path");
     import_url2 = require("url");
     init_acp();
+    init_acp();
     import_crypto14 = require("crypto");
     init_agent2();
     IDLE_SOCKET_MS3 = 4e3;
@@ -45245,7 +45495,7 @@ var init_opencode = __esm({
       ["DataPolicyError", "model_mismatch"]
     ]);
     OPENCODE_ABORTED_ERROR = "MessageAbortedError";
-    PROVIDER_EVENT_META = "alan.dev/providerEvent";
+    PROVIDER_EVENT_META = PROVIDER_EVENT_META_KEY;
     TASK_TOOL_NAME = "task";
     TASK_RESULT_TAG = /<task_result>\n?([\s\S]*?)\n?<\/task_result>/;
     TASK_ERROR_TAG = /<task_error>\n?([\s\S]*?)\n?<\/task_error>/;
@@ -46106,7 +46356,7 @@ function createAlanCodeHolderDriver(options) {
       open: open6,
       turnInput: async (spec, inputs, contextPrefix) => openCodeTurnInput(spec, {
         attachments: inputs.attachments,
-        skills: [],
+        skills: inputs.skills,
         ...contextPrefix === void 0 ? {} : { contextPrefix }
       })
     },
@@ -46719,8 +46969,8 @@ var import_crypto15, import_promises51, FACTORY_API_VERSION, FACTORY_PROTOCOL_VE
 var init_droid = __esm({
   "../agent-core/dist/providers/droid.js"() {
     "use strict";
-    init_chunk_KHYYC5IN();
-    init_chunk_UGRKZTAD();
+    init_chunk_VMGVHPBB();
+    init_chunk_XC5676SG();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
@@ -47122,7 +47372,7 @@ function createDroidHolderDriver(options) {
       },
       turnInput: (spec, inputs, contextPrefix) => droidTurnInput(spec, {
         attachments: inputs.attachments,
-        skills: [],
+        skills: inputs.skills,
         ...contextPrefix === void 0 ? {} : { contextPrefix }
       })
     },
@@ -47170,7 +47420,7 @@ function createOpenCodeHolderDriver(options) {
       },
       turnInput: async (spec, inputs, contextPrefix) => openCodeTurnInput(spec, {
         attachments: inputs.attachments,
-        skills: [],
+        skills: inputs.skills,
         ...contextPrefix === void 0 ? {} : { contextPrefix }
       })
     },
@@ -47821,9 +48071,9 @@ var import_promises52, import_path12, import_fs8, import_path13, import_path14,
 var init_antigravity = __esm({
   "../agent-core/dist/providers/antigravity.js"() {
     "use strict";
-    init_chunk_DALFHI4B();
-    init_chunk_KHYYC5IN();
-    init_chunk_UGRKZTAD();
+    init_chunk_SBT5W7L4();
+    init_chunk_VMGVHPBB();
+    init_chunk_XC5676SG();
     init_chunk_54ZRJOQP();
     init_chunk_M6YHY2EZ();
     init_chunk_ITTV3UIM();
@@ -48526,8 +48776,8 @@ var import_promises53, import_path15, import_crypto17, COMMAND_CODE_GRAMMAR_NAME
 var init_command_code = __esm({
   "../agent-core/dist/providers/command-code.js"() {
     "use strict";
-    init_chunk_KHYYC5IN();
-    init_chunk_UGRKZTAD();
+    init_chunk_VMGVHPBB();
+    init_chunk_XC5676SG();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
     init_chunk_M6YHY2EZ();
@@ -53929,7 +54179,7 @@ var require_websocket_server = __commonJS({
 // package.json
 var package_default = {
   name: "@alan-ai-hq/agent-manager",
-  version: "0.1.138",
+  version: "0.1.140",
   private: true,
   type: "module",
   description: "Alan machine runtime (alan-agent): identity, link, reconciler, session holders, run log, uploader, local API",
@@ -53979,7 +54229,7 @@ var package_default = {
 
 // src/cli/commands/compat.ts
 var import_node_crypto31 = require("crypto");
-var import_promises66 = require("fs/promises");
+var import_promises67 = require("fs/promises");
 init_runtime_v2();
 init_zod();
 
@@ -54823,7 +55073,8 @@ var openTurnResponseSchema = external_exports.object({
   runId: external_exports.string().min(1),
   userMessageId: external_exports.string().min(1),
   assistantMessageId: external_exports.string().min(1),
-  created: external_exports.boolean()
+  created: external_exports.boolean(),
+  turnOrdinals: external_exports.object({ user: external_exports.number().int().nonnegative(), assistant: external_exports.number().int().nonnegative() }).optional()
 });
 var errorBodySchema2 = external_exports.object({ code: external_exports.string() });
 function createNativeSessionsClient({
@@ -56707,9 +56958,9 @@ function isProcessAlive(pid) {
   }
 }
 async function linuxStartTime(pid) {
-  const stat21 = await (0, import_promises13.readFile)(`/proc/${pid}/stat`, "utf8").catch(() => null);
-  if (stat21 === null) return null;
-  const fields = stat21.slice(stat21.lastIndexOf(")") + 2).split(" ");
+  const stat22 = await (0, import_promises13.readFile)(`/proc/${pid}/stat`, "utf8").catch(() => null);
+  if (stat22 === null) return null;
+  const fields = stat22.slice(stat22.lastIndexOf(")") + 2).split(" ");
   return fields[19] ?? null;
 }
 async function linuxCommand(pid) {
@@ -61599,9 +61850,23 @@ async function ingestTurn(ctx, worker, entry, turn) {
       },
       ctx.shutdown
     );
+    const ordinals = opened.turnOrdinals;
     await ctx.publisher.publish({
       runId: opened.runId,
       conversationId: entry.conversationId,
+      ...ordinals ? {
+        userMessage: {
+          id: opened.userMessageId,
+          content: userMessage,
+          turnOrdinal: ordinals.user,
+          createdAt: startedAt
+        },
+        assistantMessage: {
+          id: opened.assistantMessageId,
+          turnOrdinal: ordinals.assistant,
+          createdAt: startedAt
+        }
+      } : {},
       records: nativeTurnRecords({
         updates: withTerminalIdle(turn.updates, startedAt),
         startedAt,
@@ -65639,7 +65904,7 @@ async function openWorkspaces(options) {
 
 // src/cli/config.ts
 var import_node_os11 = require("os");
-var import_node_path65 = require("path");
+var import_node_path66 = require("path");
 init_zod();
 
 // src/client/contract.ts
@@ -65942,14 +66207,18 @@ function applyField(pending, line) {
 }
 async function* readServerSentEvents(body) {
   const decoder3 = new TextDecoder();
-  let buffer = "";
+  let partial2 = [];
   let pending = emptyEvent();
   for await (const chunk of body) {
-    buffer += decoder3.decode(chunk, { stream: true });
-    let newline = buffer.indexOf("\n");
+    const text2 = decoder3.decode(chunk, { stream: true });
+    let start = 0;
+    let newline = text2.indexOf("\n");
     while (newline !== -1) {
-      const line = buffer.slice(0, newline).replace(/\r$/, "");
-      buffer = buffer.slice(newline + 1);
+      partial2.push(text2.slice(start, newline));
+      const line = partial2.join("").replace(/\r$/, "");
+      partial2 = [];
+      start = newline + 1;
+      newline = text2.indexOf("\n", start);
       if (line.length === 0) {
         if (pending.data.length > 0) {
           yield { event: pending.event, id: pending.id, data: pending.data.join("\n") };
@@ -65958,8 +66227,8 @@ async function* readServerSentEvents(body) {
       } else if (!line.startsWith(":")) {
         applyField(pending, line);
       }
-      newline = buffer.indexOf("\n");
     }
+    if (start < text2.length) partial2.push(text2.slice(start));
   }
 }
 
@@ -65996,6 +66265,23 @@ async function readDiscovery(path4) {
   }
   return parsed.data;
 }
+function conversationQuery(query) {
+  return {
+    limit: String(query.limit),
+    ...query.before ? { before: query.before } : {},
+    ...query.runtimeId ? { runtimeId: query.runtimeId } : {}
+  };
+}
+function conversationUpdate(event) {
+  const value2 = JSON.parse(event.data);
+  if (event.event === "snapshot" && isConversationMessagesPage(value2))
+    return { kind: "snapshot", page: value2 };
+  if (event.event === "turn" && isConversationMessageTurn(value2))
+    return { kind: "turn", turn: value2 };
+  if (event.event === LIVE_TURN_EVENT && isLiveTurnFrame(value2))
+    return { kind: "live_turn", frame: value2 };
+  throw new RuntimeClientError("protocol", "Invalid local conversation update");
+}
 function parseWith(schema, raw, what) {
   const parsed = schema.safeParse(raw);
   if (!parsed.success) {
@@ -66141,24 +66427,17 @@ function createRuntimeClient(options) {
     throw new RuntimeClientError("unavailable", "The run log stream closed before the run ended");
   }
   const runs = async (signal) => (await json2({ path: LOCAL_API_ROUTES.runs }, runsResponseSchema, signal)).runs;
-  async function* followConversationMessages(conversationId, limit, signal) {
+  async function* followConversationMessages(query, signal) {
     const stopped = new AbortController();
     try {
       const body = await openStream(
         {
-          path: `/v2/conversations/${encodeURIComponent(conversationId)}/messages/sse`,
-          query: { limit: String(limit) }
+          path: `/v2/conversations/${encodeURIComponent(query.conversationId)}/messages/sse`,
+          query: { ...conversationQuery(query), frames: LIVE_TURN_FRAMES }
         },
         AbortSignal.any([signal, stopped.signal])
       );
-      for await (const event of readServerSentEvents(body)) {
-        const value2 = JSON.parse(event.data);
-        if (event.event === "snapshot" && isConversationMessagesPage(value2))
-          yield { kind: "snapshot", page: value2 };
-        else if (event.event === "turn" && isConversationMessageTurn(value2))
-          yield { kind: "turn", turn: value2 };
-        else throw new RuntimeClientError("protocol", "Invalid local conversation update");
-      }
+      for await (const event of readServerSentEvents(body)) yield conversationUpdate(event);
       if (!signal.aborted)
         throw new RuntimeClientError("unavailable", "The local conversation stream closed");
     } finally {
@@ -66171,11 +66450,11 @@ function createRuntimeClient(options) {
     followConversationMessages,
     runs,
     conversationRuns: async (conversationId, signal) => (await runs(signal)).filter((run2) => run2.conversationId === conversationId),
-    readConversationMessages: async (conversationId, limit, before, signal) => {
+    readConversationMessages: async (query, signal) => {
       const response = await send2(
         {
-          path: `/v2/conversations/${encodeURIComponent(conversationId)}/messages`,
-          query: { limit: String(limit), ...before === null ? {} : { before } }
+          path: `/v2/conversations/${encodeURIComponent(query.conversationId)}/messages`,
+          query: conversationQuery(query)
         },
         signal
       );
@@ -66352,9 +66631,9 @@ async function sendNativeHookSignal(discoveryPath, hookSignal, signal) {
 
 // src/sessions/index.ts
 var import_node_crypto30 = require("crypto");
-var import_promises64 = require("fs/promises");
+var import_promises65 = require("fs/promises");
 var import_node_os10 = require("os");
-var import_node_path64 = require("path");
+var import_node_path65 = require("path");
 init_runtime_v2();
 
 // src/holder/control-client.ts
@@ -66770,7 +67049,7 @@ async function prepareRunInputs(spec, { source, tmpDir, signal, skills = [] }) {
 var import_node_crypto29 = require("crypto");
 var import_node_fs21 = require("fs");
 var import_node_net3 = require("net");
-var import_node_path63 = require("path");
+var import_node_path64 = require("path");
 init_runtime_v2();
 
 // src/holder/admission.ts
@@ -67524,14 +67803,42 @@ function createSessionFacts(options) {
 // src/holder/turn.ts
 init_acp2();
 
+// src/run-log/archive.ts
+var import_promises61 = require("fs/promises");
+var import_node_path59 = require("path");
+init_runtime_v2();
+async function openRunArchive(runsDir) {
+  const path4 = (0, import_node_path59.join)((0, import_node_path59.dirname)(runsDir), "archived-runs.txt");
+  const text2 = await (0, import_promises61.readFile)(path4, "utf8").catch((error61) => {
+    if (errnoCode(error61) === "ENOENT") return "";
+    throw error61;
+  });
+  const archived = /* @__PURE__ */ new Set();
+  for (const line of text2.split("\n")) {
+    const runId = runIdSchema.safeParse(line);
+    if (runId.success) archived.add(runId.data);
+  }
+  return {
+    has: (runId) => archived.has(runId),
+    add: async (runIds) => {
+      const added = runIds.filter((runId) => !archived.has(runId));
+      if (added.length === 0) return;
+      await (0, import_promises61.appendFile)(path4, `
+${added.join("\n")}
+`, { mode: 384 });
+      for (const runId of added) archived.add(runId);
+    }
+  };
+}
+
 // src/run-log/complete.ts
 var import_node_crypto28 = require("crypto");
 var import_node_fs19 = require("fs");
-var import_node_path60 = require("path");
+var import_node_path61 = require("path");
 
 // src/run-log/directory.ts
-var import_promises61 = require("fs/promises");
-var import_node_path59 = require("path");
+var import_promises62 = require("fs/promises");
+var import_node_path60 = require("path");
 init_runtime_v2();
 init_zod();
 var runMetaSchema = external_exports.object({
@@ -67557,17 +67864,17 @@ async function readRunMeta(path4) {
   return read.kind === "ok" ? read.value : null;
 }
 function runDirectory(runsDir, runId) {
-  const dir = (0, import_node_path59.join)(runsDir, runId);
+  const dir = (0, import_node_path60.join)(runsDir, runId);
   return {
     dir,
-    log: (0, import_node_path59.join)(dir, "log.jsonl"),
-    upload: (0, import_node_path59.join)(dir, "upload.json"),
-    meta: (0, import_node_path59.join)(dir, "run.json")
+    log: (0, import_node_path60.join)(dir, "log.jsonl"),
+    upload: (0, import_node_path60.join)(dir, "upload.json"),
+    meta: (0, import_node_path60.join)(dir, "run.json")
   };
 }
 async function isRunClaimed(runsDir, runId) {
   try {
-    return (await (0, import_promises61.stat)(runDirectory(runsDir, runId).log)).size > 0;
+    return (await (0, import_promises62.stat)(runDirectory(runsDir, runId).log)).size > 0;
   } catch (error61) {
     if (errnoCode(error61) === "ENOENT") return false;
     throw error61;
@@ -67576,7 +67883,7 @@ async function isRunClaimed(runsDir, runId) {
 
 // src/run-log/complete.ts
 function writeLogFile(path4, dir, text2) {
-  const temp = (0, import_node_path60.join)(dir, `.log.${(0, import_node_crypto28.randomUUID)()}.tmp`);
+  const temp = (0, import_node_path61.join)(dir, `.log.${(0, import_node_crypto28.randomUUID)()}.tmp`);
   const fd = (0, import_node_fs19.openSync)(temp, "wx", 384);
   try {
     (0, import_node_fs19.writeSync)(fd, text2);
@@ -67605,25 +67912,31 @@ async function writeCompleteRunLog(runsDir, meta3, records) {
 }
 
 // src/run-log/conversation-index.ts
-var import_promises62 = require("fs/promises");
-var import_node_path61 = require("path");
+var import_promises63 = require("fs/promises");
+var import_node_path62 = require("path");
 init_runtime_v2();
 init_zod();
 var ORDINALS_PER_SHARD = 1e3;
+var REBUILD_READ_CONCURRENCY = 32;
 var indexRecordSchema = external_exports.object({
   ordinal: external_exports.number().int().nonnegative(),
   nextOrdinal: external_exports.number().int().positive(),
   runId: runIdSchema
 });
 var coverageSchema = external_exports.object({
+  // Files written before ranges could start mid-conversation always started at turn 0.
+  lowestOrdinal: external_exports.number().int().nonnegative().default(0),
   highestOrdinal: external_exports.number().int().nonnegative(),
   nextExpectedOrdinal: external_exports.number().int().positive()
 });
+function conversationsDirectory(runsDir) {
+  return (0, import_node_path62.join)((0, import_node_path62.dirname)(runsDir), "conversations");
+}
 function indexDirectory(runsDir, conversationId) {
-  return (0, import_node_path61.join)((0, import_node_path61.dirname)(runsDir), "sessions", conversationId, "turn-index");
+  return (0, import_node_path62.join)(conversationsDirectory(runsDir), conversationId, "turn-index");
 }
 function shardPath(runsDir, conversationId, ordinal) {
-  return (0, import_node_path61.join)(
+  return (0, import_node_path62.join)(
     indexDirectory(runsDir, conversationId),
     `${Math.floor(ordinal / ORDINALS_PER_SHARD)}.jsonl`
   );
@@ -67632,26 +67945,31 @@ async function indexConversationRun(runsDir, conversationId, ordinal, assistantO
   const nextOrdinal = assistantOrdinal + 1;
   if (nextOrdinal <= ordinal) throw new Error("Assistant order must follow the prompt");
   const path4 = shardPath(runsDir, conversationId, ordinal);
-  await (0, import_promises62.mkdir)((0, import_node_path61.dirname)(path4), { recursive: true, mode: 448 });
-  await (0, import_promises62.appendFile)(path4, `${JSON.stringify({ ordinal, nextOrdinal, runId })}
+  await (0, import_promises63.mkdir)((0, import_node_path62.dirname)(path4), { recursive: true, mode: 448 });
+  await (0, import_promises63.appendFile)(path4, `${JSON.stringify({ ordinal, nextOrdinal, runId })}
 `, { mode: 384 });
-  const coveragePath = (0, import_node_path61.join)((0, import_node_path61.dirname)((0, import_node_path61.dirname)(path4)), "coverage.json");
+  const coveragePath = (0, import_node_path62.join)((0, import_node_path62.dirname)((0, import_node_path62.dirname)(path4)), "coverage.json");
   const coverage = await readJsonFile(coveragePath, coverageSchema);
   const current = coverage.kind === "ok" ? coverage.value : null;
-  if (ordinal === 0 && current === null || current?.nextExpectedOrdinal === ordinal)
-    await writeJsonFileAtomic(coveragePath, {
-      highestOrdinal: ordinal,
-      nextExpectedOrdinal: nextOrdinal
-    });
+  const next = nextCoverage(current, ordinal, nextOrdinal);
+  if (next) await writeJsonFileAtomic(coveragePath, next);
+}
+function nextCoverage(current, ordinal, nextOrdinal) {
+  if (current === null || ordinal > current.nextExpectedOrdinal)
+    return { lowestOrdinal: ordinal, highestOrdinal: ordinal, nextExpectedOrdinal: nextOrdinal };
+  if (ordinal === current.nextExpectedOrdinal)
+    return { ...current, highestOrdinal: ordinal, nextExpectedOrdinal: nextOrdinal };
+  if (ordinal === current.highestOrdinal) return { ...current, nextExpectedOrdinal: nextOrdinal };
+  return null;
 }
 async function readConversationIndexCoverage(runsDir, conversationId) {
-  const path4 = (0, import_node_path61.join)((0, import_node_path61.dirname)(indexDirectory(runsDir, conversationId)), "coverage.json");
+  const path4 = (0, import_node_path62.join)((0, import_node_path62.dirname)(indexDirectory(runsDir, conversationId)), "coverage.json");
   const result = await readJsonFile(path4, coverageSchema);
   return result.kind === "ok" ? result.value : null;
 }
 async function readConversationRunIndex(runsDir, conversationId, before, limit) {
   const directory = indexDirectory(runsDir, conversationId);
-  const names = await (0, import_promises62.readdir)(directory).catch((error61) => {
+  const names = await (0, import_promises63.readdir)(directory).catch((error61) => {
     if (error61.code === "ENOENT") return [];
     throw error61;
   });
@@ -67660,7 +67978,7 @@ async function readConversationRunIndex(runsDir, conversationId, before, limit)
   ).sort((left, right) => right - left);
   const selected = [];
   for (const shard of shards) {
-    const text2 = await (0, import_promises62.readFile)((0, import_node_path61.join)(directory, `${shard}.jsonl`), "utf8");
+    const text2 = await (0, import_promises63.readFile)((0, import_node_path62.join)(directory, `${shard}.jsonl`), "utf8");
     const records = text2.split("\n").flatMap((line) => {
       if (!line) return [];
       const parsed = indexRecordSchema.parse(JSON.parse(line));
@@ -67674,9 +67992,82 @@ async function readConversationRunIndex(runsDir, conversationId, before, limit)
   }
   return selected;
 }
+async function readIndexableRun(runsDir, name) {
+  const runId = runIdSchema.safeParse(name);
+  if (!runId.success) return null;
+  const meta3 = await readRunMeta(runDirectory(runsDir, runId.data).meta);
+  const ordinal = meta3?.userMessage?.turnOrdinal;
+  const assistantOrdinal = meta3?.assistantMessage?.turnOrdinal;
+  if (!meta3 || ordinal == null || assistantOrdinal == null || assistantOrdinal < ordinal)
+    return null;
+  return { conversationId: meta3.conversationId, ordinal, assistantOrdinal, runId: runId.data };
+}
+async function readIndexableRuns(runsDir) {
+  const names = await (0, import_promises63.readdir)(runsDir).catch(() => []);
+  const byConversation = /* @__PURE__ */ new Map();
+  let next = 0;
+  const worker = async () => {
+    while (next < names.length) {
+      const run2 = await readIndexableRun(runsDir, names[next++]);
+      if (run2 === null) continue;
+      const runs = byConversation.get(run2.conversationId);
+      if (runs === void 0) byConversation.set(run2.conversationId, [run2]);
+      else runs.push(run2);
+    }
+  };
+  await Promise.all(Array.from({ length: REBUILD_READ_CONCURRENCY }, worker));
+  return byConversation;
+}
+async function writeConversationIndex(directory, runs) {
+  runs.sort(
+    (left, right) => left.ordinal - right.ordinal || left.assistantOrdinal - right.assistantOrdinal
+  );
+  const shards = /* @__PURE__ */ new Map();
+  let coverage = null;
+  for (const run2 of runs) {
+    const nextOrdinal = run2.assistantOrdinal + 1;
+    const shard = Math.floor(run2.ordinal / ORDINALS_PER_SHARD);
+    const line = JSON.stringify({ ordinal: run2.ordinal, nextOrdinal, runId: run2.runId });
+    const lines2 = shards.get(shard);
+    if (lines2 === void 0) shards.set(shard, [line]);
+    else lines2.push(line);
+    coverage = nextCoverage(coverage, run2.ordinal, nextOrdinal) ?? coverage;
+  }
+  await (0, import_promises63.mkdir)((0, import_node_path62.join)(directory, "turn-index"), { recursive: true, mode: 448 });
+  for (const [shard, lines2] of shards) {
+    await (0, import_promises63.writeFile)((0, import_node_path62.join)(directory, "turn-index", `${shard}.jsonl`), `${lines2.join("\n")}
+`, {
+      mode: 384
+    });
+  }
+  await (0, import_promises63.writeFile)((0, import_node_path62.join)(directory, "coverage.json"), `${JSON.stringify(coverage)}
+`, {
+    mode: 384
+  });
+}
+async function rebuildConversationIndexes(runsDir) {
+  const root = conversationsDirectory(runsDir);
+  const exists6 = await (0, import_promises63.stat)(root).then(
+    () => true,
+    (error61) => {
+      if (errnoCode(error61) === "ENOENT") return false;
+      throw error61;
+    }
+  );
+  if (exists6) return 0;
+  const building = `${root}.rebuilding`;
+  await (0, import_promises63.rm)(building, { recursive: true, force: true });
+  await (0, import_promises63.mkdir)(building, { recursive: true, mode: 448 });
+  const byConversation = await readIndexableRuns(runsDir);
+  for (const [conversationId, runs] of byConversation) {
+    await writeConversationIndex((0, import_node_path62.join)(building, conversationId), runs);
+  }
+  await (0, import_promises63.rename)(building, root);
+  return byConversation.size;
+}
 
 // src/run-log/reader.ts
-var import_promises63 = require("fs/promises");
+var import_promises64 = require("fs/promises");
 init_runtime_v2();
 
 // src/run-log/tail.ts
@@ -67699,7 +68090,7 @@ function firstRecordLength(bytes) {
   return bytes.indexOf(RUN_LOG_RECORD_SEPARATOR) + 1;
 }
 async function openRunLogReader(path4) {
-  const handle = await (0, import_promises63.open)(path4, "r");
+  const handle = await (0, import_promises64.open)(path4, "r");
   const readAt = async (position, length) => {
     const buffer = Buffer.alloc(length);
     const { bytesRead } = await handle.read(buffer, 0, length, position);
@@ -67733,7 +68124,7 @@ async function openRunLogReader(path4) {
   };
 }
 async function readLastRecord(path4) {
-  const handle = await (0, import_promises63.open)(path4, "r").catch(() => null);
+  const handle = await (0, import_promises64.open)(path4, "r").catch(() => null);
   if (handle === null) return null;
   try {
     const { size } = await handle.stat();
@@ -67767,7 +68158,7 @@ var decoder = new TextDecoder();
 
 // src/run-log/writer.ts
 var import_node_fs20 = require("fs");
-var import_node_path62 = require("path");
+var import_node_path63 = require("path");
 init_runtime_v2();
 function lastSeq(fd, size) {
   for (const length of tailWindows(size)) {
@@ -67783,7 +68174,7 @@ function lastSeq(fd, size) {
   throw new RuntimeFault("record_too_large", "Run log tail record is larger than any record");
 }
 function openRunLog(path4, clock) {
-  (0, import_node_fs20.mkdirSync)((0, import_node_path62.dirname)(path4), { recursive: true, mode: 448 });
+  (0, import_node_fs20.mkdirSync)((0, import_node_path63.dirname)(path4), { recursive: true, mode: 448 });
   const fd = (0, import_node_fs20.openSync)(path4, "a+", 384);
   let size = (0, import_node_fs20.fstatSync)(fd).size;
   let seq = lastSeq(fd, size);
@@ -68119,7 +68510,7 @@ async function runHolder({
   try {
     const identity = await readProcessIdentity(process.pid);
     if (identity === null) throw new RuntimeFault("internal", "Cannot read own process identity");
-    const _engines = __using(_stack, recordSpawnedEngines(engineRecordsPath((0, import_node_path63.dirname)(launch.statusPath)), clock, log));
+    const _engines = __using(_stack, recordSpawnedEngines(engineRecordsPath((0, import_node_path64.dirname)(launch.statusPath)), clock, log));
     const holder = {
       state: "idle",
       runId: null,
@@ -68413,7 +68804,7 @@ var DEFAULT_MAX_ACTIVE_RUNS = 32;
 var HOLDER_BUSY = "busy";
 async function listIds(dir, schema) {
   const ids = [];
-  for (const name of await (0, import_promises64.readdir)(dir).catch(() => [])) {
+  for (const name of await (0, import_promises65.readdir)(dir).catch(() => [])) {
     const parsed = schema.safeParse(name);
     if (parsed.success) ids.push(parsed.data);
   }
@@ -68427,11 +68818,20 @@ function holderIdentity(status) {
   return command === void 0 ? { pid, startedAt } : { pid, startedAt, command };
 }
 function sessionFiles(paths, conversationId) {
-  const dir = (0, import_node_path64.join)(paths.sessions, conversationId);
-  return { dir, launch: (0, import_node_path64.join)(dir, "launch.json"), status: (0, import_node_path64.join)(dir, "holder.json") };
+  const dir = (0, import_node_path65.join)(paths.sessions, conversationId);
+  return { dir, launch: (0, import_node_path65.join)(dir, "launch.json"), status: (0, import_node_path65.join)(dir, "holder.json") };
+}
+async function removeHolderFiles(files) {
+  for (const path4 of [files.launch, files.status, engineRecordsPath(files.dir)]) {
+    await (0, import_promises65.rm)(path4, { force: true });
+  }
+  await (0, import_promises65.rmdir)(files.dir).catch((error61) => {
+    if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(errnoCode(error61) ?? "")) throw error61;
+  });
 }
 async function openSessions(deps) {
   const { paths, clock, log } = deps;
+  const recentRunIds = async () => (await listIds(paths.runs, runIdSchema)).filter((runId) => !deps.archive?.has(runId));
   const connections = /* @__PURE__ */ new Map();
   const starting = /* @__PURE__ */ new Map();
   const launched = /* @__PURE__ */ new Map();
@@ -68465,11 +68865,11 @@ async function openSessions(deps) {
     return status.kind === "ok" && await mayBeSameProcess(holderIdentity(status.value));
   };
   const discardSession = async (conversationId) => {
-    const { dir } = sessionFiles(paths, conversationId);
-    await reapLeftoverEngines(engineRecordsPath(dir), { clock, log, conversationId }).catch(
+    const files = sessionFiles(paths, conversationId);
+    await reapLeftoverEngines(engineRecordsPath(files.dir), { clock, log, conversationId }).catch(
       (error61) => log.warn("sessions.engine_reap_failed", { conversationId, error: error61 })
     );
-    await (0, import_promises64.rm)(dir, { recursive: true, force: true });
+    await removeHolderFiles(files);
   };
   const retireIfGone = async (conversationId) => {
     const files = sessionFiles(paths, conversationId);
@@ -68483,7 +68883,7 @@ async function openSessions(deps) {
     }
     await discardSession(conversationId);
     for (const [runId, owner] of launched) if (owner === conversationId) launched.delete(runId);
-    for (const runId of await listIds(paths.runs, runIdSchema)) {
+    for (const runId of await recentRunIds()) {
       const meta3 = await readRunMeta(runDirectory(paths.runs, runId).meta);
       if (meta3?.conversationId === conversationId) await markInterrupted(runId);
     }
@@ -68502,7 +68902,7 @@ async function openSessions(deps) {
   };
   const runsOf = async (conversationId) => {
     const found = [];
-    for (const runId of await listIds(paths.runs, runIdSchema)) {
+    for (const runId of await recentRunIds()) {
       const dir = runDirectory(paths.runs, runId);
       if ((await readRunMeta(dir.meta))?.conversationId !== conversationId) continue;
       const last = await readLastRecord(dir.log);
@@ -68557,7 +68957,7 @@ async function openSessions(deps) {
       log.info("sessions.reattached", { conversationId });
       return;
     }
-    if (alive) await (0, import_promises64.rm)(files.dir, { recursive: true, force: true });
+    if (alive) await removeHolderFiles(files);
     else await discardSession(conversationId);
   };
   const busyRunIds = async () => {
@@ -68578,7 +68978,7 @@ async function openSessions(deps) {
     for (const conversationId of legacy.keys()) {
       for (const runId of await unendedRunsOf(conversationId)) busy.add(runId);
     }
-    for (const runId of await listIds(paths.runs, runIdSchema)) {
+    for (const runId of await recentRunIds()) {
       if (!busy.has(runId)) await markInterrupted(runId);
     }
   };
@@ -68615,7 +69015,7 @@ async function openSessions(deps) {
     const meta3 = await readRunMeta(dir.meta);
     const last = await readLastRecord(dir.log);
     if (meta3 === null || last === null) return null;
-    const logged = await (0, import_promises64.stat)(dir.log).catch((error61) => {
+    const logged = await (0, import_promises65.stat)(dir.log).catch((error61) => {
       if (errnoCode(error61) === "ENOENT") return null;
       throw error61;
     });
@@ -68642,7 +69042,7 @@ async function openSessions(deps) {
       ({ run: run2 }) => notLoggedRun(run2.runId, run2.conversationId)
     );
     const logged = /* @__PURE__ */ new Set();
-    const onDisk = new Set(await listIds(paths.runs, runIdSchema));
+    const onDisk = new Set(await recentRunIds());
     for (const runId of endedRuns.keys()) if (!onDisk.has(runId)) endedRuns.delete(runId);
     for (const runId of onDisk) {
       const run2 = starting.has(runId) ? null : await loggedRun(runId);
@@ -68925,7 +69325,7 @@ function loadRuntimeConfig(env = process.env, totalMemoryBytes = (0, import_node
     providerProbes: ALAN_RUNTIME_PROVIDER_PROBES === "on",
     providerToolchain: ALAN_RUNTIME_PROVIDER_NODE !== void 0 && ALAN_RUNTIME_PROVIDER_NPM_CLI !== void 0 ? { node: ALAN_RUNTIME_PROVIDER_NODE, npmCli: ALAN_RUNTIME_PROVIDER_NPM_CLI } : null,
     home,
-    configHome: XDG_CONFIG_HOME ?? (0, import_node_path65.join)(home, ".config"),
+    configHome: XDG_CONFIG_HOME ?? (0, import_node_path66.join)(home, ".config"),
     ...githubProxyConfig({ ALAN_RUNTIME_GITHUB_PROXY, XDG_CONFIG_HOME, GH_CONFIG_DIR }, home),
     gitGatewayUrl: ALAN_RUNTIME_GIT_GATEWAY_URL ?? null,
     workspaceRoot: ALAN_RUNTIME_WORKSPACE_ROOT ?? null,
@@ -68934,10 +69334,10 @@ function loadRuntimeConfig(env = process.env, totalMemoryBytes = (0, import_node
   };
 }
 function githubProxyConfig(env, home) {
-  const configHome = env.XDG_CONFIG_HOME ?? (0, import_node_path65.join)(home, ".config");
+  const configHome = env.XDG_CONFIG_HOME ?? (0, import_node_path66.join)(home, ".config");
   return {
     githubProxy: env.ALAN_RUNTIME_GITHUB_PROXY === "on",
-    ghConfigDir: env.GH_CONFIG_DIR ?? (0, import_node_path65.join)(configHome, "gh")
+    ghConfigDir: env.GH_CONFIG_DIR ?? (0, import_node_path66.join)(configHome, "gh")
   };
 }
 function serviceEnvironment2(env, profile) {
@@ -68995,9 +69395,9 @@ function takeEnrollmentCodeFromEnv(env = process.env) {
 }
 
 // src/cli/context.ts
-var import_promises65 = require("fs/promises");
+var import_promises66 = require("fs/promises");
 var import_node_os12 = require("os");
-var import_node_path66 = require("path");
+var import_node_path67 = require("path");
 var DESKTOP_BUNDLE_IDS = {
   production: ["com.alan-ai.desktop"],
   staging: ["com.alan-ai.desktop.staging"],
@@ -69037,7 +69437,7 @@ function serviceSpec({ config: config2, paths, self }) {
     profile: config2.profile,
     program: serviceCommand(config2.host, self, launcher),
     environment: config2.serviceEnvironment,
-    logPath: (0, import_node_path66.join)(paths.logs, "service.log"),
+    logPath: (0, import_node_path67.join)(paths.logs, "service.log"),
     associatedBundleIds: DESKTOP_BUNDLE_IDS[config2.profile]
   };
 }
@@ -69045,7 +69445,7 @@ async function installedServiceSpec(ctx) {
   const spec = serviceSpec(ctx);
   if (ctx.config.host === "app") return spec;
   const layout = installLayout(ctx.config.installDir, ctx.config.profile);
-  const installed = await (0, import_promises65.access)(layout.launcher).then(
+  const installed = await (0, import_promises66.access)(layout.launcher).then(
     () => true,
     () => false
   );
@@ -69173,7 +69573,7 @@ var manifestRevisionSchema = external_exports.object({ revision: external_export
 async function manifestRevision(path4) {
   let raw;
   try {
-    raw = JSON.parse(await (0, import_promises66.readFile)(path4, "utf8"));
+    raw = JSON.parse(await (0, import_promises67.readFile)(path4, "utf8"));
   } catch (error61) {
     throw new RuntimeFault("invalid_file", `Cannot read the skill manifest at ${path4}`, {
       cause: error61
@@ -69227,8 +69627,8 @@ async function runSkills(argv) {
 }
 
 // src/cli/commands/doctor.ts
-var import_promises69 = require("fs/promises");
-var import_node_path70 = require("path");
+var import_promises70 = require("fs/promises");
+var import_node_path71 = require("path");
 init_runtime_v2();
 
 // src/identity/credential.ts
@@ -69405,18 +69805,18 @@ async function authorizeDevice(input2) {
 }
 
 // src/identity/enroll.ts
-var import_promises67 = require("fs/promises");
+var import_promises68 = require("fs/promises");
 init_runtime_v2();
 
 // src/identity/installation.ts
 var import_node_crypto32 = require("crypto");
-var import_node_path67 = require("path");
+var import_node_path68 = require("path");
 init_zod();
 var installationFileSchema = external_exports.object({
   installationId: external_exports.uuid()
 });
 function installationPath(paths) {
-  return (0, import_node_path67.join)(paths.stateDir, "installation.json");
+  return (0, import_node_path68.join)(paths.stateDir, "installation.json");
 }
 async function ensureInstallationId(paths) {
   const path4 = installationPath(paths);
@@ -69509,13 +69909,13 @@ async function enrollFromGrantFile(input2) {
     clock: input2.clock,
     access: input2.access
   });
-  await (0, import_promises67.rm)(input2.grantPath, { force: true });
+  await (0, import_promises68.rm)(input2.grantPath, { force: true });
   return machine;
 }
 
 // src/identity/migrate-v1.ts
-var import_promises68 = require("fs/promises");
-var import_node_path68 = require("path");
+var import_promises69 = require("fs/promises");
+var import_node_path69 = require("path");
 init_runtime_v2();
 init_zod();
 var EXIT_POLL_MS = 200;
@@ -69536,11 +69936,11 @@ var ownerLeaseSchema = external_exports.looseObject({ pid: external_exports.numb
 function legacyConfigPath(home, profile) {
   switch (profile) {
     case "production":
-      return (0, import_node_path68.join)(home, ".alan", "agent", "config.json");
+      return (0, import_node_path69.join)(home, ".alan", "agent", "config.json");
     case "staging":
-      return (0, import_node_path68.join)(home, ".alan-staging", "agent", "config.json");
+      return (0, import_node_path69.join)(home, ".alan-staging", "agent", "config.json");
     default:
-      return (0, import_node_path68.join)(home, ".alan-dev", "agent", "config.json");
+      return (0, import_node_path69.join)(home, ".alan-dev", "agent", "config.json");
   }
 }
 async function findLegacyInstall(home, profile) {
@@ -69565,8 +69965,8 @@ async function scrubLegacyInstall(install2) {
   const scrubbed = { ...install2.config, migratedToRuntimeV2: true };
   for (const key of SCRUBBED_KEYS) delete scrubbed[key];
   await writeJsonFileAtomic(`${install2.configPath}.migrated-v1`, scrubbed);
-  await (0, import_promises68.rm)(install2.configPath, { force: true });
-  await (0, import_promises68.rm)(install2.ownerLeasePath, { force: true });
+  await (0, import_promises69.rm)(install2.configPath, { force: true });
+  await (0, import_promises69.rm)(install2.ownerLeasePath, { force: true });
 }
 async function exchangeCredential(deps) {
   const { config: config2 } = deps.install;
@@ -69675,7 +70075,7 @@ async function loadIdentity(paths, options = {}) {
 }
 
 // src/cli/commands/status.ts
-var import_node_path69 = require("path");
+var import_node_path70 = require("path");
 async function serviceStatus(ctx) {
   try {
     return await createServiceManager(ctx.host, ctx.config.profile).status();
@@ -69702,7 +70102,7 @@ async function runtimeState(ctx) {
   const running = await readRunningRuntime(ctx.paths.lock);
   if (running === null) return { state: "offline", pid: null, localApi: null };
   const discovery = await readJsonFile(
-    (0, import_node_path69.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE),
+    (0, import_node_path70.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE),
     localApiDiscoverySchema
   );
   const localApi = discovery.kind === "ok" && discovery.value.pid === running.pid ? {
@@ -69923,7 +70323,7 @@ async function runtimeCheck(ctx, status) {
     return check2("runtime", "warn", "No runtime is running for this profile");
   }
   const client = createRuntimeClient({
-    discoveryPath: (0, import_node_path70.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE)
+    discoveryPath: (0, import_node_path71.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE)
   });
   try {
     const live = await client.status(AbortSignal.timeout(LOCAL_TIMEOUT_MS));
@@ -69950,7 +70350,7 @@ async function runtimeCheck(ctx, status) {
   }
 }
 async function probeHolder(dir, conversationId) {
-  const launch = await readJsonFile((0, import_node_path70.join)(dir, "launch.json"), holderLaunchSchema);
+  const launch = await readJsonFile((0, import_node_path71.join)(dir, "launch.json"), holderLaunchSchema);
   if (launch.kind !== "ok") return null;
   try {
     const reply2 = await withTimeout(
@@ -69975,8 +70375,8 @@ async function probeHolder(dir, conversationId) {
   }
 }
 async function holdersCheck(ctx) {
-  const names = await (0, import_promises69.readdir)(ctx.paths.sessions).catch(() => []);
-  const holders = (await Promise.all(names.map((name) => probeHolder((0, import_node_path70.join)(ctx.paths.sessions, name), name)))).filter((facts) => facts !== null);
+  const names = await (0, import_promises70.readdir)(ctx.paths.sessions).catch(() => []);
+  const holders = (await Promise.all(names.map((name) => probeHolder((0, import_node_path71.join)(ctx.paths.sessions, name), name)))).filter((facts) => facts !== null);
   const dead = holders.filter((holder) => !holder.alive).length;
   return check2(
     "holders",
@@ -69987,10 +70387,10 @@ async function holdersCheck(ctx) {
 }
 async function freeBytesAt(path4) {
   try {
-    const stats = await (0, import_promises69.statfs)(path4);
+    const stats = await (0, import_promises70.statfs)(path4);
     return { path: path4, freeBytes: stats.bavail * stats.bsize };
   } catch (error61) {
-    const parent = (0, import_node_path70.dirname)(path4);
+    const parent = (0, import_node_path71.dirname)(path4);
     if (parent === path4) throw error61;
     return freeBytesAt(parent);
   }
@@ -70126,7 +70526,7 @@ async function runDoctor(argv, context = cliContext) {
 }
 
 // src/cli/commands/git-credential.ts
-var import_promises70 = require("fs/promises");
+var import_promises71 = require("fs/promises");
 var import_node_net4 = require("net");
 var MAX_RESPONSE_BYTES = 64 * 1024;
 async function readAll(stream) {
@@ -70236,7 +70636,7 @@ async function configure(argv) {
 }
 async function configureGitGateway(config2, gatewayUrl, signal) {
   const { launcher } = installLayout(config2.installDir, config2.profile);
-  const installed = await (0, import_promises70.access)(launcher).then(
+  const installed = await (0, import_promises71.access)(launcher).then(
     () => true,
     () => false
   );
@@ -70263,7 +70663,7 @@ async function runGitCredential(argv) {
 }
 
 // src/cli/commands/hold.ts
-var import_node_path71 = require("path");
+var import_node_path72 = require("path");
 init_agent2();
 init_runtime_v2();
 async function machineAccess(paths, log, conversationId, transport) {
@@ -70321,7 +70721,7 @@ async function runHold(argv) {
     const config2 = loadRuntimeConfig();
     const paths = runtimePaths(config2.stateDir);
     const log = __using(_stack, openFileLog(
-      (0, import_node_path71.join)(paths.logs, `holder-${launch.value.conversationId}.jsonl`),
+      (0, import_node_path72.join)(paths.logs, `holder-${launch.value.conversationId}.jsonl`),
       config2.logLevel,
       systemClock
     ));
@@ -70332,7 +70732,7 @@ async function runHold(argv) {
     );
     const transport = __using(_stack, createHttpTransport());
     const access7 = await machineAccess(paths, log, launch.value.conversationId, transport);
-    const credentialPath = (0, import_node_path71.join)(paths.tmp, "mcp", `${launch.value.conversationId}.json`);
+    const credentialPath = (0, import_node_path72.join)(paths.tmp, "mcp", `${launch.value.conversationId}.json`);
     const managedMcp = __using(_stack, access7.managedMcp === void 0 ? void 0 : createHelperMcpAccess({
       managedMcp: access7.managedMcp,
       conversationId: launch.value.conversationId,
@@ -70372,7 +70772,7 @@ async function runHold(argv) {
 }
 
 // src/cli/commands/hook.ts
-var import_node_path72 = require("path");
+var import_node_path73 = require("path");
 var RUNTIME_ANSWER_MS = 2e3;
 var DEBUG_VARIABLE = "ALAN_HOOK_DEBUG";
 function flag(argv, name) {
@@ -70404,7 +70804,7 @@ async function forwardHook(argv, io) {
     return "transcript outside provider root";
   }
   const verdict = await io.send(
-    (0, import_node_path72.join)(io.stateDir, LOCAL_API_DISCOVERY_FILE),
+    (0, import_node_path73.join)(io.stateDir, LOCAL_API_DISCOVERY_FILE),
     hookSignal,
     AbortSignal.timeout(RUNTIME_ANSWER_MS)
   );
@@ -70440,7 +70840,7 @@ async function runHook(argv, overrides = {}) {
 }
 
 // src/cli/commands/ingestion-hooks.ts
-var import_promises71 = require("fs/promises");
+var import_promises72 = require("fs/promises");
 var CODEX_TRUST_NOTE = "Codex runs new hooks only after you review them: open /hooks in Codex.";
 function isAction(value2) {
   return value2 === "enable" || value2 === "disable" || value2 === "status";
@@ -70463,7 +70863,7 @@ function errorMessage2(error61) {
   return error61 instanceof Error ? error61.message : String(error61);
 }
 async function exists5(path4) {
-  return (0, import_promises71.access)(path4).then(
+  return (0, import_promises72.access)(path4).then(
     () => true,
     () => false
   );
@@ -70566,10 +70966,10 @@ async function runIntegrationsCommand(argv) {
 }
 
 // src/cli/commands/legacy.ts
-var import_node_path74 = require("path");
+var import_node_path75 = require("path");
 
 // src/cli/commands/setup.ts
-var import_node_path73 = require("path");
+var import_node_path74 = require("path");
 init_zod();
 
 // src/cli/legacy.ts
@@ -70651,7 +71051,7 @@ async function grantFileCredential(argv, grantPath, ctx, deps) {
   return enrollFromGrantFile({
     paths: ctx.paths,
     storeKind: credentialStoreFlag(argv) ?? ctx.config.credentialStore,
-    grantPath: (0, import_node_path73.resolve)(grantPath),
+    grantPath: (0, import_node_path74.resolve)(grantPath),
     clock: deps.clock,
     access: ctx.access
   });
@@ -70727,7 +71127,7 @@ async function runSetup(argv, signal) {
   var _stack = [];
   try {
     const ctx = cliContext();
-    const log = __using(_stack, openFileLog((0, import_node_path73.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
+    const log = __using(_stack, openFileLog((0, import_node_path74.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
     const result = await setupMachine(argv, ctx, {
       enrollment: (apiUrl) => createEnrollmentClient({ apiUrl }),
       isProcessAlive,
@@ -70810,7 +71210,7 @@ async function runToken(argv, signal) {
       );
     }
     const ctx = cliContext();
-    const log = __using(_stack, openFileLog((0, import_node_path74.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
+    const log = __using(_stack, openFileLog((0, import_node_path75.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
     const result = await rotateMachineCredential(ctx, { clock: systemClock, log, signal });
     process.stdout.write(`${rotationMessage(result)}
 `);
@@ -70822,8 +71222,8 @@ async function runToken(argv, signal) {
 }
 
 // src/cli/commands/logout.ts
-var import_promises72 = require("fs/promises");
-var import_node_path75 = require("path");
+var import_promises73 = require("fs/promises");
+var import_node_path76 = require("path");
 init_runtime_v2();
 var RUNTIME_EXIT_WAIT_MS = 35e3;
 var TURN_END_WAIT_MS = 3e4;
@@ -70882,9 +71282,9 @@ async function stopHolder(launch, deps, outcome2) {
 }
 async function stopHeldRuns(ctx, deps, outcome2 = "aborted") {
   const stopped = [];
-  for (const name of await (0, import_promises72.readdir)(ctx.paths.sessions).catch(() => [])) {
+  for (const name of await (0, import_promises73.readdir)(ctx.paths.sessions).catch(() => [])) {
     const launch = await readJsonFile(
-      (0, import_node_path75.join)(ctx.paths.sessions, name, "launch.json"),
+      (0, import_node_path76.join)(ctx.paths.sessions, name, "launch.json"),
       holderLaunchSchema
     );
     if (launch.kind !== "ok") continue;
@@ -70921,13 +71321,13 @@ async function forgetMachineLocally(ctx) {
   const machine = await readMachineFile(ctx.paths);
   if (machine === null) return;
   await credentialStoreFor(ctx.paths, machine.credentialStore, ctx.access).clear();
-  await (0, import_promises72.rm)(ctx.paths.machine, { force: true });
+  await (0, import_promises73.rm)(ctx.paths.machine, { force: true });
 }
 async function runLogout(argv, signal) {
   var _stack = [];
   try {
     const ctx = cliContext();
-    const log = __using(_stack, openFileLog((0, import_node_path75.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
+    const log = __using(_stack, openFileLog((0, import_node_path76.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
     const result = await logoutMachine(argv, ctx, {
       api: (apiUrl, accessToken) => createApiClient({ apiUrl, accessToken }),
       stopHeldRuns,
@@ -70945,7 +71345,7 @@ async function runLogout(argv, signal) {
 
 // src/cli/commands/run.ts
 var import_node_fs23 = require("fs");
-var import_node_path79 = require("path");
+var import_node_path80 = require("path");
 
 // src/local-api/app-attachments.ts
 function createAppAttachments(clock) {
@@ -71022,9 +71422,9 @@ function createRunAppends() {
 
 // src/local-api/server.ts
 var import_node_crypto34 = require("crypto");
-var import_promises73 = require("fs/promises");
+var import_promises74 = require("fs/promises");
 var import_node_http4 = require("http");
-var import_node_path76 = require("path");
+var import_node_path77 = require("path");
 
 // src/local-api/guard.ts
 var import_node_crypto33 = require("crypto");
@@ -71211,22 +71611,34 @@ async function openLocalTurnProjection(runsDir, runId, conversationId, ordinal)
   if (!reader) return null;
   let offset = toByteOffset(0);
   let ended = false;
+  let snapshot2;
   let prepared;
+  const merge2 = /* @__PURE__ */ new Map();
   const decoder3 = new TextDecoder();
+  const readState = async () => {
+    const priorOffset = offset;
+    for (; ; ) {
+      const chunk = await reader.readFrom(offset, DEFAULT_RUN_LOG_LIMIT);
+      if (chunk.bytes.length === 0) break;
+      if (applyLogChunk(decoder3.decode(chunk.bytes), assistantMessageId, state)) ended = true;
+      offset = chunk.to;
+    }
+    if (offset === priorOffset && snapshot2) return snapshot2;
+    if (ended) state.state = "idle";
+    snapshot2 = mergeTranscriptMessages(
+      [{ messageId: assistantMessageId, turnOrdinal: ordinal, role: "assistant", state }],
+      merge2
+    );
+    return snapshot2;
+  };
   return {
     runId,
     ordinal,
+    readState,
     read: async () => {
-      const priorOffset = offset;
-      for (; ; ) {
-        const chunk = await reader.readFrom(offset, DEFAULT_RUN_LOG_LIMIT);
-        if (chunk.bytes.length === 0) break;
-        if (applyLogChunk(decoder3.decode(chunk.bytes), assistantMessageId, state)) ended = true;
-        offset = chunk.to;
-      }
-      if (offset === priorOffset && prepared) return prepared;
-      if (ended) state.state = "idle";
-      prepared = { ...conversationTurnView(ordinal, snapshotTranscriptState(state)), markdown: "" };
+      const current = await readState();
+      if (prepared?.state !== current)
+        prepared = { ...conversationTurnView(ordinal, current, prepared?.display), markdown: "" };
       return prepared;
     },
     [Symbol.asyncDispose]: async () => {
@@ -71247,14 +71659,14 @@ async function projectLocalRun(runsDir, runId, conversationId, ordinal) {
   }
 }
 async function readLocalConversationMessages(runsDir, conversationId, limit, before, projection) {
-  const indexed = await readConversationRunIndex(runsDir, conversationId, before, limit + 1);
   const coverage = await readConversationIndexCoverage(runsDir, conversationId);
-  if (coverage === null || before === void 0 && indexed[0]?.ordinal !== coverage.highestOrdinal)
-    return null;
+  if (coverage === null || before !== void 0 && before <= coverage.lowestOrdinal) return null;
+  const indexed = (await readConversationRunIndex(runsDir, conversationId, before, limit + 1)).filter((entry) => entry.ordinal >= coverage.lowestOrdinal);
+  if (before === void 0 && indexed[0]?.ordinal !== coverage.highestOrdinal) return null;
   if (before !== void 0 && indexed[0]?.nextOrdinal !== before) return null;
   if (indexed.some((entry, index) => index > 0 && entry.nextOrdinal !== indexed[index - 1].ordinal))
     return null;
-  if (indexed.length < limit && indexed.at(-1)?.ordinal !== 0) return null;
+  if (indexed.length < limit && indexed.at(-1)?.ordinal !== coverage.lowestOrdinal) return null;
   const selected = indexed.slice(0, limit);
   if (selected.length === 0) return null;
   const turns = await Promise.all(
@@ -71262,17 +71674,22 @@ async function readLocalConversationMessages(runsDir, conversationId, limit, bef
       (entry) => entry.runId === projection?.runId ? projection.read() : projectLocalRun(runsDir, entry.runId, conversationId, entry.ordinal)
     )
   );
-  if (turns.some((turn) => turn === null)) return null;
-  const completeTurns = turns.filter((turn) => turn !== null);
+  const missing = turns.indexOf(null);
+  const completeTurns = (missing === -1 ? turns : turns.slice(0, missing)).filter(
+    (turn) => turn !== null
+  );
+  if (completeTurns.length === 0) return null;
+  const oldestOrdinal = selected[completeTurns.length - 1].ordinal;
   return {
     turns: compactConversationMessageTurns(completeTurns, before === void 0),
-    before: selected.at(-1)?.ordinal === 0 ? null : String(selected.at(-1)?.ordinal),
+    before: oldestOrdinal === 0 ? null : String(oldestOrdinal),
     revision: `local-${selected[0].runId}`,
     streamCursor: ""
   };
 }
 
 // src/local-api/conversation-messages-stream.ts
+init_acp();
 async function readChangedTurn(deps, conversationId, runId, slot) {
   const meta3 = await readRunMeta(runDirectory(deps.runsDir, runId).meta);
   if (meta3?.conversationId !== conversationId || meta3.userMessage?.turnOrdinal == null) return null;
@@ -71286,21 +71703,17 @@ async function readChangedTurn(deps, conversationId, runId, slot) {
     if (latest?.runId !== runId) return null;
   }
   if (slot.current && meta3.userMessage.turnOrdinal < slot.current.ordinal) {
-    var _stack = [];
-    try {
-      const previous = __using(_stack, await openLocalTurnProjection(
-        deps.runsDir,
-        runId,
-        conversationId,
-        meta3.userMessage.turnOrdinal
-      ), true);
-      return previous ? await previous.read() : null;
-    } catch (_) {
-      var _error = _, _hasError = true;
-    } finally {
-      var _promise2 = __callDispose(_stack, _error, _hasError);
-      _promise2 && await _promise2;
-    }
+    const previous = await openLocalTurnProjection(
+      deps.runsDir,
+      runId,
+      conversationId,
+      meta3.userMessage.turnOrdinal
+    );
+    if (!previous) return null;
+    return {
+      projection: previous,
+      changed: { ordinal: previous.ordinal, state: await previous.readState() }
+    };
   }
   if (slot.current?.runId !== runId) {
     const next = await openLocalTurnProjection(
@@ -71313,20 +71726,48 @@ async function readChangedTurn(deps, conversationId, runId, slot) {
     slot.current = next;
   }
   if (!slot.current) throw new Error("Local transcript metadata is incomplete");
-  return slot.current.read();
+  return {
+    projection: slot.current,
+    changed: { ordinal: slot.current.ordinal, state: await slot.current.readState() }
+  };
+}
+async function nextChangedRuns(bell, signal) {
+  if (bell.pending.size === 0) {
+    await new Promise((resolve12) => {
+      bell.wake = resolve12;
+      if (signal.aborted || bell.pending.size > 0) resolve12();
+    });
+    bell.wake = void 0;
+  }
+  if (signal.aborted) return [];
+  await systemClock.sleep(50, signal);
+  const changed = [...bell.pending];
+  bell.pending.clear();
+  return changed;
+}
+async function writeChangedTurn(writer, runId, read) {
+  const { ordinal, state } = read.changed;
+  if (state === writer.lastState) return;
+  writer.lastState = state;
+  const patch = writer.frames === "patch";
+  const data = patch ? JSON.stringify(writer.encode(ordinal, state)) : JSON.stringify(await read.projection.read());
+  await writeEvent(writer.res, {
+    name: patch ? LIVE_TURN_EVENT : "turn",
+    id: `${runId}`,
+    dataLines: [data]
+  });
 }
-async function streamLocalConversationMessages(deps, conversationId, limit, res, signal) {
+async function streamLocalConversationMessages(deps, conversationId, limit, frames, res, signal) {
   var _stack = [];
   try {
-    const pending = /* @__PURE__ */ new Set();
-    let wake;
+    const bell = { pending: /* @__PURE__ */ new Set(), wake: void 0 };
     const slot = { current: null };
     const _subscription = __using(_stack, deps.appends.subscribe((runId) => {
       const changed = runId ?? slot.current?.runId;
-      if (changed) pending.add(changed);
-      wake?.();
+      if (changed) bell.pending.add(changed);
+      bell.wake?.();
     }));
-    signal.addEventListener("abort", () => wake?.(), { once: true });
+    signal.addEventListener("abort", () => bell.wake?.(), { once: true });
     try {
       const [newest] = await readConversationRunIndex(deps.runsDir, conversationId, void 0, 1);
       if (newest)
@@ -71336,7 +71777,12 @@ async function streamLocalConversationMessages(deps, conversationId, limit, res,
           conversationId,
           newest.ordinal
         );
-      let lastTurn = await slot.current?.read();
+      const writer = {
+        frames,
+        encode: createLiveTurnFrameEncoder(),
+        res,
+        lastState: await slot.current?.readState()
+      };
       const page = await readLocalConversationMessages(
         deps.runsDir,
         conversationId,
@@ -71355,22 +71801,14 @@ async function streamLocalConversationMessages(deps, conversationId, limit, res,
         dataLines: [JSON.stringify(page)]
       });
       while (!signal.aborted) {
-        if (pending.size === 0) {
-          await new Promise((resolve12) => {
-            wake = resolve12;
-            if (signal.aborted || pending.size > 0) resolve12();
-          });
-          wake = void 0;
-        }
-        if (signal.aborted) return;
-        await systemClock.sleep(50, signal);
-        const changed = [...pending];
-        pending.clear();
-        for (const runId of changed) {
-          const turn = await readChangedTurn(deps, conversationId, runId, slot);
-          if (!turn || turn === lastTurn) continue;
-          lastTurn = turn;
-          await writeEvent(res, { name: "turn", id: `${runId}`, dataLines: [JSON.stringify(turn)] });
+        for (const runId of await nextChangedRuns(bell, signal)) {
+          const read = await readChangedTurn(deps, conversationId, runId, slot);
+          if (!read) continue;
+          try {
+            await writeChangedTurn(writer, runId, read);
+          } finally {
+            if (read.projection !== slot.current) await read.projection[Symbol.asyncDispose]();
+          }
         }
       }
     } finally {
@@ -71584,7 +72022,9 @@ var RUN_PATH = /^\/v2\/runs\/([^/]+)\/(log|log\/stream|abort)$/;
 var CONVERSATION_MESSAGES_PATH = /^\/v2\/conversations\/([^/]+)\/messages(\/sse)?$/;
 var conversationMessagesQuerySchema = external_exports.object({
   limit: external_exports.coerce.number().int().min(1).max(100).default(10),
-  before: external_exports.coerce.number().int().nonnegative().optional()
+  before: external_exports.coerce.number().int().nonnegative().optional(),
+  runtimeId: external_exports.string().uuid().optional(),
+  frames: external_exports.enum(["turn", "patch"]).default("turn")
 });
 var emptyBodySchema = external_exports.object({});
 function activeRunIds(runs) {
@@ -71805,6 +72245,44 @@ var FIXED_ROUTES = new Map([
   [LOCAL_API_ROUTES.providerExternal, { method: "POST", handle: providerExternal }],
   ...machineFeatureRoutes
 ]);
+async function routeConversationMessages(deps, request2, conversationMatch) {
+  if (request2.req.method !== "GET") {
+    sendError(request2.res, 405, "method_not_allowed", "Use GET");
+    return;
+  }
+  const conversationId = conversationIdSchema.safeParse(conversationMatch[1]);
+  const query = conversationMessagesQuerySchema.safeParse(
+    Object.fromEntries(request2.url.searchParams)
+  );
+  if (!conversationId.success || !query.success) {
+    sendError(request2.res, 400, "invalid_request", "Invalid conversation messages request");
+    return;
+  }
+  if (query.data.runtimeId && query.data.runtimeId !== deps.readFacts().machineId) {
+    sendError(request2.res, 404, "not_found", "This conversation runs on another computer");
+    return;
+  }
+  if (conversationMatch[2])
+    return streamLocalConversationMessages(
+      deps,
+      conversationId.data,
+      query.data.limit,
+      query.data.frames,
+      request2.res,
+      request2.signal
+    );
+  const page = await readLocalConversationMessages(
+    deps.runsDir,
+    conversationId.data,
+    query.data.limit,
+    query.data.before
+  );
+  if (page === null) {
+    sendError(request2.res, 404, "not_found", "This computer has no complete local page");
+    return;
+  }
+  sendJson(request2.res, 200, page);
+}
 async function routeRun(deps, request2, match) {
   const runId = runIdSchema.safeParse(match[1]);
   const action = match[2];
@@ -71833,40 +72311,8 @@ async function route(deps, request2) {
   const match = RUN_PATH.exec(request2.url.pathname);
   if (match !== null) return routeRun(deps, request2, match);
   const conversationMatch = CONVERSATION_MESSAGES_PATH.exec(request2.url.pathname);
-  if (conversationMatch !== null) {
-    if (request2.req.method !== "GET") {
-      sendError(request2.res, 405, "method_not_allowed", "Use GET");
-      return;
-    }
-    const conversationId = conversationIdSchema.safeParse(conversationMatch[1]);
-    const query = conversationMessagesQuerySchema.safeParse(
-      Object.fromEntries(request2.url.searchParams)
-    );
-    if (!conversationId.success || !query.success) {
-      sendError(request2.res, 400, "invalid_request", "Invalid conversation messages request");
-      return;
-    }
-    if (conversationMatch[2])
-      return streamLocalConversationMessages(
-        deps,
-        conversationId.data,
-        query.data.limit,
-        request2.res,
-        request2.signal
-      );
-    const page = await readLocalConversationMessages(
-      deps.runsDir,
-      conversationId.data,
-      query.data.limit,
-      query.data.before
-    );
-    if (page === null) {
-      sendError(request2.res, 404, "not_found", "This computer has no complete local page");
-      return;
-    }
-    sendJson(request2.res, 200, page);
-    return;
-  }
+  if (conversationMatch !== null)
+    return routeConversationMessages(deps, request2, conversationMatch);
   sendError(request2.res, 404, "not_found", "Not found");
 }
 
@@ -71974,6 +72420,7 @@ async function serveLocalApi(deps) {
   const appAttachments = createAppAttachments(clock);
   const routeDeps = {
     feed,
+    readFacts: deps.readFacts,
     appAttachments,
     actions: deps.actions,
     runsDir: deps.runsDir,
@@ -72015,7 +72462,7 @@ async function serveLocalApi(deps) {
     startedAtMs,
     runtimeVersion: deps.runtimeVersion
   };
-  const discoveryPath = (0, import_node_path76.join)(deps.stateDir, LOCAL_API_DISCOVERY_FILE);
+  const discoveryPath = (0, import_node_path77.join)(deps.stateDir, LOCAL_API_DISCOVERY_FILE);
   await writeJsonFileAtomic(discoveryPath, discovery);
   const followers = startMaintenance({
     everyMs: limits.refreshEveryMs,
@@ -72049,7 +72496,7 @@ async function serveLocalApi(deps) {
       await watchedStatus[Symbol.asyncDispose]();
       const current = await readJsonFile(discoveryPath, localApiDiscoverySchema);
       if (current.kind === "ok" && current.value.token === token) {
-        await (0, import_promises73.rm)(discoveryPath, { force: true });
+        await (0, import_promises74.rm)(discoveryPath, { force: true });
       }
       await closeServer(server);
       log.info("local_api.closed", {});
@@ -72134,7 +72581,7 @@ function machineFeatureActions(deps) {
 }
 
 // src/cli/commands/machine-plane.ts
-var import_node_path78 = require("path");
+var import_node_path79 = require("path");
 
 // src/link/index.ts
 init_runtime_v2();
@@ -75802,7 +76249,7 @@ function refusalFailure(refusal2) {
 }
 
 // src/link/probe.ts
-var import_promises74 = require("dns/promises");
+var import_promises75 = require("dns/promises");
 var import_node_net5 = require("net");
 var import_node_tls2 = require("tls");
 var PROBE_TIMEOUT_MS4 = 5e3;
@@ -75838,7 +76285,7 @@ async function connectOnce(url3, clock) {
 }
 async function probeEndpoint(url3, clock) {
   try {
-    await (0, import_promises74.lookup)(url3.hostname);
+    await (0, import_promises75.lookup)(url3.hostname);
   } catch (error61) {
     const reason = classifyTransportFailure(error61);
     return reason === "other" ? "dns" : reason;
@@ -76287,7 +76734,7 @@ function createReconciler(host, lifecycle, log, signal) {
 }
 
 // src/uploader/index.ts
-var import_promises75 = require("fs/promises");
+var import_promises76 = require("fs/promises");
 init_runtime_v2();
 init_zod();
 var RETRY_DELAYS_MS = [250, 500, 1e3, 2e3, 5e3, 1e4, 3e4];
@@ -76302,10 +76749,11 @@ var uploadProgressSchema = external_exports.object({
 function progressFromReceipt(receipt) {
   return { admittedOffset: receipt?.admittedOffset ?? 0, sealed: receipt?.finalized ?? false };
 }
-function startUploader({ api, runsDir, clock, log }) {
+function startUploader({ api, runsDir, clock, log, archive }) {
   const controller = new AbortController();
   const active = /* @__PURE__ */ new Map();
   const again = /* @__PURE__ */ new Set();
+  const sealed = /* @__PURE__ */ new Set();
   const reject = async (runId, progressPath, progress, rejection2) => {
     log.error("upload.rejected", { runId, status: rejection2.status, message: rejection2.message });
     if (rejection2.status === UNAUTHORIZED) return;
@@ -76318,12 +76766,15 @@ function startUploader({ api, runsDir, clock, log }) {
     if (stored.kind === "ok") return stored.value;
     const receipt = await api.readReceipt(target, controller.signal);
     switch (receipt.kind) {
-      case "read":
+      case "read": {
         log.debug("upload.resumed", {
           runId,
           admittedOffset: receipt.receipt?.admittedOffset ?? 0
         });
-        return progressFromReceipt(receipt.receipt);
+        const progress = progressFromReceipt(receipt.receipt);
+        if (progress.sealed) await writeJsonFileAtomic(path4, progress);
+        return progress;
+      }
       case "rejected":
         await reject(runId, path4, progressFromReceipt(null), receipt);
         return null;
@@ -76390,6 +76841,7 @@ function startUploader({ api, runsDir, clock, log }) {
       failures = 0;
       progress = step.progress;
       if (progress.sealed) {
+        sealed.add(runId);
         log.info("upload.sealed", { runId, bytes: progress.admittedOffset });
         return;
       }
@@ -76403,6 +76855,7 @@ function startUploader({ api, runsDir, clock, log }) {
       if (meta3 === null) return;
       const target = { conversationId: meta3.conversationId, runId };
       const progress = await progressOf(runId, target, dir.upload);
+      if (progress?.sealed) sealed.add(runId);
       if (progress === null || progress.sealed) return;
       if (progress.parkedUntil !== void 0 && progress.parkedUntil > clock.now()) return;
       const reader = __using(_stack, await openRunLogReader(dir.log), true);
@@ -76427,40 +76880,44 @@ function startUploader({ api, runsDir, clock, log }) {
     });
     active.set(runId, task);
   };
-  const sweep2 = async () => {
-    for (const name of await (0, import_promises75.readdir)(runsDir).catch(() => [])) {
+  const unsealedRunIds = async () => {
+    const runIds = [];
+    for (const name of await (0, import_promises76.readdir)(runsDir).catch(() => [])) {
       const runId = runIdSchema.safeParse(name);
-      if (runId.success) run2(runId.data);
+      if (runId.success && !sealed.has(runId.data) && !archive?.has(runId.data))
+        runIds.push(runId.data);
     }
+    return runIds;
+  };
+  const sweep2 = async () => {
+    for (const runId of await unsealedRunIds()) run2(runId);
   };
-  const isPrunable = async (runId, options) => {
+  const isArchivable = async (runId, options) => {
     if (options.keep.has(runId) || active.has(runId)) return false;
     const dir = runDirectory(runsDir, runId);
     const progress = await readJsonFile(dir.upload, uploadProgressSchema);
     if (progress.kind !== "ok" || !progress.value.sealed) return false;
-    const sealedAt = (await (0, import_promises75.stat)(dir.upload)).mtimeMs;
+    const sealedAt = (await (0, import_promises76.stat)(dir.upload)).mtimeMs;
     if (clock.now() - sealedAt < options.sealedForMs) return false;
     return (await readLastRecord(dir.log))?.update.sessionUpdate === "_alan/run.ended";
   };
-  const prune = async (options) => {
-    let removed = 0;
-    for (const name of await (0, import_promises75.readdir)(runsDir).catch(() => [])) {
+  const archivable = async (options) => {
+    const found = [];
+    for (const name of await (0, import_promises76.readdir)(runsDir).catch(() => [])) {
       const runId = runIdSchema.safeParse(name);
-      if (!runId.success) continue;
+      if (!runId.success || archive?.has(runId.data)) continue;
       try {
-        if (!await isPrunable(runId.data, options)) continue;
-        await (0, import_promises75.rm)(runDirectory(runsDir, runId.data).dir, { recursive: true, force: true });
-        removed += 1;
+        if (await isArchivable(runId.data, options)) found.push(runId.data);
       } catch (error61) {
-        log.warn("upload.prune_failed", { runId: runId.data, error: error61 });
+        log.warn("upload.archive_check_failed", { runId: runId.data, error: error61 });
       }
     }
-    return removed;
+    return found;
   };
   return {
     notify: run2,
-    prune,
     sweep: sweep2,
+    archivable,
     flush: async () => {
       await sweep2();
       while (active.size > 0 && !controller.signal.aborted) {
@@ -76573,6 +77030,28 @@ function unwrap(outcome2, what) {
     outcome2.code
   );
 }
+async function writeNativeTurnRun(runsDir, run2, log) {
+  const runId = runIdSchema.parse(run2.runId);
+  const conversationId = conversationIdSchema.parse(run2.conversationId);
+  const { userMessage, assistantMessage } = run2;
+  await writeCompleteRunLog(
+    runsDir,
+    { runId, conversationId, userMessage, assistantMessage },
+    run2.records
+  );
+  if (userMessage?.turnOrdinal != null && assistantMessage?.turnOrdinal != null) {
+    await indexConversationRun(
+      runsDir,
+      conversationId,
+      userMessage.turnOrdinal,
+      assistantMessage.turnOrdinal,
+      runId
+    ).catch(
+      (error61) => log.warn("native_ingest.conversation_index_failed", { runId, error: error61 })
+    );
+  }
+  return runId;
+}
 async function startMachineNativeIngest(deps) {
   const client = createNativeSessionsClient({
     apiUrl: deps.apiUrl,
@@ -76589,13 +77068,7 @@ async function startMachineNativeIngest(deps) {
     api,
     publisher: {
       publish: async (run2) => {
-        const runId = runIdSchema.parse(run2.runId);
-        await writeCompleteRunLog(
-          deps.runsDir,
-          { runId, conversationId: conversationIdSchema.parse(run2.conversationId) },
-          run2.records
-        );
-        deps.onPublished(runId);
+        deps.onPublished(await writeNativeTurnRun(deps.runsDir, run2, deps.log));
       }
     },
     clock: deps.clock,
@@ -76631,12 +77104,12 @@ async function startMachineNativeIngest(deps) {
 }
 
 // src/cli/commands/run-updates.ts
-var import_node_path77 = require("path");
+var import_node_path78 = require("path");
 init_runtime_v2();
 var UPDATE_CHECK_EVERY_MS = 6 * 60 * 60 * 1e3;
 var DEFERRED_RETRY_MS = 5 * 60 * 1e3;
 function isInstalledBundle(layout, bundlePath) {
-  return (0, import_node_path77.resolve)((0, import_node_path77.dirname)((0, import_node_path77.dirname)(bundlePath))) === (0, import_node_path77.resolve)(layout.versions);
+  return (0, import_node_path78.resolve)((0, import_node_path78.dirname)((0, import_node_path78.dirname)(bundlePath))) === (0, import_node_path78.resolve)(layout.versions);
 }
 async function settleUpgradeOnStart({
   layout,
@@ -76743,7 +77216,7 @@ function startRuntimeUpdates(options) {
       layout,
       release: npmRelease,
       tarball: await options.downloader.download(npmRelease.dist.tarball, signal),
-      tmpDir: (0, import_node_path77.join)(layout.root, ".downloads")
+      tmpDir: (0, import_node_path78.join)(layout.root, ".downloads")
     });
     await lifecycle.exclusive("upgrade", async () => {
       await recordPendingUpgrade(layout, currentVersion2, version2, clock.now());
@@ -76789,10 +77262,10 @@ var MAINTENANCE_EVERY_MS = 3e3;
 var CAPABILITY_RESCAN_MS = 15 * 6e4;
 var LOCAL_SKILLS_RESCAN_MS = 6e4;
 var CAPABILITY_MAX_AGE_MS = 6e4;
+var RUN_ARCHIVE_EVERY_MS = 6 * 60 * 6e4;
+var SEALED_RUN_ARCHIVE_MS = 7 * 24 * 60 * 6e4;
 var DESIRED_RESYNC_TICK_MS = 5e3;
 var UPLOAD_SWEEP_EVERY_MS = 3e4;
-var RUN_PRUNE_EVERY_MS = 6 * 60 * 6e4;
-var SEALED_RUN_RETENTION_MS = 7 * 24 * 60 * 6e4;
 function setupFor(state) {
   if (state.kind !== "stopped") return "ready";
   switch (state.failure.reason) {
@@ -76928,7 +77401,12 @@ async function startMachinePlane(deps) {
       return null;
     };
     const cliEnvironment = providerEnvironment2();
-    const uploader = stack.use(startUploader({ api, runsDir: paths.runs, clock, log }));
+    await rebuildConversationIndexes(paths.runs).then(
+      (rebuilt) => rebuilt > 0 && log.info("conversation_index.rebuilt", { conversations: rebuilt }),
+      (error61) => log.warn("conversation_index.rebuild_failed", { error: error61 })
+    );
+    const archive = await openRunArchive(paths.runs);
+    const uploader = stack.use(startUploader({ api, runsDir: paths.runs, clock, log, archive }));
     const nativeIngest = stack.use(
       await startMachineNativeIngest({
         stateDir: paths.stateDir,
@@ -76956,6 +77434,7 @@ async function startMachinePlane(deps) {
         maxActiveRuns: config2.maxActiveRuns,
         suspendPolicy: config2.sessionSuspend,
         openedConversation: () => openedConversation,
+        archive,
         spawnHolder: (launchPath) => {
           spawnDetached(
             {
@@ -76968,7 +77447,7 @@ async function startMachinePlane(deps) {
                 [ALAN_MANAGED_SESSION_ENV]: "1"
               },
               cwd: paths.stateDir,
-              outputPath: (0, import_node_path78.join)(paths.logs, "holders.log")
+              outputPath: (0, import_node_path79.join)(paths.logs, "holders.log")
             },
             deps.holderIsolation
           );
@@ -77106,19 +77585,20 @@ async function startMachinePlane(deps) {
       })
     );
     await uploader.sweep();
-    const runsPrune = stack.use(
+    const runsArchive = stack.use(
       startMaintenance({
-        everyMs: RUN_PRUNE_EVERY_MS,
+        everyMs: RUN_ARCHIVE_EVERY_MS,
         jobs: [
           {
-            name: "runs.prune",
+            name: "runs.archive",
             run: async (signal) => {
               const desired = await api.fetchDesired(signal);
-              const removed = await uploader.prune({
-                sealedForMs: SEALED_RUN_RETENTION_MS,
+              const archived = await uploader.archivable({
+                sealedForMs: SEALED_RUN_ARCHIVE_MS,
                 keep: new Set(desired.runs.map((run2) => run2.runId))
               });
-              if (removed > 0) log.info("runs.pruned", { removed });
+              await archive.add(archived);
+              if (archived.length > 0) log.info("runs.archived", { archived: archived.length });
             }
           }
         ],
@@ -77126,10 +77606,11 @@ async function startMachinePlane(deps) {
         log
       })
     );
-    const pruneAtStart = async () => {
-      if ((await sessions.heldRuns()).some((run2) => run2.state === "ended")) await runsPrune.runNow();
+    const archiveAtStart = async () => {
+      if ((await sessions.heldRuns()).some((run2) => run2.state === "ended"))
+        await runsArchive.runNow();
     };
-    pruneAtStart().catch((error61) => log.warn("runs.prune_failed", { error: error61 }));
+    archiveAtStart().catch((error61) => log.warn("runs.archive_failed", { error: error61 }));
     const capabilities = createCapabilityPublisher({
       inventory: createCapabilityInventory({
         env: providerEnvironment2,
@@ -77199,7 +77680,7 @@ async function startMachinePlane(deps) {
             git: createGitRunner({ env: cliEnvironment }),
             clock,
             log,
-            dir: (0, import_node_path78.join)(paths.stateDir, "checkout-freshness")
+            dir: (0, import_node_path79.join)(paths.stateDir, "checkout-freshness")
           },
           stopped.signal
         );
@@ -77493,7 +77974,7 @@ function lockWaitMs(argv) {
 }
 async function openManagedProviders(config2, paths) {
   const providerEnv = readCliEnvironment();
-  const bundledNpm = (0, import_node_path79.join)((0, import_node_path79.dirname)(process.execPath), "npm", "bin", "npm-cli.js");
+  const bundledNpm = (0, import_node_path80.join)((0, import_node_path80.dirname)(process.execPath), "npm", "bin", "npm-cli.js");
   const providerToolchain = config2.providerToolchain ?? (process.platform === "win32" && (0, import_node_fs23.existsSync)(bundledNpm) ? { node: process.execPath, npmCli: bundledNpm } : null);
   const npmPath = providerToolchain?.node ?? await resolveCommandOnPath("npm", providerEnv, process.platform);
   const npmOptions = npmPath === null || process.platform === "win32" && providerToolchain === null ? null : {
@@ -77501,7 +77982,7 @@ async function openManagedProviders(config2, paths) {
     ...providerToolchain === null ? {} : { argsBeforeNpm: [providerToolchain.npmCli] },
     env: providerEnv
   };
-  const providerNodeDir = providerToolchain?.node === void 0 ? void 0 : (0, import_node_path79.dirname)(providerToolchain.node);
+  const providerNodeDir = providerToolchain?.node === void 0 ? void 0 : (0, import_node_path80.dirname)(providerToolchain.node);
   const probeEnv = providerNodeDir === void 0 ? providerEnv : {
     ...providerEnv,
     PATH: `${providerNodeDir}${pathDelimiter(process.platform)}${envValue(providerEnv, "PATH")}`
@@ -77511,7 +77992,7 @@ async function openManagedProviders(config2, paths) {
     throw new Error("Provider installer is unavailable on this computer");
   };
   const managed = createManagedProviderClis({
-    root: (0, import_node_path79.join)(paths.stateDir, "provider-clis"),
+    root: (0, import_node_path80.join)(paths.stateDir, "provider-clis"),
     resolveVersion: npmOptions === null ? unavailable : createNpmVersionResolver(npmOptions),
     installPackage: npmOptions === null ? unavailable : createNpmPackageInstaller(npmOptions),
     probe: (executable, backendKind) => probeManagedProvider(executable, backendKind, canonicalProbeEnv)
@@ -77543,7 +78024,7 @@ async function runService(argv, stop, restart = new AbortController().signal) {
       waitMs: lockWaitMs(argv),
       signal: stop
     }));
-    const log = __using(_stack, openFileLog((0, import_node_path79.join)(paths.logs, "runtime.jsonl"), config2.logLevel, clock));
+    const log = __using(_stack, openFileLog((0, import_node_path80.join)(paths.logs, "runtime.jsonl"), config2.logLevel, clock));
     const lifecycle = createLifecycleQueue({ clock, log });
     const install2 = installLayout(config2.installDir, config2.profile);
     const bundlePath = process.argv[1] ?? "";
@@ -77577,7 +78058,7 @@ async function runService(argv, stop, restart = new AbortController().signal) {
         openCliEnvironment({
           env: readCliEnvironment(),
           platform: process.platform,
-          lastKnownGoodFile: (0, import_node_path79.join)(paths.stateDir, "login-path.json"),
+          lastKnownGoodFile: (0, import_node_path80.join)(paths.stateDir, "login-path.json"),
           clock,
           decorate: (env) => withPackagedAlanCodeEngine(env, bundlePath, process.platform)
         })
@@ -77754,17 +78235,17 @@ async function runServiceCommand(argv, ctx = cliContext()) {
 }
 
 // src/cli/commands/upgrade.ts
-var import_promises76 = require("fs/promises");
-var import_node_path80 = require("path");
+var import_promises77 = require("fs/promises");
+var import_node_path81 = require("path");
 function isNotNewer(version2, installed) {
   return installed !== null && isReleaseVersion(version2) && isReleaseVersion(installed) && compareVersions(version2, installed) <= 0;
 }
 async function installFromSource(source) {
   const { layout, from, ifNewer } = source;
-  const isTarball = (await (0, import_promises76.stat)(from)).isFile();
-  const downloads = (0, import_node_path80.join)(layout.root, ".downloads");
-  if (isTarball) await (0, import_promises76.mkdir)(downloads, { recursive: true, mode: 448 });
-  const scratch = isTarball ? await (0, import_promises76.mkdtemp)((0, import_node_path80.join)(downloads, "upgrade-")) : null;
+  const isTarball = (await (0, import_promises77.stat)(from)).isFile();
+  const downloads = (0, import_node_path81.join)(layout.root, ".downloads");
+  if (isTarball) await (0, import_promises77.mkdir)(downloads, { recursive: true, mode: 448 });
+  const scratch = isTarball ? await (0, import_promises77.mkdtemp)((0, import_node_path81.join)(downloads, "upgrade-")) : null;
   try {
     const sourceDir = scratch === null ? from : await extractPackageTarball(from, scratch);
     const version2 = await readPackageVersion(sourceDir);
@@ -77772,7 +78253,7 @@ async function installFromSource(source) {
     if (ifNewer && isNotNewer(version2, installed)) return { kind: "skipped", version: version2, installed };
     return { kind: "installed", ...await installVersion(layout, sourceDir) };
   } finally {
-    if (scratch !== null) await (0, import_promises76.rm)(scratch, { recursive: true, force: true });
+    if (scratch !== null) await (0, import_promises77.rm)(scratch, { recursive: true, force: true });
   }
 }
 async function runUpgrade(argv) {
@@ -77784,7 +78265,7 @@ async function runUpgrade(argv) {
   const layout = installLayout(config2.installDir, config2.profile);
   const outcome2 = await installFromSource({
     layout,
-    from: (0, import_node_path80.resolve)(from),
+    from: (0, import_node_path81.resolve)(from),
     ifNewer: hasFlag(argv, "--if-newer")
   });
   if (outcome2.kind === "skipped") {