@alan-ai-hq/agent-manager-linux-arm64 0.1.137 → 0.1.139

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(),
@@ -21762,6 +21766,9 @@ For any UI or design work, read and follow the \`uiux\` skill in \`.agents/skill
 });
 
 // ../shared/dist/agent/attachment-mention.js
+function attachmentMentionPattern() {
+  return /@\[attachment:([^:\]\s]+):(.*?)\](?=[.,;:!?)]*(?:\s|$))/gi;
+}
 var init_attachment_mention = __esm({
   "../shared/dist/agent/attachment-mention.js"() {
     "use strict";
@@ -22238,6 +22245,22 @@ var init_agent = __esm({
   }
 });
 
+// ../shared/dist/agent/transcript/preview.js
+function toPreviewText(value2, limit) {
+  const text2 = value2.replace(/```[\s\S]*?```/g, (block) => block.replace(/```\w*\n?|```/g, " ")).replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s{0,3}#{1,6}\s+/gm, "").replace(/^\s{0,3}>\s?/gm, "").replace(/^\s{0,3}(?:[-*+]|\d+\.)\s+/gm, "").replace(/^\s{0,3}(?:[-*_]\s*){3,}$/gm, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/\*([^*\n]+)\*/g, "$1").replace(/~~([^~]+)~~/g, "$1").replace(/\s+/g, " ").trim();
+  if (text2.length <= limit)
+    return text2;
+  const clipped = text2.slice(0, limit - 1);
+  const lastSpace = clipped.lastIndexOf(" ");
+  const body = lastSpace > limit * 0.6 ? clipped.slice(0, lastSpace) : clipped;
+  return `${body.trimEnd()}\u2026`;
+}
+var init_preview = __esm({
+  "../shared/dist/agent/transcript/preview.js"() {
+    "use strict";
+  }
+});
+
 // ../shared/dist/agent/transcript/index.js
 var init_transcript = __esm({
   "../shared/dist/agent/transcript/index.js"() {
@@ -22344,23 +22367,31 @@ var init_chunk_YXWJW7I5 = __esm({
   }
 });
 
-// ../agent-core/dist/chunk-J4T6L5LX.js
+// ../agent-core/dist/chunk-M6YHY2EZ.js
 function windowsEnvValue(env, name) {
   const wanted = name.toLowerCase();
-  for (const [key, value2] of Object.entries(env)) {
+  for (const [key, value2] of Object.entries(env).reverse()) {
     if (key.toLowerCase() === wanted) return value2;
   }
   return void 0;
 }
+function canonicalWindowsEnvironment(env) {
+  const unique2 = /* @__PURE__ */ new Map();
+  for (const [name, value2] of Object.entries(env)) {
+    unique2.set(name.toLowerCase(), [name.toLowerCase() === "path" ? "PATH" : name, value2]);
+  }
+  return Object.fromEntries(unique2.values());
+}
 function hasExtension(name, extensions) {
   const ext = import_path.win32.extname(name).toLowerCase();
   return ext.length > 0 && extensions.includes(ext);
 }
 function candidates(base, extensions) {
-  return hasExtension(base, extensions) ? [base] : extensions.map((ext) => `${base}${ext}`);
+  const extension = import_path.win32.extname(base).toLowerCase();
+  return extension === ".exe" || extension === ".com" || hasExtension(base, extensions) ? [base] : extensions.map((ext) => `${base}${ext}`);
 }
 function resolveWindowsCommand(command, env, files) {
-  const extensions = (windowsEnvValue(env, "PATHEXT") ?? DEFAULT_PATHEXT).split(";").map((ext) => ext.trim().toLowerCase()).filter((ext) => ext.startsWith("."));
+  const extensions = (windowsEnvValue(env, "PATHEXT") ?? DEFAULT_PATHEXT).split(";").map((ext) => ext.trim().toLowerCase()).filter((ext) => LAUNCHABLE_EXTENSIONS.has(ext));
   if (/[\\/]/.test(command)) {
     return candidates(command, extensions).find((path4) => files.isFile(path4));
   }
@@ -22373,6 +22404,18 @@ function resolveWindowsCommand(command, env, files) {
   }
   return void 0;
 }
+function unwrapNativeShim(shim, args, files) {
+  const lines2 = files.readShim(shim)?.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lines2?.length !== NATIVE_SHIM_LINES.length + 1) return void 0;
+  if (!NATIVE_SHIM_LINES.every((pattern, index) => pattern.test(lines2[index] ?? ""))) {
+    return void 0;
+  }
+  const target = NATIVE_SHIM_ENTRY.exec(lines2.at(-1) ?? "")?.[1];
+  if (target === void 0) return void 0;
+  const directory = import_path.win32.dirname(shim);
+  const file2 = import_path.win32.resolve(directory, target.replace(/^%dp0%\\/i, ""));
+  return files.isFile(file2) ? { kind: "native", file: file2, args } : void 0;
+}
 function isSimpleNodeShim(text2) {
   return text2.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).every((line) => /^@?echo off$/i.test(line) || NODE_SHIM_ENTRY.test(line));
 }
@@ -22398,7 +22441,7 @@ function planWindowsLaunch(command, args, env, files) {
   const file2 = resolveWindowsCommand(command, env, files);
   if (file2 === void 0) return void 0;
   if (!/\.(cmd|bat)$/i.test(file2)) return { kind: "native", file: file2, args };
-  return unwrapNodeShim(file2, args, env, files) ?? { kind: "batch", file: file2, args };
+  return unwrapNativeShim(file2, args, files) ?? unwrapNodeShim(file2, args, env, files) ?? { kind: "batch", file: file2, args };
 }
 function quoteWindowsArgument(value2) {
   if (value2.length === 0) return '""';
@@ -22900,11 +22943,12 @@ function onCliSpawned(listener) {
 }
 function spawnCli(options) {
   const platform3 = options.platform ?? process.platform;
-  const plan2 = planSpawn({ ...options, platform: platform3 });
-  if (plan2.commandLine !== null) return spawnInWindowsJob(plan2, options);
+  const env = platform3 === "win32" ? canonicalWindowsEnvironment(options.env) : options.env;
+  const plan2 = planSpawn({ ...options, env, platform: platform3 });
+  if (plan2.commandLine !== null) return spawnInWindowsJob(plan2, { ...options, env });
   const child = (0, import_child_process5.spawn)(plan2.file, [...plan2.args], {
     cwd: options.cwd,
-    env: { ...options.env },
+    env: { ...env },
     stdio: ["pipe", "pipe", "pipe"],
     shell: false,
     detached: true
@@ -22931,9 +22975,9 @@ function waitForSpawn(child, command) {
     child.once("error", onError);
   });
 }
-var import_child_process, import_fs, import_path, import_child_process2, import_promises9, import_child_process3, import_child_process4, import_child_process5, import_child_process6, import_crypto, import_fs2, import_promises10, import_os, import_path2, SHIM_MAX_BYTES, CMD_MAX_COMMAND_LINE, MAX_COMMAND_LINE, DEFAULT_PATHEXT, nodeWindowsFiles, NODE_SHIM_ENTRY, CMD_META, NEVER_STARTED, HIDDEN_FLAG_PROBE_VALUE, NEWLINE, CARRIAGE_RETURN, EMPTY, MAX_LINE_BYTES, LineSplitter, PS_LINE, POLL_MS, DEFAULT_GRACE_MS, DEFAULT_KILL_WAIT_MS, DEFAULT_TASKKILL_TIMEOUT_MS, statuses, START_TIMEOUT_MS, spawnListeners;
-var init_chunk_J4T6L5LX = __esm({
-  "../agent-core/dist/chunk-J4T6L5LX.js"() {
+var import_child_process, import_fs, import_path, import_child_process2, import_promises9, import_child_process3, import_child_process4, import_child_process5, import_child_process6, import_crypto, import_fs2, import_promises10, import_os, import_path2, SHIM_MAX_BYTES, CMD_MAX_COMMAND_LINE, MAX_COMMAND_LINE, DEFAULT_PATHEXT, LAUNCHABLE_EXTENSIONS, nodeWindowsFiles, NODE_SHIM_ENTRY, NATIVE_SHIM_LINES, NATIVE_SHIM_ENTRY, CMD_META, NEVER_STARTED, HIDDEN_FLAG_PROBE_VALUE, NEWLINE, CARRIAGE_RETURN, EMPTY, MAX_LINE_BYTES, LineSplitter, PS_LINE, POLL_MS, DEFAULT_GRACE_MS, DEFAULT_KILL_WAIT_MS, DEFAULT_TASKKILL_TIMEOUT_MS, statuses, START_TIMEOUT_MS, spawnListeners;
+var init_chunk_M6YHY2EZ = __esm({
+  "../agent-core/dist/chunk-M6YHY2EZ.js"() {
     "use strict";
     init_chunk_YXWJW7I5();
     import_child_process = require("child_process");
@@ -22954,6 +22998,7 @@ var init_chunk_J4T6L5LX = __esm({
     CMD_MAX_COMMAND_LINE = 8191;
     MAX_COMMAND_LINE = 32766;
     DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
+    LAUNCHABLE_EXTENSIONS = /* @__PURE__ */ new Set([".com", ".exe", ".bat", ".cmd"]);
     nodeWindowsFiles = {
       isFile: (path4) => {
         try {
@@ -22972,6 +23017,17 @@ var init_chunk_J4T6L5LX = __esm({
       }
     };
     NODE_SHIM_ENTRY = /"(%_prog%|[^"\r\n]*node(?:\.exe)?)"\s+"([^"\r\n]+\.(?:c?js|mjs))"\s+%\*/i;
+    NATIVE_SHIM_LINES = [
+      /^@echo off$/i,
+      /^goto start$/i,
+      /^:find_dp0$/i,
+      /^set dp0=%~dp0$/i,
+      /^exit \/b$/i,
+      /^:start$/i,
+      /^setlocal$/i,
+      /^call :find_dp0$/i
+    ];
+    NATIVE_SHIM_ENTRY = /^"(%dp0%\\(?:\.\.\\)?(?:node_modules\\)?[\w@.-]+(?:\\[\w@.-]+)*\.exe)"\s+%\*$/i;
     CMD_META = /([()\][%!^"`<>&|;, *?])/g;
     NEVER_STARTED = { stdout: "", stderr: "", exitCode: void 0 };
     HIDDEN_FLAG_PROBE_VALUE = "__alan_probe__";
@@ -23729,29 +23785,209 @@ var init_constants = __esm({
 });
 
 // ../shared/dist/agent/acp/transcript-http.js
+var TRANSCRIPT_TOOL_RESPONSE_ID_META, TRANSCRIPT_TURN_ID_META;
 var init_transcript_http = __esm({
   "../shared/dist/agent/acp/transcript-http.js"() {
     "use strict";
+    TRANSCRIPT_TOOL_RESPONSE_ID_META = "alan.dev/transcriptToolResponseId";
+    TRANSCRIPT_TURN_ID_META = "alan.dev/transcriptTurnId";
   }
 });
 
 // ../shared/dist/agent/acp/ask.js
+function asRecord2(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : void 0;
+}
+function readOptions(value2) {
+  if (!Array.isArray(value2))
+    return [];
+  const options = [];
+  for (const raw of value2) {
+    const option2 = asRecord2(raw);
+    const label = typeof option2?.label === "string" ? option2.label : void 0;
+    if (!label)
+      continue;
+    options.push({
+      label,
+      description: typeof option2?.description === "string" ? option2.description : void 0
+    });
+  }
+  return options;
+}
+function readQuestions(input2) {
+  const record2 = asRecord2(input2);
+  const raw = record2?.questions;
+  if (!Array.isArray(raw))
+    return [];
+  const questions = [];
+  for (const item of raw) {
+    const entry = asRecord2(item);
+    const question = typeof entry?.question === "string" ? entry.question : void 0;
+    if (!question)
+      continue;
+    questions.push({
+      question,
+      header: typeof entry?.header === "string" ? entry.header : void 0,
+      options: readOptions(entry?.options),
+      multiSelect: entry?.multiSelect === true
+    });
+  }
+  return questions;
+}
+function isAskToolCall(entry) {
+  const name = entry.title || entry.toolKind;
+  return isAskUserQuestionTool(name, entry.rawInput);
+}
+function findPendingAsk(entries, answeredIds = /* @__PURE__ */ new Set()) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (!entry || entry.kind !== "tool_call")
+      continue;
+    if (entry.status === "completed" || entry.status === "failed" || entry.status === "cancelled") {
+      continue;
+    }
+    if (answeredIds.has(entry.id))
+      continue;
+    if (!isAskToolCall(entry))
+      continue;
+    const questions = readQuestions(entry.rawInput);
+    if (questions.length === 0)
+      continue;
+    return { toolCallId: entry.id, questions, rawInput: asRecord2(entry.rawInput) ?? {} };
+  }
+  return null;
+}
 var init_ask = __esm({
   "../shared/dist/agent/acp/ask.js"() {
     "use strict";
+    init_agent();
   }
 });
 
 // ../shared/dist/agent/acp/background-task.js
-var BACKGROUND_TASK_META_KEY;
+function oneOf(values, value2) {
+  return typeof value2 === "string" && values.some((candidate) => candidate === value2);
+}
+function isRecord6(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+function optionalString(value2) {
+  return typeof value2 === "string" && value2.length > 0 ? value2 : void 0;
+}
+function readBackgroundTaskMeta(meta3) {
+  if (!isRecord6(meta3))
+    return null;
+  const raw = meta3[BACKGROUND_TASK_META_KEY];
+  if (!isRecord6(raw))
+    return null;
+  const taskId = optionalString(raw.taskId);
+  if (!taskId)
+    return null;
+  const kind = oneOf(KINDS, raw.kind) ? raw.kind : void 0;
+  const stop = oneOf(STRATEGIES, raw.stop) ? raw.stop : void 0;
+  const status = oneOf(STATUSES, raw.status) ? raw.status : void 0;
+  const label = optionalString(raw.label);
+  const subagentType = optionalString(raw.subagentType);
+  const taskType = optionalString(raw.taskType);
+  return {
+    taskId,
+    backgrounded: raw.backgrounded === true,
+    ...kind ? { kind } : {},
+    ...label ? { label } : {},
+    ...typeof raw.startedAt === "number" ? { startedAt: raw.startedAt } : {},
+    ...stop ? { stop } : {},
+    ...status ? { status } : {},
+    ...raw.stoppedByUser === true ? { stoppedByUser: true } : {},
+    ...subagentType ? { subagentType } : {},
+    ...taskType ? { taskType } : {},
+    ...typeof raw.spawnDepth === "number" ? { spawnDepth: raw.spawnDepth } : {},
+    ...raw.ownedBySubagent === true ? { ownedBySubagent: true } : {}
+  };
+}
+var BACKGROUND_TASK_META_KEY, KINDS, STRATEGIES, STATUSES;
 var init_background_task = __esm({
   "../shared/dist/agent/acp/background-task.js"() {
     "use strict";
     BACKGROUND_TASK_META_KEY = "alan.dev/backgroundTask";
+    KINDS = ["shell", "agent"];
+    STRATEGIES = [
+      "native",
+      "pid",
+      "none"
+    ];
+    STATUSES = [
+      "running",
+      "stopping",
+      "stopped",
+      "completed",
+      "failed"
+    ];
   }
 });
 
 // ../shared/dist/agent/acp/presentation/terminal-events.js
+function isRecord7(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+function foldPreview(events) {
+  const output2 = [];
+  const slots = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const update = event.update;
+    const kind = canonicalKind(update.sessionUpdate);
+    const identity = update.messageId ?? update.toolCallId ?? update.terminalId ?? update.planId;
+    const singleton = [
+      "state_update",
+      "usage_update",
+      "session_info_update",
+      "available_commands_update",
+      "config_option_update",
+      "_alan/thinking_tokens"
+    ].includes(kind);
+    const key = identity !== void 0 || singleton ? JSON.stringify([event.sessionId ?? "", kind, identity ?? "session"]) : void 0;
+    const slot = key ? slots.get(key) : void 0;
+    const previous = slot === void 0 ? void 0 : output2[slot];
+    const merged = {
+      ...previous?.update,
+      ...update,
+      sessionUpdate: kind
+    };
+    if (update.sessionUpdate === "terminal_output_chunk") {
+      const before = previous && isRecord7(previous.update.output) ? previous.update.output.data : "";
+      merged.output = { data: String(before ?? "") + String(update.data ?? "") };
+    } else if (update.sessionUpdate.endsWith("_chunk")) {
+      const before = previous && Array.isArray(previous.update.content) ? previous.update.content : [];
+      merged.content = [
+        ...before,
+        ...Array.isArray(update.content) ? update.content : update.content ? [update.content] : []
+      ];
+    }
+    if (isRecord7(update._meta))
+      merged._meta = {
+        ...isRecord7(previous?.update._meta) ? previous.update._meta : {},
+        ...update._meta
+      };
+    if (kind === "state_update")
+      merged.stopReason = update.state === "idle" ? update.stopReason : void 0;
+    if (kind === "tool_call_update" && ["completed", "failed", "cancelled"].includes(String(previous?.update.status)))
+      merged.status = previous?.update.status;
+    const next = { ...event, line: previous?.line ?? event.line, update: merged };
+    if (slot === void 0) {
+      if (key)
+        slots.set(key, output2.length);
+      output2.push(next);
+    } else
+      output2[slot] = next;
+  }
+  return output2;
+}
+function canonicalKind(kind) {
+  if (kind === "tool_call_content_chunk")
+    return "tool_call_update";
+  if (kind === "terminal_output_chunk")
+    return "terminal_update";
+  return kind.replace(/_chunk$/, "");
+}
 var init_terminal_events = __esm({
   "../shared/dist/agent/acp/presentation/terminal-events.js"() {
     "use strict";
@@ -23759,23 +23995,357 @@ var init_terminal_events = __esm({
 });
 
 // ../shared/dist/agent/acp/presentation/file-edits.js
+function diffRows(patch) {
+  let oldLine = 0;
+  let newLine = 0;
+  let oldRemaining = 0;
+  let newRemaining = 0;
+  const lines2 = patch.split("\n");
+  if (lines2.at(-1) === "")
+    lines2.pop();
+  return lines2.map((line) => {
+    const hunk = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line);
+    if (hunk) {
+      oldLine = Number(hunk[1]);
+      newLine = Number(hunk[3]);
+      oldRemaining = Number(hunk[2] ?? 1);
+      newRemaining = Number(hunk[4] ?? 1);
+      return { kind: "hunk", text: line };
+    }
+    if (newRemaining > 0 && line.startsWith("+")) {
+      newRemaining--;
+      return { kind: "add", text: line.slice(1), newLine: newLine++ };
+    }
+    if (oldRemaining > 0 && line.startsWith("-")) {
+      oldRemaining--;
+      return { kind: "remove", text: line.slice(1), oldLine: oldLine++ };
+    }
+    if (oldRemaining > 0 && newRemaining > 0 && line.startsWith(" ")) {
+      oldRemaining--;
+      newRemaining--;
+      return { kind: "context", text: line.slice(1), oldLine: oldLine++, newLine: newLine++ };
+    }
+    return { kind: "meta", text: line };
+  });
+}
+function patchForPath(text2, path4, count) {
+  if (count === 1)
+    return text2;
+  const normalized2 = path4.replace(/^\/+/, "");
+  return text2.split(/(?=^diff --git )/m).find((part) => {
+    const names = [...part.matchAll(/^(?:---|\+\+\+) (?:[ab]\/)?([^\t\n]+)/gm)];
+    return names.some((match) => match[1].replace(/^\/+/, "") === normalized2);
+  });
+}
+function readDiff(value2, id) {
+  if (!isRecord7(value2) || !Array.isArray(value2.changes))
+    return [];
+  const patch = isRecord7(value2.patch) && typeof value2.patch.text === "string" ? value2.patch : void 0;
+  const changes = value2.changes;
+  return changes.flatMap((change, index) => {
+    if (!isRecord7(change) || typeof change.path !== "string" || typeof change.operation !== "string")
+      return [];
+    const text2 = patch ? patchForPath(String(patch.text), change.path, changes.length) : void 0;
+    const rows = text2 && patch?.format !== "text" ? diffRows(text2) : [];
+    const counted = rows.some((row) => row.kind === "hunk");
+    return [
+      {
+        id: `${id}:${index}`,
+        path: change.path,
+        operation: change.operation,
+        ...typeof change.oldPath === "string" ? { oldPath: change.oldPath } : {},
+        patch: text2,
+        rows,
+        ...counted ? {
+          additions: rows.filter((row) => row.kind === "add").length,
+          deletions: rows.filter((row) => row.kind === "remove").length
+        } : {}
+      }
+    ];
+  });
+}
+function toolEdits(node2) {
+  const content = node2.event.update.content;
+  if (!Array.isArray(content))
+    return [];
+  return content.flatMap((block, index) => isRecord7(block) && block.type === "diff" ? readDiff(block.diff, `${node2.key}:${index}`) : []);
+}
+function collectEditedFiles(nodes) {
+  const files = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  function visit2(node2) {
+    if (seen.has(node2.key))
+      return;
+    seen.add(node2.key);
+    if (node2.event.update.sessionUpdate === "tool_call_update" && node2.event.update.status === "completed") {
+      for (const edit of toolEdits(node2)) {
+        const previous = files.get(edit.path);
+        const edits = [...previous?.edits ?? [], edit];
+        const counted = edits.every((item) => item.additions !== void 0 && item.deletions !== void 0);
+        files.set(edit.path, {
+          path: edit.path,
+          edits,
+          ...counted ? {
+            additions: edits.reduce((sum, item) => sum + (item.additions ?? 0), 0),
+            deletions: edits.reduce((sum, item) => sum + (item.deletions ?? 0), 0)
+          } : {}
+        });
+      }
+    }
+    node2.children.forEach(visit2);
+  }
+  nodes.forEach(visit2);
+  return [...files.values()];
+}
 var init_file_edits = __esm({
   "../shared/dist/agent/acp/presentation/file-edits.js"() {
     "use strict";
+    init_terminal_events();
   }
 });
 
 // ../shared/dist/agent/acp/presentation/notice-visibility.js
+function isConversationNotice({ message: message2, kind, meta: meta3 }) {
+  const category = kind ?? (isRecord7(meta3) ? meta3["alan.dev/noticeKind"] : void 0);
+  return !(category === "turn_summary" || category === "task_summary" || typeof category === "string" && category.startsWith("turn_summary/") || message2.startsWith("Under-development features enabled:") || /^clamping \S+ hook timeout to /.test(message2) || message2.startsWith("Skill descriptions were shortened to fit") || /^Rate limited \(allowed(?:_warning)?\):/.test(message2));
+}
+function uniqueNotices(notices) {
+  const seen = /* @__PURE__ */ new Set();
+  return notices.filter((notice2) => {
+    const key = `${notice2.message}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
 var init_notice_visibility = __esm({
   "../shared/dist/agent/acp/presentation/notice-visibility.js"() {
     "use strict";
+    init_terminal_events();
   }
 });
 
 // ../shared/dist/agent/acp/presentation/prepare-conversation-turns.js
+function entryNode(entry, index) {
+  const prepared = preparedEntries.get(entry);
+  if (prepared?.index === index && prepared.lastUpdateIndex === entry.lastUpdateIndex) {
+    return { key: prepared.key, event: prepared.event, children: [] };
+  }
+  const update = entry.kind === "message" ? {
+    sessionUpdate: entry.role === "user" ? "user_message" : entry.role === "thought" ? "agent_thought" : "agent_message",
+    messageId: entry.id,
+    content: Array.isArray(entry.content) ? entry.content : [],
+    _meta: entry._meta
+  } : {
+    sessionUpdate: "tool_call_update",
+    toolCallId: entry.id,
+    name: entry.name ?? entry.title,
+    title: entry.title,
+    kind: entry.toolKind,
+    status: entry.status,
+    content: entry.content,
+    locations: entry.locations,
+    rawInput: entry.rawInput,
+    rawOutput: entry.rawOutput,
+    _meta: entry._meta
+  };
+  const clientId = entry._meta?.["alan.dev/clientMessageId"];
+  const identity = entry.kind === "message" && entry.role === "user" && typeof clientId === "string" ? clientId : entry.id;
+  const key = entry.kind === "message" ? `message:${entry.role}:${identity}` : `tool:${entry.id}`;
+  const event = { id: key, line: index, seq: entry.lastUpdateIndex, update };
+  preparedEntries.set(entry, { index, lastUpdateIndex: entry.lastUpdateIndex, key, event });
+  return { key, event, children: [] };
+}
+function attachChildren(nodes) {
+  const tools = /* @__PURE__ */ new Map();
+  const terminals = /* @__PURE__ */ new Map();
+  for (const node2 of nodes) {
+    const u = node2.event.update;
+    if (typeof u.toolCallId === "string")
+      tools.set(u.toolCallId, node2);
+    for (const block of Array.isArray(u.content) ? u.content : []) {
+      if (isRecord7(block) && block.type === "terminal" && typeof block.terminalId === "string")
+        terminals.set(block.terminalId, node2);
+    }
+  }
+  const parents = /* @__PURE__ */ new Map();
+  for (const node2 of nodes) {
+    const u = node2.event.update;
+    const parentId = isRecord7(u._meta) ? u._meta["alan.dev/parentToolCallId"] : void 0;
+    const parent = typeof parentId === "string" ? tools.get(parentId) : typeof u.terminalId === "string" ? terminals.get(u.terminalId) : void 0;
+    if (parent)
+      parents.set(node2, parent);
+    else if (typeof parentId === "string")
+      node2.issue = `Waiting for parent tool ${parentId}`;
+  }
+  return nodes.filter((node2) => {
+    let ancestor = parents.get(node2);
+    const seen = /* @__PURE__ */ new Set([node2]);
+    while (ancestor) {
+      if (seen.has(ancestor)) {
+        node2.issue = "Cyclic parent reference; shown at root";
+        return true;
+      }
+      seen.add(ancestor);
+      ancestor = parents.get(ancestor);
+    }
+    const parent = parents.get(node2);
+    if (!parent)
+      return true;
+    parent.children.push(node2);
+    return false;
+  });
+}
+function turnStart(turn) {
+  if (turn.users[0])
+    return turn.users[0].event.line;
+  return turn.working[0]?.event.line;
+}
+function hasAnswerContent(node2) {
+  const content = node2.event.update.content;
+  return Array.isArray(content) && content.some((block) => isRecord7(block) && (block.type !== "text" || typeof block.text === "string" && block.text.trim().length > 0));
+}
+function messageText(node2) {
+  const content = node2.event.update.content;
+  return Array.isArray(content) ? content.flatMap((block) => isRecord7(block) && block.type === "text" && typeof block.text === "string" ? [block.text] : []).join("") : "";
+}
+function prepareConversationTurns(transcript, streaming, previousTurns = []) {
+  const entries = Array.isArray(transcript.entries) ? transcript.entries : [];
+  const nodes = entries.map(entryNode);
+  const terminals = transcript.unknown.flatMap((update, index) => ["terminal_update", "terminal_output_chunk"].includes(update.sessionUpdate) || isRecord7(update._meta) && typeof update._meta["alan.dev/parentToolCallId"] === "string" ? [{ id: `terminal:${index}`, line: entries.length + index, update: { ...update } }] : []);
+  for (const event of foldPreview(terminals))
+    nodes.push({ key: event.id, event, children: [] });
+  const nestedThoughtIds = new Set(nodes.flatMap((node2) => node2.event.update.sessionUpdate === "agent_thought" && typeof node2.event.update.messageId === "string" && isRecord7(node2.event.update._meta) && typeof node2.event.update._meta["alan.dev/parentToolCallId"] === "string" ? [node2.event.update.messageId] : []));
+  const visible = nodes.filter((node2) => !isThought(node2));
+  const roots = attachChildren(visible).filter((node2, index, all) => {
+    const previous = all[index - 1];
+    if (previous?.event.update.sessionUpdate !== "agent_message" || node2.event.update.sessionUpdate !== "agent_message" || !nestedThoughtIds.has(String(node2.event.update.messageId)))
+      return true;
+    const previousText = messageText(previous);
+    return !(previousText.length > 0 && previousText === messageText(node2));
+  });
+  const turns = [];
+  for (const node2 of roots) {
+    const user = node2.event.update.sessionUpdate === "user_message";
+    let turn = turns.at(-1);
+    if (!turn || user) {
+      turn = { key: node2.key, users: [], working: [], activity: { key: node2.key, state: "idle" } };
+      turns.push(turn);
+    }
+    if (user)
+      turn.users.push(node2);
+    else
+      turn.working.push(node2);
+  }
+  const activities = [...transcript.activities ?? []].sort((left, right) => left.firstEntryIndex - right.firstEntryIndex);
+  for (const [turnIndex, turn] of turns.entries()) {
+    const last = turn === turns.at(-1);
+    const firstEntryIndex = turnStart(turn);
+    const next = turns[turnIndex + 1];
+    const nextStart = (next && turnStart(next)) ?? Number.POSITIVE_INFINITY;
+    const runs = firstEntryIndex === void 0 ? [] : activities.filter((activity) => activity.firstEntryIndex >= firstEntryIndex && activity.firstEntryIndex < nextStart);
+    const recorded = runs.at(-1);
+    turn.activity.state = last && transcript.state === "requires_action" ? "requires_action" : last && streaming ? "running" : (
+      // Bytes cut off mid-run are history once the thread is not live; they are not still working.
+      recorded?.state === "running" ? "idle" : recorded?.state ?? "idle"
+    );
+    turn.activity.stopReason = turn.activity.state === "running" ? void 0 : recorded?.stopReason ?? (last ? transcript.stopReason : void 0);
+    const captured = runs.reduce((total, run2) => {
+      const duration3 = run2.startedAt !== void 0 ? Math.max(0, (run2.endedAt ?? run2.updatedAt) - run2.startedAt) : run2.durationMs;
+      return duration3 === void 0 ? total : (total ?? 0) + duration3;
+    }, void 0);
+    if (captured !== void 0)
+      turn.activity.capturedMs = captured;
+    const startedAt = runs.find((run2) => run2.startedAt !== void 0)?.startedAt;
+    if (startedAt !== void 0)
+      turn.activity.startedAt = startedAt;
+    if (turn.activity.state !== "running" && recorded?.endedAt !== void 0)
+      turn.activity.endedAt = recorded.endedAt;
+    turn.activity.neverStarted = recorded?.state === "idle" && recorded.stopReason === "cancelled" && captured === void 0;
+    if (last && streaming && turn.activity.state === "running") {
+      const anchor2 = Math.max(recorded?.startedAt ?? 0, transcript.userMessageAt ?? 0);
+      if (anchor2 > 0)
+        turn.activity.liveStartedAt = anchor2;
+    }
+    const tail = turn.working.reduce((latest, node2) => !latest || (node2.event.seq ?? node2.event.line) > (latest.event.seq ?? latest.event.line) ? node2 : latest, void 0);
+    turn.working = turn.working.filter((node2) => !isThought(node2));
+    const final = turn.activity.state === "idle" && (!turn.activity.stopReason || turn.activity.stopReason === "end_turn" || turn.activity.stopReason === "cancelled") && tail?.event.update.sessionUpdate === "agent_message" && hasAnswerContent(tail) ? tail : void 0;
+    if (final)
+      turn.final = final;
+  }
+  const noticesByEntry = /* @__PURE__ */ new Map();
+  for (const notice2 of uniqueNotices(transcript.notices)) {
+    if (notice2.firstEntryIndex === void 0 || !isConversationNotice(notice2))
+      continue;
+    const group = noticesByEntry.get(notice2.firstEntryIndex);
+    if (group)
+      group.push(notice2);
+    else
+      noticesByEntry.set(notice2.firstEntryIndex, [notice2]);
+  }
+  for (const turn of turns) {
+    const firstEntryIndex = turnStart(turn);
+    const notices = firstEntryIndex === void 0 ? void 0 : noticesByEntry.get(firstEntryIndex);
+    if (notices)
+      turn.notices = notices;
+  }
+  const startedTurn = turns[0];
+  if (transcript.cloudStart && startedTurn?.users.length) {
+    startedTurn.cloudStart = transcript.cloudStart;
+  }
+  const previousByKey = new Map(previousTurns.map((turn) => [turn.key, turn]));
+  return turns.map((turn) => retainTurn(turn, previousByKey.get(turn.key)));
+}
+function sameNotices(left, right) {
+  if (left === right)
+    return true;
+  if (!left || !right || left.length !== right.length)
+    return false;
+  return left.every((notice2, index) => notice2.kind === right[index].kind && notice2.level === right[index].level && notice2.message === right[index].message);
+}
+function sameFields(left, right) {
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => Reflect.get(left, key) === Reflect.get(right, key));
+}
+function retainNodes(nodes, previous) {
+  const byKey = new Map(previous.map((node2) => [node2.key, node2]));
+  const retained = nodes.map((node2) => {
+    const before = byKey.get(node2.key);
+    if (!before)
+      return node2;
+    node2.children = retainNodes(node2.children, before.children);
+    return node2.children === before.children && node2.issue === before.issue && (node2.event === before.event || node2.event.id === before.event.id && sameFields(node2.event.update, before.event.update)) ? before : node2;
+  });
+  return retained.length === previous.length && retained.every((node2, index) => node2 === previous[index]) ? previous : retained;
+}
+function retainTurn(turn, previous) {
+  if (previous) {
+    turn.users = retainNodes(turn.users, previous.users);
+    turn.working = retainNodes(turn.working, previous.working);
+    if (turn.final && previous.final)
+      turn.final = retainNodes([turn.final], [previous.final])[0];
+    if (sameFields(turn.activity, previous.activity))
+      turn.activity = previous.activity;
+    if (sameNotices(turn.notices, previous.notices))
+      turn.notices = previous.notices;
+    if (turn.cloudStart && previous.cloudStart && sameFields(turn.cloudStart, previous.cloudStart))
+      turn.cloudStart = previous.cloudStart;
+  }
+  turn.editedFiles = previous && turn.working === previous.working && turn.activity === previous.activity ? previous.editedFiles : turn.activity.state === "idle" ? collectEditedFiles(turn.working) : [];
+  return previous && turn.users === previous.users && turn.working === previous.working && turn.final === previous.final && turn.activity === previous.activity && turn.editedFiles === previous.editedFiles && turn.notices === previous.notices && turn.cloudStart === previous.cloudStart ? previous : turn;
+}
+function isThought(node2) {
+  return ["agent_thought", "agent_thought_chunk"].includes(node2.event.update.sessionUpdate);
+}
+var preparedEntries;
 var init_prepare_conversation_turns = __esm({
   "../shared/dist/agent/acp/presentation/prepare-conversation-turns.js"() {
     "use strict";
+    init_file_edits();
+    init_notice_visibility();
+    init_terminal_events();
+    preparedEntries = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -23790,23 +24360,510 @@ var init_event = __esm({
 function isUpdate(update, kind) {
   return update.sessionUpdate === kind;
 }
+function isContentUpdate(update) {
+  return update.sessionUpdate === "user_message" || update.sessionUpdate === "user_message_chunk" || update.sessionUpdate === "agent_message" || update.sessionUpdate === "agent_message_chunk" || update.sessionUpdate === "agent_thought" || update.sessionUpdate === "agent_thought_chunk";
+}
+function isToolUpdate(update) {
+  return update.sessionUpdate === "tool_call_update" || update.sessionUpdate === "tool_call_content_chunk";
+}
+var MEDIA_SESSION_UPDATE_KINDS;
 var init_types2 = __esm({
   "../shared/dist/agent/acp/types.js"() {
     "use strict";
+    MEDIA_SESSION_UPDATE_KINDS = /* @__PURE__ */ new Set([
+      "_alan/generated_image",
+      "_alan/session_media"
+    ]);
   }
 });
 
 // ../shared/dist/agent/acp/reduce.js
+function emptyTranscript() {
+  return { entries: [], state: "idle", notices: [], unknown: [] };
+}
+function applySessionEvent(state, event) {
+  applyUpdate(state, event.update);
+  const update = event.update;
+  if (update._meta && typeof update._meta === "object" && "alan.dev/parentToolCallId" in update._meta && typeof update._meta["alan.dev/parentToolCallId"] === "string")
+    return state;
+  if ((update.sessionUpdate === "user_message" || update.sessionUpdate === "user_message_chunk") && Number.isFinite(event.at))
+    state.userMessageAt = event.at;
+  const lifecycle = isUpdate(update, "state_update");
+  const activities = state.activities ?? [];
+  let activity = activities.at(-1);
+  if (lifecycle) {
+    let userIndex = -1;
+    for (let index = state.entries.length - 1; index >= 0; index -= 1) {
+      const entry = state.entries[index];
+      if (entry.kind === "message" && entry.role === "user") {
+        userIndex = index;
+        break;
+      }
+    }
+    if (!activity || activity.endedAt !== void 0 && (update.state === "running" || userIndex > activity.firstEntryIndex)) {
+      const firstEntryIndex = userIndex >= 0 && (!activity || userIndex > activity.firstEntryIndex) ? userIndex : activity ? state.entries.length : 0;
+      activity = { firstEntryIndex, state: update.state, updatedAt: event.at };
+      activities.push(activity);
+      state.activities = activities;
+    }
+  }
+  if (!activity)
+    return state;
+  const usage = isUpdate(update, "usage_update") ? update._meta?.["alan.dev/usage"] : void 0;
+  if (typeof usage === "object" && usage !== null && "durationMs" in usage && typeof usage.durationMs === "number" && Number.isFinite(usage.durationMs))
+    activity.durationMs = Math.max(0, usage.durationMs);
+  if (activity.endedAt === void 0)
+    activity.updatedAt = event.at;
+  if (lifecycle) {
+    activity.state = update.state;
+    activity.stopReason = update.state === "idle" ? update.stopReason ?? void 0 : void 0;
+    if (update.state === "running" && activity.startedAt === void 0)
+      activity.startedAt = event.at;
+    if (update.state === "idle" && activity.endedAt === void 0)
+      activity.endedAt = event.at;
+  }
+  return state;
+}
+function entryIndex(state) {
+  const cached2 = entryIndexes.get(state);
+  if (cached2 && cached2.entries === state.entries && cached2.size === state.entries.length && cached2.last === state.entries.at(-1))
+    return cached2;
+  const byKey = /* @__PURE__ */ new Map();
+  for (const entry of state.entries)
+    byKey.set(entryKey(entry), entry);
+  const index = {
+    entries: state.entries,
+    size: state.entries.length,
+    last: state.entries.at(-1),
+    byKey
+  };
+  entryIndexes.set(state, index);
+  return index;
+}
+function applyUpdate(state, update) {
+  const index = entryIndex(state);
+  applyOne(state, index.byKey, update);
+  index.size = state.entries.length;
+  index.last = state.entries.at(-1);
+  return state;
+}
+function awaitingToolCallIds(meta3) {
+  const ids = meta3?.[AWAITING_TOOL_CALLS_META];
+  return Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : [];
+}
+function entryKey(entry) {
+  return entry.kind === "message" ? `m:${entry.role}:${entry.id}` : `t:${entry.id}`;
+}
+function applyOne(state, index, update) {
+  state.updateCount = (state.updateCount ?? 0) + 1;
+  if (isContentUpdate(update)) {
+    applyContent(state, index, update);
+    return;
+  }
+  if (isToolUpdate(update)) {
+    applyTool(state, index, update);
+    return;
+  }
+  if (update.sessionUpdate === "_alan/log" || update.sessionUpdate === "_alan/unhandled")
+    return;
+  if (update._meta && typeof update._meta === "object" && "alan.dev/parentToolCallId" in update._meta && typeof update._meta["alan.dev/parentToolCallId"] === "string") {
+    state.unknown.push(update);
+    return;
+  }
+  switch (update.sessionUpdate) {
+    case "state_update": {
+      if (!isUpdate(update, "state_update"))
+        return;
+      if (update.state === "running" && state.state === "idle")
+        delete state.thinkingTokens;
+      state.state = update.state;
+      if (update.state !== "idle")
+        state.stopReason = void 0;
+      else if (update.stopReason)
+        state.stopReason = update.stopReason;
+      if (update.state === "requires_action")
+        state.awaitingToolCallIds = awaitingToolCallIds(update._meta);
+      else
+        delete state.awaitingToolCallIds;
+      if (update.state === "idle")
+        settleOpenToolCalls(state);
+      return;
+    }
+    case "plan_update": {
+      if (!isUpdate(update, "plan_update"))
+        return;
+      state.plan = { planId: update.planId, entries: update.entries };
+      return;
+    }
+    case "usage_update": {
+      if (!isUpdate(update, "usage_update"))
+        return;
+      state.usage = {
+        used: update.used,
+        size: update.size,
+        ...update.cost ? { cost: update.cost } : {}
+      };
+      delete state.thinkingTokens;
+      return;
+    }
+    case "session_info_update": {
+      if (!isUpdate(update, "session_info_update"))
+        return;
+      if (update.title !== void 0)
+        state.title = update.title ?? void 0;
+      return;
+    }
+    case "notice": {
+      if (!isUpdate(update, "notice"))
+        return;
+      const notice2 = {
+        level: update.severity,
+        kind: noticeKind(update.severity, update._meta),
+        message: update.description ? `${update.title}
+${update.description}` : update.title,
+        ...update._meta ? { _meta: update._meta } : {}
+      };
+      const seen = state.notices.some((existing) => existing.level === notice2.level && existing.message === notice2.message);
+      if (!seen)
+        state.notices.push(notice2);
+      return;
+    }
+    case "_alan/thinking_tokens": {
+      if (!isUpdate(update, "_alan/thinking_tokens"))
+        return;
+      state.thinkingTokens = update.estimated;
+      return;
+    }
+    // Owned by the tool call that references it, but kept so a terminal-aware
+    // renderer can still consume the raw update.
+    case "terminal_update":
+    case "terminal_output_chunk":
+      state.unknown.push(update);
+      return;
+    // ACP: preserve a variant this build does not know rather than dropping it.
+    default:
+      state.unknown.push(update);
+  }
+}
+function noticeKind(severity, meta3) {
+  const kind = meta3?.["alan.dev/noticeKind"];
+  return typeof kind === "string" ? kind : severity;
+}
+function applyContent(state, index, update) {
+  const role = ROLE_BY_KIND[update.sessionUpdate];
+  if (!role)
+    return;
+  const key = `m:${role}:${update.messageId}`;
+  let entry = index.get(key);
+  if (!entry) {
+    entry = { kind: "message", id: update.messageId, role, content: [] };
+    index.set(key, entry);
+    state.entries.push(entry);
+  }
+  entry.lastUpdateIndex = state.updateCount;
+  if (update.sessionUpdate.endsWith("_chunk")) {
+    const block = update.content;
+    if (block)
+      entry.content.push(block);
+  } else {
+    const content = update.content;
+    if (content !== void 0) {
+      entry.content = content === null ? [] : Array.isArray(content) ? content : [content];
+    }
+  }
+  if (update._meta !== void 0) {
+    entry._meta = update._meta === null ? void 0 : { ...entry._meta, ...update._meta };
+  }
+}
+function isSettled(status) {
+  return SETTLED.has(status);
+}
+function outlivesTheTurn(entry) {
+  if (readBackgroundTaskMeta(entry._meta))
+    return true;
+  const input2 = entry.rawInput;
+  return entry.name?.toLowerCase() === "bash" && typeof input2 === "object" && input2 !== null && input2.run_in_background === true;
+}
+function settleOpenToolCalls(state) {
+  for (const entry of state.entries) {
+    if (entry.kind !== "tool_call" || isSettled(entry.status))
+      continue;
+    if (outlivesTheTurn(entry))
+      continue;
+    entry.status = "cancelled";
+  }
+}
+function applyTool(state, index, update) {
+  const key = `t:${update.toolCallId}`;
+  let entry = index.get(key);
+  if (!entry) {
+    entry = {
+      kind: "tool_call",
+      id: update.toolCallId,
+      toolKind: "other",
+      status: "pending",
+      content: [],
+      locations: []
+    };
+    index.set(key, entry);
+    state.entries.push(entry);
+  }
+  entry.lastUpdateIndex = state.updateCount;
+  if (update.sessionUpdate === "tool_call_content_chunk") {
+    const block = update.content;
+    if (block)
+      entry.content.push(block);
+    return;
+  }
+  const u = update;
+  if (u.name !== void 0)
+    entry.name = u.name ?? void 0;
+  if (u.title !== void 0)
+    entry.title = u.title ?? void 0;
+  if (!entry.title && typeof u.name === "string" && u.name.length > 0)
+    entry.title = u.name;
+  if (u.kind !== void 0)
+    entry.toolKind = u.kind ?? "other";
+  if (u.status !== void 0 && !isSettled(entry.status))
+    entry.status = u.status ?? "pending";
+  if (u.content !== void 0)
+    entry.content = u.content ?? [];
+  if (u.locations !== void 0)
+    entry.locations = u.locations ?? [];
+  if (u.rawInput !== void 0)
+    entry.rawInput = u.rawInput;
+  if (u.rawOutput !== void 0)
+    entry.rawOutput = u.rawOutput;
+  if (u._meta !== void 0) {
+    entry._meta = u._meta === null ? void 0 : { ...entry._meta, ...u._meta };
+  }
+}
+function messageText2(entry) {
+  return entry.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+}
+var ROLE_BY_KIND, entryIndexes, AWAITING_TOOL_CALLS_META, SETTLED;
 var init_reduce = __esm({
   "../shared/dist/agent/acp/reduce.js"() {
     "use strict";
+    init_background_task();
+    init_types2();
+    ROLE_BY_KIND = {
+      user_message: "user",
+      user_message_chunk: "user",
+      agent_message: "agent",
+      agent_message_chunk: "agent",
+      agent_thought: "thought",
+      agent_thought_chunk: "thought"
+    };
+    entryIndexes = /* @__PURE__ */ new WeakMap();
+    AWAITING_TOOL_CALLS_META = "alan.dev/awaitingToolCallIds";
+    SETTLED = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
   }
 });
 
 // ../shared/dist/agent/acp/conversation-messages.js
+function compactConversationMessageTurns(turns, keepNewestEntries) {
+  return turns.map((turn, index) => ({
+    ...turn,
+    display: turn.display.map((displayTurn) => {
+      if (!displayTurn.final)
+        return displayTurn;
+      return {
+        ...displayTurn,
+        working: displayTurn.working.map((node2) => node2.key === displayTurn.final?.key ? {
+          ...node2,
+          children: [],
+          event: {
+            ...node2.event,
+            update: { ...node2.event.update, content: [] }
+          }
+        } : node2)
+      };
+    }),
+    state: {
+      ...turn.state,
+      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);
+        return {
+          ...entry,
+          content: [],
+          locations: [],
+          rawInput: ask ? entry.rawInput : void 0,
+          rawOutput: void 0
+        };
+      }) : []
+    }
+  }));
+}
+function prepareConversationTurnRead(state) {
+  const prompts = [];
+  const navigation = [];
+  const interactiveTools = [];
+  let modeChange = null;
+  let latestAgentMessageId = null;
+  for (const entry of state.entries) {
+    if (entry.kind === "message" && entry.role === "user") {
+      const meta3 = entry._meta ?? {};
+      if (typeof meta3["alan.dev/parentToolCallId"] !== "string") {
+        const clientMessageId = meta3["alan.dev/clientMessageId"];
+        prompts.push({
+          entryId: entry.id,
+          ...typeof clientMessageId === "string" ? { clientMessageId } : {},
+          content: messageText2(entry),
+          agentMode: typeof meta3["alan.dev/agentMode"] === "string" ? meta3["alan.dev/agentMode"] : null,
+          attachmentIds: Array.isArray(meta3["alan.dev/attachmentIds"]) ? meta3["alan.dev/attachmentIds"] : void 0,
+          references: Array.isArray(meta3["alan.dev/references"]) ? meta3["alan.dev/references"] : void 0
+        });
+      }
+      const title = toPreviewText(messageText2(entry).slice(0, 960).replace(attachmentMentionPattern(), ""), 240);
+      navigation.push({ id: entry.id, title: title || "Message with attachments" });
+      continue;
+    }
+    if (entry.kind === "message" && entry.role === "agent" && navigation.length > 0) {
+      latestAgentMessageId = entry.id;
+      if (typeof entry._meta?.["alan.dev/parentToolCallId"] === "string")
+        continue;
+      const content = messageText2(entry);
+      if (!/\S/.test(content))
+        continue;
+      const preview = toPreviewText(content.slice(0, 960).replace(attachmentMentionPattern(), ""), 240);
+      if (preview)
+        navigation[navigation.length - 1].preview = preview;
+      continue;
+    }
+    if (entry.kind === "message" && entry.role === "agent") {
+      latestAgentMessageId = entry.id;
+      continue;
+    }
+    if (entry.kind !== "tool_call")
+      continue;
+    const name = entry.name || entry.title || entry.toolKind;
+    const responseToolId = entry._meta?.[TRANSCRIPT_TOOL_RESPONSE_ID_META];
+    interactiveTools.push({
+      id: entry.id,
+      name,
+      ...(entry.status === "pending" || entry.status === "in_progress") && {
+        input: entry.rawInput
+      },
+      ...typeof responseToolId === "string" ? { responseToolId } : {}
+    });
+    const toolName2 = (entry.name || entry.title)?.trim().toLowerCase();
+    if (toolName2 === "enterplanmode") {
+      modeChange = "plan";
+      continue;
+    }
+    if (toolName2 !== "exitplanmode")
+      continue;
+    if (entry.status !== "completed" && entry.status !== "failed")
+      continue;
+    const output2 = typeof entry.rawOutput === "string" ? entry.rawOutput : entry.content.flatMap((item) => item.type === "content" && item.content.type === "text" ? [item.content.text] : []).join("\n");
+    const response = output2.trim().toLowerCase();
+    if (response === "accepted" && entry.status === "completed")
+      modeChange = "agent";
+    else if (response === "rejected")
+      modeChange = "plan";
+  }
+  return {
+    entryCount: state.entries.length,
+    latestAgentMessageId,
+    prompts,
+    navigation,
+    modeChange,
+    pendingAsk: findPendingAsk(state.entries),
+    interactiveTools
+  };
+}
+function conversationTurnView(ordinal, state, previousDisplay = []) {
+  return {
+    ordinal,
+    state,
+    display: prepareConversationTurns(state, state.state === "running", 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")));
+}
+function isInteractiveTool(value2) {
+  return isRecord8(value2) && typeof value2.id === "string" && typeof value2.name === "string" && (value2.responseToolId === void 0 || typeof value2.responseToolId === "string");
+}
+function isConversationTurnRead(value2) {
+  return isRecord8(value2) && Number.isSafeInteger(value2.entryCount) && (value2.latestAgentMessageId === null || typeof value2.latestAgentMessageId === "string") && Array.isArray(value2.prompts) && value2.prompts.every((prompt) => isRecord8(prompt) && (prompt.entryId === void 0 || typeof prompt.entryId === "string") && (prompt.clientMessageId === void 0 || typeof prompt.clientMessageId === "string") && typeof prompt.content === "string" && (prompt.agentMode === null || typeof prompt.agentMode === "string")) && Array.isArray(value2.navigation) && value2.navigation.every((item) => isRecord8(item) && typeof item.id === "string" && typeof item.title === "string" && (item.preview === void 0 || typeof item.preview === "string")) && (value2.modeChange === null || value2.modeChange === "plan" || value2.modeChange === "agent") && isPendingAsk(value2.pendingAsk) && Array.isArray(value2.interactiveTools) && value2.interactiveTools.every(isInteractiveTool);
+}
+function isConversationMessageTurn(value2) {
+  return isRecord8(value2) && Number.isSafeInteger(value2.ordinal) && typeof value2.markdown === "string" && isTranscriptState(value2.state) && Array.isArray(value2.display) && isConversationTurnRead(value2.read) && value2.display.every((turn) => isRecord8(turn) && typeof turn.key === "string" && Array.isArray(turn.users) && Array.isArray(turn.working) && isRecord8(turn.activity));
+}
+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 LIVE_TURN_FRAMES, LIVE_TURN_EVENT, SENT_LIVE_TURNS;
 var init_conversation_messages = __esm({
   "../shared/dist/agent/acp/conversation-messages.js"() {
     "use strict";
+    init_agent();
+    init_attachment_mention();
+    init_preview();
+    init_ask();
+    init_prepare_conversation_turns();
+    init_reduce();
+    init_transcript_http();
+    LIVE_TURN_FRAMES = "patch";
+    LIVE_TURN_EVENT = "live_turn";
+    SENT_LIVE_TURNS = 8;
   }
 });
 
@@ -23832,9 +24889,172 @@ var init_transcript_byte_decoder = __esm({
 });
 
 // ../shared/dist/agent/acp/transcript-fold.js
+function isRecord9(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
+}
+function scopedContent(value2, turnId) {
+  if (!Array.isArray(value2))
+    return value2;
+  return value2.map((block) => isRecord9(block) && block.type === "terminal" && typeof block.terminalId === "string" ? { ...block, terminalId: `${turnId}:${block.terminalId}` } : block);
+}
+function scopeTranscriptEvent(value2) {
+  if (!isRecord9(value2) || !Number.isSafeInteger(value2.seq) || !Number.isFinite(value2.at))
+    return null;
+  if (!isRecord9(value2.update) || typeof value2.update.sessionUpdate !== "string")
+    return null;
+  const update = value2.update;
+  const turnId = typeof value2.turnId === "string" ? value2.turnId : void 0;
+  const event = {
+    seq: Number(value2.seq),
+    at: Number(value2.at),
+    ...typeof value2.sessionId === "string" ? { sessionId: value2.sessionId } : {},
+    update
+  };
+  if (!turnId)
+    return event;
+  const meta3 = isRecord9(update._meta) ? { ...update._meta } : {};
+  const parent = meta3["alan.dev/parentToolCallId"];
+  if (typeof parent === "string")
+    meta3["alan.dev/parentToolCallId"] = `${turnId}:${parent}`;
+  if (typeof update.toolCallId === "string")
+    meta3[TRANSCRIPT_TOOL_RESPONSE_ID_META] = update.toolCallId;
+  if (typeof update.sessionUpdate === "string" && MEDIA_SESSION_UPDATE_KINDS.has(update.sessionUpdate))
+    meta3[TRANSCRIPT_TURN_ID_META] = turnId;
+  const scoped = { ...update, _meta: meta3 };
+  for (const key of ["messageId", "toolCallId", "terminalId", "planId"]) {
+    if (typeof update[key] === "string")
+      scoped[key] = `${turnId}:${update[key]}`;
+  }
+  if ("content" in update)
+    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();
   }
 });
 
@@ -24101,7 +25321,7 @@ function withoutInlineMedia(update) {
     ...nextRawOutput === rawOutput ? {} : { rawOutput: nextRawOutput }
   };
 }
-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_META, 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 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"() {
     "use strict";
@@ -24119,7 +25339,7 @@ var init_chunk_UGRKZTAD = __esm({
     NOTICE_KIND_META = "alan.dev/noticeKind";
     ASK_USER_QUESTIONS_META = "alan.dev/askUserQuestions";
     USER_ANSWER_META = "alan.dev/userAnswer";
-    AWAITING_TOOL_CALLS_META = "alan.dev/awaitingToolCallIds";
+    AWAITING_TOOL_CALLS_META2 = "alan.dev/awaitingToolCallIds";
     EXIT_PLAN_MODE_INPUT_META = "alan.dev/exitPlanModeInput";
     BACKGROUND_TASK_META = BACKGROUND_TASK_META_KEY;
     TASK_PROGRESS_META = "alan.dev/taskProgress";
@@ -24893,7 +26113,7 @@ var init_chunk_54ZRJOQP = __esm({
   }
 });
 
-// ../agent-core/dist/chunk-YPYC4VBL.js
+// ../agent-core/dist/chunk-KHYYC5IN.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);
@@ -25263,12 +26483,12 @@ 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_YPYC4VBL = __esm({
-  "../agent-core/dist/chunk-YPYC4VBL.js"() {
+var init_chunk_KHYYC5IN = __esm({
+  "../agent-core/dist/chunk-KHYYC5IN.js"() {
     "use strict";
     init_chunk_UGRKZTAD();
     init_chunk_54ZRJOQP();
-    init_chunk_J4T6L5LX();
+    init_chunk_M6YHY2EZ();
     init_chunk_YXWJW7I5();
     import_crypto3 = require("crypto");
     import_fs4 = require("fs");
@@ -26759,7 +27979,7 @@ function launcherLabel(update) {
   const description = asRecord(update.rawInput)?.description;
   return nonEmpty(description) ?? nonEmpty(update.title);
 }
-function isSettled(update) {
+function isSettled2(update) {
   return update.status === "completed" || update.status === "failed" || update.status === "cancelled";
 }
 function isRunningTask(record2) {
@@ -26931,7 +28151,10 @@ function classifyResultError(event, context) {
   if (classified.errorKind !== "unknown_cli_error" || !isApiError) return classified;
   return { ...specForErrorKind("provider_error"), message: classified.message };
 }
-function isSettled2(update) {
+function isIdleUpdate(update) {
+  return isUpdate(update, "state_update") && update.state === "idle";
+}
+function isSettled22(update) {
   return update.status === "completed" || update.status === "failed" || update.status === "cancelled";
 }
 function parentToolUseId(event) {
@@ -27359,11 +28582,11 @@ var init_claude = __esm({
   "../agent-core/dist/providers/claude.js"() {
     "use strict";
     init_chunk_DALFHI4B();
-    init_chunk_YPYC4VBL();
+    init_chunk_KHYYC5IN();
     init_chunk_UGRKZTAD();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
-    init_chunk_J4T6L5LX();
+    init_chunk_M6YHY2EZ();
     init_chunk_ITTV3UIM();
     init_chunk_YXWJW7I5();
     init_effort();
@@ -27520,7 +28743,7 @@ var init_claude = __esm({
         if (!record2) return update;
         const remembered = record2.meta.label ?? this.#labels.get(update.toolCallId);
         if (!record2.meta.label && remembered) record2.meta = { ...record2.meta, label: remembered };
-        if (isSettled(update) && record2.meta.kind === "agent" && isRunningTask(record2)) {
+        if (isSettled2(update) && record2.meta.kind === "agent" && isRunningTask(record2)) {
           this.settle(record2, update.status ?? void 0, update.status !== "completed");
         }
         return { ...update, _meta: { ...update._meta, [BACKGROUND_TASK_META_KEY]: record2.meta } };
@@ -27667,6 +28890,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()));
@@ -27714,7 +28938,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;
       }
@@ -27941,7 +29175,7 @@ var init_claude = __esm({
           this.#announced.add(id);
           if (isLauncher) this.#registerLauncher(update, meta3);
         }
-        if (isLauncher && isSettled2(update)) this.tasks.clear([id]);
+        if (isLauncher && isSettled22(update)) this.tasks.clear([id]);
       }
       #registerLauncher(update, meta3) {
         this.tasks.registerLauncher(update.toolCallId);
@@ -30136,11 +31370,11 @@ var init_codex = __esm({
   "../agent-core/dist/providers/codex.js"() {
     "use strict";
     init_chunk_DALFHI4B();
-    init_chunk_YPYC4VBL();
+    init_chunk_KHYYC5IN();
     init_chunk_UGRKZTAD();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
-    init_chunk_J4T6L5LX();
+    init_chunk_M6YHY2EZ();
     init_chunk_ITTV3UIM();
     init_chunk_YXWJW7I5();
     import_fs6 = require("fs");
@@ -41406,10 +42640,10 @@ var require_tar_stream = __commonJS({
 var init_dist = __esm({
   "../agent-core/dist/index.js"() {
     "use strict";
-    init_chunk_YPYC4VBL();
+    init_chunk_KHYYC5IN();
     init_chunk_UGRKZTAD();
     init_chunk_54ZRJOQP();
-    init_chunk_J4T6L5LX();
+    init_chunk_M6YHY2EZ();
     init_chunk_YXWJW7I5();
   }
 });
@@ -41645,7 +42879,7 @@ function isRunning(task) {
   return task.meta.status === "running" || task.meta.status === "stopping";
 }
 function isPlanStatus(value2) {
-  return STATUSES.has(value2);
+  return STATUSES2.has(value2);
 }
 function todoEntries2(todos) {
   return asArray(todos).flatMap((raw) => {
@@ -42149,15 +43383,15 @@ async function acpTurnInput(run2, context) {
     ...encoded.length ? { images: encoded, imagePaths: images.map((image) => image.path) } : {}
   };
 }
-var import_promises48, import_path9, import_crypto12, import_promises49, CURSOR_ASK_QUESTION, copilotAcpProfile, cursorAcpProfile, MODEL_REJECTED, MAX_READ_BYTES, FsDenied, ENV_REFERENCE, AcpBackgroundTasks, CURSOR_CREATE_PLAN, STATUSES, READ_KINDS, ALLOW_KINDS, REJECT_KINDS, CANCELLED_PERMISSION, STOP_REASONS, CHUNKS, ECHOES, AcpTurn, STDERR_TAIL_LINES4, MAX_BETWEEN_UPDATES2, AcpSession, DEFAULTS3, CLIENT_INFO2, TASK_BACKGROUNDED, TASK_COMPLETED, SESSION_NOTIFICATION, KILLED_STATUSES, SUCCESS_STATUSES, SUBAGENT_ID, grokTaskDialect, grokAcpProfile, kimiAcpProfile, ACP_PROFILES, ACP_MODES;
+var import_promises48, import_path9, import_crypto12, import_promises49, CURSOR_ASK_QUESTION, copilotAcpProfile, cursorAcpProfile, MODEL_REJECTED, MAX_READ_BYTES, FsDenied, ENV_REFERENCE, AcpBackgroundTasks, CURSOR_CREATE_PLAN, STATUSES2, READ_KINDS, ALLOW_KINDS, REJECT_KINDS, CANCELLED_PERMISSION, STOP_REASONS, CHUNKS, ECHOES, AcpTurn, STDERR_TAIL_LINES4, MAX_BETWEEN_UPDATES2, AcpSession, DEFAULTS3, CLIENT_INFO2, TASK_BACKGROUNDED, TASK_COMPLETED, SESSION_NOTIFICATION, KILLED_STATUSES, SUCCESS_STATUSES, SUBAGENT_ID, grokTaskDialect, grokAcpProfile, kimiAcpProfile, ACP_PROFILES, ACP_MODES;
 var init_acp3 = __esm({
   "../agent-core/dist/providers/acp.js"() {
     "use strict";
-    init_chunk_YPYC4VBL();
+    init_chunk_KHYYC5IN();
     init_chunk_UGRKZTAD();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
-    init_chunk_J4T6L5LX();
+    init_chunk_M6YHY2EZ();
     init_chunk_ITTV3UIM();
     init_chunk_YXWJW7I5();
     import_promises48 = require("fs/promises");
@@ -42364,7 +43598,7 @@ var init_acp3 = __esm({
       }
     };
     CURSOR_CREATE_PLAN = "cursor/create_plan";
-    STATUSES = /* @__PURE__ */ new Set(["pending", "in_progress", "completed", "cancelled"]);
+    STATUSES2 = /* @__PURE__ */ new Set(["pending", "in_progress", "completed", "cancelled"]);
     READ_KINDS = /* @__PURE__ */ new Set(["read", "search", "think", "fetch"]);
     ALLOW_KINDS = ["allow_once", "allow", "allow_always"];
     REJECT_KINDS = ["reject_once", "reject", "deny", "reject_always"];
@@ -43038,15 +44272,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;
@@ -43121,6 +44356,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();
@@ -43231,7 +44467,7 @@ function awaitingUpdate(waiting) {
   return {
     sessionUpdate: "state_update",
     state: "requires_action",
-    _meta: { [AWAITING_TOOL_CALLS_META]: [...waiting] }
+    _meta: { [AWAITING_TOOL_CALLS_META2]: [...waiting] }
   };
 }
 var RESUME_UNAVAILABLE;
@@ -43857,11 +45093,11 @@ 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_YPYC4VBL();
+    init_chunk_KHYYC5IN();
     init_chunk_UGRKZTAD();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
-    init_chunk_J4T6L5LX();
+    init_chunk_M6YHY2EZ();
     init_chunk_ITTV3UIM();
     init_chunk_YXWJW7I5();
     import_http10 = require("http");
@@ -45052,7 +46288,7 @@ function createAlanCodeHolderDriver(options) {
       open: open6,
       turnInput: async (spec, inputs, contextPrefix) => openCodeTurnInput(spec, {
         attachments: inputs.attachments,
-        skills: [],
+        skills: inputs.skills,
         ...contextPrefix === void 0 ? {} : { contextPrefix }
       })
     },
@@ -45134,7 +46370,7 @@ __export(codex_exports, {
   createCodexHolderDriver: () => createCodexHolderDriver
 });
 function sha2563(value2) {
-  return (0, import_node_crypto25.createHash)("sha256").update(value2).digest("hex");
+  return (0, import_node_crypto26.createHash)("sha256").update(value2).digest("hex");
 }
 function createCodexLogin(broker) {
   const state = {};
@@ -45209,11 +46445,11 @@ function createCodexHolderDriver(options) {
     }
   );
 }
-var import_node_crypto25;
+var import_node_crypto26;
 var init_codex2 = __esm({
   "src/holder/drivers/codex.ts"() {
     "use strict";
-    import_node_crypto25 = require("crypto");
+    import_node_crypto26 = require("crypto");
     init_dist();
     init_codex();
     init_persistent();
@@ -45665,11 +46901,11 @@ 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_YPYC4VBL();
+    init_chunk_KHYYC5IN();
     init_chunk_UGRKZTAD();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
-    init_chunk_J4T6L5LX();
+    init_chunk_M6YHY2EZ();
     init_chunk_ITTV3UIM();
     init_chunk_YXWJW7I5();
     init_runtime_v2();
@@ -46068,7 +47304,7 @@ function createDroidHolderDriver(options) {
       },
       turnInput: (spec, inputs, contextPrefix) => droidTurnInput(spec, {
         attachments: inputs.attachments,
-        skills: [],
+        skills: inputs.skills,
         ...contextPrefix === void 0 ? {} : { contextPrefix }
       })
     },
@@ -46116,7 +47352,7 @@ function createOpenCodeHolderDriver(options) {
       },
       turnInput: async (spec, inputs, contextPrefix) => openCodeTurnInput(spec, {
         attachments: inputs.attachments,
-        skills: [],
+        skills: inputs.skills,
         ...contextPrefix === void 0 ? {} : { contextPrefix }
       })
     },
@@ -46768,10 +48004,10 @@ var init_antigravity = __esm({
   "../agent-core/dist/providers/antigravity.js"() {
     "use strict";
     init_chunk_DALFHI4B();
-    init_chunk_YPYC4VBL();
+    init_chunk_KHYYC5IN();
     init_chunk_UGRKZTAD();
     init_chunk_54ZRJOQP();
-    init_chunk_J4T6L5LX();
+    init_chunk_M6YHY2EZ();
     init_chunk_ITTV3UIM();
     init_chunk_YXWJW7I5();
     import_promises52 = require("fs/promises");
@@ -47472,11 +48708,11 @@ 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_YPYC4VBL();
+    init_chunk_KHYYC5IN();
     init_chunk_UGRKZTAD();
     init_chunk_54ZRJOQP();
     init_chunk_J2KTV5FP();
-    init_chunk_J4T6L5LX();
+    init_chunk_M6YHY2EZ();
     init_chunk_ITTV3UIM();
     init_chunk_YXWJW7I5();
     import_promises53 = require("fs/promises");
@@ -48098,7 +49334,7 @@ var require_XMLHttpRequest = __commonJS({
     "use strict";
     var fs = require("fs");
     var Url = require("url");
-    var spawn11 = require("child_process").spawn;
+    var spawn10 = require("child_process").spawn;
     module2.exports = XMLHttpRequest3;
     XMLHttpRequest3.XMLHttpRequest = XMLHttpRequest3;
     function XMLHttpRequest3(opts) {
@@ -48394,7 +49630,7 @@ var require_XMLHttpRequest = __commonJS({
           var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
           fs.writeFileSync(syncFile, "", "utf8");
           var execString = "var http = require('http'), https = require('https'), fs = require('fs');var doRequest = http" + (ssl ? "s" : "") + ".request;var options = " + JSON.stringify(options) + ";var responseText = '';var responseData = Buffer.alloc(0);var req = doRequest(options, function(response) {response.on('data', function(chunk) {  var data = Buffer.from(chunk);  responseText += data.toString('utf8');  responseData = Buffer.concat([responseData, data]);});response.on('end', function() {fs.writeFileSync('" + contentFile + "', JSON.stringify({err: null, data: {statusCode: response.statusCode, headers: response.headers, text: responseText, data: responseData.toString('base64')}}), 'utf8');fs.unlinkSync('" + syncFile + "');});response.on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});}).on('error', function(error) {fs.writeFileSync('" + contentFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');fs.unlinkSync('" + syncFile + "');});" + (data ? "req.write('" + JSON.stringify(data).slice(1, -1).replace(/'/g, "\\'") + "');" : "") + "req.end();";
-          var syncProc = spawn11(process.argv[0], ["-e", execString]);
+          var syncProc = spawn10(process.argv[0], ["-e", execString]);
           var statusText;
           while (fs.existsSync(syncFile)) {
           }
@@ -52875,7 +54111,7 @@ var require_websocket_server = __commonJS({
 // package.json
 var package_default = {
   name: "@alan-ai-hq/agent-manager",
-  version: "0.1.137",
+  version: "0.1.139",
   private: true,
   type: "module",
   description: "Alan machine runtime (alan-agent): identity, link, reconciler, session holders, run log, uploader, local API",
@@ -52924,8 +54160,8 @@ var package_default = {
 };
 
 // src/cli/commands/compat.ts
-var import_node_crypto30 = require("crypto");
-var import_promises65 = require("fs/promises");
+var import_node_crypto31 = require("crypto");
+var import_promises66 = require("fs/promises");
 init_runtime_v2();
 init_zod();
 
@@ -53769,7 +55005,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({
@@ -54961,7 +56198,7 @@ async function push(context, request2) {
 var import_node_child_process = require("child_process");
 
 // ../agent-core/dist/process.js
-init_chunk_J4T6L5LX();
+init_chunk_M6YHY2EZ();
 init_chunk_YXWJW7I5();
 
 // src/capabilities/git/run-git.ts
@@ -55969,6 +57206,7 @@ function markVersionInUse(bundlePath) {
 }
 
 // src/platform/instance-lock.ts
+var import_node_crypto7 = require("crypto");
 var import_node_fs5 = require("fs");
 var import_promises15 = require("fs/promises");
 var import_node_path10 = require("path");
@@ -55997,17 +57235,22 @@ function inodeOf(path4) {
   }
 }
 function tryCreate(path4, self) {
+  const staged = `${path4}.${(0, import_node_crypto7.randomUUID)()}.candidate`;
   try {
-    const fd = (0, import_node_fs5.openSync)(path4, "wx", 384);
+    const fd = (0, import_node_fs5.openSync)(staged, "wx", 384);
     try {
       (0, import_node_fs5.writeSync)(fd, JSON.stringify(self));
     } finally {
       (0, import_node_fs5.closeSync)(fd);
     }
-    return true;
+    const inode = (0, import_node_fs5.statSync)(staged).ino;
+    (0, import_node_fs5.linkSync)(staged, path4);
+    return inode;
   } catch (error61) {
-    if (errnoCode(error61) === "EEXIST") return false;
+    if (errnoCode(error61) === "EEXIST") return null;
     throw error61;
+  } finally {
+    (0, import_node_fs5.rmSync)(staged, { force: true });
   }
 }
 function removeStale(path4, inode) {
@@ -56019,21 +57262,26 @@ function removeStale(path4, inode) {
   }
 }
 async function attempt(path4, self, probe) {
-  if (tryCreate(path4, self)) return { kind: "acquired" };
+  const created = tryCreate(path4, self);
+  if (created !== null) return { kind: "acquired", inode: created };
   const inode = inodeOf(path4);
   const owner = readOwner(path4);
   if (owner !== null && await mayBeSameProcess(owner, probe)) return { kind: "held", owner };
   if (inode !== null) removeStale(path4, inode);
-  return tryCreate(path4, self) ? { kind: "acquired" } : attempt(path4, self, probe);
+  return attempt(path4, self, probe);
 }
 async function acquireInstanceLock(path4, { clock, waitMs, signal, probe = systemProcessProbe }) {
   await (0, import_promises15.mkdir)((0, import_node_path10.dirname)(path4), { recursive: true, mode: 448 });
   const self = await readProcessIdentity(process.pid);
   if (self === null) throw new RuntimeFault("internal", "Cannot read this process's identity");
   const deadline = clock.monotonic() + waitMs;
+  let heldInode = null;
   for (; ; ) {
     const result = await attempt(path4, self, probe);
-    if (result.kind === "acquired") break;
+    if (result.kind === "acquired") {
+      heldInode = result.inode;
+      break;
+    }
     if (clock.monotonic() >= deadline) {
       throw new RuntimeFault(
         "already_running",
@@ -56046,13 +57294,15 @@ async function acquireInstanceLock(path4, { clock, waitMs, signal, probe = syste
     owner: self,
     [Symbol.dispose]: () => {
       const owner = readOwner(path4);
-      if (owner?.pid === self.pid && owner.startedAt === self.startedAt) (0, import_node_fs5.unlinkSync)(path4);
+      if (inodeOf(path4) === heldInode && owner?.pid === self.pid && owner.startedAt === self.startedAt) {
+        (0, import_node_fs5.unlinkSync)(path4);
+      }
     }
   };
 }
 
 // src/platform/ipc-endpoint.ts
-var import_node_crypto7 = require("crypto");
+var import_node_crypto8 = require("crypto");
 var import_node_fs6 = require("fs");
 var import_node_os = require("os");
 var import_node_path11 = require("path");
@@ -56061,7 +57311,7 @@ function windowsPipeName(socketsDir, id) {
   return `\\\\.\\pipe\\alan-${socketsScope(socketsDir)}-${id}`;
 }
 function socketsScope(socketsDir) {
-  return (0, import_node_crypto7.createHash)("sha256").update(socketsDir.toLowerCase()).digest("hex").slice(0, 12);
+  return (0, import_node_crypto8.createHash)("sha256").update(socketsDir.toLowerCase()).digest("hex").slice(0, 12);
 }
 function ipcEndpoint(socketsDir, id, platform3 = process.platform) {
   if (platform3 === "win32") return windowsPipeName(socketsDir, id);
@@ -56084,11 +57334,12 @@ var HOLDER_JITLESS_FLAG = "--jitless";
 var HOLDER_NODE_FLAGS = [
   "--max-semi-space-size=1",
   "--max-old-space-size=1024",
+  "--use-system-ca",
   HOLDER_JITLESS_FLAG
 ];
 
 // src/platform/npm-release.ts
-var import_node_crypto8 = require("crypto");
+var import_node_crypto9 = require("crypto");
 init_zod();
 var RELEASE_TARGETS = [
   "darwin-arm64",
@@ -56156,11 +57407,11 @@ function verifyNpmIntegrity(bytes, dist) {
     if (expected.length === 0) {
       return { ok: false, reason: "the registry's integrity has no sha512 digest" };
     }
-    const actual = (0, import_node_crypto8.createHash)("sha512").update(bytes).digest("base64");
+    const actual = (0, import_node_crypto9.createHash)("sha512").update(bytes).digest("base64");
     return expected.includes(actual) ? { ok: true, algorithm: "sha512" } : { ok: false, reason: "the tarball does not match the registry's sha512 integrity" };
   }
   if (dist.shasum !== void 0) {
-    return (0, import_node_crypto8.createHash)("sha1").update(bytes).digest("hex") === dist.shasum ? { ok: true, algorithm: "sha1" } : { ok: false, reason: "the tarball does not match the registry's shasum" };
+    return (0, import_node_crypto9.createHash)("sha1").update(bytes).digest("hex") === dist.shasum ? { ok: true, algorithm: "sha1" } : { ok: false, reason: "the tarball does not match the registry's shasum" };
   }
   return { ok: false, reason: "the registry lists no integrity for the tarball" };
 }
@@ -56234,7 +57485,7 @@ function readMemoryPressure() {
 }
 
 // src/platform/release.ts
-var import_node_crypto9 = require("crypto");
+var import_node_crypto10 = require("crypto");
 var REJECTED_VERSION_RETRY_MS = 24 * 60 * 60 * 1e3;
 function parseVersion(version2) {
   if (!releaseVersionSchema.safeParse(version2).success) return null;
@@ -56277,7 +57528,7 @@ function compareVersions(a, b) {
   return comparePrerelease(left.prerelease, right.prerelease);
 }
 function rolloutBucket(machineId, version2) {
-  return (0, import_node_crypto9.createHash)("sha256").update(`${machineId}
+  return (0, import_node_crypto10.createHash)("sha256").update(`${machineId}
 ${version2}`).digest().readUInt32BE(0) % 100;
 }
 function hostReleaseTarget(platform3 = process.platform, arch2 = process.arch) {
@@ -56307,7 +57558,7 @@ function planUpdate(input2) {
 
 // src/platform/release-apply.ts
 var import_node_child_process5 = require("child_process");
-var import_node_crypto10 = require("crypto");
+var import_node_crypto11 = require("crypto");
 var import_promises17 = require("fs/promises");
 var import_node_path13 = require("path");
 var import_node_util4 = require("util");
@@ -56344,7 +57595,7 @@ async function stageNpmTarball({
 }) {
   const integrity = verifyNpmIntegrity(tarball, release2.dist);
   if (!integrity.ok) throw new RuntimeFault("invalid_file", integrity.reason);
-  const scratch = (0, import_node_path13.join)(tmpDir, (0, import_node_crypto10.randomUUID)());
+  const scratch = (0, import_node_path13.join)(tmpDir, (0, import_node_crypto11.randomUUID)());
   await (0, import_promises17.mkdir)(scratch, { recursive: true, mode: 448 });
   try {
     const tarballPath = (0, import_node_path13.join)(scratch, "package.tgz");
@@ -57452,19 +58703,21 @@ function createServiceManager(host, profile) {
 // src/platform/sleep.ts
 var import_node_child_process7 = require("child_process");
 var WAKE_THRESHOLD_MS = 3e4;
-function createWakeDetector(clock, thresholdMs = WAKE_THRESHOLD_MS) {
-  const last = { drift: clock.now() - clock.monotonic() };
+function createWakeDetector(clock, thresholdMs = WAKE_THRESHOLD_MS, platform3 = process.platform) {
+  const last = { wall: clock.now(), drift: clock.now() - clock.monotonic() };
   return {
     check: () => {
-      const drift = clock.now() - clock.monotonic();
-      const slept = drift - last.drift;
+      const wall = clock.now();
+      const drift = wall - clock.monotonic();
+      const slept = platform3 === "win32" ? wall - last.wall : drift - last.drift;
+      last.wall = wall;
       last.drift = drift;
       return slept >= thresholdMs ? slept : 0;
     }
   };
 }
-function wakeJob(clock, onWake, thresholdMs = WAKE_THRESHOLD_MS) {
-  const detector = createWakeDetector(clock, thresholdMs);
+function wakeJob(clock, onWake, thresholdMs = WAKE_THRESHOLD_MS, platform3 = process.platform) {
+  const detector = createWakeDetector(clock, thresholdMs, platform3);
   return {
     name: "wake.detect",
     run: () => {
@@ -57554,7 +58807,7 @@ function systemAssertionSpawner(log) {
 
 // src/platform/spawn-detached.ts
 var import_node_child_process8 = require("child_process");
-var import_node_crypto11 = require("crypto");
+var import_node_crypto12 = require("crypto");
 var import_node_fs8 = require("fs");
 var import_node_path21 = require("path");
 var WINDOWS_UNSAFE_ENV = "NODE_PENDING_PIPE_INSTANCES";
@@ -57591,7 +58844,7 @@ async function probeHolderIsolation(platform3, exec, env) {
   }
   const probe = await exec({
     command: SYSTEMD_RUN,
-    args: [...scopeArguments(`${SCOPE_PREFIX}-probe-${(0, import_node_crypto11.randomBytes)(4).toString("hex")}`), "true"],
+    args: [...scopeArguments(`${SCOPE_PREFIX}-probe-${(0, import_node_crypto12.randomBytes)(4).toString("hex")}`), "true"],
     timeoutMs: SCOPE_PROBE_TIMEOUT_MS
   });
   if (probe.status === 0) return { kind: "systemd-scope" };
@@ -57603,7 +58856,7 @@ async function probeHolderIsolation(platform3, exec, env) {
 }
 function isolatedCommand(request2, isolation) {
   if (isolation.kind === "detached") return { command: request2.command, args: [...request2.args] };
-  const unit = `${SCOPE_PREFIX}-${(0, import_node_crypto11.randomBytes)(6).toString("hex")}`;
+  const unit = `${SCOPE_PREFIX}-${(0, import_node_crypto12.randomBytes)(6).toString("hex")}`;
   return {
     command: SYSTEMD_RUN,
     args: [...scopeArguments(unit), request2.command, ...request2.args]
@@ -57881,7 +59134,7 @@ function createGit(options) {
 
 // src/capabilities/github-proxy/certificates.ts
 var import_node_child_process9 = require("child_process");
-var import_node_crypto12 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var import_promises24 = require("fs/promises");
 var import_node_path22 = require("path");
 var OPENSSL_TIMEOUT_MS = 1e4;
@@ -57946,7 +59199,7 @@ async function createGitHubProxyCertificates(stateDir) {
       work
     );
     await openssl(
-      ["x509", "-req", "-in", "leaf.csr", "-CA", "ca.pem", "-CAkey", "ca.key", "-sha256"].concat(["-set_serial", `0x${(0, import_node_crypto12.randomBytes)(16).toString("hex")}`, "-days", VALIDITY_DAYS]).concat(["-extfile", "leaf.cnf", "-extensions", "leaf", "-out", "leaf.pem"]),
+      ["x509", "-req", "-in", "leaf.csr", "-CA", "ca.pem", "-CAkey", "ca.key", "-sha256"].concat(["-set_serial", `0x${(0, import_node_crypto13.randomBytes)(16).toString("hex")}`, "-days", VALIDITY_DAYS]).concat(["-extfile", "leaf.cnf", "-extensions", "leaf", "-out", "leaf.pem"]),
       work
     );
     const caPath = (0, import_node_path22.join)(stateDir, "github-ca.pem");
@@ -58172,7 +59425,7 @@ async function startGitHubProxy(options) {
 }
 
 // src/capabilities/mcp-config/mcp-config.ts
-var import_node_crypto13 = require("crypto");
+var import_node_crypto14 = require("crypto");
 var import_promises27 = require("fs/promises");
 var import_node_path24 = require("path");
 
@@ -59156,7 +60409,7 @@ async function readConfig(cli, home) {
   }
 }
 async function writeConfig(path4, text2) {
-  const temporary = `${path4}.alan-${(0, import_node_crypto13.randomUUID)()}.tmp`;
+  const temporary = `${path4}.alan-${(0, import_node_crypto14.randomUUID)()}.tmp`;
   try {
     await (0, import_promises27.writeFile)(temporary, text2, { encoding: "utf8", mode: 384, flag: "wx" });
     await (0, import_promises27.rename)(temporary, path4);
@@ -60264,7 +61517,7 @@ function reconcileTranscriptIdentity(entry, transcriptPath, identity, size) {
 }
 
 // src/capabilities/native-ingest/transcript-window.ts
-var import_node_crypto14 = require("crypto");
+var import_node_crypto15 = require("crypto");
 var import_promises32 = require("fs/promises");
 init_acp2();
 init_claude();
@@ -60414,7 +61667,7 @@ function lastMatchingTurnIndex(turns, target) {
 function signalDigest(target) {
   const fingerprint = target.assistantFingerprint;
   const basis = target.providerTurnId ?? (fingerprint ? `${fingerprint.length}\0${fingerprint.head}\0${fingerprint.tail}` : null);
-  return basis ? (0, import_node_crypto14.createHash)("sha256").update(basis).digest("hex") : null;
+  return basis ? (0, import_node_crypto15.createHash)("sha256").update(basis).digest("hex") : null;
 }
 function lastForegroundStop(updates) {
   for (let index = updates.length - 1; index >= 0; index -= 1) {
@@ -60529,9 +61782,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,
@@ -61156,7 +62423,9 @@ function providerCommandFor(backendKind) {
   return BY_BACKEND.get(backendKind)?.command;
 }
 function envValue(env, name) {
-  const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name);
+  const key = Object.keys(env).findLast(
+    (candidate) => candidate.toUpperCase() === name.toUpperCase()
+  );
   return key === void 0 ? "" : env[key] ?? "";
 }
 function pathDelimiter(platform3) {
@@ -61172,12 +62441,18 @@ async function isRunnable(path4, platform3) {
   }
 }
 function windowsExtensions(command, env) {
-  const extensions = (envValue(env, "PATHEXT") || ".COM;.EXE;.BAT;.CMD").split(";").filter((extension) => extension.startsWith("."));
+  const extensions = (envValue(env, "PATHEXT") || ".COM;.EXE;.BAT;.CMD").split(";").map((extension) => extension.trim()).filter((extension) => [".COM", ".EXE", ".BAT", ".CMD"].includes(extension.toUpperCase()));
   const named = command.toLowerCase();
-  return extensions.some((extension) => named.endsWith(extension.toLowerCase())) ? [""] : extensions;
+  return [".com", ".exe", ...extensions.map((extension) => extension.toLowerCase())].some(
+    (extension) => named.endsWith(extension)
+  ) ? [""] : extensions;
 }
 async function resolveCommandOnPath(command, env, platform3) {
-  const directories = envValue(env, "PATH").split(pathDelimiter(platform3)).filter((directory) => directory.length > 0);
+  const directories = envValue(env, "PATH").split(pathDelimiter(platform3)).map(
+    (directory) => platform3 === "win32" ? directory.trim().replace(/^"(.*)"$/, "$1") : directory
+  ).filter(
+    (directory) => platform3 === "win32" ? import_node_path32.win32.isAbsolute(directory) : directory.length > 0
+  );
   const extensions = platform3 === "win32" ? windowsExtensions(command, env) : [""];
   for (const directory of directories) {
     for (const extension of extensions) {
@@ -61224,8 +62499,21 @@ function alanCodeProviderModels() {
 var import_node_child_process10 = require("child_process");
 var DEFAULT_TIMEOUT_MS2 = 5e3;
 var DEFAULT_MAX_BYTES = 1024 * 1024;
+function withWindowsHelper(env) {
+  const helper = windowsHelperPath();
+  return helper === null ? env : { ...env, ALAN_WINHELPER_PATH: helper };
+}
 function directLaunch(command, args, options) {
   try {
+    if ((options.platform ?? process.platform) === "win32") {
+      const plan2 = planSpawn({
+        command,
+        args,
+        env: canonicalWindowsEnvironment(options.env),
+        platform: "win32"
+      });
+      return { file: plan2.file, args: plan2.args, windowsVerbatimArguments: false };
+    }
     return planDirectLaunch({
       command,
       args,
@@ -61237,42 +62525,88 @@ function directLaunch(command, args, options) {
   }
 }
 function captureProbe(command, args, options) {
+  const platform3 = options.platform ?? process.platform;
   const launch = directLaunch(command, args, options);
   if (launch === void 0) return Promise.resolve({ stdout: "", stderr: "", exitCode: void 0 });
+  const env = platform3 === "win32" ? withWindowsHelper(canonicalWindowsEnvironment(options.env)) : options.env;
   return new Promise((resolve12) => {
     const limit = options.maxBufferBytes ?? DEFAULT_MAX_BYTES;
     const stdout = [];
     const stderr = [];
     let bytes = 0;
     let overflowed = false;
-    const child = (0, import_node_child_process10.spawn)(launch.file, [...launch.args], {
-      env: { ...options.env },
+    const windowsChild = platform3 === "win32" ? spawnInWindowsJob(planSpawn({ command, args, env, platform: platform3 }), {
+      cwd: process.cwd(),
+      env
+    }) : void 0;
+    const child = windowsChild ?? (0, import_node_child_process10.spawn)(launch.file, [...launch.args], {
+      env: { ...env },
       stdio: ["ignore", "pipe", "pipe"],
-      timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
+      detached: true,
       windowsHide: true,
       windowsVerbatimArguments: launch.windowsVerbatimArguments
     });
+    child.stdin?.end();
+    const terminate = () => {
+      if (platform3 !== "win32" && child.pid !== void 0) {
+        try {
+          process.kill(-child.pid, "SIGKILL");
+          return;
+        } catch {
+        }
+      }
+      child.kill("SIGKILL");
+    };
+    let settled2 = false;
+    const deadlineController = new AbortController();
+    const finish = (exitCode) => {
+      if (settled2) return;
+      settled2 = true;
+      deadlineController.abort();
+      options.signal?.removeEventListener("abort", abort);
+      resolve12({
+        stdout: Buffer.concat(stdout).toString("utf8"),
+        stderr: Buffer.concat(stderr).toString("utf8"),
+        exitCode
+      });
+    };
+    void systemClock.sleep(options.timeoutMs ?? DEFAULT_TIMEOUT_MS2, deadlineController.signal).then(
+      () => {
+        terminate();
+        child.stdout.destroy();
+        child.stderr.destroy();
+        finish(void 0);
+      },
+      () => void 0
+    );
+    const abort = () => {
+      terminate();
+      child.stdout.destroy();
+      child.stderr.destroy();
+      finish(void 0);
+    };
+    options.signal?.addEventListener("abort", abort, { once: true });
+    if (options.signal?.aborted) abort();
     const collect = (into) => (chunk) => {
       bytes += chunk.length;
       if (bytes > limit) {
         overflowed = true;
-        child.kill("SIGKILL");
+        terminate();
+        finish(void 0);
         return;
       }
       into.push(chunk);
     };
     child.stdout.on("data", collect(stdout));
     child.stderr.on("data", collect(stderr));
-    const finish = (exitCode) => resolve12({
-      stdout: Buffer.concat(stdout).toString("utf8"),
-      stderr: Buffer.concat(stderr).toString("utf8"),
-      exitCode
-    });
     child.once("error", () => finish(void 0));
     child.once(
       "close",
       (code, signal) => finish(overflowed || signal !== null || code === null ? void 0 : code)
     );
+    if (windowsChild !== void 0) {
+      void waitForWindowsJob(windowsChild, command).catch(() => finish(void 0));
+    }
   });
 }
 
@@ -61719,7 +63053,7 @@ var import_node_path37 = require("path");
 
 // ../shared/dist/node/shell-environment.js
 var import_node_child_process12 = require("child_process");
-var import_node_crypto15 = require("crypto");
+var import_node_crypto16 = require("crypto");
 var import_node_fs15 = require("fs");
 var import_node_os5 = require("os");
 var import_node_path36 = require("path");
@@ -61863,6 +63197,15 @@ function installerDirectories(home, platform3) {
   const system = platform3 === "darwin" ? ["/opt/homebrew/bin", "/usr/local/bin"] : ["/usr/local/bin"];
   return [...user, ...system];
 }
+function windowsInstallerDirectories(env) {
+  const home = envValue(env, "USERPROFILE") || envValue(env, "HOME");
+  const hasHome = import_node_path37.win32.isAbsolute(home);
+  const appData = envValue(env, "APPDATA") || (hasHome ? import_node_path37.win32.join(home, "AppData", "Roaming") : "");
+  return [
+    ...hasHome ? [import_node_path37.win32.join(home, ".local", "bin")] : [],
+    ...import_node_path37.win32.isAbsolute(appData) ? [import_node_path37.win32.join(appData, "npm")] : []
+  ];
+}
 function printPathCommand() {
   return `printf '${MARKER}%s${MARKER}' "$PATH"`;
 }
@@ -61915,7 +63258,14 @@ async function rememberLastKnownGood(file2, path4) {
 }
 async function resolveCliEnvironmentDetailed(options) {
   const { env, platform: platform3 } = options;
-  if (platform3 === "win32") return { env: { ...env }, source: "none" };
+  if (platform3 === "win32") {
+    const path4 = appendPathDirectories(
+      envValue(env, "PATH"),
+      windowsInstallerDirectories(env),
+      ";"
+    );
+    return { env: canonicalWindowsEnvironment({ ...env, PATH: path4 }), source: "none" };
+  }
   const loginPath = await readLoginShellPath(env, options.capture ?? captureProbe);
   if (loginPath !== null) await rememberLastKnownGood(options.lastKnownGoodFile, loginPath);
   const lastKnownGood = loginPath === null ? await readLastKnownGood(options.lastKnownGoodFile) : null;
@@ -61962,8 +63312,7 @@ async function openCliEnvironment(options) {
 }
 
 // src/capabilities/providers/managed.ts
-var import_node_child_process13 = require("child_process");
-var import_node_crypto16 = require("crypto");
+var import_node_crypto17 = require("crypto");
 var import_promises36 = require("fs/promises");
 var import_node_path38 = require("path");
 init_zod();
@@ -61992,9 +63341,10 @@ function withManagedProviderPaths(manager, env, nodeDirectory, platform3 = proce
   const path4 = [
     ...manager.selections().map((item) => item.binDir),
     ...nodeDirectory === void 0 ? [] : [nodeDirectory],
-    env.PATH ?? ""
+    envValue(env, "PATH")
   ].filter(Boolean);
-  return { ...env, PATH: path4.join(pathDelimiter(platform3)) };
+  const merged = { ...env, PATH: path4.join(pathDelimiter(platform3)) };
+  return platform3 === "win32" ? canonicalWindowsEnvironment(merged) : merged;
 }
 function packageFor(backendKind) {
   const provider4 = PACKAGES[backendKind];
@@ -62091,7 +63441,7 @@ function createManagedProviderClis(options) {
   };
   const persist = async () => {
     await (0, import_promises36.mkdir)(options.root, { recursive: true, mode: 448 });
-    const staged = `${file2}.${(0, import_node_crypto16.randomUUID)()}`;
+    const staged = `${file2}.${(0, import_node_crypto17.randomUUID)()}`;
     try {
       await (0, import_promises36.writeFile)(staged, JSON.stringify(state), { mode: 384 });
       await (0, import_promises36.rename)(staged, file2);
@@ -62126,7 +63476,7 @@ function createManagedProviderClis(options) {
       try {
         parsed = selectedSchema.parse(JSON.parse(raw));
       } catch {
-        await (0, import_promises36.rename)(file2, `${file2}.invalid.${(0, import_node_crypto16.randomUUID)()}`).catch(() => void 0);
+        await (0, import_promises36.rename)(file2, `${file2}.invalid.${(0, import_node_crypto17.randomUUID)()}`).catch(() => void 0);
         return;
       }
       for (const [backendKind, version2] of Object.entries(parsed)) {
@@ -62184,7 +63534,7 @@ function createManagedProviderClis(options) {
       const existing = selection(options.root, backendKind, exact);
       if (!await runnable(existing.executable) || !await options.probe(existing.executable, backendKind)) {
         await (0, import_promises36.mkdir)((0, import_node_path38.dirname)(target), { recursive: true, mode: 448 });
-        const staged = `${target}.${(0, import_node_crypto16.randomUUID)()}`;
+        const staged = `${target}.${(0, import_node_crypto17.randomUUID)()}`;
         try {
           await options.installPackage(provider4.name, exact, staged, provider4.command, signal);
           const built = (0, import_node_path38.join)(staged, "node_modules", ".bin", provider4.command);
@@ -62214,9 +63564,18 @@ function createManagedProviderClis(options) {
     })
   };
 }
+function withInstallerPath(options) {
+  const platform3 = options.platform ?? process.platform;
+  const path4 = [
+    platform3 === "win32" ? import_node_path38.win32.dirname(options.command) : (0, import_node_path38.dirname)(options.command),
+    envValue(options.env, "PATH")
+  ].filter(Boolean).join(pathDelimiter(platform3));
+  const env = { ...options.env, PATH: path4 };
+  return platform3 === "win32" ? canonicalWindowsEnvironment(env) : env;
+}
 function createNpmPackageInstaller(options) {
-  return (packageName, version2, destination, _command, signal) => new Promise((resolve12, reject) => {
-    const child = (0, import_node_child_process13.spawn)(
+  return async (packageName, version2, destination, _command, signal) => {
+    const result = await captureProbe(
       options.command,
       [
         ...options.argsBeforeNpm ?? [],
@@ -62228,53 +63587,35 @@ function createNpmPackageInstaller(options) {
         `${packageName}@${version2}`
       ],
       {
-        env: { ...options.env, PATH: `${(0, import_node_path38.dirname)(options.command)}:${options.env.PATH ?? ""}` },
+        env: withInstallerPath(options),
         signal,
-        stdio: ["ignore", "pipe", "pipe"]
+        timeoutMs: 10 * 6e4,
+        maxBufferBytes: 1024 * 1024
       }
     );
-    let output2 = "";
-    for (const stream of [child.stdout, child.stderr]) {
-      stream?.on("data", (chunk) => {
-        output2 = `${output2}${chunk.toString()}`.slice(-8e3);
-      });
+    if (result.exitCode !== 0) {
+      const output2 = `${result.stdout}
+${result.stderr}`.trim().slice(-8e3);
+      throw new Error(
+        `npm install failed (${result.exitCode ?? "timeout, cancellation or launch"}): ${output2}`
+      );
     }
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0) resolve12();
-      else reject(new Error(`npm install failed (${code ?? "signal"}): ${output2.trim()}`));
-    });
-  });
+  };
 }
 function createNpmVersionResolver(options) {
-  return (packageName, signal) => new Promise((resolve12, reject) => {
-    const child = (0, import_node_child_process13.spawn)(
+  return async (packageName, signal) => {
+    const result = await captureProbe(
       options.command,
       [...options.argsBeforeNpm ?? [], "view", packageName, "version", "--json"],
-      {
-        env: { ...options.env },
-        signal: AbortSignal.any([
-          signal ?? new AbortController().signal,
-          AbortSignal.timeout(3e4)
-        ]),
-        stdio: ["ignore", "pipe", "pipe"]
-      }
+      { env: withInstallerPath(options), signal, timeoutMs: 3e4, maxBufferBytes: 1e5 }
     );
-    let output2 = "";
-    child.stdout.on("data", (chunk) => {
-      output2 = `${output2}${chunk.toString()}`;
-      if (output2.length > 1e5) child.kill();
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code !== 0) return reject(new Error(`Cannot look up ${packageName} version`));
-      try {
-        resolve12(parseNpmVersion(output2, packageName));
-      } catch (error61) {
-        reject(error61);
-      }
-    });
-  });
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `Cannot look up ${packageName} version: ${result.stderr.trim().slice(-2e3)}`
+      );
+    }
+    return parseNpmVersion(result.stdout, packageName);
+  };
 }
 function parseNpmVersion(output2, packageName) {
   const versions = external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).parse(JSON.parse(output2));
@@ -62311,7 +63652,7 @@ var import_node_path43 = __toESM(require("path"));
 
 // ../shared/dist/node/skill-package.js
 var import_node_buffer = require("buffer");
-var import_node_crypto17 = require("crypto");
+var import_node_crypto18 = require("crypto");
 var import_promises37 = require("fs/promises");
 var import_node_path39 = require("path");
 var import_yaml = __toESM(require_dist(), 1);
@@ -62711,7 +64052,7 @@ function comparePackageFiles(left, right) {
   return import_node_buffer.Buffer.compare(import_node_buffer.Buffer.from(left.manifest.path, "utf8"), import_node_buffer.Buffer.from(right.manifest.path, "utf8"));
 }
 function hashPackageTree(files) {
-  const hash2 = (0, import_node_crypto17.createHash)("sha256");
+  const hash2 = (0, import_node_crypto18.createHash)("sha256");
   hash2.update(TREE_HASH_PREFIX);
   for (const file2 of files) {
     const path4 = import_node_buffer.Buffer.from(file2.path, "utf8");
@@ -62724,7 +64065,7 @@ function hashPackageTree(files) {
   return `sha256:${hash2.digest("hex")}`;
 }
 function sha256(bytes) {
-  return `sha256:${(0, import_node_crypto17.createHash)("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${(0, import_node_crypto18.createHash)("sha256").update(bytes).digest("hex")}`;
 }
 function uint322(value2) {
   const buffer = import_node_buffer.Buffer.allocUnsafe(4);
@@ -62738,13 +64079,13 @@ function uint642(value2) {
 }
 
 // src/capabilities/skills/local-sources.ts
-var import_node_crypto19 = require("crypto");
+var import_node_crypto20 = require("crypto");
 var import_promises39 = require("fs/promises");
 var import_node_path41 = __toESM(require("path"));
 init_type_guards();
 
 // src/capabilities/skills/local-scan.ts
-var import_node_crypto18 = require("crypto");
+var import_node_crypto19 = require("crypto");
 var import_promises38 = require("fs/promises");
 var import_node_path40 = __toESM(require("path"));
 var MAX_CANDIDATES = 2e3;
@@ -62753,7 +64094,7 @@ function createLocalSkillScanCache() {
   return { inspections: /* @__PURE__ */ new Map(), lastCompleteRevision: null };
 }
 async function scanSkillRoots(input2, cache2) {
-  const attemptId = (0, import_node_crypto18.randomUUID)();
+  const attemptId = (0, import_node_crypto19.randomUUID)();
   const ignoredPaths = input2.ignoredPaths ?? [];
   const resolvedRoots = resolveScanRoots(input2.roots, input2.enabledProviderKinds ?? []);
   const pass = {
@@ -62818,7 +64159,7 @@ function failedLocalSkillScan(cache2, code, message2) {
   return {
     outcome: {
       status: "failed",
-      attemptId: (0, import_node_crypto18.randomUUID)(),
+      attemptId: (0, import_node_crypto19.randomUUID)(),
       retainedInventoryRevision: cache2.lastCompleteRevision,
       diagnostics: [{ code, message: message2.slice(0, 2048) }]
     },
@@ -62982,11 +64323,11 @@ function candidateOrigin(root) {
 }
 function createLocalKey(root, skillName) {
   const rootIdentity = root.kind === "configured" ? `configured:${root.declarationId}` : root.kind === "repository" ? `repository:${root.repositoryId}` : "drafts";
-  const digest = (0, import_node_crypto18.createHash)("sha256").update("alan-local-skill-v1\0").update(rootIdentity).update("\0").update(skillName.normalize("NFC")).digest("hex");
+  const digest = (0, import_node_crypto19.createHash)("sha256").update("alan-local-skill-v1\0").update(rootIdentity).update("\0").update(skillName.normalize("NFC")).digest("hex");
   return `local:${digest}`;
 }
 function hashInventory(candidates2) {
-  const hash2 = (0, import_node_crypto18.createHash)("sha256").update("alan-skill-inventory-v1\0");
+  const hash2 = (0, import_node_crypto19.createHash)("sha256").update("alan-skill-inventory-v1\0");
   for (const candidate of candidates2) {
     hash2.update(candidate.localKey).update("\0");
     hash2.update(candidate.contentHash).update("\0");
@@ -63006,7 +64347,7 @@ function deduplicateByContent(candidates2) {
   return candidates2.filter((located) => winners.has(located));
 }
 async function fingerprintPackage(root) {
-  const hash2 = (0, import_node_crypto18.createHash)("sha256").update("alan-skill-stat-fingerprint-v1\0");
+  const hash2 = (0, import_node_crypto19.createHash)("sha256").update("alan-skill-stat-fingerprint-v1\0");
   const visit2 = async (directory, relativeDirectory) => {
     const entries = await (0, import_promises38.readdir)(directory, { withFileTypes: true });
     entries.sort((left, right) => Buffer.compare(Buffer.from(left.name), Buffer.from(right.name)));
@@ -63209,7 +64550,7 @@ function staleCodexDeclaration(relativeDirectory, label, providerKinds) {
   return ownedByCursor || label === "Legacy Cursor-compatible skills";
 }
 function stableSourceDeclarationId(sourcePath) {
-  const digest = (0, import_node_crypto19.createHash)("sha256").update("alan-skill-source-v1\0").update(sourcePath.normalize("NFC")).digest("hex").slice(0, 24);
+  const digest = (0, import_node_crypto20.createHash)("sha256").update("alan-skill-source-v1\0").update(sourcePath.normalize("NFC")).digest("hex").slice(0, 24);
   return `source-${digest}`;
 }
 function requiredSourceId(value2, field3) {
@@ -63256,10 +64597,10 @@ var import_promises40 = require("fs/promises");
 var import_node_path42 = require("path");
 
 // ../shared/dist/node/alan-skill-identity.js
-var import_node_crypto20 = require("crypto");
+var import_node_crypto21 = require("crypto");
 var ALAN_SKILL_NAMESPACE = "ec71d99b-d207-4ca2-a9eb-3a7bed4a73fd";
 function uuidV5(name, namespace) {
-  const bytes = (0, import_node_crypto20.createHash)("sha1").update(Buffer.from(namespace.replaceAll("-", ""), "hex")).update(name, "utf8").digest().subarray(0, 16);
+  const bytes = (0, import_node_crypto21.createHash)("sha1").update(Buffer.from(namespace.replaceAll("-", ""), "hex")).update(name, "utf8").digest().subarray(0, 16);
   bytes[6] = bytes[6] & 15 | 80;
   bytes[8] = bytes[8] & 63 | 128;
   const hex3 = bytes.toString("hex");
@@ -63526,7 +64867,7 @@ var import_promises43 = require("fs/promises");
 
 // ../shared/dist/node/skill-bundle.js
 var import_node_buffer2 = require("buffer");
-var import_node_crypto21 = require("crypto");
+var import_node_crypto22 = require("crypto");
 var import_promises42 = require("fs/promises");
 var import_node_path44 = require("path");
 var import_node_stream = require("stream");
@@ -63665,7 +65006,7 @@ function requireSafeArchivePath(value2) {
   return normalized2;
 }
 function sha2562(bytes) {
-  return `sha256:${(0, import_node_crypto21.createHash)("sha256").update(bytes).digest("hex")}`;
+  return `sha256:${(0, import_node_crypto22.createHash)("sha256").update(bytes).digest("hex")}`;
 }
 
 // src/capabilities/skills/local-upload.ts
@@ -63709,14 +65050,14 @@ async function publishLocalSkill(options) {
 }
 
 // src/capabilities/skills/sync.ts
-var import_node_crypto22 = require("crypto");
+var import_node_crypto23 = require("crypto");
 var import_promises44 = require("fs/promises");
 var import_node_path45 = require("path");
 var SKILL_PREPARE_WAIT_MS = 15e3;
 async function install(layout, source, skill, download, signal) {
   const bytes = await source.download(download.url, signal);
   await (0, import_promises44.mkdir)(layout.tmpDir, { recursive: true, mode: 448 });
-  const staging = (0, import_node_path45.join)(layout.tmpDir, (0, import_node_crypto22.randomUUID)());
+  const staging = (0, import_node_path45.join)(layout.tmpDir, (0, import_node_crypto23.randomUUID)());
   await extractSkillBundle(Buffer.from(bytes), staging, {
     expectedArchiveHash: download.archiveHash,
     expectedContentHash: skill.contentHash
@@ -64129,7 +65470,7 @@ async function openApprovedPaths(options) {
 }
 
 // src/capabilities/workspace/locks.ts
-var import_node_crypto23 = require("crypto");
+var import_node_crypto24 = require("crypto");
 var import_promises46 = require("fs/promises");
 var import_node_path47 = require("path");
 init_zod();
@@ -64146,7 +65487,7 @@ var ownerSchema = external_exports.object({
   since: external_exports.number().int().nonnegative()
 });
 function repositoryLockKey(commonDir, platform3) {
-  return (0, import_node_crypto23.createHash)("sha256").update(comparablePath(commonDir, platform3)).digest("hex").slice(0, 32);
+  return (0, import_node_crypto24.createHash)("sha256").update(comparablePath(commonDir, platform3)).digest("hex").slice(0, 32);
 }
 async function readOwner2(path4) {
   let text2;
@@ -64259,7 +65600,7 @@ function openRepositoryLocks(options) {
     },
     tryShared: async (commonDir, runId) => {
       const { key, dir } = await folder(commonDir);
-      const file2 = `${RUN_FILE_PREFIX}${(0, import_node_crypto23.createHash)("sha256").update(runId).digest("hex").slice(0, 32)}.json`;
+      const file2 = `${RUN_FILE_PREFIX}${(0, import_node_crypto24.createHash)("sha256").update(runId).digest("hex").slice(0, 32)}.json`;
       const path4 = (0, import_node_path47.join)(dir, file2);
       const owner = await self(runId);
       await writeJsonFileAtomic(path4, owner);
@@ -64495,7 +65836,7 @@ async function openWorkspaces(options) {
 
 // src/cli/config.ts
 var import_node_os11 = require("os");
-var import_node_path64 = require("path");
+var import_node_path65 = require("path");
 init_zod();
 
 // src/client/contract.ts
@@ -64780,6 +66121,7 @@ var mcpConfigResultSchema = external_exports.object({
 
 // src/client/runtime-client.ts
 var import_promises47 = require("fs/promises");
+init_acp();
 init_runtime_v2();
 
 // src/client/sse.ts
@@ -64797,14 +66139,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") };
@@ -64813,8 +66159,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));
   }
 }
 
@@ -64851,6 +66197,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) {
@@ -64996,11 +66359,44 @@ 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(query, signal) {
+    const stopped = new AbortController();
+    try {
+      const body = await openStream(
+        {
+          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)) yield conversationUpdate(event);
+      if (!signal.aborted)
+        throw new RuntimeClientError("unavailable", "The local conversation stream closed");
+    } finally {
+      stopped.abort();
+    }
+  }
   return {
     status: (signal) => json2({ path: LOCAL_API_ROUTES.status }, runtimeStatusSchema, signal),
     watchStatus,
+    followConversationMessages,
     runs,
     conversationRuns: async (conversationId, signal) => (await runs(signal)).filter((run2) => run2.conversationId === conversationId),
+    readConversationMessages: async (query, signal) => {
+      const response = await send2(
+        {
+          path: `/v2/conversations/${encodeURIComponent(query.conversationId)}/messages`,
+          query: conversationQuery(query)
+        },
+        signal
+      );
+      if (response.status === 404) return null;
+      if (!response.ok) throw await rejection(response);
+      const page = await response.json();
+      if (!isConversationMessagesPage(page))
+        throw new RuntimeClientError("protocol", "Invalid local conversation page");
+      return page;
+    },
     readRunLog: async (runId, query, signal) => {
       const response = await send2(
         {
@@ -65166,14 +66562,14 @@ async function sendNativeHookSignal(discoveryPath, hookSignal, signal) {
 }
 
 // src/sessions/index.ts
-var import_node_crypto29 = require("crypto");
-var import_promises63 = require("fs/promises");
+var import_node_crypto30 = require("crypto");
+var import_promises64 = require("fs/promises");
 var import_node_os10 = require("os");
-var import_node_path63 = require("path");
+var import_node_path64 = require("path");
 init_runtime_v2();
 
 // src/holder/control-client.ts
-var import_node_crypto24 = require("crypto");
+var import_node_crypto25 = require("crypto");
 var import_node_net2 = require("net");
 init_runtime_v2();
 
@@ -65243,7 +66639,7 @@ async function connectHolder(endpoint, token, onEvent) {
   });
   const pid = await ready;
   const request2 = (body) => {
-    const id = (0, import_node_crypto24.randomUUID)();
+    const id = (0, import_node_crypto25.randomUUID)();
     return new Promise((resolve12, reject) => {
       const timer = AbortSignal.timeout(REQUEST_TIMEOUT_MS7);
       timer.addEventListener("abort", () => {
@@ -65582,10 +66978,10 @@ async function prepareRunInputs(spec, { source, tmpDir, signal, skills = [] }) {
 }
 
 // src/holder/serve.ts
-var import_node_crypto28 = require("crypto");
+var import_node_crypto29 = require("crypto");
 var import_node_fs21 = require("fs");
 var import_node_net3 = require("net");
-var import_node_path62 = require("path");
+var import_node_path63 = require("path");
 init_runtime_v2();
 
 // src/holder/admission.ts
@@ -65676,7 +67072,7 @@ async function discoverRelocatedWorkspace(search) {
 }
 
 // src/holder/checkout-refresh.ts
-var import_node_crypto26 = require("crypto");
+var import_node_crypto27 = require("crypto");
 var import_promises57 = require("fs/promises");
 var import_node_path56 = require("path");
 function short(sha) {
@@ -65723,7 +67119,7 @@ async function fastForward(freshness, operationId, deps, signal) {
 async function atFirstLease(freshness, spec, deps, signal) {
   const first = await claimOnce(
     (0, import_node_path56.join)(deps.dir, "leased"),
-    (0, import_node_crypto26.createHash)("sha256").update(freshness.path).digest("hex")
+    (0, import_node_crypto27.createHash)("sha256").update(freshness.path).digest("hex")
   );
   switch (freshness.state) {
     case "current":
@@ -66340,7 +67736,7 @@ function createSessionFacts(options) {
 init_acp2();
 
 // src/run-log/complete.ts
-var import_node_crypto27 = require("crypto");
+var import_node_crypto28 = require("crypto");
 var import_node_fs19 = require("fs");
 var import_node_path60 = require("path");
 
@@ -66349,7 +67745,24 @@ var import_promises61 = require("fs/promises");
 var import_node_path59 = require("path");
 init_runtime_v2();
 init_zod();
-var runMetaSchema = external_exports.object({ runId: runIdSchema, conversationId: conversationIdSchema });
+var runMetaSchema = external_exports.object({
+  runId: runIdSchema,
+  conversationId: conversationIdSchema,
+  agentMode: external_exports.string().optional(),
+  userMessage: external_exports.object({
+    id: external_exports.string(),
+    content: external_exports.string(),
+    turnOrdinal: external_exports.number().int().nullable(),
+    createdAt: external_exports.string(),
+    clientMessageId: external_exports.string().optional(),
+    attachmentIds: external_exports.array(external_exports.string()).optional()
+  }).optional(),
+  assistantMessage: external_exports.object({
+    id: external_exports.string(),
+    turnOrdinal: external_exports.number().int().nullable(),
+    createdAt: external_exports.string()
+  }).optional()
+});
 async function readRunMeta(path4) {
   const read = await readJsonFile(path4, runMetaSchema);
   return read.kind === "ok" ? read.value : null;
@@ -66374,7 +67787,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_crypto27.randomUUID)()}.tmp`);
+  const temp = (0, import_node_path60.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);
@@ -66402,8 +67815,86 @@ async function writeCompleteRunLog(runsDir, meta3, records) {
   if (await readRunMeta(paths.meta) === null) await writeJsonFileAtomic(paths.meta, meta3);
 }
 
-// src/run-log/reader.ts
+// src/run-log/conversation-index.ts
 var import_promises62 = require("fs/promises");
+var import_node_path61 = require("path");
+init_runtime_v2();
+init_zod();
+var ORDINALS_PER_SHARD = 1e3;
+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 indexDirectory(runsDir, conversationId) {
+  return (0, import_node_path61.join)((0, import_node_path61.dirname)(runsDir), "sessions", conversationId, "turn-index");
+}
+function shardPath(runsDir, conversationId, ordinal) {
+  return (0, import_node_path61.join)(
+    indexDirectory(runsDir, conversationId),
+    `${Math.floor(ordinal / ORDINALS_PER_SHARD)}.jsonl`
+  );
+}
+async function indexConversationRun(runsDir, conversationId, ordinal, assistantOrdinal, runId) {
+  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 })}
+`, { mode: 384 });
+  const coveragePath = (0, import_node_path61.join)((0, import_node_path61.dirname)((0, import_node_path61.dirname)(path4)), "coverage.json");
+  const coverage = await readJsonFile(coveragePath, coverageSchema);
+  const current = coverage.kind === "ok" ? coverage.value : null;
+  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 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) => {
+    if (error61.code === "ENOENT") return [];
+    throw error61;
+  });
+  const shards = names.map((name) => /^\d+\.jsonl$/.test(name) ? Number(name.slice(0, -6)) : NaN).filter((shard) => Number.isSafeInteger(shard)).filter(
+    (shard) => before === void 0 || shard <= Math.floor((before - 1) / ORDINALS_PER_SHARD)
+  ).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 records = text2.split("\n").flatMap((line) => {
+      if (!line) return [];
+      const parsed = indexRecordSchema.parse(JSON.parse(line));
+      return [parsed];
+    }).filter((record2) => before === void 0 || record2.ordinal < before).reverse().sort((left, right) => right.ordinal - left.ordinal);
+    for (const record2 of records) {
+      if (selected.some((entry) => entry.ordinal === record2.ordinal)) continue;
+      selected.push(record2);
+      if (selected.length >= limit) return selected;
+    }
+  }
+  return selected;
+}
+
+// src/run-log/reader.ts
+var import_promises63 = require("fs/promises");
 init_runtime_v2();
 
 // src/run-log/tail.ts
@@ -66426,7 +67917,7 @@ function firstRecordLength(bytes) {
   return bytes.indexOf(RUN_LOG_RECORD_SEPARATOR) + 1;
 }
 async function openRunLogReader(path4) {
-  const handle = await (0, import_promises62.open)(path4, "r");
+  const handle = await (0, import_promises63.open)(path4, "r");
   const readAt = async (position, length) => {
     const buffer = Buffer.alloc(length);
     const { bytesRead } = await handle.read(buffer, 0, length, position);
@@ -66460,7 +67951,7 @@ async function openRunLogReader(path4) {
   };
 }
 async function readLastRecord(path4) {
-  const handle = await (0, import_promises62.open)(path4, "r").catch(() => null);
+  const handle = await (0, import_promises63.open)(path4, "r").catch(() => null);
   if (handle === null) return null;
   try {
     const { size } = await handle.stat();
@@ -66494,7 +67985,7 @@ var decoder = new TextDecoder();
 
 // src/run-log/writer.ts
 var import_node_fs20 = require("fs");
-var import_node_path61 = require("path");
+var import_node_path62 = require("path");
 init_runtime_v2();
 function lastSeq(fd, size) {
   for (const length of tailWindows(size)) {
@@ -66510,7 +68001,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_path61.dirname)(path4), { recursive: true, mode: 448 });
+  (0, import_node_fs20.mkdirSync)((0, import_node_path62.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);
@@ -66742,10 +68233,30 @@ async function admitAndRun(spec, context, append, sink, signal) {
 async function claimRun(spec, context) {
   if (await isRunClaimed(context.runsDir, spec.runId)) return null;
   const paths = runDirectory(context.runsDir, spec.runId);
-  await writeJsonFileAtomic(paths.meta, { runId: spec.runId, conversationId: spec.conversationId });
+  await writeJsonFileAtomic(paths.meta, {
+    runId: spec.runId,
+    conversationId: spec.conversationId,
+    ...spec.mode ? { agentMode: spec.mode } : {},
+    ...spec.userMessage ? { userMessage: spec.userMessage } : {},
+    ...spec.assistantMessage ? { assistantMessage: spec.assistantMessage } : {}
+  });
   const log = openRunLog(paths.log, context.clock);
   const offset = log.append(runAccepted(context.machineId, context.clock.now()));
   context.onAppended(spec.runId, offset);
+  if (spec.userMessage?.turnOrdinal !== null && spec.userMessage?.turnOrdinal !== void 0 && spec.assistantMessage?.turnOrdinal !== null && spec.assistantMessage?.turnOrdinal !== void 0) {
+    try {
+      await indexConversationRun(
+        context.runsDir,
+        spec.conversationId,
+        spec.userMessage.turnOrdinal,
+        spec.assistantMessage.turnOrdinal,
+        spec.runId
+      );
+      context.onAppended(spec.runId, offset);
+    } catch (error61) {
+      context.log.warn("holder.conversation_index_failed", { runId: spec.runId, error: error61 });
+    }
+  }
   return log;
 }
 async function runClaimedTurn(spec, claimed, context, signal) {
@@ -66807,12 +68318,12 @@ var TASK_UNSUPPORTED = {
   message: "This agent cannot stop one background task."
 };
 function sha2564(value2) {
-  return (0, import_node_crypto28.createHash)("sha256").update(value2).digest("hex");
+  return (0, import_node_crypto29.createHash)("sha256").update(value2).digest("hex");
 }
 function tokenMatches(expected, presented) {
   const a = Buffer.from(sha2564(expected), "hex");
   const b = Buffer.from(sha2564(presented), "hex");
-  return (0, import_node_crypto28.timingSafeEqual)(a, b);
+  return (0, import_node_crypto29.timingSafeEqual)(a, b);
 }
 async function runHolder({
   launch,
@@ -66826,7 +68337,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_path62.dirname)(launch.statusPath)), clock, log));
+    const _engines = __using(_stack, recordSpawnedEngines(engineRecordsPath((0, import_node_path63.dirname)(launch.statusPath)), clock, log));
     const holder = {
       state: "idle",
       runId: null,
@@ -67120,7 +68631,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_promises63.readdir)(dir).catch(() => [])) {
+  for (const name of await (0, import_promises64.readdir)(dir).catch(() => [])) {
     const parsed = schema.safeParse(name);
     if (parsed.success) ids.push(parsed.data);
   }
@@ -67134,8 +68645,8 @@ function holderIdentity(status) {
   return command === void 0 ? { pid, startedAt } : { pid, startedAt, command };
 }
 function sessionFiles(paths, conversationId) {
-  const dir = (0, import_node_path63.join)(paths.sessions, conversationId);
-  return { dir, launch: (0, import_node_path63.join)(dir, "launch.json"), status: (0, import_node_path63.join)(dir, "holder.json") };
+  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") };
 }
 async function openSessions(deps) {
   const { paths, clock, log } = deps;
@@ -67176,7 +68687,7 @@ async function openSessions(deps) {
     await reapLeftoverEngines(engineRecordsPath(dir), { clock, log, conversationId }).catch(
       (error61) => log.warn("sessions.engine_reap_failed", { conversationId, error: error61 })
     );
-    await (0, import_promises63.rm)(dir, { recursive: true, force: true });
+    await (0, import_promises64.rm)(dir, { recursive: true, force: true });
   };
   const retireIfGone = async (conversationId) => {
     const files = sessionFiles(paths, conversationId);
@@ -67264,7 +68775,7 @@ async function openSessions(deps) {
       log.info("sessions.reattached", { conversationId });
       return;
     }
-    if (alive) await (0, import_promises63.rm)(files.dir, { recursive: true, force: true });
+    if (alive) await (0, import_promises64.rm)(files.dir, { recursive: true, force: true });
     else await discardSession(conversationId);
   };
   const busyRunIds = async () => {
@@ -67289,14 +68800,14 @@ async function openSessions(deps) {
       if (!busy.has(runId)) await markInterrupted(runId);
     }
   };
-  const spawn11 = async (conversationId) => {
+  const spawn10 = async (conversationId) => {
     const files = sessionFiles(paths, conversationId);
     const launch = {
       protocol: HOLDER_PROTOCOL,
       conversationId,
       machineId: deps.machineId,
-      endpoint: ipcEndpoint(paths.sockets, (0, import_node_crypto29.randomUUID)().slice(0, 8)),
-      token: (0, import_node_crypto29.randomBytes)(32).toString("hex"),
+      endpoint: ipcEndpoint(paths.sockets, (0, import_node_crypto30.randomUUID)().slice(0, 8)),
+      token: (0, import_node_crypto30.randomBytes)(32).toString("hex"),
       runsDir: paths.runs,
       statusPath: files.status
     };
@@ -67322,7 +68833,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_promises63.stat)(dir.log).catch((error61) => {
+    const logged = await (0, import_promises64.stat)(dir.log).catch((error61) => {
       if (errnoCode(error61) === "ENOENT") return null;
       throw error61;
     });
@@ -67433,7 +68944,7 @@ async function openSessions(deps) {
       return "started";
     }
     if (await activeRunsOtherThan(run2.runId) >= maxActiveRuns) return "waiting";
-    if (!connections.has(run2.conversationId)) await spawn11(run2.conversationId);
+    if (!connections.has(run2.conversationId)) await spawn10(run2.conversationId);
     const connection = connections.get(run2.conversationId);
     if (connection === void 0) {
       throw new RuntimeFault("internal", "Holder connection missing");
@@ -67632,7 +69143,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_path64.join)(home, ".config"),
+    configHome: XDG_CONFIG_HOME ?? (0, import_node_path65.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,
@@ -67641,10 +69152,10 @@ function loadRuntimeConfig(env = process.env, totalMemoryBytes = (0, import_node
   };
 }
 function githubProxyConfig(env, home) {
-  const configHome = env.XDG_CONFIG_HOME ?? (0, import_node_path64.join)(home, ".config");
+  const configHome = env.XDG_CONFIG_HOME ?? (0, import_node_path65.join)(home, ".config");
   return {
     githubProxy: env.ALAN_RUNTIME_GITHUB_PROXY === "on",
-    ghConfigDir: env.GH_CONFIG_DIR ?? (0, import_node_path64.join)(configHome, "gh")
+    ghConfigDir: env.GH_CONFIG_DIR ?? (0, import_node_path65.join)(configHome, "gh")
   };
 }
 function serviceEnvironment2(env, profile) {
@@ -67702,9 +69213,9 @@ function takeEnrollmentCodeFromEnv(env = process.env) {
 }
 
 // src/cli/context.ts
-var import_promises64 = require("fs/promises");
+var import_promises65 = require("fs/promises");
 var import_node_os12 = require("os");
-var import_node_path65 = require("path");
+var import_node_path66 = require("path");
 var DESKTOP_BUNDLE_IDS = {
   production: ["com.alan-ai.desktop"],
   staging: ["com.alan-ai.desktop.staging"],
@@ -67744,7 +69255,7 @@ function serviceSpec({ config: config2, paths, self }) {
     profile: config2.profile,
     program: serviceCommand(config2.host, self, launcher),
     environment: config2.serviceEnvironment,
-    logPath: (0, import_node_path65.join)(paths.logs, "service.log"),
+    logPath: (0, import_node_path66.join)(paths.logs, "service.log"),
     associatedBundleIds: DESKTOP_BUNDLE_IDS[config2.profile]
   };
 }
@@ -67752,7 +69263,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_promises64.access)(layout.launcher).then(
+  const installed = await (0, import_promises65.access)(layout.launcher).then(
     () => true,
     () => false
   );
@@ -67880,7 +69391,7 @@ var manifestRevisionSchema = external_exports.object({ revision: external_export
 async function manifestRevision(path4) {
   let raw;
   try {
-    raw = JSON.parse(await (0, import_promises65.readFile)(path4, "utf8"));
+    raw = JSON.parse(await (0, import_promises66.readFile)(path4, "utf8"));
   } catch (error61) {
     throw new RuntimeFault("invalid_file", `Cannot read the skill manifest at ${path4}`, {
       cause: error61
@@ -67898,7 +69409,7 @@ async function runSkills(argv) {
     case "scan":
       writeJson({
         status: "failed",
-        attemptId: (0, import_node_crypto30.randomUUID)(),
+        attemptId: (0, import_node_crypto31.randomUUID)(),
         retainedInventoryRevision: null,
         diagnostics: [
           { code: "RUNTIME_SKILL_SCAN_UNSUPPORTED", message: SKILLS_SYNCED_BY_RUNTIME }
@@ -67914,7 +69425,7 @@ async function runSkills(argv) {
         );
       }
       writeJson({
-        attemptId: (0, import_node_crypto30.randomUUID)(),
+        attemptId: (0, import_node_crypto31.randomUUID)(),
         desiredRevision: await manifestRevision(manifest),
         skills: []
       });
@@ -67934,8 +69445,8 @@ async function runSkills(argv) {
 }
 
 // src/cli/commands/doctor.ts
-var import_promises68 = require("fs/promises");
-var import_node_path69 = require("path");
+var import_promises69 = require("fs/promises");
+var import_node_path70 = require("path");
 init_runtime_v2();
 
 // src/identity/credential.ts
@@ -68112,24 +69623,24 @@ async function authorizeDevice(input2) {
 }
 
 // src/identity/enroll.ts
-var import_promises66 = require("fs/promises");
+var import_promises67 = require("fs/promises");
 init_runtime_v2();
 
 // src/identity/installation.ts
-var import_node_crypto31 = require("crypto");
-var import_node_path66 = require("path");
+var import_node_crypto32 = require("crypto");
+var import_node_path67 = require("path");
 init_zod();
 var installationFileSchema = external_exports.object({
   installationId: external_exports.uuid()
 });
 function installationPath(paths) {
-  return (0, import_node_path66.join)(paths.stateDir, "installation.json");
+  return (0, import_node_path67.join)(paths.stateDir, "installation.json");
 }
 async function ensureInstallationId(paths) {
   const path4 = installationPath(paths);
   const existing = await readJsonFile(path4, installationFileSchema);
   if (existing.kind === "ok") return existing.value.installationId;
-  const created = { installationId: (0, import_node_crypto31.randomUUID)() };
+  const created = { installationId: (0, import_node_crypto32.randomUUID)() };
   await writeJsonFileAtomic(path4, created);
   return created.installationId;
 }
@@ -68216,13 +69727,13 @@ async function enrollFromGrantFile(input2) {
     clock: input2.clock,
     access: input2.access
   });
-  await (0, import_promises66.rm)(input2.grantPath, { force: true });
+  await (0, import_promises67.rm)(input2.grantPath, { force: true });
   return machine;
 }
 
 // src/identity/migrate-v1.ts
-var import_promises67 = require("fs/promises");
-var import_node_path67 = require("path");
+var import_promises68 = require("fs/promises");
+var import_node_path68 = require("path");
 init_runtime_v2();
 init_zod();
 var EXIT_POLL_MS = 200;
@@ -68243,11 +69754,11 @@ var ownerLeaseSchema = external_exports.looseObject({ pid: external_exports.numb
 function legacyConfigPath(home, profile) {
   switch (profile) {
     case "production":
-      return (0, import_node_path67.join)(home, ".alan", "agent", "config.json");
+      return (0, import_node_path68.join)(home, ".alan", "agent", "config.json");
     case "staging":
-      return (0, import_node_path67.join)(home, ".alan-staging", "agent", "config.json");
+      return (0, import_node_path68.join)(home, ".alan-staging", "agent", "config.json");
     default:
-      return (0, import_node_path67.join)(home, ".alan-dev", "agent", "config.json");
+      return (0, import_node_path68.join)(home, ".alan-dev", "agent", "config.json");
   }
 }
 async function findLegacyInstall(home, profile) {
@@ -68272,8 +69783,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_promises67.rm)(install2.configPath, { force: true });
-  await (0, import_promises67.rm)(install2.ownerLeasePath, { force: true });
+  await (0, import_promises68.rm)(install2.configPath, { force: true });
+  await (0, import_promises68.rm)(install2.ownerLeasePath, { force: true });
 }
 async function exchangeCredential(deps) {
   const { config: config2 } = deps.install;
@@ -68382,7 +69893,7 @@ async function loadIdentity(paths, options = {}) {
 }
 
 // src/cli/commands/status.ts
-var import_node_path68 = require("path");
+var import_node_path69 = require("path");
 async function serviceStatus(ctx) {
   try {
     return await createServiceManager(ctx.host, ctx.config.profile).status();
@@ -68409,7 +69920,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_path68.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE),
+    (0, import_node_path69.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE),
     localApiDiscoverySchema
   );
   const localApi = discovery.kind === "ok" && discovery.value.pid === running.pid ? {
@@ -68630,7 +70141,7 @@ async function runtimeCheck(ctx, status) {
     return check2("runtime", "warn", "No runtime is running for this profile");
   }
   const client = createRuntimeClient({
-    discoveryPath: (0, import_node_path69.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE)
+    discoveryPath: (0, import_node_path70.join)(ctx.paths.stateDir, LOCAL_API_DISCOVERY_FILE)
   });
   try {
     const live = await client.status(AbortSignal.timeout(LOCAL_TIMEOUT_MS));
@@ -68657,7 +70168,7 @@ async function runtimeCheck(ctx, status) {
   }
 }
 async function probeHolder(dir, conversationId) {
-  const launch = await readJsonFile((0, import_node_path69.join)(dir, "launch.json"), holderLaunchSchema);
+  const launch = await readJsonFile((0, import_node_path70.join)(dir, "launch.json"), holderLaunchSchema);
   if (launch.kind !== "ok") return null;
   try {
     const reply2 = await withTimeout(
@@ -68682,8 +70193,8 @@ async function probeHolder(dir, conversationId) {
   }
 }
 async function holdersCheck(ctx) {
-  const names = await (0, import_promises68.readdir)(ctx.paths.sessions).catch(() => []);
-  const holders = (await Promise.all(names.map((name) => probeHolder((0, import_node_path69.join)(ctx.paths.sessions, name), name)))).filter((facts) => facts !== null);
+  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 dead = holders.filter((holder) => !holder.alive).length;
   return check2(
     "holders",
@@ -68694,10 +70205,10 @@ async function holdersCheck(ctx) {
 }
 async function freeBytesAt(path4) {
   try {
-    const stats = await (0, import_promises68.statfs)(path4);
+    const stats = await (0, import_promises69.statfs)(path4);
     return { path: path4, freeBytes: stats.bavail * stats.bsize };
   } catch (error61) {
-    const parent = (0, import_node_path69.dirname)(path4);
+    const parent = (0, import_node_path70.dirname)(path4);
     if (parent === path4) throw error61;
     return freeBytesAt(parent);
   }
@@ -68833,7 +70344,7 @@ async function runDoctor(argv, context = cliContext) {
 }
 
 // src/cli/commands/git-credential.ts
-var import_promises69 = require("fs/promises");
+var import_promises70 = require("fs/promises");
 var import_node_net4 = require("net");
 var MAX_RESPONSE_BYTES = 64 * 1024;
 async function readAll(stream) {
@@ -68943,7 +70454,7 @@ async function configure(argv) {
 }
 async function configureGitGateway(config2, gatewayUrl, signal) {
   const { launcher } = installLayout(config2.installDir, config2.profile);
-  const installed = await (0, import_promises69.access)(launcher).then(
+  const installed = await (0, import_promises70.access)(launcher).then(
     () => true,
     () => false
   );
@@ -68970,7 +70481,7 @@ async function runGitCredential(argv) {
 }
 
 // src/cli/commands/hold.ts
-var import_node_path70 = require("path");
+var import_node_path71 = require("path");
 init_agent2();
 init_runtime_v2();
 async function machineAccess(paths, log, conversationId, transport) {
@@ -69028,7 +70539,7 @@ async function runHold(argv) {
     const config2 = loadRuntimeConfig();
     const paths = runtimePaths(config2.stateDir);
     const log = __using(_stack, openFileLog(
-      (0, import_node_path70.join)(paths.logs, `holder-${launch.value.conversationId}.jsonl`),
+      (0, import_node_path71.join)(paths.logs, `holder-${launch.value.conversationId}.jsonl`),
       config2.logLevel,
       systemClock
     ));
@@ -69039,7 +70550,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_path70.join)(paths.tmp, "mcp", `${launch.value.conversationId}.json`);
+    const credentialPath = (0, import_node_path71.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,
@@ -69079,7 +70590,7 @@ async function runHold(argv) {
 }
 
 // src/cli/commands/hook.ts
-var import_node_path71 = require("path");
+var import_node_path72 = require("path");
 var RUNTIME_ANSWER_MS = 2e3;
 var DEBUG_VARIABLE = "ALAN_HOOK_DEBUG";
 function flag(argv, name) {
@@ -69111,7 +70622,7 @@ async function forwardHook(argv, io) {
     return "transcript outside provider root";
   }
   const verdict = await io.send(
-    (0, import_node_path71.join)(io.stateDir, LOCAL_API_DISCOVERY_FILE),
+    (0, import_node_path72.join)(io.stateDir, LOCAL_API_DISCOVERY_FILE),
     hookSignal,
     AbortSignal.timeout(RUNTIME_ANSWER_MS)
   );
@@ -69147,7 +70658,7 @@ async function runHook(argv, overrides = {}) {
 }
 
 // src/cli/commands/ingestion-hooks.ts
-var import_promises70 = require("fs/promises");
+var import_promises71 = 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";
@@ -69170,7 +70681,7 @@ function errorMessage2(error61) {
   return error61 instanceof Error ? error61.message : String(error61);
 }
 async function exists5(path4) {
-  return (0, import_promises70.access)(path4).then(
+  return (0, import_promises71.access)(path4).then(
     () => true,
     () => false
   );
@@ -69273,10 +70784,10 @@ async function runIntegrationsCommand(argv) {
 }
 
 // src/cli/commands/legacy.ts
-var import_node_path73 = require("path");
+var import_node_path74 = require("path");
 
 // src/cli/commands/setup.ts
-var import_node_path72 = require("path");
+var import_node_path73 = require("path");
 init_zod();
 
 // src/cli/legacy.ts
@@ -69358,7 +70869,7 @@ async function grantFileCredential(argv, grantPath, ctx, deps) {
   return enrollFromGrantFile({
     paths: ctx.paths,
     storeKind: credentialStoreFlag(argv) ?? ctx.config.credentialStore,
-    grantPath: (0, import_node_path72.resolve)(grantPath),
+    grantPath: (0, import_node_path73.resolve)(grantPath),
     clock: deps.clock,
     access: ctx.access
   });
@@ -69434,7 +70945,7 @@ async function runSetup(argv, signal) {
   var _stack = [];
   try {
     const ctx = cliContext();
-    const log = __using(_stack, openFileLog((0, import_node_path72.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
+    const log = __using(_stack, openFileLog((0, import_node_path73.join)(ctx.paths.logs, "cli.jsonl"), ctx.config.logLevel, systemClock));
     const result = await setupMachine(argv, ctx, {
       enrollment: (apiUrl) => createEnrollmentClient({ apiUrl }),
       isProcessAlive,
@@ -69517,7 +71028,7 @@ async function runToken(argv, signal) {
       );
     }
     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 rotateMachineCredential(ctx, { clock: systemClock, log, signal });
     process.stdout.write(`${rotationMessage(result)}
 `);
@@ -69529,8 +71040,8 @@ async function runToken(argv, signal) {
 }
 
 // src/cli/commands/logout.ts
-var import_promises71 = require("fs/promises");
-var import_node_path74 = require("path");
+var import_promises72 = require("fs/promises");
+var import_node_path75 = require("path");
 init_runtime_v2();
 var RUNTIME_EXIT_WAIT_MS = 35e3;
 var TURN_END_WAIT_MS = 3e4;
@@ -69589,9 +71100,9 @@ async function stopHolder(launch, deps, outcome2) {
 }
 async function stopHeldRuns(ctx, deps, outcome2 = "aborted") {
   const stopped = [];
-  for (const name of await (0, import_promises71.readdir)(ctx.paths.sessions).catch(() => [])) {
+  for (const name of await (0, import_promises72.readdir)(ctx.paths.sessions).catch(() => [])) {
     const launch = await readJsonFile(
-      (0, import_node_path74.join)(ctx.paths.sessions, name, "launch.json"),
+      (0, import_node_path75.join)(ctx.paths.sessions, name, "launch.json"),
       holderLaunchSchema
     );
     if (launch.kind !== "ok") continue;
@@ -69628,13 +71139,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_promises71.rm)(ctx.paths.machine, { force: true });
+  await (0, import_promises72.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_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 logoutMachine(argv, ctx, {
       api: (apiUrl, accessToken) => createApiClient({ apiUrl, accessToken }),
       stopHeldRuns,
@@ -69651,7 +71162,8 @@ async function runLogout(argv, signal) {
 }
 
 // src/cli/commands/run.ts
-var import_node_path78 = require("path");
+var import_node_fs23 = require("fs");
+var import_node_path79 = require("path");
 
 // src/local-api/app-attachments.ts
 function createAppAttachments(clock) {
@@ -69685,7 +71197,9 @@ function createAppAttachments(clock) {
 // src/local-api/run-appends.ts
 function createRunAppends() {
   const waiters = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
   const wake = (runId) => {
+    for (const listener of listeners) listener(runId);
     const pending = waiters.get(runId);
     if (pending === void 0) return;
     waiters.delete(runId);
@@ -69693,8 +71207,17 @@ function createRunAppends() {
   };
   return {
     notify: wake,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return {
+        [Symbol.dispose]: () => {
+          listeners.delete(listener);
+        }
+      };
+    },
     notifyAll: () => {
       for (const runId of [...waiters.keys()]) wake(runId);
+      for (const listener of listeners) listener(null);
     },
     nextAppend: (runId, signal) => {
       if (signal.aborted) return Promise.resolve();
@@ -69716,18 +71239,18 @@ function createRunAppends() {
 }
 
 // src/local-api/server.ts
-var import_node_crypto33 = require("crypto");
-var import_promises72 = require("fs/promises");
+var import_node_crypto34 = require("crypto");
+var import_promises73 = require("fs/promises");
 var import_node_http4 = require("http");
-var import_node_path75 = require("path");
+var import_node_path76 = require("path");
 
 // src/local-api/guard.ts
-var import_node_crypto32 = require("crypto");
+var import_node_crypto33 = require("crypto");
 var ALLOWED = { kind: "allowed" };
 function tokenMatches2(expected, header) {
   if (header === void 0 || !header.startsWith("Bearer ")) return false;
   const presented = Buffer.from(header.slice("Bearer ".length));
-  return presented.length === expected.length && (0, import_node_crypto32.timingSafeEqual)(presented, expected);
+  return presented.length === expected.length && (0, import_node_crypto33.timingSafeEqual)(presented, expected);
 }
 function isBrowserReachable(req, allowedHosts) {
   if (req.headers.origin !== void 0 || req.headers.referer !== void 0) return true;
@@ -69835,6 +71358,283 @@ function requestSignal(res) {
 init_runtime_v2();
 init_zod();
 
+// src/local-api/conversation-messages.ts
+init_acp();
+init_runtime_v2();
+function applyLogLine(line, assistantMessageId, state) {
+  const raw = JSON.parse(line);
+  const record2 = runLogRecordSchema.safeParse(raw);
+  if (!record2.success) return null;
+  const kind = record2.data.update.sessionUpdate;
+  if (isRunLifecycleKind(kind)) {
+    const lifecycle = runLifecycleUpdateSchema.parse(record2.data.update);
+    if (lifecycle.sessionUpdate === "_alan/run.accepted") {
+      state.state = "running";
+      return false;
+    }
+    const ended = lifecycle.sessionUpdate === "_alan/run.ended";
+    applySessionEvent(state, {
+      seq: record2.data.seq,
+      at: record2.data.at,
+      update: {
+        sessionUpdate: "state_update",
+        state: ended ? "idle" : "running",
+        ...ended && {
+          stopReason: lifecycle.outcome === "aborted" || lifecycle.outcome === "interrupted" ? "cancelled" : "end_turn"
+        }
+      }
+    });
+    return ended;
+  }
+  const event = scopeTranscriptEvent({ ...record2.data, turnId: assistantMessageId });
+  if (!event) return null;
+  applySessionEvent(state, event);
+  return false;
+}
+function applyLogChunk(text2, assistantMessageId, state) {
+  let ended = false;
+  for (const line of text2.trimEnd().split("\n")) {
+    const applied = applyLogLine(line, assistantMessageId, state);
+    if (applied === null) throw new Error("Invalid local transcript record");
+    if (applied) ended = true;
+  }
+  return ended;
+}
+async function openLocalTurnProjection(runsDir, runId, conversationId, ordinal) {
+  const paths = runDirectory(runsDir, runId);
+  const meta3 = await readRunMeta(paths.meta);
+  if (!meta3?.userMessage || !meta3.assistantMessage || meta3.conversationId !== conversationId || meta3.userMessage.turnOrdinal !== ordinal)
+    return null;
+  const assistantMessageId = meta3.assistantMessage.id;
+  const state = emptyTranscript();
+  const promptAt = Date.parse(meta3.userMessage.createdAt);
+  applySessionEvent(state, {
+    seq: 0,
+    at: Number.isFinite(promptAt) ? promptAt : 0,
+    update: {
+      sessionUpdate: "user_message",
+      messageId: meta3.userMessage.id,
+      content: [{ type: "text", text: meta3.userMessage.content }],
+      _meta: {
+        ...meta3.userMessage.clientMessageId ? { "alan.dev/clientMessageId": meta3.userMessage.clientMessageId } : {},
+        ...meta3.agentMode ? { "alan.dev/agentMode": meta3.agentMode } : {},
+        ...meta3.userMessage.attachmentIds?.length ? { "alan.dev/attachmentIds": meta3.userMessage.attachmentIds } : {}
+      }
+    }
+  });
+  const reader = await openRunLogReader(paths.log).catch((error61) => {
+    if (error61.code === "ENOENT") return null;
+    throw error61;
+  });
+  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 current = await readState();
+      if (prepared?.state !== current)
+        prepared = { ...conversationTurnView(ordinal, current, prepared?.display), markdown: "" };
+      return prepared;
+    },
+    [Symbol.asyncDispose]: async () => {
+      await reader[Symbol.asyncDispose]();
+    }
+  };
+}
+async function projectLocalRun(runsDir, runId, conversationId, ordinal) {
+  var _stack = [];
+  try {
+    const projection = __using(_stack, await openLocalTurnProjection(runsDir, runId, conversationId, ordinal), true);
+    return projection ? await projection.read() : null;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    var _promise2 = __callDispose(_stack, _error, _hasError);
+    _promise2 && await _promise2;
+  }
+}
+async function readLocalConversationMessages(runsDir, conversationId, limit, before, projection) {
+  const coverage = await readConversationIndexCoverage(runsDir, conversationId);
+  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 !== coverage.lowestOrdinal) return null;
+  const selected = indexed.slice(0, limit);
+  if (selected.length === 0) return null;
+  const turns = await Promise.all(
+    selected.map(
+      (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);
+  return {
+    turns: compactConversationMessageTurns(completeTurns, before === void 0),
+    before: selected.at(-1)?.ordinal === 0 ? null : String(selected.at(-1)?.ordinal),
+    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;
+  if (slot.current?.ordinal === meta3.userMessage.turnOrdinal && slot.current.runId !== runId) {
+    const [latest] = await readConversationRunIndex(
+      deps.runsDir,
+      conversationId,
+      meta3.userMessage.turnOrdinal + 1,
+      1
+    );
+    if (latest?.runId !== runId) return null;
+  }
+  if (slot.current && meta3.userMessage.turnOrdinal < slot.current.ordinal) {
+    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(
+      deps.runsDir,
+      runId,
+      conversationId,
+      meta3.userMessage.turnOrdinal
+    );
+    await slot.current?.[Symbol.asyncDispose]();
+    slot.current = next;
+  }
+  if (!slot.current) throw new Error("Local transcript metadata is incomplete");
+  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, frames, res, signal) {
+  var _stack = [];
+  try {
+    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) bell.pending.add(changed);
+      bell.wake?.();
+    }));
+    signal.addEventListener("abort", () => bell.wake?.(), { once: true });
+    try {
+      const [newest] = await readConversationRunIndex(deps.runsDir, conversationId, void 0, 1);
+      if (newest)
+        slot.current = await openLocalTurnProjection(
+          deps.runsDir,
+          newest.runId,
+          conversationId,
+          newest.ordinal
+        );
+      const writer = {
+        frames,
+        encode: createLiveTurnFrameEncoder(),
+        res,
+        lastState: await slot.current?.readState()
+      };
+      const page = await readLocalConversationMessages(
+        deps.runsDir,
+        conversationId,
+        limit,
+        void 0,
+        slot.current ?? void 0
+      );
+      if (!page) {
+        sendError(res, 404, "not_found", "This computer has no complete local page");
+        return;
+      }
+      startEventStream(res);
+      await writeEvent(res, {
+        name: "snapshot",
+        id: page.revision,
+        dataLines: [JSON.stringify(page)]
+      });
+      while (!signal.aborted) {
+        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 {
+      await slot.current?.[Symbol.asyncDispose]();
+    }
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+
 // src/local-api/request.ts
 async function readBody3(request2, schema) {
   const body = await readJsonBody(request2.req);
@@ -70033,6 +71833,13 @@ async function followRunLogRoute(deps, runId, url3, res, signal) {
 
 // src/local-api/routes.ts
 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(),
+  runtimeId: external_exports.string().uuid().optional(),
+  frames: external_exports.enum(["turn", "patch"]).default("turn")
+});
 var emptyBodySchema = external_exports.object({});
 function activeRunIds(runs) {
   return runs.filter((run2) => run2.state !== "ended").map((run2) => run2.runId);
@@ -70252,6 +72059,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];
@@ -70279,6 +72124,9 @@ 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)
+    return routeConversationMessages(deps, request2, conversationMatch);
   sendError(request2.res, 404, "not_found", "Not found");
 }
 
@@ -70328,6 +72176,15 @@ var REQUEST_TIMEOUT_MS8 = 1e4;
 var KEEP_ALIVE_TIMEOUT_MS = 2e3;
 var ACTION_TIMEOUT_MS = 3e4;
 var PROVIDER_INSTALL_TIMEOUT_MS = 10 * 6e4;
+function localRequestSignal(path4, closed) {
+  if (path4.endsWith("/stream") || path4.endsWith("/sse")) return closed;
+  return AbortSignal.any([
+    closed,
+    AbortSignal.timeout(
+      path4 === LOCAL_API_ROUTES.providerInstall ? PROVIDER_INSTALL_TIMEOUT_MS : ACTION_TIMEOUT_MS
+    )
+  ]);
+}
 async function listenOnLoopback(server) {
   await new Promise((resolve12, reject) => {
     server.once("error", reject);
@@ -70372,11 +72229,12 @@ async function serveLocalApi(deps) {
   server.keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS;
   server.maxConnections = HARD_MAX_CONNECTIONS;
   const port = await listenOnLoopback(server);
-  const token = (0, import_node_crypto33.randomBytes)(32).toString("base64url");
+  const token = (0, import_node_crypto34.randomBytes)(32).toString("base64url");
   const guard = createRequestGuard({ token, port, rateLimit: limits.rateLimit, clock });
   const appAttachments = createAppAttachments(clock);
   const routeDeps = {
     feed,
+    readFacts: deps.readFacts,
     appAttachments,
     actions: deps.actions,
     runsDir: deps.runsDir,
@@ -70398,15 +72256,11 @@ async function serveLocalApi(deps) {
     inFlight += 1;
     const url3 = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
     const closed = requestSignal(res);
-    const signal = url3.pathname.endsWith("/stream") ? closed : AbortSignal.any([
-      closed,
-      AbortSignal.timeout(
-        url3.pathname === LOCAL_API_ROUTES.providerInstall ? PROVIDER_INSTALL_TIMEOUT_MS : ACTION_TIMEOUT_MS
-      )
-    ]);
+    const signal = localRequestSignal(url3.pathname, closed);
     try {
       await route(routeDeps, { req, res, url: url3, signal });
     } catch (error61) {
+      if (closed.aborted) return;
       log.warn("local_api.request_failed", { path: url3.pathname, error: error61 });
       sendError(res, 500, "internal", "The runtime could not complete the request");
     } finally {
@@ -70422,7 +72276,7 @@ async function serveLocalApi(deps) {
     startedAtMs,
     runtimeVersion: deps.runtimeVersion
   };
-  const discoveryPath = (0, import_node_path75.join)(deps.stateDir, LOCAL_API_DISCOVERY_FILE);
+  const discoveryPath = (0, import_node_path76.join)(deps.stateDir, LOCAL_API_DISCOVERY_FILE);
   await writeJsonFileAtomic(discoveryPath, discovery);
   const followers = startMaintenance({
     everyMs: limits.refreshEveryMs,
@@ -70456,7 +72310,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_promises72.rm)(discoveryPath, { force: true });
+        await (0, import_promises73.rm)(discoveryPath, { force: true });
       }
       await closeServer(server);
       log.info("local_api.closed", {});
@@ -70541,7 +72395,7 @@ function machineFeatureActions(deps) {
 }
 
 // src/cli/commands/machine-plane.ts
-var import_node_path77 = require("path");
+var import_node_path78 = require("path");
 
 // src/link/index.ts
 init_runtime_v2();
@@ -74209,7 +76063,7 @@ function refusalFailure(refusal2) {
 }
 
 // src/link/probe.ts
-var import_promises73 = require("dns/promises");
+var import_promises74 = require("dns/promises");
 var import_node_net5 = require("net");
 var import_node_tls2 = require("tls");
 var PROBE_TIMEOUT_MS4 = 5e3;
@@ -74245,7 +76099,7 @@ async function connectOnce(url3, clock) {
 }
 async function probeEndpoint(url3, clock) {
   try {
-    await (0, import_promises73.lookup)(url3.hostname);
+    await (0, import_promises74.lookup)(url3.hostname);
   } catch (error61) {
     const reason = classifyTransportFailure(error61);
     return reason === "other" ? "dns" : reason;
@@ -74368,8 +76222,12 @@ function connectLink(options) {
     const hello = await options.hello(connectEpoch);
     const ack = await socket.timeout(HELLO_TIMEOUT_MS).emitWithAck("hello", hello);
     await ready;
-    if (connectEpoch !== epoch) return;
+    if (connectEpoch !== epoch || !socket.connected) return;
     options.onHelloAck(helloAckSchema.parse(ack), connectEpoch);
+    retry.attempt = 0;
+    retry.credentialFailures = 0;
+    setState({ kind: "connected", epoch: connectEpoch });
+    log.info("link.connected", { epoch: connectEpoch });
   };
   const setState = (next) => {
     current = next;
@@ -74439,12 +76297,16 @@ function connectLink(options) {
   };
   socket.on("connect", () => {
     epoch += 1;
-    retry.attempt = 0;
-    retry.credentialFailures = 0;
+    const connectEpoch = epoch;
     cancelRedial();
-    setState({ kind: "connected", epoch });
-    log.info("link.connected", { epoch });
-    greet(epoch).catch((error61) => log.warn("link.hello_failed", { epoch, error: error61 }));
+    setState({ kind: "connecting", lastFailure: null });
+    greet(connectEpoch).catch((error61) => {
+      if (connectEpoch !== epoch || current.kind === "stopped" || !socket.connected) return;
+      log.warn("link.hello_failed", { epoch: connectEpoch, error: error61 });
+      recordTransportFailure("other", "The backend did not acknowledge this runtime");
+      socket.disconnect();
+      redialAfter(redialDelayMs(retry.attempt++));
+    });
   });
   socket.on("disconnect", (reason) => {
     log.info("link.disconnected", { reason });
@@ -74498,7 +76360,7 @@ function connectLink(options) {
     void ready.then(() => answerModelsScan(raw, options.scanModels, log)).then((result) => ack(result));
   });
   const pushCapabilities = async (capabilities) => {
-    if (!socket.connected) return false;
+    if (current.kind !== "connected" || !socket.connected) return false;
     try {
       const ack = await socket.timeout(CAPABILITIES_ACK_TIMEOUT_MS).emitWithAck("capabilities", capabilities);
       const parsed = capabilitiesAckSchema.safeParse(ack);
@@ -74547,9 +76409,9 @@ function planReconcile(desired, held) {
 }
 
 // src/reconciler/desired-sync.ts
-var import_node_crypto34 = require("crypto");
+var import_node_crypto35 = require("crypto");
 function fingerprintOf(desired) {
-  return (0, import_node_crypto34.createHash)("sha256").update(JSON.stringify(desired)).digest("hex");
+  return (0, import_node_crypto35.createHash)("sha256").update(JSON.stringify(desired)).digest("hex");
 }
 var FAILED_READ_RETRY_MS = 3e4;
 function createDesiredSync(deps) {
@@ -74686,7 +76548,7 @@ function createReconciler(host, lifecycle, log, signal) {
 }
 
 // src/uploader/index.ts
-var import_promises74 = require("fs/promises");
+var import_promises75 = require("fs/promises");
 init_runtime_v2();
 init_zod();
 var RETRY_DELAYS_MS = [250, 500, 1e3, 2e3, 5e3, 1e4, 3e4];
@@ -74717,12 +76579,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;
@@ -74827,7 +76692,7 @@ function startUploader({ api, runsDir, clock, log }) {
     active.set(runId, task);
   };
   const sweep2 = async () => {
-    for (const name of await (0, import_promises74.readdir)(runsDir).catch(() => [])) {
+    for (const name of await (0, import_promises75.readdir)(runsDir).catch(() => [])) {
       const runId = runIdSchema.safeParse(name);
       if (runId.success) run2(runId.data);
     }
@@ -74837,18 +76702,18 @@ function startUploader({ api, runsDir, clock, log }) {
     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_promises74.stat)(dir.upload)).mtimeMs;
+    const sealedAt = (await (0, import_promises75.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_promises74.readdir)(runsDir).catch(() => [])) {
+    for (const name of await (0, import_promises75.readdir)(runsDir).catch(() => [])) {
       const runId = runIdSchema.safeParse(name);
       if (!runId.success) continue;
       try {
         if (!await isPrunable(runId.data, options)) continue;
-        await (0, import_promises74.rm)(runDirectory(runsDir, runId.data).dir, { recursive: true, force: true });
+        await (0, import_promises75.rm)(runDirectory(runsDir, runId.data).dir, { recursive: true, force: true });
         removed += 1;
       } catch (error61) {
         log.warn("upload.prune_failed", { runId: runId.data, error: error61 });
@@ -74972,6 +76837,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,
@@ -74988,13 +76875,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,
@@ -75030,12 +76911,12 @@ async function startMachineNativeIngest(deps) {
 }
 
 // src/cli/commands/run-updates.ts
-var import_node_path76 = require("path");
+var import_node_path77 = 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_path76.resolve)((0, import_node_path76.dirname)((0, import_node_path76.dirname)(bundlePath))) === (0, import_node_path76.resolve)(layout.versions);
+  return (0, import_node_path77.resolve)((0, import_node_path77.dirname)((0, import_node_path77.dirname)(bundlePath))) === (0, import_node_path77.resolve)(layout.versions);
 }
 async function settleUpgradeOnStart({
   layout,
@@ -75142,7 +77023,7 @@ function startRuntimeUpdates(options) {
       layout,
       release: npmRelease,
       tarball: await options.downloader.download(npmRelease.dist.tarball, signal),
-      tmpDir: (0, import_node_path76.join)(layout.root, ".downloads")
+      tmpDir: (0, import_node_path77.join)(layout.root, ".downloads")
     });
     await lifecycle.exclusive("upgrade", async () => {
       await recordPendingUpgrade(layout, currentVersion2, version2, clock.now());
@@ -75367,7 +77248,7 @@ async function startMachinePlane(deps) {
                 [ALAN_MANAGED_SESSION_ENV]: "1"
               },
               cwd: paths.stateDir,
-              outputPath: (0, import_node_path77.join)(paths.logs, "holders.log")
+              outputPath: (0, import_node_path78.join)(paths.logs, "holders.log")
             },
             deps.holderIsolation
           );
@@ -75598,7 +77479,7 @@ async function startMachinePlane(deps) {
             git: createGitRunner({ env: cliEnvironment }),
             clock,
             log,
-            dir: (0, import_node_path77.join)(paths.stateDir, "checkout-freshness")
+            dir: (0, import_node_path78.join)(paths.stateDir, "checkout-freshness")
           },
           stopped.signal
         );
@@ -75892,23 +77773,28 @@ function lockWaitMs(argv) {
 }
 async function openManagedProviders(config2, paths) {
   const providerEnv = readCliEnvironment();
-  const npmPath = config2.providerToolchain?.node ?? await resolveCommandOnPath("npm", providerEnv, process.platform);
-  const npmOptions = npmPath === null ? null : {
+  const bundledNpm = (0, import_node_path79.join)((0, import_node_path79.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 : {
     command: npmPath,
-    ...config2.providerToolchain === null ? {} : { argsBeforeNpm: [config2.providerToolchain.npmCli] },
+    ...providerToolchain === null ? {} : { argsBeforeNpm: [providerToolchain.npmCli] },
     env: providerEnv
   };
-  const providerNodeDir = config2.providerToolchain?.node === void 0 ? void 0 : (0, import_node_path78.join)(config2.providerToolchain.node, "..");
-  const providerProbeEnv = providerNodeDir === void 0 ? providerEnv : { ...providerEnv, PATH: `${providerNodeDir}:${providerEnv.PATH ?? ""}` };
+  const providerNodeDir = providerToolchain?.node === void 0 ? void 0 : (0, import_node_path79.dirname)(providerToolchain.node);
+  const probeEnv = providerNodeDir === void 0 ? providerEnv : {
+    ...providerEnv,
+    PATH: `${providerNodeDir}${pathDelimiter(process.platform)}${envValue(providerEnv, "PATH")}`
+  };
+  const canonicalProbeEnv = process.platform === "win32" ? canonicalWindowsEnvironment(probeEnv) : probeEnv;
+  const unavailable = async () => {
+    throw new Error("Provider installer is unavailable on this computer");
+  };
   const managed = createManagedProviderClis({
-    root: (0, import_node_path78.join)(paths.stateDir, "provider-clis"),
-    resolveVersion: npmOptions === null ? async () => {
-      throw new Error("Provider installer is unavailable on this computer");
-    } : createNpmVersionResolver(npmOptions),
-    installPackage: npmOptions === null ? async () => {
-      throw new Error("Provider installer is unavailable on this computer");
-    } : createNpmPackageInstaller(npmOptions),
-    probe: (executable, backendKind) => probeManagedProvider(executable, backendKind, providerProbeEnv)
+    root: (0, import_node_path79.join)(paths.stateDir, "provider-clis"),
+    resolveVersion: npmOptions === null ? unavailable : createNpmVersionResolver(npmOptions),
+    installPackage: npmOptions === null ? unavailable : createNpmPackageInstaller(npmOptions),
+    probe: (executable, backendKind) => probeManagedProvider(executable, backendKind, canonicalProbeEnv)
   });
   await managed.load();
   return { managed, providerNodeDir };
@@ -75937,7 +77823,7 @@ async function runService(argv, stop, restart = new AbortController().signal) {
       waitMs: lockWaitMs(argv),
       signal: stop
     }));
-    const log = __using(_stack, openFileLog((0, import_node_path78.join)(paths.logs, "runtime.jsonl"), config2.logLevel, clock));
+    const log = __using(_stack, openFileLog((0, import_node_path79.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] ?? "";
@@ -75971,7 +77857,7 @@ async function runService(argv, stop, restart = new AbortController().signal) {
         openCliEnvironment({
           env: readCliEnvironment(),
           platform: process.platform,
-          lastKnownGoodFile: (0, import_node_path78.join)(paths.stateDir, "login-path.json"),
+          lastKnownGoodFile: (0, import_node_path79.join)(paths.stateDir, "login-path.json"),
           clock,
           decorate: (env) => withPackagedAlanCodeEngine(env, bundlePath, process.platform)
         })
@@ -76148,17 +78034,17 @@ async function runServiceCommand(argv, ctx = cliContext()) {
 }
 
 // src/cli/commands/upgrade.ts
-var import_promises75 = require("fs/promises");
-var import_node_path79 = require("path");
+var import_promises76 = require("fs/promises");
+var import_node_path80 = 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_promises75.stat)(from)).isFile();
-  const downloads = (0, import_node_path79.join)(layout.root, ".downloads");
-  if (isTarball) await (0, import_promises75.mkdir)(downloads, { recursive: true, mode: 448 });
-  const scratch = isTarball ? await (0, import_promises75.mkdtemp)((0, import_node_path79.join)(downloads, "upgrade-")) : null;
+  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;
   try {
     const sourceDir = scratch === null ? from : await extractPackageTarball(from, scratch);
     const version2 = await readPackageVersion(sourceDir);
@@ -76166,7 +78052,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_promises75.rm)(scratch, { recursive: true, force: true });
+    if (scratch !== null) await (0, import_promises76.rm)(scratch, { recursive: true, force: true });
   }
 }
 async function runUpgrade(argv) {
@@ -76178,7 +78064,7 @@ async function runUpgrade(argv) {
   const layout = installLayout(config2.installDir, config2.profile);
   const outcome2 = await installFromSource({
     layout,
-    from: (0, import_node_path79.resolve)(from),
+    from: (0, import_node_path80.resolve)(from),
     ifNewer: hasFlag(argv, "--if-newer")
   });
   if (outcome2.kind === "skipped") {