@alan-ai-hq/agent-manager 0.1.122 → 0.1.123

package/dist/index.cjs

@@ -33429,6 +33429,13 @@ var activeRunSlotSchema = external_exports.object({
   awaitingUser: external_exports.boolean().optional(),
   stale: external_exports.boolean().optional()
 });
+var MAX_REPORTED_TRANSCRIPT_SYNC_RUNS = 50;
+var transcriptSyncPendingRunSchema = external_exports.object({
+  runId: external_exports.uuid(),
+  conversationId: external_exports.uuid(),
+  problemStatus: external_exports.number().int().optional(),
+  problemPermanent: external_exports.boolean().optional()
+});
 var RUNNER_CAPACITY_SOURCES = ["default", "config", "provider_limit"];
 var DEFAULT_MAX_ACTIVE_RUNS = 4;
 var MIN_MAX_ACTIVE_RUNS = 1;
@@ -33444,6 +33451,8 @@ var runtimeRunnerStatusSchema = external_exports.object({
   restartRecommended: external_exports.boolean(),
   activeRuns: external_exports.array(activeRunSlotSchema),
   interruptedRunIds: external_exports.array(external_exports.uuid()).optional(),
+  // A malformed backlog must not discard the rest of the heartbeat.
+  transcriptSyncPending: external_exports.array(transcriptSyncPendingRunSchema).max(MAX_REPORTED_TRANSCRIPT_SYNC_RUNS).optional().catch(void 0),
   activeRunCount: external_exports.number().int().nonnegative(),
   staleRunCount: external_exports.number().int().nonnegative(),
   /**
@@ -34913,10 +34922,28 @@ function resolveWindowsCodexNativeExecutable(executable) {
   }
   return executable;
 }
+function promoteAheadOfVersionManagers(path2, promoted, versionManagerDirs) {
+  const managed = new Set(versionManagerDirs);
+  const firstManaged = path2.findIndex((dir) => managed.has(dir));
+  if (firstManaged === -1) return path2;
+  const before = path2.slice(0, firstManaged);
+  const tail = path2.slice(firstManaged);
+  const moved = tail.filter((dir) => promoted.has(dir));
+  if (moved.length === 0) return path2;
+  return [...before, ...moved, ...tail.filter((dir) => !promoted.has(dir))];
+}
+function promotedUserBinDirs(home) {
+  return /* @__PURE__ */ new Set([
+    (0, import_node_path5.join)(home, ".local", "bin"),
+    (0, import_node_path5.join)(home, ".bun", "bin"),
+    (0, import_node_path5.join)(home, ".cargo", "bin")
+  ]);
+}
 function augmentCliPath2(env, includeSystemPaths = true) {
   const home = env.HOME || env.USERPROFILE || (0, import_node_os4.homedir)();
   const isWin = (0, import_node_os4.platform)() === "win32";
   const windowsLocalAppData = env.LOCALAPPDATA || (0, import_node_path5.join)(home, "AppData", "Local");
+  const versionManagerDirs = isWin ? [] : resolveVersionManagerBinDirs(home);
   const userPaths = isWin ? [
     (0, import_node_path5.join)(home, "AppData", "Roaming", "npm"),
     (0, import_node_path5.join)(windowsLocalAppData, "Programs", "OpenAI", "Codex", "bin"),
@@ -34930,18 +34957,17 @@ function augmentCliPath2(env, includeSystemPaths = true) {
     // nvm/fnm/volta/asdf/mise live behind shell functions and leave nothing
     // on a non-interactive PATH, so resolve them from disk. Without this a
     // degraded shell probe hides node entirely and `env node` hooks die 127.
-    ...resolveVersionManagerBinDirs(home)
+    ...versionManagerDirs
   ];
   const systemPaths = isWin ? ["C:\\Program Files\\nodejs", "C:\\Program Files\\Git\\cmd"] : ["/opt/homebrew/bin", "/usr/local/bin"];
   const extraPaths = includeSystemPaths ? [...userPaths, ...systemPaths] : userPaths;
   const basePath = env.PATH ?? "";
   const existing = new Set(splitPath3(basePath));
   const missing = extraPaths.filter((dir) => !existing.has(dir));
-  if (missing.length === 0) return env;
-  return {
-    ...env,
-    PATH: missing.length > 0 ? `${missing.join(pathSeparator())}${pathSeparator()}${basePath}` : basePath
-  };
+  const combined = missing.length > 0 ? [...missing, ...splitPath3(basePath)] : splitPath3(basePath);
+  const ordered = isWin ? combined : promoteAheadOfVersionManagers(combined, promotedUserBinDirs(home), versionManagerDirs);
+  if (ordered === combined && missing.length === 0) return env;
+  return { ...env, PATH: ordered.join(pathSeparator()) };
 }
 function resolveCliExecutable(command, env) {
   const trimmed4 = command.trim();
@@ -35245,7 +35271,7 @@ function buildComputerReadiness(input2) {
 }
 
 // src/version.ts
-var AGENT_VERSION = "0.1.122";
+var AGENT_VERSION = "0.1.123";
 
 // src/daemon/status.ts
 var PENDING_RUN_START_TTL_MS = 10 * 6e4;
@@ -35348,6 +35374,10 @@ function buildAbortResult(reason) {
     errorKind: reason
   };
 }
+function abortResultFor(reason, sessionId) {
+  const result = buildAbortResult(reason);
+  return sessionId ? { ...result, providerSessionId: sessionId, runtimeSessionId: sessionId } : result;
+}
 function abortActiveAgent(entry, options) {
   const awaitingAsk = entry.runHost.pendingAskUserToolIds.size > 0;
   const reason = options?.reason ?? (options?.userInitiated ? "user" : "runner_stalled");
@@ -35355,7 +35385,7 @@ function abortActiveAgent(entry, options) {
     return;
   }
   entry.cleanupState = "stopping";
-  entry.runHost.onComplete(buildAbortResult(reason));
+  entry.runHost.onComplete(abortResultFor(reason, entry.runHost.sessionId));
   entry.agent.kill();
 }
 function isProviderProcessAlive(pid) {
@@ -35444,6 +35474,7 @@ function buildRunnerStatusPayload(input2) {
     restartRecommended: false,
     activeRuns,
     interruptedRunIds: input2.interruptedRunIds ?? [],
+    transcriptSyncPending: input2.transcriptSyncPending ?? [],
     activeRunCount,
     staleRunCount,
     maxActiveRuns,
@@ -35512,7 +35543,7 @@ function reconcileActiveRuns(input2) {
     const verdict = reconcileVerdict(entry, nowMs);
     if (verdict.action === "keep") continue;
     if (verdict.action === "finalize_for_resume") {
-      entry.runHost.onComplete(buildAbortResult("provider_exited"));
+      entry.runHost.onComplete(abortResultFor("provider_exited", entry.runHost.sessionId));
       entry.agent.kill();
       releaseAfterCleanup(input2.activeAgents, runId, entry);
       input2.pushLog?.(
@@ -35570,7 +35601,8 @@ function runnerStateFingerprint(summary) {
     summary.staleRunCount,
     summary.runnerStatus.primaryMessage ?? "",
     readiness,
-    [...summary.activeRunIds].sort().join(",")
+    [...summary.activeRunIds].sort().join(","),
+    (summary.runnerStatus.transcriptSyncPending ?? []).map((run) => `${run.runId}:${run.problemStatus ?? ""}`).sort().join(",")
   ].join("|");
 }
 
@@ -40153,20 +40185,36 @@ function providerModelCacheKey(provider, executable) {
   return `${provider}:${executable}`;
 }
 var providerVersionCache = /* @__PURE__ */ new Map();
+var providerRunCache = /* @__PURE__ */ new Map();
 var providerModelCache = /* @__PURE__ */ new Map();
 var providerAvailabilitySeen = /* @__PURE__ */ new Set();
 var providerProbesInFlight = /* @__PURE__ */ new Map();
 var providerModelProbesInFlight = /* @__PURE__ */ new Map();
 var VERSION_REFRESH_INTERVAL_MS = 20 * 60 * 1e3;
+function firstNonEmptyLine(text2) {
+  return text2.split("\n").map((line) => line.trim()).find((line) => line.length > 0);
+}
 function refreshSingleProviderVersion(provider, executable, env) {
   const inFlight = providerProbesInFlight.get(provider);
   if (inFlight) return inFlight;
   const probe = (async () => {
     try {
       const result = await runCliVersionProbeAsync(executable, env);
-      if (result.error || result.status !== 0) return;
-      const version2 = (result.stdout || result.stderr).split("\n")[0]?.trim();
-      if (version2) providerVersionCache.set(provider, version2);
+      if (result.error || result.signal || typeof result.status !== "number") {
+        providerRunCache.delete(provider);
+        return;
+      }
+      const firstLine3 = firstNonEmptyLine(result.stdout) ?? firstNonEmptyLine(result.stderr);
+      if (result.status !== 0) {
+        providerRunCache.set(provider, {
+          status: "cannot_start",
+          ...firstLine3 ? { message: firstLine3 } : {},
+          checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return;
+      }
+      if (firstLine3) providerVersionCache.set(provider, firstLine3);
+      providerRunCache.set(provider, { status: "ready", checkedAt: (/* @__PURE__ */ new Date()).toISOString() });
     } finally {
       providerProbesInFlight.delete(provider);
     }
@@ -40278,10 +40326,12 @@ function discoverCapabilities() {
         void refreshSingleProviderVersion(provider, executable, env);
       } else if (!available) {
         providerAvailabilitySeen.delete(provider);
+        providerRunCache.delete(provider);
       }
       const version2 = providerVersionCache.get(provider);
       const modelDiscovery = executable ? providerModelCache.get(providerModelCacheKey(provider, executable)) : void 0;
       const auth = !available ? void 0 : provider === ALAN_CODE_PROVIDER_KIND ? { status: "ready", checkedAt: now } : providerAuthCache.get(provider);
+      const run = available ? providerRunCache.get(provider) : void 0;
       return {
         provider,
         available,
@@ -40297,6 +40347,11 @@ function discoverCapabilities() {
           authStatus: auth.status,
           ...auth.message ? { authMessage: auth.message } : {},
           authCheckedAt: auth.checkedAt
+        } : {},
+        ...run ? {
+          runStatus: run.status,
+          ...run.message ? { runMessage: run.message } : {},
+          runCheckedAt: run.checkedAt
         } : {}
       };
     }),
@@ -43410,21 +43465,23 @@ var import_os3 = require("os");
 var import_path7 = require("path");
 var import_promises3 = require("fs/promises");
 var import_path8 = require("path");
+var import_promises4 = require("fs/promises");
+var import_path9 = require("path");
 var import_crypto4 = require("crypto");
 var import_crypto5 = require("crypto");
 var import_fs9 = require("fs");
 var import_os4 = require("os");
-var import_path9 = require("path");
+var import_path10 = require("path");
 var import_url2 = require("url");
 var import_child_process6 = require("child_process");
 var import_util14 = require("util");
 var import_os5 = require("os");
-var import_path10 = require("path");
+var import_path11 = require("path");
 var import_url3 = require("url");
 var import_fs10 = require("fs");
 var import_fs11 = require("fs");
 var import_fs12 = require("fs");
-var import_path11 = require("path");
+var import_path12 = require("path");
 var import_crypto6 = require("crypto");
 
 // ../shared/dist/constants/local-workspace.js
@@ -43437,16 +43494,19 @@ function isAlanDefaultWorkspace(value2) {
 var import_crypto7 = require("crypto");
 var import_fs13 = require("fs");
 var import_os6 = require("os");
-var import_path12 = require("path");
-var import_fs14 = require("fs");
 var import_path13 = require("path");
+var import_fs14 = require("fs");
+var import_path14 = require("path");
 var import_fs15 = require("fs");
 var import_os7 = require("os");
-var import_path14 = require("path");
-var import_child_process7 = require("child_process");
+var import_path15 = require("path");
 var import_fs16 = require("fs");
 var import_os8 = require("os");
-var import_path15 = require("path");
+var import_path16 = require("path");
+var import_child_process7 = require("child_process");
+var import_fs17 = require("fs");
+var import_os9 = require("os");
+var import_path17 = require("path");
 function createGrammarState() {
   return { seenToolCallIds: /* @__PURE__ */ new Set(), counter: 0, scratch: {} };
 }
@@ -43891,6 +43951,7 @@ var CLI_PROBLEM_CODE_BY_ERROR_KIND = {
   network: "cli.unknown",
   provider_timeout: "cli.process.timeout",
   resume_failed: "cli.resume_failed",
+  history_rejected: "cli.resume_failed",
   permission_denied: "cli.tool.failed",
   interpreter_missing: "cli.process.not_found",
   out_of_memory: "cli.process.nonzero_exit",
@@ -43986,6 +44047,10 @@ var ERROR_SPECS = {
     message: "The previous session could not be resumed \u2014 its stored session was missing or expired. The next message starts a fresh session without earlier context.",
     recoveryClass: "retry"
   },
+  history_rejected: {
+    message: "The provider rejected this session's stored history, so it could not be continued. The next message starts a fresh session with the recent conversation re-included.",
+    recoveryClass: "retry"
+  },
   permission_denied: {
     message: "Permission denied. Check file or command permissions on the runtime.",
     recoveryClass: "needs_env"
@@ -44060,6 +44125,7 @@ function normalizeCodexCliErrorMessage(message) {
   }
   return message;
 }
+var NAMED_SESSION_NOT_FOUND = /\b(?:session|chat|conversation)\s+(?:"[^"\n]{1,160}"|'[^'\n]{1,160}'|[\w-]{6,})\s+not found\b/;
 function classifyCliErrorDetailed(stderr, exitCode, opts) {
   const normalizedCodexError = normalizeCodexCliErrorMessage(stderr);
   if (normalizedCodexError !== stderr) {
@@ -44088,7 +44154,28 @@ function classifyCliErrorDetailed(stderr, exitCode, opts) {
     return specForErrorKind("usage_limit");
   if (has("creditserror", "no payment method")) return specForErrorKind("subscription_required");
   if (has("datapolicyerror", "requires explicit opt in")) return specForErrorKind("model_mismatch");
-  if (has("no chat found", "chat not found", "session not found", "could not resume"))
+  if (has(
+    "text content blocks must be non-empty",
+    "content field in the message object",
+    "ids were found without `tool_result` blocks",
+    "ids were found without tool_result blocks",
+    "unexpected `tool_use_id`",
+    "unexpected tool_use_id",
+    "tool use concurrency issues",
+    "no tool output found for",
+    "does not support assistant message prefill"
+  ))
+    return specForErrorKind("history_rejected");
+  if (has(
+    "no chat found",
+    "chat not found",
+    "session not found",
+    "could not resume",
+    "no conversation found",
+    "no rollout found",
+    "no session, task, or name matched",
+    "conversation not found"
+  ) || NAMED_SESSION_NOT_FOUND.test(haystack))
     return specForErrorKind("resume_failed");
   if (has("rate_limit", "rate limit", "resource_exhausted", "resource exhausted") || /\b429\b/.test(haystack))
     return specForErrorKind("rate_limited");
@@ -44714,14 +44801,6 @@ function settleControlRequest(kind, state, requestId) {
   }
 }
 function deferOrFinalizeStructuredResult(kind, _context, state) {
-  const pendingAsks = state.pendingAskUserToolIds?.size ?? 0;
-  if (pendingAsks > 0) {
-    console.info(
-      `[${kind}] Keeping stdin open \u2014 ${pendingAsks} interactive question(s) awaiting user response`
-    );
-    state.resultDeferredOnPendingAnswer = true;
-    return "deferred_pending_answer";
-  }
   const activeBackgroundTasks = state.activeBackgroundTaskIds?.size ?? 0;
   if (activeBackgroundTasks > 0) {
     console.info(
@@ -44734,17 +44813,12 @@ function deferOrFinalizeStructuredResult(kind, _context, state) {
   return "finalized";
 }
 function maybeFinalizeDeferredResult(kind, _context, state) {
-  if (!state.resultDeferredOnBackgroundWork && !state.resultDeferredOnPendingAnswer) return;
-  if (state.pendingAskUserToolIds?.size || state.activeBackgroundTaskIds?.size) return;
-  if (state.resultDeferredOnBackgroundWork) {
-    state.awaitingPostBackgroundSynthesis = true;
-    console.info(
-      `[${kind}] Background work drained \u2014 awaiting post-subagent synthesis before stdin close`
-    );
-    return;
-  }
-  state.resultDeferredOnPendingAnswer = false;
-  finalizeStructuredResult(kind, state);
+  if (!state.resultDeferredOnBackgroundWork) return;
+  if (state.activeBackgroundTaskIds?.size) return;
+  state.awaitingPostBackgroundSynthesis = true;
+  console.info(
+    `[${kind}] Background work drained \u2014 awaiting post-subagent synthesis before stdin close`
+  );
 }
 function logResumeObservability(event, fields) {
   console.info(`[agent-resume] ${event}`, { event, ...fields });
@@ -44771,12 +44845,6 @@ function buildCliResult(facts, identity, state) {
 function cliProblemScope(context) {
   return context.config.conversationId ? { conversationId: context.config.conversationId } : {};
 }
-var IDLE_TIMEOUT_MESSAGES = {
-  background_task: "Agent timed out waiting for a background task to finish \u2014 no terminal event arrived, so the run was stopped. Send your message again to continue.",
-  post_subagent_synthesis: "Agent timed out waiting for a post-subagent summary \u2014 synthesis did not finish, so the run was stopped. Send your message again to continue.",
-  post_startup_silence: "The agent went silent and stopped responding, so the run was stopped. Send your message again to retry.",
-  pending_user_answer: "Agent timed out waiting for your answer to its question \u2014 no response arrived, so the run was stopped. Send your reply as a new message to continue."
-};
 function timeoutProblem(closing, message, phase) {
   const { options, context, observed } = closing;
   return createCliProblem(
@@ -44874,44 +44942,6 @@ function startupTimeoutResult(closing) {
     state
   );
 }
-async function idleTimeoutResult(closing) {
-  const { options, context, state, observed } = closing;
-  if (!observed.idleTimedOut) return null;
-  console.error(`[${options.kind}] Process force-killed after idle timeout`, {
-    stderrLines: observed.recentStderrLines,
-    summaryPreview: state.summary.slice(0, 200),
-    runtimeSessionId: state.runtimeSessionId
-  });
-  await options.afterExit?.(context, state);
-  if (hasRenderableTurn(state)) emitTurnEnd(context, state);
-  const deferred = deferredBackgroundSummary(closing);
-  if (deferred) {
-    console.warn(
-      `[${options.kind}] Finalizing deferred result after background-task idle timeout \u2014 turn content was already delivered`
-    );
-    return buildCliResult({ success: true, summary: deferred }, options, state);
-  }
-  const message = observed.idleTimeoutReason ? IDLE_TIMEOUT_MESSAGES[observed.idleTimeoutReason] : IDLE_TIMEOUT_MESSAGES.pending_user_answer;
-  return buildCliResult(
-    {
-      success: false,
-      summary: state.summary.trim() || "Agent execution timed out",
-      error: message,
-      errorKind: "provider_timeout",
-      recoveryClass: "retry",
-      problem: timeoutProblem(closing, message, "stream")
-    },
-    options,
-    state
-  );
-}
-function deferredBackgroundSummary(closing) {
-  const { state, observed } = closing;
-  const waitingOnBackground = observed.idleTimeoutReason === "background_task" || observed.idleTimeoutReason === "post_subagent_synthesis";
-  if (!waitingOnBackground) return "";
-  if (!state.resultDeferredOnBackgroundWork && !state.awaitingPostBackgroundSynthesis) return "";
-  return state.summary.trim();
-}
 function hasRenderableTurn(state) {
   return state.summary.trim().length > 0 || state.iterations > 0;
 }
@@ -44920,8 +44950,13 @@ function backgroundStillActive(state) {
 }
 function observeClose(closing) {
   const { state, observed } = closing;
+  const backgroundActive = backgroundStillActive(state);
   return {
-    midSubagentParentExit: !observed.idleTimedOut && !observed.startupTimedOut && backgroundStillActive(state),
+    // A turn we ended because its result had already been delivered is cleanup, not a
+    // parent that died on its subagents. The content reached the reader, so only a
+    // provider that left on its own with work outstanding fails the run.
+    midSubagentParentExit: backgroundActive && !observed.startupTimedOut && state.exitGraceKillTriggered !== true,
+    abandonedBackgroundWork: backgroundActive,
     activeBackgroundTaskCount: state.activeBackgroundTaskIds?.size ?? 0
   };
 }
@@ -44980,8 +45015,6 @@ function logProcessClose(closing, facts) {
     activeBackgroundTaskCount: facts.activeBackgroundTaskCount,
     activeBackgroundTaskIds: [...state.activeBackgroundTaskIds ?? []].slice(0, 8),
     pendingAskCount: state.pendingAskUserToolIds?.size ?? 0,
-    idleTimedOut: observed.idleTimedOut,
-    idleTimeoutReason: observed.idleTimeoutReason,
     startupTimedOut: observed.startupTimedOut,
     midSubagentParentExit: facts.midSubagentParentExit,
     runtimeSessionId: state.runtimeSessionId
@@ -45112,28 +45145,30 @@ function failureProblem(closing, verdict, failure2) {
     }
   );
 }
-function summaryFor(state, verdict) {
+function summaryFor(state, verdict, failureMessage) {
   const reported = state.summary.trim() || state.error?.trim();
   if (reported) return reported;
   if (!verdict.failed) return "Task completed";
+  if (failureMessage?.trim()) return failureMessage.trim();
   return verdict.midSubagentParentExit ? "Background agents interrupted" : "Task failed";
 }
 async function closedRunResult(closing, silentResumeFork) {
   const { options, context, state } = closing;
   const facts = observeClose(closing);
   const diagnostics = logProcessClose(closing, facts);
-  if (facts.midSubagentParentExit) settleAbandonedSubagents(closing, diagnostics);
+  if (facts.abandonedBackgroundWork) settleAbandonedSubagents(closing, diagnostics);
   await options.afterExit?.(context, state);
   if (hasRenderableTurn(state)) emitTurnEnd(context, state);
   const verdict = judge(closing, facts);
   if (silentResumeFork && !verdict.failed) return resumeFailedResult(closing);
-  const summary = summaryFor(state, verdict);
-  if (!verdict.failed) return buildCliResult({ success: true, summary }, options, state);
+  if (!verdict.failed) {
+    return buildCliResult({ success: true, summary: summaryFor(state, verdict) }, options, state);
+  }
   const failure2 = withRequiredResumeId(explainFailure(closing, verdict), context);
   return buildCliResult(
     {
       success: false,
-      summary,
+      summary: summaryFor(state, verdict, failure2.error),
       error: failure2.error,
       errorKind: failure2.errorKind,
       recoveryClass: failure2.recoveryClass,
@@ -45525,9 +45560,7 @@ var TEXT_TIER_MESSAGE_ID = "cli-stdout";
 var CLI_STDERR_TAIL_CHARS = 256 * 1024;
 var SPAWN_OUTCOME_TIMEOUT_MS = 2e3;
 var RESULT_EXIT_GRACE_MS = 5e3;
-var IDLE_KILL_EXIT_WAIT_MS = 5e3;
 var DESCENDANT_CLEANUP_MS = 1e3;
-var DEFAULT_RESULT_IDLE_MS = 10 * 60 * 1e3;
 var SPAWN_RETRY_DELAYS_BY_CODE = {
   ETXTBSY: [250, 750, 1500, 3e3, 5e3],
   ENOENT: [250, 750]
@@ -45668,24 +45701,6 @@ var StreamCapture = class {
     emitSessionUpdate(logUpdate(this.options.kind, line), this.context, this.state);
   }
 };
-function idleTimeoutReasonNow(options, state, sawStdoutLine) {
-  if (state.pendingAskUserToolIds?.size) return "pending_user_answer";
-  if (state.awaitingPostBackgroundSynthesis) return "post_subagent_synthesis";
-  if (state.resultDeferredOnBackgroundWork && state.activeBackgroundTaskIds?.size) {
-    return "background_task";
-  }
-  const silenceMs = options.postStartupSilenceTimeoutMs;
-  if (silenceMs && sawStdoutLine && typeof state.lastRawOutputAtMs === "number" && Date.now() - state.lastRawOutputAtMs >= silenceMs) {
-    return "post_startup_silence";
-  }
-  return null;
-}
-var IDLE_WAIT_LABELS = {
-  background_task: "a background task terminal event",
-  post_subagent_synthesis: "post-subagent synthesis result",
-  post_startup_silence: "any further output (silent hang)",
-  pending_user_answer: "a pending user answer"
-};
 var CliProcessSupervisor = class {
   constructor(options, context, state) {
     this.options = options;
@@ -45698,8 +45713,6 @@ var CliProcessSupervisor = class {
   postExitTimer;
   onAbort;
   startupTimedOut = false;
-  idleTimedOut = false;
-  idleTimeoutReason = null;
   async run(prompt, args) {
     const child = await this.spawn(args);
     this.streams = new StreamCapture(this.options, child, this.context, this.state);
@@ -45709,8 +45722,6 @@ var CliProcessSupervisor = class {
       return {
         exit: await this.awaitExit(child),
         startupTimedOut: this.startupTimedOut,
-        idleTimedOut: this.idleTimedOut,
-        idleTimeoutReason: this.idleTimeoutReason,
         stderrTail: this.streams.stderrTail,
         recentStderrLines: this.streams.recentStderrLines
       };
@@ -45795,51 +45806,26 @@ var CliProcessSupervisor = class {
     const exit = this.exitPromise(child);
     return this.options.keepStdinOpen ? this.raceExitAgainstResult(child, exit) : exit;
   }
+  /**
+   * A structured CLI that holds stdin open ends its turn with a `result` frame and exits
+   * once stdin closes. The process exit still decides the run's terminal state, so a
+   * result only sets how long that exit is worth waiting for.
+   */
   async raceExitAgainstResult(child, exit) {
     const resultPromise = new Promise((resolve52) => {
       this.state.onResultReceived = () => resolve52("result_received");
       if (this.state.resultReceived) resolve52("result_received");
     });
-    const idleMs = this.options.resultIdleTimeoutMs ?? DEFAULT_RESULT_IDLE_MS;
-    let idleTimer = null;
-    const idlePromise = new Promise((resolve52) => {
-      const armIdleTimer = () => {
-        if (idleTimer) clearTimeout(idleTimer);
-        idleTimer = setTimeout(() => {
-          const reason = idleTimeoutReasonNow(
-            this.options,
-            this.state,
-            this.streams?.sawStdoutLine === true
-          );
-          if (!reason) return armIdleTimer();
-          this.idleTimeoutReason = reason;
-          resolve52("idle_timeout");
-        }, idleMs);
-      };
-      this.state.onNewOutput = armIdleTimer;
-      armIdleTimer();
-    });
-    const outcome = await Promise.race([exit, resultPromise, idlePromise]);
-    if (idleTimer) clearTimeout(idleTimer);
-    if (outcome === "idle_timeout") return this.killAfterIdleTimeout(child, exit, idleMs);
-    if (outcome === "result_received") return this.killAfterResult(child, exit);
-    return outcome;
-  }
-  async killAfterIdleTimeout(child, exit, idleMs) {
-    this.idleTimedOut = true;
-    const waiting = this.idleTimeoutReason ? IDLE_WAIT_LABELS[this.idleTimeoutReason] : "the CLI";
-    console.warn(
-      `[${this.options.kind}] Idle timeout (${idleMs}ms) waiting for ${waiting} \u2014 force-killing orphaned process`
-    );
-    killProcessTree(child.pid, { signal: "SIGKILL", child });
-    return Promise.race([
-      exit,
-      new Promise(
-        (resolve52) => setTimeout(() => resolve52({ exitCode: null, signal: "SIGKILL" }), IDLE_KILL_EXIT_WAIT_MS)
-      )
-    ]);
+    const outcome = await Promise.race([exit, resultPromise]);
+    if (outcome !== "result_received") return outcome;
+    return this.closeAfterResult(child, exit);
   }
-  async killAfterResult(child, exit) {
+  /**
+   * The turn is already delivered by the time this runs, so a process that will not leave
+   * is cleanup rather than a verdict. Termination is awaited and verified, and recorded as
+   * an expected grace kill so it cannot turn a delivered turn into a failure.
+   */
+  async closeAfterResult(child, exit) {
     const gracedExit = await Promise.race([
       exit,
       new Promise((resolve52) => setTimeout(() => resolve52(null), RESULT_EXIT_GRACE_MS))
@@ -45847,9 +45833,14 @@ var CliProcessSupervisor = class {
     if (gracedExit) return gracedExit;
     if (child.exitCode === null && !child.killed) {
       console.warn(
-        `[${this.options.kind}] Process still alive ${RESULT_EXIT_GRACE_MS}ms after result event, killing`
+        `[${this.options.kind}] Process still alive ${RESULT_EXIT_GRACE_MS}ms after result event \u2014 terminating the process tree`
       );
-      killProcessTree(child.pid, { signal: "SIGKILL", child });
+      this.state.exitGraceKillTriggered = true;
+      if (!await terminateProcessTree(child)) {
+        console.error(
+          `[${this.options.kind}] Process tree survived termination after result event`
+        );
+      }
     }
     return { exitCode: null, signal: null };
   }
@@ -45891,7 +45882,7 @@ function createCliBackend(options) {
       const observed = await supervisor.run(prompt, resolveArgs(options, context, prompt));
       const closing = { options, context, state, observed };
       const silentResumeFork = detectSilentResumeFork(closing);
-      return abortedResult(closing) ?? startupTimeoutResult(closing) ?? await idleTimeoutResult(closing) ?? await closedRunResult(closing, silentResumeFork);
+      return abortedResult(closing) ?? startupTimeoutResult(closing) ?? await closedRunResult(closing, silentResumeFork);
     }
   };
 }
@@ -46501,20 +46492,21 @@ function requireManagedBearerToken(registration) {
 function requireManagedRunId(registration) {
   return requiredHeader(registration, "x-alan-run-id");
 }
-async function withCursorProjectMcpEntry(cwd, url3, run) {
-  const path2 = (0, import_path8.join)(cwd, ".cursor", "mcp.json");
+async function withCommandCodeProjectMcpEntry(cwd, url3, run) {
+  const path2 = (0, import_path8.join)(cwd, ".mcp.json");
   const original = await (0, import_promises3.readFile)(path2, "utf8").catch(() => null);
   const config4 = parseConfig(original);
-  const servers = config4.mcpServers ?? {};
-  config4.mcpServers = servers;
+  const servers = asRecord2(config4.mcpServers);
   servers.alan = {
-    type: "http",
+    transport: "http",
+    enabled: true,
     url: url3,
     headers: {
-      Authorization: `\${env:${ALAN_MCP_AUTHORIZATION_ENV}}`,
-      "x-alan-run-id": `\${env:${ALAN_RUN_ID_ENV}}`
+      Authorization: `\${${ALAN_MCP_AUTHORIZATION_ENV}}`,
+      "x-alan-run-id": `\${${ALAN_RUN_ID_ENV}}`
     }
   };
+  config4.mcpServers = servers;
   await (0, import_promises3.mkdir)((0, import_path8.dirname)(path2), { recursive: true });
   await (0, import_promises3.writeFile)(path2, `${JSON.stringify(config4, null, 2)}
 `);
@@ -46526,6 +46518,42 @@ async function withCursorProjectMcpEntry(cwd, url3, run) {
   }
 }
 function parseConfig(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function asRecord2(value2) {
+  return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
+}
+async function withCursorProjectMcpEntry(cwd, url3, run) {
+  const path2 = (0, import_path9.join)(cwd, ".cursor", "mcp.json");
+  const original = await (0, import_promises4.readFile)(path2, "utf8").catch(() => null);
+  const config4 = parseConfig2(original);
+  const servers = config4.mcpServers ?? {};
+  config4.mcpServers = servers;
+  servers.alan = {
+    type: "http",
+    url: url3,
+    headers: {
+      Authorization: `\${env:${ALAN_MCP_AUTHORIZATION_ENV}}`,
+      "x-alan-run-id": `\${env:${ALAN_RUN_ID_ENV}}`
+    }
+  };
+  await (0, import_promises4.mkdir)((0, import_path9.dirname)(path2), { recursive: true });
+  await (0, import_promises4.writeFile)(path2, `${JSON.stringify(config4, null, 2)}
+`);
+  try {
+    return await run();
+  } finally {
+    if (original === null) await (0, import_promises4.rm)(path2, { force: true });
+    else await (0, import_promises4.writeFile)(path2, original);
+  }
+}
+function parseConfig2(raw) {
   if (!raw) return {};
   try {
     const parsed = JSON.parse(raw);
@@ -47713,13 +47741,78 @@ async function createSession(baseUrl, context, signal) {
     throw new Error(`${openCodeEngineLabel(context)} session create response had no id`);
   return info.id;
 }
+function storedPartOf(value2) {
+  const record4 = asRecord(value2);
+  const id = asString(record4?.id);
+  const type = asString(record4?.type);
+  return id && type ? { id, type, text: asString(record4?.text) } : null;
+}
+function storedMessageOf(value2) {
+  const record4 = asRecord(value2);
+  const info = asRecord(record4?.info);
+  const id = asString(info?.id);
+  if (!id || !Array.isArray(record4?.parts)) return null;
+  const parts2 = record4.parts.flatMap((part) => storedPartOf(part) ?? []);
+  return { id, role: asString(info?.role), parts: parts2 };
+}
+var TEXT_PART_TYPES = /* @__PURE__ */ new Set(["text", "reasoning"]);
+var STEP_PART_TYPES = /* @__PURE__ */ new Set(["step-start", "step-finish"]);
+function isBlankTextPart(part) {
+  return TEXT_PART_TYPES.has(part.type) && !part.text.trim();
+}
+async function removeBlankAssistantContent(baseUrl, sessionId, signal) {
+  const sessionUrl = `${baseUrl}/session/${encodeURIComponent(sessionId)}`;
+  const response = await fetch(`${sessionUrl}/message`, { signal }).catch(() => null);
+  if (!response?.ok) return 0;
+  const body = await response.json().catch(() => null);
+  if (!Array.isArray(body)) return 0;
+  const deletions = [];
+  for (const message of body.flatMap((entry) => storedMessageOf(entry) ?? [])) {
+    if (message.role !== "assistant") continue;
+    const messageUrl = `${sessionUrl}/message/${encodeURIComponent(message.id)}`;
+    const holdsNothing = message.parts.every(
+      (part) => isBlankTextPart(part) || STEP_PART_TYPES.has(part.type)
+    );
+    if (holdsNothing) {
+      deletions.push(messageUrl);
+      continue;
+    }
+    for (const part of message.parts.filter(isBlankTextPart)) {
+      deletions.push(`${messageUrl}/part/${encodeURIComponent(part.id)}`);
+    }
+  }
+  let removed = 0;
+  for (const url3 of deletions) {
+    const deleted = await fetch(url3, { method: "DELETE", signal }).catch(() => null);
+    if (deleted?.ok) removed += 1;
+  }
+  return removed;
+}
+var SESSION_ABORT_TIMEOUT_MS = 1500;
+async function requestSessionAbort(baseUrl, sessionId) {
+  if (!baseUrl || !sessionId) return;
+  await fetch(`${baseUrl}/session/${encodeURIComponent(sessionId)}/abort`, {
+    method: "POST",
+    signal: AbortSignal.timeout(SESSION_ABORT_TIMEOUT_MS)
+  }).catch(() => void 0);
+}
 async function resolveSession(baseUrl, context, signal) {
   const resumeId3 = context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim();
   if (!resumeId3) {
     return { id: await createSession(baseUrl, context, signal), resumed: false };
   }
   const existing = await fetch(`${baseUrl}/session/${encodeURIComponent(resumeId3)}`, { signal });
-  if (existing.ok) return { id: resumeId3, resumed: true };
+  if (existing.ok) {
+    const removed = await removeBlankAssistantContent(baseUrl, resumeId3, signal);
+    if (removed > 0) {
+      logResumeObservability("agent_resume_history_repaired", {
+        backendKind: context.config.backendKind ?? "opencode_serve",
+        requestedResumeId: resumeId3,
+        removedBlankEntries: removed
+      });
+    }
+    return { id: resumeId3, resumed: true };
+  }
   if (existing.status !== 404) {
     throw new Error(
       `Failed to look up ${openCodeEngineLabel(context)} session ${resumeId3}: HTTP ${existing.status}`
@@ -47932,8 +48025,8 @@ function buildAgentResult(state, sessionId, aborted2, backendKind = "opencode_se
       usage: state.usage
     };
   }
+  const producedOutput = Boolean(state.summary.trim()) || [...state.opencodePartTypeById?.values() ?? []].some((type) => OUTPUT_PART_TYPES.has(type));
   if (!state.error?.trim()) {
-    const producedOutput = Boolean(state.summary.trim()) || [...state.opencodePartTypeById?.values() ?? []].some((type) => OUTPUT_PART_TYPES.has(type));
     if (state.opencodeFinishReason === "length") {
       state.error = "The model's response was cut off because it hit the output token limit.";
       state.errorKind = "context_length";
@@ -47973,7 +48066,8 @@ function buildAgentResult(state, sessionId, aborted2, backendKind = "opencode_se
         // Failures arrive via the SSE stream, never a CLI exit.
         phase: "stream",
         finality: "terminal",
-        outcomeCertainty: "effect_unknown"
+        // A rejected history fails the first request, so with no output nothing ran.
+        outcomeCertainty: errorKind === "history_rejected" && !producedOutput ? "no_effect" : "effect_unknown"
       }
     );
   }
@@ -48045,17 +48139,19 @@ function createOpencodeServeBackend(command = "opencode", options = PLAIN_OPENCO
       }));
       let sseClose = null;
       let sessionId = "";
+      let serverBaseUrl = null;
       let aborted2 = false;
       const onAbort = () => {
         aborted2 = true;
         sseClose?.();
         if (leaseKey) serveLeases.delete(leaseKey);
-        void terminateProcessTree(child);
+        void requestSessionAbort(serverBaseUrl, sessionId).then(() => terminateProcessTree(child));
       };
       context.abortController.signal.addEventListener("abort", onAbort, { once: true });
       if (context.abortController.signal.aborted) onAbort();
       try {
         const server = await ready;
+        serverBaseUrl = server.baseUrl;
         state.lastRawOutputAtMs = Date.now();
         context.registerBackgroundTaskStopper?.(
           (taskId) => stopBackgroundTaskInRun(
@@ -48184,6 +48280,7 @@ var ALAN_CODE_ENGINE_PROVIDER_ID = "alan";
 var ALAN_CODE_API_KEY_ENV = "ALAN_CODE_API_KEY";
 var ALAN_CODE_RUN_ID_ENV = "ALAN_CODE_RUN_ID";
 var ALAN_CODE_PROXY_PATH = "/public/harness/v1";
+var ALAN_CODE_WEBSEARCH_PATH = "/public/harness/v1/websearch";
 var ALAN_CODE_CATALOG_PATH = "/public/harness/models";
 var CATALOG_TIMEOUT_MS = 5e3;
 function seedAlanCodeModels() {
@@ -48243,21 +48340,133 @@ function resolveAlanCodeModelId(selectedModel2, models) {
   if (requested && models.some((model2) => model2.id === requested)) return requested;
   return models.find((model2) => model2.isDefault)?.id ?? models[0]?.id ?? (requested || DEFAULT_HARNESS_MODEL_ID);
 }
-var OPERATION_KEY_PLUGIN_SOURCE = `
-export const AlanOperationKeyPlugin = async () => ({
+function enginePluginSource(apiOrigin) {
+  return `
+const WEB_SEARCH_URL = ${JSON.stringify(`${apiOrigin}${ALAN_CODE_WEBSEARCH_PATH}`)};
+const API_KEY_ENV = ${JSON.stringify(ALAN_CODE_API_KEY_ENV)};
+const RUN_ID_ENV = ${JSON.stringify(ALAN_CODE_RUN_ID_ENV)};
+const PROVIDER_ID = ${JSON.stringify(ALAN_CODE_ENGINE_PROVIDER_ID)};
+const INCLUDED_RESULTS = 8;
+const MAX_AUTO_RETRIES = 2;
+const MAX_AUTO_RETRY_WAIT_MS = 10_000;
+
+function truncate(text, max) {
+  const trimmed = String(text == null ? "" : text).trim();
+  return trimmed.length <= max ? trimmed : trimmed.slice(0, max - 1) + "\u2026";
+}
+
+function formatResults(results) {
+  const lines = [];
+  results.slice(0, INCLUDED_RESULTS).forEach(function (item, index) {
+    const title = (item.title || "").trim() || (item.url || "").trim() || "Result " + (index + 1);
+    lines.push(index + 1 + ". " + title);
+    if (item.url) lines.push("   " + item.url);
+    const excerpt = Array.isArray(item.excerpts)
+      ? item.excerpts.find(function (part) { return part && part.trim(); })
+      : "";
+    if (excerpt) lines.push("   " + truncate(excerpt, 400));
+  });
+  return lines.join("\\n");
+}
+
+/** Mirrors the harness CLI: say what the agent can do next instead of just failing. */
+function describeRefusal(refusal, status, text) {
+  const code = refusal && typeof refusal.error === "string" ? refusal.error : "";
+  const message = refusal && typeof refusal.message === "string" ? refusal.message : truncate(text, 300);
+  const reset = refusal && typeof refusal.resetsAt === "string" ? refusal.resetsAt.slice(0, 10) : "";
+  if (code === "quota_exceeded") {
+    return "Web search allowance exhausted" + (reset ? "; it resets " + reset : "") + ". Do not retry \u2014 continue without search or tell the user.";
+  }
+  if (code === "search_daily_limit") {
+    return "Daily web search limit reached; it resets at 00:00 UTC. Continue without search rather than retrying.";
+  }
+  if (code === "billing_review_required" || code === "not_a_member" || code === "seat_required" || code.indexOf("entitlement") === 0) {
+    return "Web search is not available for this account (" + message + "). Do not retry \u2014 report it to the user.";
+  }
+  if (refusal && refusal.retryable === true) {
+    return "Web search is temporarily unavailable (" + message + "). Retry shortly.";
+  }
+  return "Web search failed (" + status + "): " + message;
+}
+
+async function callWebSearch(query, signal) {
+  const apiKey = process.env[API_KEY_ENV];
+  if (!apiKey) {
+    return { title: "web_search unavailable", output: "Web search is unavailable: this run has no Alan credential." };
+  }
+  const headers = { Authorization: "Bearer " + apiKey, "Content-Type": "application/json" };
+  if (process.env[RUN_ID_ENV]) headers["x-alan-run-id"] = process.env[RUN_ID_ENV];
+
+  for (let attempt = 0; ; attempt += 1) {
+    const response = await fetch(WEB_SEARCH_URL, {
+      method: "POST",
+      headers: headers,
+      body: JSON.stringify({ query: query }),
+      signal: signal,
+    });
+    const text = await response.text();
+    if (response.ok) {
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        return { title: "web_search", output: "Web search returned an unreadable response." };
+      }
+      const results = Array.isArray(parsed.results) ? parsed.results : [];
+      if (results.length === 0) {
+        return { title: "web_search: " + query, output: 'No results for "' + query + '". Try a tighter query, then webfetch promising URLs.' };
+      }
+      return {
+        title: "web_search: " + query,
+        output: [
+          'Web search (Alan) for "' + query + '":',
+          formatResults(results),
+          "",
+          "Next: pick the best URL(s) and call webfetch to read the page. Cite title + URL.",
+        ].join("\\n"),
+        metadata: { resultCount: results.length, searchId: parsed.search_id },
+      };
+    }
+
+    let refusal;
+    try { refusal = JSON.parse(text); } catch { refusal = undefined; }
+    const waitMs = refusal && typeof refusal.retryAfterSeconds === "number" ? refusal.retryAfterSeconds * 1000 : 0;
+    if (refusal && refusal.retryable === true && waitMs > 0 && waitMs <= MAX_AUTO_RETRY_WAIT_MS && attempt < MAX_AUTO_RETRIES) {
+      await new Promise(function (resolve) { setTimeout(resolve, waitMs); });
+      continue;
+    }
+    return { title: "web_search " + response.status, output: describeRefusal(refusal, response.status, text) };
+  }
+}
+
+export const AlanEnginePlugin = async () => ({
   "chat.headers": async (input, output) => {
-    if (input.model.providerID === "${ALAN_CODE_ENGINE_PROVIDER_ID}") {
+    if (input.model.providerID === PROVIDER_ID) {
       output.headers["x-alan-operation-key"] = Date.now() + "-" + crypto.randomUUID()
     }
   },
+  tool: {
+    web_search: {
+      description: "web_search: Search the public web via Alan's Parallel proxy. Use when you do not already have a URL. Follow up with webfetch on the best result(s).",
+      args: {
+        query: { type: "string", description: "Search query / objective" },
+      },
+      async execute(args, context) {
+        const query = String((args && args.query) || "").trim();
+        if (!query) return { title: "web_search", output: "web_search requires a non-empty query." };
+        return callWebSearch(query, context && context.abort);
+      },
+    },
+  },
 })
 `;
-function materializeOperationKeyPlugin(directory = (0, import_os4.tmpdir)()) {
-  const dir = (0, import_path9.join)(directory, "alan-code");
-  const target = (0, import_path9.join)(dir, "operation-key-v1.mjs");
+}
+function materializeEnginePlugin(directory = (0, import_os4.tmpdir)(), apiOrigin) {
+  const dir = (0, import_path10.join)(directory, "alan-code");
+  const target = (0, import_path10.join)(dir, "engine-plugin-v1.mjs");
   const temporary = `${target}.${process.pid}.${(0, import_crypto5.randomUUID)()}.tmp`;
   (0, import_fs9.mkdirSync)(dir, { recursive: true, mode: 448 });
-  (0, import_fs9.writeFileSync)(temporary, OPERATION_KEY_PLUGIN_SOURCE, { mode: 384 });
+  (0, import_fs9.writeFileSync)(temporary, enginePluginSource(apiOrigin), { mode: 384 });
   (0, import_fs9.renameSync)(temporary, target);
   return (0, import_url2.pathToFileURL)(target).href;
 }
@@ -48321,15 +48530,15 @@ function buildAlanCodeConfigContent(existing, input2) {
 }
 function alanCodeEngineDirectories(root) {
   const directories = {
-    XDG_DATA_HOME: (0, import_path9.join)(root, "share"),
-    XDG_STATE_HOME: (0, import_path9.join)(root, "state"),
-    XDG_CACHE_HOME: (0, import_path9.join)(root, "cache")
+    XDG_DATA_HOME: (0, import_path10.join)(root, "share"),
+    XDG_STATE_HOME: (0, import_path10.join)(root, "state"),
+    XDG_CACHE_HOME: (0, import_path10.join)(root, "cache")
   };
   for (const directory of Object.values(directories)) (0, import_fs9.mkdirSync)(directory, { recursive: true });
   return directories;
 }
 function defaultEngineRoot(env) {
-  return (0, import_path9.join)(env.HOME?.trim() || (0, import_os4.homedir)(), ".alan", "alan-code", "engine");
+  return (0, import_path10.join)(env.HOME?.trim() || (0, import_os4.homedir)(), ".alan", "alan-code", "engine");
 }
 async function withAlanCodeEngine(context, dependencies = {}) {
   const registration = context.config.alanMcp;
@@ -48356,7 +48565,7 @@ async function withAlanCodeEngine(context, dependencies = {}) {
         baseURL: `${apiOrigin}${ALAN_CODE_PROXY_PATH}`,
         modelId,
         models,
-        pluginUrl: materializeOperationKeyPlugin(dependencies.pluginDirectory)
+        pluginUrl: materializeEnginePlugin(dependencies.pluginDirectory, apiOrigin)
       })
     }
   };
@@ -49170,7 +49379,7 @@ var TranscriptTail = class {
     const wanted = /* @__PURE__ */ new Set();
     for (const path2 of this.options.transcriptPaths()) {
       if (!path2) continue;
-      wanted.add(this.armFile(path2) ? path2 : (0, import_path11.dirname)(path2));
+      wanted.add(this.armFile(path2) ? path2 : (0, import_path12.dirname)(path2));
     }
     for (const target of wanted) this.arm(target, false);
     for (const target of this.watchers.keys()) {
@@ -49223,10 +49432,10 @@ var ANTIGRAVITY_TOOL_RESULT_TYPES = /* @__PURE__ */ new Set([
 ]);
 function antigravityTranscriptRoot(context) {
   const home = context.env.HOME || process.env.HOME || (0, import_os5.homedir)();
-  return (0, import_path10.resolve)(home, ".gemini", "antigravity-cli", "brain");
+  return (0, import_path11.resolve)(home, ".gemini", "antigravity-cli", "brain");
 }
 function parentTranscriptPath(conversationId, context) {
-  return (0, import_path10.resolve)(
+  return (0, import_path11.resolve)(
     antigravityTranscriptRoot(context),
     conversationId,
     ".system_generated",
@@ -49241,10 +49450,10 @@ function childTranscriptPath(event, context) {
   try {
     const url3 = new URL(logUri);
     if (url3.protocol !== "file:") return void 0;
-    const transcriptPath2 = (0, import_path10.resolve)((0, import_url3.fileURLToPath)(url3));
-    const pathFromRoot = (0, import_path10.relative)(antigravityTranscriptRoot(context), transcriptPath2);
-    const segments = pathFromRoot.split(import_path10.sep);
-    if (!pathFromRoot || pathFromRoot === ".." || pathFromRoot.startsWith(`..${import_path10.sep}`) || (0, import_path10.isAbsolute)(pathFromRoot) || segments[0] !== conversationId || segments.at(-1) !== "transcript.jsonl" || segments.at(-2) !== "logs" || segments.at(-3) !== ".system_generated") {
+    const transcriptPath2 = (0, import_path11.resolve)((0, import_url3.fileURLToPath)(url3));
+    const pathFromRoot = (0, import_path11.relative)(antigravityTranscriptRoot(context), transcriptPath2);
+    const segments = pathFromRoot.split(import_path11.sep);
+    if (!pathFromRoot || pathFromRoot === ".." || pathFromRoot.startsWith(`..${import_path11.sep}`) || (0, import_path11.isAbsolute)(pathFromRoot) || segments[0] !== conversationId || segments.at(-1) !== "transcript.jsonl" || segments.at(-2) !== "logs" || segments.at(-3) !== ".system_generated") {
       return void 0;
     }
     return transcriptPath2;
@@ -49260,7 +49469,7 @@ function parseTranscriptEntry(text2) {
   }
 }
 function fullTranscriptPath(transcriptPath2) {
-  return (0, import_path10.resolve)((0, import_path10.dirname)(transcriptPath2), FULL_TRANSCRIPT_FILENAME);
+  return (0, import_path11.resolve)((0, import_path11.dirname)(transcriptPath2), FULL_TRANSCRIPT_FILENAME);
 }
 function resolveTruncatedEntry(entry, lineIndex, transcriptPath2, full) {
   const truncated = Array.isArray(entry.truncated_fields) ? entry.truncated_fields : [];
@@ -51244,18 +51453,18 @@ function recoverCodexFileChange(state, item) {
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var MAX_HEADER_BYTES = 1024 * 1024;
 function workerDirectories(rootLog) {
-  const directory = (0, import_path13.dirname)(rootLog);
-  const monthDirectory = (0, import_path13.dirname)(directory);
-  const yearDirectory = (0, import_path13.dirname)(monthDirectory);
-  const date5 = `${(0, import_path13.basename)(yearDirectory)}-${(0, import_path13.basename)(monthDirectory)}-${(0, import_path13.basename)(directory)}`;
+  const directory = (0, import_path14.dirname)(rootLog);
+  const monthDirectory = (0, import_path14.dirname)(directory);
+  const yearDirectory = (0, import_path14.dirname)(monthDirectory);
+  const date5 = `${(0, import_path14.basename)(yearDirectory)}-${(0, import_path14.basename)(monthDirectory)}-${(0, import_path14.basename)(directory)}`;
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date5)) return [directory];
   const timestamp = Date.parse(`${date5}T00:00:00Z`);
   if (!Number.isFinite(timestamp) || new Date(timestamp).toISOString().slice(0, 10) !== date5)
     return [directory];
-  const sessionsDirectory2 = (0, import_path13.dirname)(yearDirectory);
+  const sessionsDirectory2 = (0, import_path14.dirname)(yearDirectory);
   return [0, 1, -1].map((offset2) => {
     const day = new Date(timestamp + offset2 * DAY_MS).toISOString().slice(0, 10);
-    return (0, import_path13.join)(sessionsDirectory2, ...day.split("-"));
+    return (0, import_path14.join)(sessionsDirectory2, ...day.split("-"));
   });
 }
 function firstLine(path2) {
@@ -51292,7 +51501,7 @@ function findCodexWorkerLogs(rootLog, parentThreadId) {
     }
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
-      const path2 = (0, import_path13.join)(directory, entry.name);
+      const path2 = (0, import_path14.join)(directory, entry.name);
       if (path2 === rootLog) continue;
       try {
         const line = firstLine(path2);
@@ -51320,7 +51529,7 @@ function findCodexWorkerLogs(rootLog, parentThreadId) {
   return workers;
 }
 function resolveCodexHome(env) {
-  return env.CODEX_HOME || process.env.CODEX_HOME || (0, import_path12.join)((0, import_os6.homedir)(), ".codex");
+  return env.CODEX_HOME || process.env.CODEX_HOME || (0, import_path13.join)((0, import_os6.homedir)(), ".codex");
 }
 function mtimeOf(path2) {
   try {
@@ -51334,11 +51543,11 @@ function newestMatchIn(dir, entries, sessionId) {
     (entry) => entry.isFile() && entry.name.endsWith(".jsonl") && entry.name.includes(sessionId)
   );
   if (matches.length === 0) return null;
-  if (matches.length === 1) return (0, import_path12.join)(dir, matches[0].name);
+  if (matches.length === 1) return (0, import_path13.join)(dir, matches[0].name);
   let best = "";
   let bestMtime = -1;
   for (const entry of matches) {
-    const path2 = (0, import_path12.join)(dir, entry.name);
+    const path2 = (0, import_path13.join)(dir, entry.name);
     const mtime = mtimeOf(path2);
     if (mtime > bestMtime) {
       best = path2;
@@ -51349,7 +51558,7 @@ function newestMatchIn(dir, entries, sessionId) {
 }
 function findCodexSessionLog(runtimeSessionId, codexHome) {
   if (!runtimeSessionId) return null;
-  const stack = [(0, import_path12.join)(codexHome, "sessions")];
+  const stack = [(0, import_path13.join)(codexHome, "sessions")];
   while (stack.length > 0) {
     const dir = stack.pop();
     let entries;
@@ -51362,7 +51571,7 @@ function findCodexSessionLog(runtimeSessionId, codexHome) {
     if (match) return match;
     const subdirs = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
     subdirs.sort();
-    for (const name of subdirs) stack.push((0, import_path12.join)(dir, name));
+    for (const name of subdirs) stack.push((0, import_path13.join)(dir, name));
   }
   return null;
 }
@@ -53028,6 +53237,7 @@ var COMMAND_CODE_GRAMMAR_NAME = "command_code_cli";
 var TEXT_MESSAGE_KEY = "commandCode.textMessageId";
 var THINKING_MESSAGE_KEY = "commandCode.thinkingMessageId";
 var ANONYMOUS_TOOL_KEY2 = "commandCode.lastAnonymousToolCallId";
+var ANSWER_MESSAGE_KEY = "commandCode.answerMessageId";
 function commandCodeString(value2) {
   return typeof value2 === "string" && value2.trim().length > 0 ? value2.trim() : "";
 }
@@ -53116,10 +53326,12 @@ function parseEvent2(event, state) {
     case "text_delta": {
       const delta = typeof event.delta === "string" ? event.delta : "";
       if (!delta) return [];
+      const messageId = latchedMessageId(state, TEXT_MESSAGE_KEY, "command-code-msg");
+      state.scratch[ANSWER_MESSAGE_KEY] = messageId;
       return [
         {
           sessionUpdate: "agent_message_chunk",
-          messageId: latchedMessageId(state, TEXT_MESSAGE_KEY, "command-code-msg"),
+          messageId,
           content: textBlock(delta)
         }
       ];
@@ -53127,6 +53339,7 @@ function parseEvent2(event, state) {
     case "message_update":
       return parseMessageUpdate(event, state);
     case "tool_running":
+      delete state.scratch[ANSWER_MESSAGE_KEY];
       return [
         toolCallStart(
           resolveToolCallId(commandCodeString(event.toolCallId), state),
@@ -53209,13 +53422,22 @@ function parseResult2(event, state) {
   const sessionId = commandCodeString(event.sessionId);
   if (sessionId) state.sessionId = sessionId;
   const subtype = commandCodeString(event.subtype);
-  return [
-    {
-      sessionUpdate: "state_update",
-      state: "idle",
-      ...subtype === "error" ? {} : { stopReason: "end_turn" }
-    }
-  ];
+  const updates = [];
+  const finalText = commandCodeString(event.finalText);
+  const answerId = state.scratch[ANSWER_MESSAGE_KEY];
+  if (finalText && typeof answerId === "string" && answerId) {
+    updates.push({
+      sessionUpdate: "agent_message",
+      messageId: answerId,
+      content: [textBlock(finalText)]
+    });
+  }
+  updates.push({
+    sessionUpdate: "state_update",
+    state: "idle",
+    ...subtype === "error" ? {} : { stopReason: "end_turn" }
+  });
+  return updates;
 }
 var backgroundStates = /* @__PURE__ */ new WeakMap();
 function backgroundStateFor(state) {
@@ -53483,39 +53705,49 @@ function createCommandCodeCliBackend(command = "command-code", defaultArgs = [])
         context.config.images,
         context.cwd
       );
+      const managed = context.config.alanMcp;
+      const runContext = managed ? {
+        ...context,
+        env: {
+          ...context.env,
+          [ALAN_MCP_AUTHORIZATION_ENV]: requireManagedAuthorization(managed),
+          [ALAN_RUN_ID_ENV]: requireManagedRunId(managed)
+        }
+      } : context;
+      const runBackend = () => createCliBackend({
+        kind: "command_code_cli",
+        supportTier: "structured",
+        command,
+        args: [],
+        buildArgs: (ctx, prompt) => {
+          const args = [
+            "-p",
+            "--output-format",
+            "json",
+            "--skip-onboarding",
+            "--trust",
+            "--no-auto-update",
+            ...commandCodePermissionArgs(ctx.config),
+            ...defaultArgs
+          ];
+          const resumeId3 = ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim();
+          if (resumeId3) args.push("--resume", resumeId3);
+          const model2 = ctx.config.selectedModel?.trim();
+          if (model2) args.push("--model", model2);
+          const effort3 = ctx.config.selectedEffortLevel?.trim();
+          if (effort3) args.push("--effort", effort3);
+          args.push(prompt);
+          return args;
+        },
+        augmentPrompt: (ctx) => buildPromptWithImagePathReferences(ctx, imageFiles),
+        parseStructuredLine: grammarAsStructuredLineParser(
+          commandCodeGrammar,
+          commandCodeEffects
+        ),
+        keepStdinOpen: true
+      }).run(runContext);
       try {
-        return await createCliBackend({
-          kind: "command_code_cli",
-          supportTier: "structured",
-          command,
-          args: [],
-          buildArgs: (ctx, prompt) => {
-            const args = [
-              "-p",
-              "--output-format",
-              "json",
-              "--skip-onboarding",
-              "--trust",
-              "--no-auto-update",
-              ...commandCodePermissionArgs(ctx.config),
-              ...defaultArgs
-            ];
-            const resumeId3 = ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim();
-            if (resumeId3) args.push("--resume", resumeId3);
-            const model2 = ctx.config.selectedModel?.trim();
-            if (model2) args.push("--model", model2);
-            const effort3 = ctx.config.selectedEffortLevel?.trim();
-            if (effort3) args.push("--effort", effort3);
-            args.push(prompt);
-            return args;
-          },
-          augmentPrompt: (ctx) => buildPromptWithImagePathReferences(ctx, imageFiles),
-          parseStructuredLine: grammarAsStructuredLineParser(
-            commandCodeGrammar,
-            commandCodeEffects
-          ),
-          keepStdinOpen: true
-        }).run(context);
+        return await (managed ? withCommandCodeProjectMcpEntry(context.cwd, managed.url, runBackend) : runBackend());
       } finally {
         cleanup();
       }
@@ -54001,7 +54233,27 @@ function activeTaskIdNamedIn(state, content) {
   }
   return void 0;
 }
-function buildCopilotCliArgs(context, prompt, defaultArgs = []) {
+function writeCopilotMcpConfig(registration) {
+  if (!registration) return null;
+  const dir = (0, import_fs15.mkdtempSync)((0, import_path15.join)((0, import_os7.tmpdir)(), "alan-copilot-mcp-"));
+  const path2 = (0, import_path15.join)(dir, "mcp-config.json");
+  (0, import_fs15.writeFileSync)(
+    path2,
+    JSON.stringify({
+      mcpServers: {
+        [MANAGED_MCP_SERVER_NAME]: {
+          type: "http",
+          url: registration.url,
+          tools: ["*"],
+          headers: registration.headers
+        }
+      }
+    }),
+    { mode: 384 }
+  );
+  return { path: path2, cleanup: () => (0, import_fs15.rmSync)(dir, { recursive: true, force: true }) };
+}
+function buildCopilotCliArgs(context, prompt, defaultArgs = [], options = {}) {
   const args = [
     "--yolo",
     "-s",
@@ -54029,6 +54281,9 @@ function buildCopilotCliArgs(context, prompt, defaultArgs = []) {
       args.push("--effort", effort3);
     }
   }
+  if (options.additionalMcpConfigPath) {
+    args.push("--additional-mcp-config", `@${options.additionalMcpConfigPath}`);
+  }
   args.push("-p", prompt);
   return [...args, ...defaultArgs];
 }
@@ -54041,19 +54296,23 @@ function createCopilotCliBackend(command = "copilot", defaultArgs = []) {
         context.config.images,
         context.cwd
       );
+      const mcpConfig = writeCopilotMcpConfig(context.config.alanMcp);
       try {
         return await createCliBackend({
           kind: "copilot_cli",
           supportTier: "structured",
           command,
           args: [],
-          buildArgs: (ctx, prompt) => buildCopilotCliArgs(ctx, prompt, defaultArgs),
+          buildArgs: (ctx, prompt) => buildCopilotCliArgs(ctx, prompt, defaultArgs, {
+            additionalMcpConfigPath: mcpConfig?.path
+          }),
           augmentPrompt: (ctx) => buildPromptWithImagePathReferences(ctx, imageFiles),
           parseStructuredLine: grammarAsStructuredLineParser(copilotGrammar, copilotEffects),
           // Held open so a deferred `result` can wait for background work to drain.
           keepStdinOpen: true
         }).run(context);
       } finally {
+        mcpConfig?.cleanup();
         cleanup();
       }
     }
@@ -54600,11 +54859,11 @@ function cursorConversationStepText(steps) {
 }
 function cursorTranscriptsRoot(context) {
   const projectKey = context.cwd.replace(/^[/\\]+/, "").replace(/[/\\]+/g, "-");
-  const home = context.env.HOME || process.env.HOME || (0, import_os7.homedir)();
-  return (0, import_path14.join)(home, ".cursor", "projects", projectKey, "agent-transcripts");
+  const home = context.env.HOME || process.env.HOME || (0, import_os8.homedir)();
+  return (0, import_path16.join)(home, ".cursor", "projects", projectKey, "agent-transcripts");
 }
 function cursorTranscriptPathForAgent(context, agentId) {
-  return (0, import_path14.join)(cursorTranscriptsRoot(context), agentId, `${agentId}.jsonl`);
+  return (0, import_path16.join)(cursorTranscriptsRoot(context), agentId, `${agentId}.jsonl`);
 }
 function resolveCursorSubagentTranscriptPath(success2, context) {
   const explicit = success2?.transcriptPath ?? success2?.transcript_path;
@@ -54629,13 +54888,13 @@ function cursorTranscriptUserText(transcriptPath2) {
 }
 function discoverCursorSubagentTranscript(context, state, task) {
   const root = cursorTranscriptsRoot(context);
-  if (!(0, import_fs15.existsSync)(root)) return void 0;
+  if (!(0, import_fs16.existsSync)(root)) return void 0;
   const prompt = task.prompt?.trim();
   const description = task.description?.trim().toLowerCase();
   const candidates = [];
   let entries;
   try {
-    entries = (0, import_fs15.readdirSync)(root, { withFileTypes: true });
+    entries = (0, import_fs16.readdirSync)(root, { withFileTypes: true });
   } catch {
     return void 0;
   }
@@ -54644,7 +54903,7 @@ function discoverCursorSubagentTranscript(context, state, task) {
     const path2 = cursorTranscriptPathForAgent(context, entry.name);
     let mtimeMs;
     try {
-      mtimeMs = (0, import_fs15.statSync)(path2).mtimeMs;
+      mtimeMs = (0, import_fs16.statSync)(path2).mtimeMs;
     } catch {
       continue;
     }
@@ -55072,10 +55331,6 @@ function createCursorAgentCliBackend(command = "cursor-agent", defaultArgs = [])
         closeStdinAfterPrompt: true,
         // cursor-agent headless can hang at startup with zero output.
         startupTimeoutMs: 18e4,
-        // Its asks never fire the idle timer's conditions, so silence after output
-        // is otherwise bounded only by the ~30-min external reaper.
-        resultIdleTimeoutMs: 5 * 6e4,
-        postStartupSilenceTimeoutMs: 15 * 6e4,
         augmentPrompt: (ctx) => {
           const isResume = Boolean(
             ctx.config.runtimeSessionId?.trim() || ctx.config.providerSessionId?.trim()
@@ -55893,6 +56148,17 @@ var GENERIC_GROK_RPC_ERRORS = /* @__PURE__ */ new Set([
   "grok agent error",
   "grok build run failed"
 ]);
+function buildGrokAcpMcpServers(registration) {
+  if (!registration) return [];
+  return [
+    {
+      name: MANAGED_MCP_SERVER_NAME,
+      type: "http",
+      url: registration.url,
+      headers: Object.entries(registration.headers).map(([name, value2]) => ({ name, value: value2 }))
+    }
+  ];
+}
 function resumeSessionId(context) {
   return context.config.runtimeSessionId?.trim() || context.config.providerSessionId?.trim() || "";
 }
@@ -55941,8 +56207,9 @@ function toolSettlement(toolCallId, state) {
   return hasUntrackedBackgroundWork(state) ? "drain" : "self";
 }
 var GrokAcpSession = class {
-  constructor(imageFiles) {
+  constructor(imageFiles, alanMcp) {
     this.imageFiles = imageFiles;
+    this.alanMcp = alanMcp;
   }
   stdin = null;
   nextId = 0;
@@ -55983,7 +56250,10 @@ var GrokAcpSession = class {
   }
   newSession(context) {
     this.attemptedNewSession = true;
-    this.sessionOpId = this.request("session/new", { cwd: context.cwd, mcpServers: [] });
+    this.sessionOpId = this.request("session/new", {
+      cwd: context.cwd,
+      mcpServers: buildGrokAcpMcpServers(this.alanMcp)
+    });
   }
   beginSession(context, state) {
     const resume = resumeSessionId(context);
@@ -55995,7 +56265,7 @@ var GrokAcpSession = class {
     this.sessionOpId = this.request("session/load", {
       sessionId: resume,
       cwd: context.cwd,
-      mcpServers: []
+      mcpServers: buildGrokAcpMcpServers(this.alanMcp)
     });
   }
   sendPrompt(context, state) {
@@ -56316,8 +56586,8 @@ var GrokAcpSession = class {
     });
   }
 };
-function createGrokAcpRuntime(imageFiles) {
-  const session = new GrokAcpSession(imageFiles);
+function createGrokAcpRuntime(imageFiles, alanMcp) {
+  const session = new GrokAcpSession(imageFiles, alanMcp);
   const effects = { lifecycle: session.lifecycle };
   return {
     start: (stdinStream) => session.start(stdinStream),
@@ -56353,7 +56623,7 @@ function createGrokCliBackend(command = "grok", defaultArgs = []) {
         context.config.images,
         context.cwd
       );
-      const runtime = createGrokAcpRuntime(imageFiles);
+      const runtime = createGrokAcpRuntime(imageFiles, context.config.alanMcp);
       try {
         return await createCliBackend({
           kind: "grok_cli",
@@ -56922,10 +57192,10 @@ function createKimiCliBackend(command = "kimi", defaultArgs = []) {
     async run(context) {
       const dialect = await detectKimiCliDialect(command, context);
       const registration = dialect === "kimi-cli" ? context.config.alanMcp : void 0;
-      const mcpDirectory = registration ? (0, import_fs16.mkdtempSync)((0, import_path15.join)((0, import_os8.tmpdir)(), "alan-kimi-mcp-")) : null;
-      const mcpConfigPath = mcpDirectory ? (0, import_path15.join)(mcpDirectory, "mcp.json") : null;
+      const mcpDirectory = registration ? (0, import_fs17.mkdtempSync)((0, import_path17.join)((0, import_os9.tmpdir)(), "alan-kimi-mcp-")) : null;
+      const mcpConfigPath = mcpDirectory ? (0, import_path17.join)(mcpDirectory, "mcp.json") : null;
       if (registration && mcpConfigPath) {
-        (0, import_fs16.writeFileSync)(
+        (0, import_fs17.writeFileSync)(
           mcpConfigPath,
           JSON.stringify(
             buildKimiMcpConfig(registration, selectExternalMcpServers(context.config))
@@ -56960,7 +57230,7 @@ function createKimiCliBackend(command = "kimi", defaultArgs = []) {
         }).run(context);
       } finally {
         cleanup();
-        if (mcpDirectory) (0, import_fs16.rmSync)(mcpDirectory, { recursive: true, force: true });
+        if (mcpDirectory) (0, import_fs17.rmSync)(mcpDirectory, { recursive: true, force: true });
       }
     }
   };
@@ -58723,6 +58993,56 @@ var RunLedger = class {
   }
 };
 
+// src/events/inline-media.ts
+var MIN_INLINE_MEDIA_CHARS = 8 * 1024;
+var DATA_URL_PREFIX = /^data:([\w.+-]+\/[\w.+-]+);base64,/;
+var BASE64_BODY = /^[A-Za-z0-9+/]+={0,2}$/;
+function omittedMedia(value2) {
+  if (value2.length < MIN_INLINE_MEDIA_CHARS) return null;
+  const dataUrl = DATA_URL_PREFIX.exec(value2);
+  if (dataUrl) {
+    return `[${dataUrl[1]} omitted: ${value2.length - dataUrl[0].length} base64 chars]`;
+  }
+  return BASE64_BODY.test(value2) ? `[base64 omitted: ${value2.length} chars]` : null;
+}
+function withoutMedia(value2) {
+  if (typeof value2 === "string") return omittedMedia(value2) ?? value2;
+  if (Array.isArray(value2)) {
+    let changed = false;
+    const items = value2.map((item) => {
+      const next = withoutMedia(item);
+      if (next !== item) changed = true;
+      return next;
+    });
+    return changed ? items : value2;
+  }
+  if (value2 !== null && typeof value2 === "object") {
+    let changed = false;
+    const entries = Object.entries(value2).map(([key, item]) => {
+      const next = withoutMedia(item);
+      if (next !== item) changed = true;
+      return [key, next];
+    });
+    return changed ? Object.fromEntries(entries) : value2;
+  }
+  return value2;
+}
+function isMeta(value2) {
+  return value2 !== null && typeof value2 === "object" && !Array.isArray(value2);
+}
+function withoutInlineMedia(event) {
+  const { update } = event;
+  const currentMeta = isMeta(update._meta) ? update._meta : void 0;
+  const payload = currentMeta?.[PROVIDER_PAYLOAD_META];
+  const nextPayload = withoutMedia(payload);
+  const rawOutput = update.sessionUpdate === "tool_call_update" ? update.rawOutput : void 0;
+  const nextRawOutput = withoutMedia(rawOutput);
+  if (nextPayload === payload && nextRawOutput === rawOutput) return event;
+  const meta4 = currentMeta && nextPayload !== payload ? { ...currentMeta, [PROVIDER_PAYLOAD_META]: nextPayload } : currentMeta;
+  const next = update.sessionUpdate === "tool_call_update" ? { ...update, _meta: meta4, rawOutput: nextRawOutput } : { ...update, _meta: meta4 };
+  return { ...event, update: next };
+}
+
 // src/events/stream.ts
 var listeners = /* @__PURE__ */ new Map();
 var FINISHED_LIMIT = 256;
@@ -58741,9 +59061,10 @@ function subscribeSessionEvents(key, listener, options = {}) {
 function publishSessionEvent(runId, event, conversationId) {
   const sets = [listeners.get(runId), conversationId ? listeners.get(conversationId) : void 0];
   if (!sets.some((set2) => set2 && set2.size > 0)) return;
+  const outgoing = withoutInlineMedia(event);
   let serialized;
   try {
-    serialized = JSON.stringify(event);
+    serialized = JSON.stringify(outgoing);
   } catch {
     return;
   }
@@ -58754,7 +59075,7 @@ function publishSessionEvent(runId, event, conversationId) {
       if (delivered.has(subscriber)) continue;
       delivered.add(subscriber);
       try {
-        subscriber.listener(event, serialized);
+        subscriber.listener(outgoing, serialized);
       } catch {
         set2.delete(subscriber);
       }
@@ -59949,7 +60270,7 @@ var Polling = class extends Transport {
    */
   pause(onPause) {
     this.readyState = "pausing";
-    const pause = () => {
+    const pause2 = () => {
       debug2("paused");
       this.readyState = "paused";
       onPause();
@@ -59961,7 +60282,7 @@ var Polling = class extends Transport {
         total++;
         this.once("pollComplete", function() {
           debug2("pre-pause polling complete");
-          --total || pause();
+          --total || pause2();
         });
       }
       if (!this.writable) {
@@ -59969,11 +60290,11 @@ var Polling = class extends Transport {
         total++;
         this.once("drain", function() {
           debug2("pre-pause writing complete");
-          --total || pause();
+          --total || pause2();
         });
       }
     } else {
-      pause();
+      pause2();
     }
   }
   /**
@@ -63040,11 +63361,11 @@ function removeNativeHooks(homeDir = (0, import_node_os13.homedir)()) {
 }
 
 // src/events/runtime-command-reply.ts
-var import_promises4 = require("timers/promises");
+var import_promises5 = require("timers/promises");
 async function publishRuntimeCommandReply(path2, reply, credentials) {
   const body = JSON.stringify(reply);
   for (let attempt = 0; attempt < 2; attempt += 1) {
-    if (attempt > 0) await (0, import_promises4.setTimeout)(250, void 0, { signal: credentials.signal });
+    if (attempt > 0) await (0, import_promises5.setTimeout)(250, void 0, { signal: credentials.signal });
     credentials.signal.throwIfAborted();
     let response;
     try {
@@ -63076,18 +63397,17 @@ async function publishModelScanReply(reply, credentials) {
 }
 
 // src/events/replay.ts
-var import_node_fs18 = require("fs");
-var import_promises8 = require("fs/promises");
+var import_node_fs19 = require("fs");
 
 // src/events/live.ts
 var import_node_crypto8 = require("crypto");
 var import_node_fs17 = require("fs");
-var import_promises7 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 
 // src/events/http-retry.ts
 var TranscriptRequestError = class extends Error {
-  retryAfterMs;
   status;
+  retryAfterMs;
   constructor(response) {
     super(`Transcript request failed (${response.status})`);
     this.status = response.status;
@@ -63097,18 +63417,53 @@ var TranscriptRequestError = class extends Error {
     this.retryAfterMs = Number.isFinite(seconds) ? Math.max(0, seconds * 1e3) : Number.isFinite(date5) ? Math.max(0, date5 - Date.now()) : 0;
   }
 };
+var PERMANENT_STATUSES = /* @__PURE__ */ new Set([400, 401, 403, 404, 410, 413, 415]);
+var TRANSIENT_BACKOFF_CAP_MS = 3e4;
+var PERMANENT_BACKOFF_BASE_MS = 6e4;
+var PERMANENT_BACKOFF_CAP_MS = 5 * 6e4;
+function isPermanentTranscriptError(error61) {
+  return error61 instanceof TranscriptRequestError && PERMANENT_STATUSES.has(error61.status);
+}
+function transcriptSyncProblem(error61, at = Date.now()) {
+  return {
+    ...error61 instanceof TranscriptRequestError ? { status: error61.status } : {},
+    message: error61 instanceof Error ? error61.message : String(error61),
+    permanent: isPermanentTranscriptError(error61),
+    at
+  };
+}
 function transcriptRetryDeadline(failures, error61) {
-  const backoff = Math.min(1e3 * 2 ** Math.min(failures - 1, 5), 3e4);
+  const exponent = Math.min(failures - 1, 5);
+  const backoff = isPermanentTranscriptError(error61) ? Math.min(PERMANENT_BACKOFF_BASE_MS * 2 ** exponent, PERMANENT_BACKOFF_CAP_MS) : Math.min(1e3 * 2 ** exponent, TRANSIENT_BACKOFF_CAP_MS);
   return Date.now() + Math.max(
     backoff + Math.floor(Math.random() * backoff * 0.2),
     error61 instanceof TranscriptRequestError ? error61.retryAfterMs : 0
   );
 }
+function requestDeadline(timeoutMs, parent) {
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(
+      new DOMException("The operation was aborted due to timeout", "TimeoutError")
+    ),
+    timeoutMs
+  );
+  const onAbort = () => controller.abort(parent?.reason);
+  if (parent?.aborted) onAbort();
+  else parent?.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: controller.signal,
+    dispose() {
+      clearTimeout(timer);
+      parent?.removeEventListener("abort", onAbort);
+    }
+  };
+}
 
 // src/events/push.ts
 var import_node_crypto7 = require("crypto");
 var import_node_fs16 = require("fs");
-var import_promises6 = require("fs/promises");
+var import_promises7 = require("fs/promises");
 
 // src/events/session.ts
 var import_node_fs15 = require("fs");
@@ -63203,6 +63558,7 @@ function runState(value2) {
     ...offset(value2.liveFailures) ? { liveFailures: value2.liveFailures } : {},
     ...offset(value2.pushRetryAfter) ? { pushRetryAfter: value2.pushRetryAfter } : {},
     ...offset(value2.pushFailures) ? { pushFailures: value2.pushFailures } : {},
+    ...isSyncProblem(value2.syncProblem) ? { syncProblem: value2.syncProblem } : {},
     ...record2(sandbox) && typeof sandbox.sandboxId === "string" && typeof sandbox.taskId === "string" && typeof sandbox.agentSessionId === "string" ? {
       sandbox: {
         sandboxId: sandbox.sandboxId,
@@ -63212,6 +63568,9 @@ function runState(value2) {
     } : {}
   };
 }
+function isSyncProblem(value2) {
+  return record2(value2) && typeof value2.message === "string" && typeof value2.permanent === "boolean" && offset(value2.at) && (value2.status === void 0 || offset(value2.status));
+}
 function readJson(path2) {
   try {
     return JSON.parse((0, import_node_fs14.readFileSync)(path2, "utf8"));
@@ -63313,7 +63672,7 @@ function writeRunTranscriptState(configPath, conversationId, runId, state) {
 }
 
 // src/events/transcript-buffer.ts
-var import_promises5 = require("fs/promises");
+var import_promises6 = require("fs/promises");
 var RETAINED_BYTES = 256 * 1024;
 var MAX_PENDING_TRANSCRIPT_BYTES = 8 * 1024 * 1024;
 var TranscriptBuffer = class {
@@ -63373,7 +63732,7 @@ function closeTranscriptBuffer(path2, buffer) {
 async function retryTranscriptWrites(path2, runId) {
   const buffer = active.get(path2);
   if (!buffer || buffer.runId !== runId) return void 0;
-  const file2 = await (0, import_promises5.open)(path2, "r+");
+  const file2 = await (0, import_promises6.open)(path2, "r+");
   try {
     const stat4 = await file2.stat();
     if (`${stat4.dev}.${stat4.ino}.${stat4.birthtimeMs}` !== buffer.generation)
@@ -63410,6 +63769,13 @@ var openTranscripts = /* @__PURE__ */ new Set();
 function isSessionTranscriptOpen(runId) {
   return openTranscripts.has(runId);
 }
+function canonicalPromptMeta(message) {
+  const meta4 = {
+    ...message.clientMessageId ? { "alan.dev/clientMessageId": message.clientMessageId } : {},
+    ...message.attachmentIds?.length ? { "alan.dev/attachmentIds": message.attachmentIds } : {}
+  };
+  return Object.keys(meta4).length > 0 ? { _meta: meta4 } : {};
+}
 function requestTranscriptFinalization(configPath, conversationId, runId) {
   const state = readRunTranscriptState(configPath, conversationId, runId);
   if (state && state.endOffset !== void 0 && !state.interrupted)
@@ -63480,7 +63846,7 @@ function openSessionTranscript(input2) {
             sessionUpdate: "user_message",
             messageId: message.id,
             content: [{ type: "text", text: message.content }],
-            ...message.clientMessageId ? { _meta: { "alan.dev/clientMessageId": message.clientMessageId } } : {}
+            ...canonicalPromptMeta(message)
           }
         };
         const bytes = Buffer.from(`${JSON.stringify(event)}
@@ -63644,6 +64010,11 @@ function sizeOf(path2) {
 var CHECKPOINT_MS = 5e3;
 var MAX_RECEIPT_POLL_MS = 15e3;
 var MAX_PUSH_BYTES = 512 * 1024;
+var MIN_PUSH_BYTES = 64 * 1024;
+var adaptivePushBytes = MAX_PUSH_BYTES;
+function isTimeout(error61) {
+  return error61 instanceof Error && error61.name === "TimeoutError";
+}
 var REQUEST_TIMEOUT_MS = 1e4;
 function transcriptPushUrl(apiUrl, conversationId) {
   return `${apiUrl.replace(/\/+$/, "")}/public/conversations/${encodeURIComponent(conversationId)}/transcript`;
@@ -63656,34 +64027,39 @@ function isReceipt(value2) {
 async function exchange(target, body, offset2, final = false) {
   const token = target.getRuntimeToken();
   if (!token) throw new Error("Transcript token unavailable");
-  const response = await fetch(transcriptPushUrl(target.apiUrl, target.conversationId), {
-    method: body ? "POST" : "GET",
-    signal: target.signal ? AbortSignal.any([target.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]) : AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-    headers: {
-      authorization: `Bearer ${token}`,
-      "x-alan-run-id": target.runId,
-      ...target.sandbox ? {
-        "x-alan-sandbox-id": target.sandbox.sandboxId,
-        "x-alan-task-id": target.sandbox.taskId,
-        "x-alan-agent-session-id": target.sandbox.agentSessionId
-      } : {},
-      ...body ? {
-        "content-type": "application/octet-stream",
-        "x-alan-offset": String(offset2),
-        "x-alan-revision": "0",
-        "x-alan-sha256": (0, import_node_crypto7.createHash)("sha256").update(body).digest("hex"),
-        ...final ? { "x-alan-final": "1" } : {}
-      } : {}
-    },
-    ...body ? { body: new Uint8Array(body) } : {}
-  });
-  if (!response.ok) throw new TranscriptRequestError(response);
-  const result = await response.json();
-  if (!result || typeof result !== "object" || !("receipt" in result))
-    throw new Error("Invalid transcript receipt");
-  if (result.receipt === null && !body) return null;
-  if (!isReceipt(result.receipt)) throw new Error("Invalid transcript receipt");
-  return result.receipt;
+  const deadline = requestDeadline(REQUEST_TIMEOUT_MS, target.signal);
+  try {
+    const response = await fetch(transcriptPushUrl(target.apiUrl, target.conversationId), {
+      method: body ? "POST" : "GET",
+      signal: deadline.signal,
+      headers: {
+        authorization: `Bearer ${token}`,
+        "x-alan-run-id": target.runId,
+        ...target.sandbox ? {
+          "x-alan-sandbox-id": target.sandbox.sandboxId,
+          "x-alan-task-id": target.sandbox.taskId,
+          "x-alan-agent-session-id": target.sandbox.agentSessionId
+        } : {},
+        ...body ? {
+          "content-type": "application/octet-stream",
+          "x-alan-offset": String(offset2),
+          "x-alan-revision": "0",
+          "x-alan-sha256": (0, import_node_crypto7.createHash)("sha256").update(body).digest("hex"),
+          ...final ? { "x-alan-final": "1" } : {}
+        } : {}
+      },
+      ...body ? { body: new Uint8Array(body) } : {}
+    });
+    if (!response.ok) throw new TranscriptRequestError(response);
+    const result = await response.json();
+    if (!result || typeof result !== "object" || !("receipt" in result))
+      throw new Error("Invalid transcript receipt");
+    if (result.receipt === null && !body) return null;
+    if (!isReceipt(result.receipt)) throw new Error("Invalid transcript receipt");
+    return result.receipt;
+  } finally {
+    deadline.dispose();
+  }
 }
 function readTranscriptReceipt(target) {
   return exchange(target);
@@ -63755,8 +64131,8 @@ function startTranscriptPush(target, onProblem) {
     while (!stopped && uploadDue && admitted < boundary) {
       const current = state();
       if (!current) throw new Error("Transcript run range disappeared");
-      const end = Math.min(boundary, admitted + MAX_PUSH_BYTES);
-      const file2 = await (0, import_promises6.open)(path2, "r");
+      const end = Math.min(boundary, admitted + adaptivePushBytes);
+      const file2 = await (0, import_promises7.open)(path2, "r");
       let bytes;
       try {
         bytes = Buffer.alloc(end - admitted);
@@ -63770,6 +64146,7 @@ function startTranscriptPush(target, onProblem) {
       const next = accept(receipt);
       if (next <= admitted) throw new Error("Transcript admission did not advance");
       admitted = next;
+      adaptivePushBytes = Math.min(MAX_PUSH_BYTES, adaptivePushBytes * 2);
       checkpointAt = Date.now() + CHECKPOINT_MS;
     }
     if (stopped) return;
@@ -63795,15 +64172,17 @@ function startTranscriptPush(target, onProblem) {
       failures = 0;
       retryNotBefore = 0;
       const current = state();
-      if (current?.pushRetryAfter !== void 0 || current?.pushFailures !== void 0) {
+      if (current?.pushRetryAfter !== void 0 || current?.pushFailures !== void 0 || current?.syncProblem !== void 0) {
         writeRunTranscriptState(target.configPath, target.conversationId, target.runId, {
           ...current,
           pushRetryAfter: void 0,
-          pushFailures: void 0
+          pushFailures: void 0,
+          syncProblem: void 0
         });
       }
     }).catch((error61) => {
       if (target.signal?.aborted) return;
+      if (isTimeout(error61)) adaptivePushBytes = Math.max(MIN_PUSH_BYTES, adaptivePushBytes / 2);
       failures += 1;
       pending = true;
       cached2 = void 0;
@@ -63814,7 +64193,8 @@ function startTranscriptPush(target, onProblem) {
           writeRunTranscriptState(target.configPath, target.conversationId, target.runId, {
             ...current,
             pushRetryAfter: retryNotBefore,
-            pushFailures: failures
+            pushFailures: failures,
+            syncProblem: transcriptSyncProblem(error61)
           });
       } catch (stateError) {
         onProblem(
@@ -63934,30 +64314,37 @@ function startTranscriptLive(target, onProblem) {
   const exchange2 = async (body, offset2, epoch) => {
     const token = target.getRuntimeToken();
     if (!token) throw new Error("Live transcript token unavailable");
-    const response = await fetch(transcriptPushUrl(target.apiUrl, target.conversationId), {
-      method: body ? "POST" : "GET",
-      signal: AbortSignal.any([signal, AbortSignal.timeout(5e3)]),
-      headers: {
-        authorization: `Bearer ${token}`,
-        "x-alan-run-id": target.runId,
-        [TRANSCRIPT_LIVE_DELIVERY_HEADER]: "live",
-        ...target.sandbox ? {
-          "x-alan-sandbox-id": target.sandbox.sandboxId,
-          "x-alan-task-id": target.sandbox.taskId,
-          "x-alan-agent-session-id": target.sandbox.agentSessionId
-        } : {},
-        ...body ? {
-          "content-type": "application/octet-stream",
-          "x-alan-offset": String(offset2),
-          "x-alan-revision": "0",
-          "x-alan-sha256": (0, import_node_crypto8.createHash)("sha256").update(body).digest("hex"),
-          "x-alan-live-epoch": epoch ?? ""
-        } : {}
-      },
-      ...body ? { body: new Uint8Array(body) } : {}
-    });
-    if (!response.ok) throw new TranscriptRequestError(response);
-    const result = await response.json();
+    const deadline = requestDeadline(5e3, signal);
+    let response;
+    let result;
+    try {
+      response = await fetch(transcriptPushUrl(target.apiUrl, target.conversationId), {
+        method: body ? "POST" : "GET",
+        signal: deadline.signal,
+        headers: {
+          authorization: `Bearer ${token}`,
+          "x-alan-run-id": target.runId,
+          [TRANSCRIPT_LIVE_DELIVERY_HEADER]: "live",
+          ...target.sandbox ? {
+            "x-alan-sandbox-id": target.sandbox.sandboxId,
+            "x-alan-task-id": target.sandbox.taskId,
+            "x-alan-agent-session-id": target.sandbox.agentSessionId
+          } : {},
+          ...body ? {
+            "content-type": "application/octet-stream",
+            "x-alan-offset": String(offset2),
+            "x-alan-revision": "0",
+            "x-alan-sha256": (0, import_node_crypto8.createHash)("sha256").update(body).digest("hex"),
+            "x-alan-live-epoch": epoch ?? ""
+          } : {}
+        },
+        ...body ? { body: new Uint8Array(body) } : {}
+      });
+      if (!response.ok) throw new TranscriptRequestError(response);
+      result = await response.json();
+    } finally {
+      deadline.dispose();
+    }
     if (!record3(result) || !isReceipt2(result.receipt))
       throw new Error("Invalid live transcript receipt");
     const receipt = result.receipt;
@@ -63988,7 +64375,7 @@ function startTranscriptLive(target, onProblem) {
         if (active2 && from < active2.retainedFrom)
           length = Math.min(length, active2.retainedFrom - from);
         bytes = Buffer.alloc(length);
-        const file2 = await (0, import_promises7.open)(path2, "r");
+        const file2 = await (0, import_promises8.open)(path2, "r");
         try {
           const read = await file2.read(bytes, 0, length, from);
           if (read.bytesRead !== length) throw new Error("Live transcript changed during read");
@@ -64094,19 +64481,104 @@ function startTranscriptLive(target, onProblem) {
   };
 }
 
+// src/events/sync-backlog.ts
+var import_node_fs18 = require("fs");
+function isTranscriptDelivered(state) {
+  if (!state || state.endOffset === void 0) return true;
+  const size = state.endOffset - state.startOffset;
+  return state.syncedOffset === size && state.finalizedOffset === size;
+}
+function decodeConversationId(name) {
+  try {
+    const id = decodeURIComponent(name);
+    return id.length > 0 ? id : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function listStoredConversationIds(configPath) {
+  let entries;
+  try {
+    entries = (0, import_node_fs18.readdirSync)(sessionsDirectory(configPath), { withFileTypes: true });
+  } catch (error61) {
+    if (error61.code === "ENOENT") return [];
+    throw error61;
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const name = entry.isDirectory() ? entry.name.replace(/\.runs$/, "") : entry.isFile() && entry.name.endsWith(".jsonl") ? entry.name.slice(0, -6) : void 0;
+    const id = name === void 0 ? void 0 : decodeConversationId(name);
+    if (id) ids.add(id);
+  }
+  return [...ids];
+}
+function readTranscriptSyncBacklog(configPath, isRunActive) {
+  const backlog = [];
+  for (const conversationId of listStoredConversationIds(configPath)) {
+    let runs;
+    try {
+      runs = readConversationSyncState(configPath, conversationId).runs;
+    } catch {
+      continue;
+    }
+    for (const [runId, state] of Object.entries(runs)) {
+      if (isRunActive(runId) || isTranscriptDelivered(state) || state.endOffset === void 0)
+        continue;
+      backlog.push({
+        runId,
+        conversationId,
+        pendingBytes: Math.max(0, state.endOffset - state.startOffset - state.syncedOffset),
+        failures: state.pushFailures ?? 0,
+        ...state.syncProblem ? { problem: state.syncProblem } : {}
+      });
+    }
+  }
+  return backlog.sort((a, b) => b.pendingBytes - a.pendingBytes);
+}
+function releasePermanentTranscriptCooldowns(configPath) {
+  let released = 0;
+  for (const conversationId of listStoredConversationIds(configPath)) {
+    let runs;
+    try {
+      runs = readConversationSyncState(configPath, conversationId).runs;
+    } catch {
+      continue;
+    }
+    for (const [runId, state] of Object.entries(runs)) {
+      if (!state.syncProblem?.permanent) continue;
+      writeRunTranscriptState(configPath, conversationId, runId, {
+        ...state,
+        pushRetryAfter: void 0,
+        pushFailures: void 0,
+        liveRetryAfter: void 0,
+        liveFailures: void 0
+      });
+      released += 1;
+    }
+  }
+  return released;
+}
+
 // src/events/replay.ts
 function startTranscriptReplay(options) {
   const controller = new AbortController();
   const signal = AbortSignal.any([options.signal, controller.signal]);
   let running;
   let notifiedDuringReplay = false;
+  let cooldownTimer;
+  const retryAfterCooldown = (retryAt) => {
+    if (retryAt === void 0 || signal.aborted) return;
+    if (cooldownTimer) clearTimeout(cooldownTimer);
+    cooldownTimer = setTimeout(notify, Math.max(0, retryAt - Date.now()));
+    cooldownTimer.unref();
+  };
   const notify = () => {
     if (signal.aborted) return;
     if (running) {
       notifiedDuringReplay = true;
       return;
     }
-    running = replayClosedTranscripts({ ...options, signal }).catch((error61) => options.onProblem(`transcript-replay-failed ${String(error61)}`)).finally(() => {
+    running = replayClosedTranscripts({ ...options, signal }).then(retryAfterCooldown).catch((error61) => options.onProblem(`transcript-replay-failed ${String(error61)}`)).finally(() => {
       running = void 0;
       if (notifiedDuringReplay) {
         notifiedDuringReplay = false;
@@ -64120,6 +64592,7 @@ function startTranscriptReplay(options) {
     notify,
     async stop() {
       clearInterval(timer);
+      if (cooldownTimer) clearTimeout(cooldownTimer);
       controller.abort();
       await running;
     }
@@ -64131,7 +64604,7 @@ function recoverInterruptedRange(options, conversationId, runId) {
   if (!state) throw new Error("Transcript range disappeared");
   if ((state.finalRequested || state.interrupted) && state.endOffset !== void 0) return state;
   const path2 = transcriptPath(options.configPath, conversationId);
-  const length = (0, import_node_fs18.statSync)(path2).size;
+  const length = (0, import_node_fs19.statSync)(path2).size;
   const nextStart = Object.values(conversation.runs).reduce(
     (end2, range) => range.startOffset > state.startOffset ? Math.min(end2, range.startOffset) : end2,
     length
@@ -64139,12 +64612,12 @@ function recoverInterruptedRange(options, conversationId, runId) {
   let end = state.endOffset ?? nextStart;
   if (end > length || end < state.startOffset)
     throw new Error("Interrupted transcript range is outside its journal");
-  const file2 = (0, import_node_fs18.openSync)(path2, "r");
+  const file2 = (0, import_node_fs19.openSync)(path2, "r");
   try {
     const buffer = Buffer.alloc(64 * 1024);
     while (end > state.startOffset) {
       const start = Math.max(state.startOffset, end - buffer.length);
-      const count2 = (0, import_node_fs18.readSync)(file2, buffer, 0, end - start, start);
+      const count2 = (0, import_node_fs19.readSync)(file2, buffer, 0, end - start, start);
       if (count2 !== end - start) throw new Error("Interrupted transcript changed during recovery");
       const newline = buffer.subarray(0, count2).lastIndexOf(10);
       if (newline >= 0) {
@@ -64154,7 +64627,7 @@ function recoverInterruptedRange(options, conversationId, runId) {
       end = start;
     }
   } finally {
-    (0, import_node_fs18.closeSync)(file2);
+    (0, import_node_fs19.closeSync)(file2);
   }
   if (end < state.startOffset + state.syncedOffset)
     throw new Error("Interrupted transcript has committed incomplete bytes; repair required");
@@ -64170,114 +64643,121 @@ function recoverInterruptedRange(options, conversationId, runId) {
   );
   return recovered;
 }
-function waitUntil(at, signal) {
-  return new Promise((resolve16) => {
-    const done = () => {
-      signal.removeEventListener("abort", done);
-      clearTimeout(timer);
-      resolve16();
-    };
-    const timer = setTimeout(done, Math.max(0, at - Date.now()));
-    signal.addEventListener("abort", done, { once: true });
-  });
-}
-function isDelivered(state) {
-  if (!state || state.endOffset === void 0) return true;
-  const size = state.endOffset - state.startOffset;
-  return state.syncedOffset === size && state.finalizedOffset === size;
-}
-function decodeId(name) {
+var REPLAY_CONCURRENCY = 3;
+function lastActivityMs(configPath, conversationId) {
   try {
-    const id = decodeURIComponent(name);
-    return id.length > 0 ? id : void 0;
+    return (0, import_node_fs19.statSync)(syncStatePath(configPath, conversationId)).mtimeMs;
   } catch {
-    return void 0;
+    return 0;
   }
 }
 async function replayClosedTranscripts(options) {
-  if (options.signal.aborted || !options.canReplay()) return;
-  const root = sessionsDirectory(options.configPath);
-  const directories = await (0, import_promises8.opendir)(root).catch((error61) => {
-    if (error61.code === "ENOENT") return void 0;
-    throw error61;
-  });
-  if (!directories) return;
-  const conversations = /* @__PURE__ */ new Set();
-  for await (const directory of directories) {
-    const name = directory.isDirectory() ? directory.name.replace(/\.runs$/, "") : directory.isFile() && directory.name.endsWith(".jsonl") ? directory.name.slice(0, -6) : void 0;
-    const conversationId = name === void 0 ? void 0 : decodeId(name);
-    if (!conversationId) continue;
-    conversations.add(conversationId);
-  }
-  for (const conversationId of conversations) {
-    if (options.conversationId && options.conversationId !== conversationId) continue;
+  if (options.signal.aborted || !options.canReplay()) return void 0;
+  const conversations = listStoredConversationIds(options.configPath).filter((id) => !options.conversationId || options.conversationId === id).map((id) => ({ id, activity: lastActivityMs(options.configPath, id) })).sort((a, b) => b.activity - a.activity).map((entry) => entry.id);
+  const cooldowns = { earliest: void 0 };
+  let next = 0;
+  const worker = async () => {
+    while (next < conversations.length) {
+      if (options.signal.aborted || !options.canReplay()) return;
+      const conversationId = conversations[next++];
+      if (conversationId) await replayConversation(options, conversationId, cooldowns);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(REPLAY_CONCURRENCY, conversations.length) }, worker)
+  );
+  return cooldowns.earliest;
+}
+async function replayConversation(options, conversationId, cooldowns) {
+  let conversation;
+  try {
+    migrateConversationStorage(options.configPath, conversationId);
+    conversation = readConversationSyncState(options.configPath, conversationId);
+  } catch (error61) {
+    options.onProblem(`transcript-state-failed conversation=${conversationId}: ${String(error61)}`);
+    return;
+  }
+  const runIds = Object.keys(conversation.runs).sort(
+    (a, b) => (conversation.runs[b]?.startOffset ?? 0) - (conversation.runs[a]?.startOffset ?? 0)
+  );
+  for (const runId of runIds) {
     if (options.signal.aborted || !options.canReplay()) return;
-    let conversation;
+    if (options.isRunActive(runId) || isSessionTranscriptOpen(runId)) continue;
+    if (options.sandboxId && conversation.runs[runId]?.sandbox?.sandboxId !== options.sandboxId)
+      continue;
+    let state;
     try {
-      migrateConversationStorage(options.configPath, conversationId);
-      conversation = readConversationSyncState(options.configPath, conversationId);
+      const recoveredEnd = await retryTranscriptWrites(
+        transcriptPath(options.configPath, conversationId),
+        runId
+      );
+      if (recoveredEnd !== void 0) {
+        const current = readConversationSyncState(options.configPath, conversationId).runs[runId];
+        if (!current) throw new Error("Transcript range disappeared during write recovery");
+        writeRunTranscriptState(options.configPath, conversationId, runId, {
+          ...current,
+          endOffset: recoveredEnd,
+          interrupted: true,
+          finalRequested: false
+        });
+        const path2 = transcriptPath(options.configPath, conversationId);
+        const buffer = getTranscriptBuffer(path2);
+        if (buffer) closeTranscriptBuffer(path2, buffer);
+      }
+      state = recoverInterruptedRange(options, conversationId, runId);
     } catch (error61) {
-      options.onProblem(`transcript-state-failed conversation=${conversationId}: ${String(error61)}`);
+      options.onProblem(`transcript-recovery-failed run=${runId}: ${String(error61)}`);
       continue;
     }
-    for (const runId of Object.keys(conversation.runs)) {
-      if (options.signal.aborted || !options.canReplay()) return;
-      if (options.isRunActive(runId) || isSessionTranscriptOpen(runId)) continue;
-      if (options.sandboxId && conversation.runs[runId]?.sandbox?.sandboxId !== options.sandboxId)
-        continue;
-      let state;
-      try {
-        const recoveredEnd = await retryTranscriptWrites(
-          transcriptPath(options.configPath, conversationId),
-          runId
-        );
-        if (recoveredEnd !== void 0) {
-          const current = readConversationSyncState(options.configPath, conversationId).runs[runId];
-          if (!current) throw new Error("Transcript range disappeared during write recovery");
-          writeRunTranscriptState(options.configPath, conversationId, runId, {
-            ...current,
-            endOffset: recoveredEnd,
-            interrupted: true,
-            finalRequested: false
-          });
-          const path2 = transcriptPath(options.configPath, conversationId);
-          const buffer = getTranscriptBuffer(path2);
-          if (buffer) closeTranscriptBuffer(path2, buffer);
-        }
-        state = recoverInterruptedRange(options, conversationId, runId);
-      } catch (error61) {
-        options.onProblem(`transcript-recovery-failed run=${runId}: ${String(error61)}`);
-        continue;
-      }
-      if (state.endOffset === void 0) continue;
-      const size = state.endOffset - state.startOffset;
-      if (state.syncedOffset === size && state.finalizedOffset === size) continue;
-      const target = {
-        configPath: options.configPath,
-        apiUrl: options.apiUrl,
-        conversationId,
-        runId,
-        getRuntimeToken: options.getRuntimeToken,
-        signal: options.signal,
-        sandbox: state.sandbox
-      };
-      const cooldownUntil = Math.max(state.pushRetryAfter ?? 0, state.liveRetryAfter ?? 0);
-      const push2 = startTranscriptPush(target, options.onProblem);
-      const live = startTranscriptLive(target, options.onProblem);
-      try {
-        await Promise.all([push2.flush(), live.flush()]);
-        if (cooldownUntil > Date.now() && !isDelivered(readConversationSyncState(options.configPath, conversationId).runs[runId])) {
-          await waitUntil(cooldownUntil, options.signal);
-          if (!options.signal.aborted) await Promise.all([push2.flush(), live.flush()]);
-        }
-      } finally {
-        await Promise.all([push2.stop(), live.stop()]);
-      }
+    if (state.endOffset === void 0 || isTranscriptDelivered(state)) continue;
+    const cooldownUntil = Math.max(state.pushRetryAfter ?? 0, state.liveRetryAfter ?? 0);
+    if (cooldownUntil > Date.now()) {
+      cooldowns.earliest = Math.min(cooldowns.earliest ?? cooldownUntil, cooldownUntil);
+      continue;
+    }
+    const target = {
+      configPath: options.configPath,
+      apiUrl: options.apiUrl,
+      conversationId,
+      runId,
+      getRuntimeToken: options.getRuntimeToken,
+      signal: options.signal,
+      sandbox: state.sandbox
+    };
+    const push2 = startTranscriptPush(target, options.onProblem);
+    const live = startTranscriptLive(target, options.onProblem);
+    try {
+      await Promise.all([push2.flush(), live.flush()]);
+    } finally {
+      await Promise.all([push2.stop(), live.stop()]);
     }
   }
 }
 
 // src/events/run-events.ts
+var TERMINAL_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "query_complete",
+  "complete",
+  "session_complete",
+  "session_error",
+  "agent_run_finished"
+]);
+var TERMINAL_RETRY_WINDOW_MS = 10 * 6e4;
+var RETRY_BACKOFF_CAP_MS = 3e4;
+function isRetryableStatus(status2) {
+  return status2 === 408 || status2 === 429 || status2 >= 500;
+}
+function pause(ms, signal) {
+  return new Promise((resolve16) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve16();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
 function runEventsUrl(wsUrl) {
   const base = wsUrl.replace(/^ws:/, "http:").replace(/^wss:/, "https:").replace(/\/+$/, "");
   return `${base}/runtime/run-events`;
@@ -64339,24 +64819,41 @@ function createHttpRunEventSink(input2, url3, binding) {
     }
   }
   async function deliver(conversationId, runId, event) {
-    if (shutdown.signal.aborted) return;
-    const token = input2.getRuntimeToken();
-    if (!token) return;
-    try {
-      const response = await postRunEvent({
-        url: url3,
-        token,
-        conversationId,
-        runId,
-        event,
-        signal: shutdown.signal,
-        binding
-      });
-      if (!response.ok) input2.onFailure?.(`run-event rejected ${response.status} run=${runId}`);
-    } catch (error61) {
-      input2.onFailure?.(
-        `run-event send failed run=${runId}: ${error61 instanceof Error ? error61.message : String(error61)}`
-      );
+    const terminal = TERMINAL_EVENT_TYPES.has(event.type);
+    const giveUpAt = Date.now() + TERMINAL_RETRY_WINDOW_MS;
+    for (let attempt = 0; ; attempt++) {
+      if (shutdown.signal.aborted) return;
+      const token = input2.getRuntimeToken();
+      if (!token) return;
+      let failure2;
+      let retryable;
+      const deadline = requestDeadline(1e4, shutdown.signal);
+      try {
+        const response = await postRunEvent({
+          url: url3,
+          token,
+          conversationId,
+          runId,
+          event,
+          signal: deadline.signal,
+          binding
+        });
+        if (response.ok) return;
+        failure2 = `run-event rejected ${response.status} run=${runId}`;
+        retryable = isRetryableStatus(response.status);
+      } catch (error61) {
+        failure2 = `run-event send failed run=${runId}: ${error61 instanceof Error ? error61.message : String(error61)}`;
+        retryable = true;
+      } finally {
+        deadline.dispose();
+      }
+      const backoff = Math.min(1e3 * 2 ** attempt, RETRY_BACKOFF_CAP_MS);
+      if (!terminal || !retryable || Date.now() + backoff > giveUpAt) {
+        input2.onFailure?.(failure2);
+        return;
+      }
+      input2.onFailure?.(`${failure2}; retrying in ${backoff}ms`);
+      await pause(backoff, shutdown.signal);
     }
   }
   return {
@@ -64424,7 +64921,7 @@ function createTranscriptWatchRegistry() {
 }
 
 // src/native/ingest.ts
-var import_node_fs20 = require("fs");
+var import_node_fs21 = require("fs");
 var import_promises10 = require("fs/promises");
 
 // src/native/alan-runs.ts
@@ -64664,7 +65161,7 @@ async function pushNativeTurn(delivery, record4) {
 
 // src/native/session-store.ts
 var import_node_crypto9 = require("crypto");
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_path19 = require("path");
 var MAX_NATIVE_SESSION_ENTRIES = 500;
 var nativeRunFinishEvents = ["agent_run_finished", "query_complete"];
@@ -64701,7 +65198,7 @@ function isSessionEntry(value2) {
 function loadSessions(path2) {
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs19.readFileSync)(path2, "utf8"));
+    parsed = JSON.parse((0, import_node_fs20.readFileSync)(path2, "utf8"));
   } catch {
     return [];
   }
@@ -64709,14 +65206,14 @@ function loadSessions(path2) {
   return parsed.sessions.filter(isSessionEntry);
 }
 function writeAtomically(path2, contents) {
-  (0, import_node_fs19.mkdirSync)((0, import_node_path19.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs20.mkdirSync)((0, import_node_path19.dirname)(path2), { recursive: true, mode: 448 });
   const pending = `${path2}.pending-${process.pid}-${(0, import_node_crypto9.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs19.writeFileSync)(pending, contents, { mode: 384 });
-    (0, import_node_fs19.chmodSync)(pending, 384);
-    (0, import_node_fs19.renameSync)(pending, path2);
+    (0, import_node_fs20.writeFileSync)(pending, contents, { mode: 384 });
+    (0, import_node_fs20.chmodSync)(pending, 384);
+    (0, import_node_fs20.renameSync)(pending, path2);
   } finally {
-    (0, import_node_fs19.rmSync)(pending, { force: true });
+    (0, import_node_fs20.rmSync)(pending, { force: true });
   }
 }
 function evictionOrder(a, b) {
@@ -64965,7 +65462,7 @@ function sleep2(ms, signal) {
   });
 }
 function holdFor(entry) {
-  const stats = (0, import_node_fs20.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
+  const stats = (0, import_node_fs21.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
   if (!stats) return [];
   return [
     {
@@ -65181,7 +65678,7 @@ function createNativeIngestionSink(deps) {
   const recordAlanRun = (hold, runId) => {
     const entry = store.get(hold.provider, hold.externalSessionId);
     if (!entry || entry.dead) return;
-    const stats = (0, import_node_fs20.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
+    const stats = (0, import_node_fs21.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
     if (!stats) return;
     const identity = { device: String(stats.dev), inode: String(stats.ino) };
     const size = Number(stats.size);
@@ -65463,7 +65960,7 @@ function createNativeIngestionSink(deps) {
     schedule(worker, timing.debounceMs);
   };
   const hasUnreadBytes = (entry, now) => {
-    const stats = (0, import_node_fs20.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
+    const stats = (0, import_node_fs21.statSync)(entry.transcriptPath, { bigint: true, throwIfNoEntry: false });
     if (!stats || now - Number(stats.mtimeMs) > timing.sweepRecencyMs) return false;
     const replaced = String(stats.dev) !== entry.device || String(stats.ino) !== entry.inode;
     return replaced || Number(stats.size) > entry.cursor.offset;
@@ -67826,16 +68323,16 @@ function applyLeaseCheckResult(input2) {
 }
 
 // src/daemon/admission.ts
-var import_node_fs22 = require("fs");
+var import_node_fs23 = require("fs");
 var import_node_path26 = require("path");
 
 // src/workspace-relocation.ts
 var import_node_child_process6 = require("child_process");
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_path24 = require("path");
 var MAX_RELOCATION_CANDIDATES = 200;
 var DEFAULT_PROBE2 = {
-  childDirectories: (parentPath, limit) => (0, import_node_fs21.readdirSync)(parentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).slice(0, limit).map((entry) => (0, import_node_path24.join)(parentPath, entry.name)),
+  childDirectories: (parentPath, limit) => (0, import_node_fs22.readdirSync)(parentPath, { withFileTypes: true }).filter((entry) => entry.isDirectory()).slice(0, limit).map((entry) => (0, import_node_path24.join)(parentPath, entry.name)),
   gitRemoteUrl: (candidatePath) => {
     const result = (0, import_node_child_process6.spawnSync)("git", ["-C", candidatePath, "config", "--get", "remote.origin.url"], {
       encoding: "utf8",
@@ -68140,7 +68637,7 @@ function resolveWorkspace(ctx, payload) {
   const workspacePathPinned = payload.workspacePathPinned === true;
   if (isAlanDefaultWorkspace(payload.projectPath) && !workspacePathPinned) {
     try {
-      (0, import_node_fs22.mkdirSync)(cwd, { recursive: true });
+      (0, import_node_fs23.mkdirSync)(cwd, { recursive: true });
     } catch {
     }
   }
@@ -68616,7 +69113,7 @@ async function launchRun(ctx, payload, plan) {
 }
 
 // src/daemon/journal.ts
-var import_node_fs23 = require("fs");
+var import_node_fs24 = require("fs");
 var import_node_path27 = require("path");
 var JOURNAL_VERSION = 1;
 var INTERRUPTED_ENTRY_TTL_MS = 24 * 60 * 6e4;
@@ -68636,9 +69133,9 @@ function isEntry(value2) {
 var RuntimeRunJournal = class {
   constructor(path2, nowMs = Date.now()) {
     this.path = path2;
-    if (!(0, import_node_fs23.existsSync)(path2)) return;
+    if (!(0, import_node_fs24.existsSync)(path2)) return;
     try {
-      const parsed = JSON.parse((0, import_node_fs23.readFileSync)(path2, "utf8"));
+      const parsed = JSON.parse((0, import_node_fs24.readFileSync)(path2, "utf8"));
       if (parsed.version !== JOURNAL_VERSION || !Array.isArray(parsed.entries)) {
         throw new Error("unsupported run journal format");
       }
@@ -68761,18 +69258,18 @@ var RuntimeRunJournal = class {
   }
   persist() {
     const pendingPath = `${this.path}.pending`;
-    (0, import_node_fs23.mkdirSync)((0, import_node_path27.dirname)(this.path), { recursive: true });
+    (0, import_node_fs24.mkdirSync)((0, import_node_path27.dirname)(this.path), { recursive: true });
     try {
-      (0, import_node_fs23.writeFileSync)(
+      (0, import_node_fs24.writeFileSync)(
         pendingPath,
         `${JSON.stringify({ version: JOURNAL_VERSION, entries: [...this.entries.values()] })}
 `,
         { mode: 384 }
       );
-      (0, import_node_fs23.chmodSync)(pendingPath, 384);
-      (0, import_node_fs23.renameSync)(pendingPath, this.path);
+      (0, import_node_fs24.chmodSync)(pendingPath, 384);
+      (0, import_node_fs24.renameSync)(pendingPath, this.path);
     } catch (error61) {
-      (0, import_node_fs23.rmSync)(pendingPath, { force: true });
+      (0, import_node_fs24.rmSync)(pendingPath, { force: true });
       throw error61;
     }
   }
@@ -68931,7 +69428,7 @@ function bindLocalApi(server, port) {
 }
 
 // src/daemon/log.ts
-var import_node_fs24 = require("fs");
+var import_node_fs25 = require("fs");
 var import_node_path28 = require("path");
 var RECENT_LIMIT = 200;
 var MAX_BYTES = 5 * 1024 * 1024;
@@ -68944,20 +69441,20 @@ function openDaemonLog(configPath) {
   let written = 0;
   let sinceSizeCheck = 0;
   const open6 = () => {
-    (0, import_node_fs24.mkdirSync)(directory, { recursive: true, mode: 448 });
-    handle = (0, import_node_fs24.openSync)(path2, "a", 384);
+    (0, import_node_fs25.mkdirSync)(directory, { recursive: true, mode: 448 });
+    handle = (0, import_node_fs25.openSync)(path2, "a", 384);
     try {
-      written = (0, import_node_fs24.statSync)(path2).size;
+      written = (0, import_node_fs25.statSync)(path2).size;
     } catch {
       written = 0;
     }
   };
   const rotate = () => {
     if (handle === null) return;
-    (0, import_node_fs24.closeSync)(handle);
+    (0, import_node_fs25.closeSync)(handle);
     handle = null;
     try {
-      (0, import_node_fs24.renameSync)(path2, `${path2}.1`);
+      (0, import_node_fs25.renameSync)(path2, `${path2}.1`);
     } catch {
     }
     open6();
@@ -68982,7 +69479,7 @@ function openDaemonLog(configPath) {
         sinceSizeCheck = 0;
         rotate();
       }
-      if (handle !== null) written += (0, import_node_fs24.writeSync)(handle, line);
+      if (handle !== null) written += (0, import_node_fs25.writeSync)(handle, line);
     } catch {
     }
   };
@@ -68992,7 +69489,7 @@ function openDaemonLog(configPath) {
     close: () => {
       if (handle === null) return;
       try {
-        (0, import_node_fs24.closeSync)(handle);
+        (0, import_node_fs25.closeSync)(handle);
       } catch {
       }
       handle = null;
@@ -69251,16 +69748,16 @@ function handleCapabilities(res) {
 }
 
 // src/daemon/routes/local-transcript.ts
-var import_node_fs25 = require("fs");
+var import_node_fs26 = require("fs");
 var LocalTranscriptUnavailable = class extends Error {
 };
 function completeEnd(path2, start, end) {
-  const file2 = (0, import_node_fs25.openSync)(path2, "r");
+  const file2 = (0, import_node_fs26.openSync)(path2, "r");
   const buffer = Buffer.alloc(64 * 1024);
   try {
     while (end > start) {
       const from = Math.max(start, end - buffer.length);
-      const count2 = (0, import_node_fs25.readSync)(file2, buffer, 0, end - from, from);
+      const count2 = (0, import_node_fs26.readSync)(file2, buffer, 0, end - from, from);
       if (count2 !== end - from)
         throw new LocalTranscriptUnavailable("Journal changed during snapshot");
       const newline = buffer.subarray(0, count2).lastIndexOf(10);
@@ -69269,12 +69766,12 @@ function completeEnd(path2, start, end) {
     }
     return start;
   } finally {
-    (0, import_node_fs25.closeSync)(file2);
+    (0, import_node_fs26.closeSync)(file2);
   }
 }
 function localTranscriptSnapshot(configPath, conversationId) {
   const path2 = transcriptPath(configPath, conversationId);
-  const stat4 = (0, import_node_fs25.statSync)(path2);
+  const stat4 = (0, import_node_fs26.statSync)(path2);
   const state = readConversationSyncState(configPath, conversationId);
   const messages = [];
   const active2 = getTranscriptBuffer(path2);
@@ -69352,9 +69849,9 @@ function localRange(snapshot, messageId, offset2, maxBytes) {
     throw new LocalTranscriptUnavailable("Unknown local message range");
   const length = message.role === "user" ? message.end - message.start : Math.min(maxBytes, message.bytes - offset2);
   const bytes = Buffer.alloc(length);
-  const file2 = (0, import_node_fs25.openSync)(snapshot.path, "r");
+  const file2 = (0, import_node_fs26.openSync)(snapshot.path, "r");
   try {
-    const stat4 = (0, import_node_fs25.fstatSync)(file2);
+    const stat4 = (0, import_node_fs26.fstatSync)(file2);
     if (`${stat4.dev}.${stat4.ino}.${stat4.birthtimeMs}` !== snapshot.generation)
       throw new LocalTranscriptUnavailable("Local journal generation changed");
     const start = message.start + offset2;
@@ -69362,7 +69859,7 @@ function localRange(snapshot, messageId, offset2, maxBytes) {
     const active2 = candidate && start + length <= candidate.produced ? candidate : void 0;
     const memoryStart = active2 ? Math.max(start, active2.retainedFrom) : start + length;
     const diskLength = Math.min(length, memoryStart - start);
-    if (diskLength > 0 && (0, import_node_fs25.readSync)(file2, bytes, 0, diskLength, start) !== diskLength)
+    if (diskLength > 0 && (0, import_node_fs26.readSync)(file2, bytes, 0, diskLength, start) !== diskLength)
       throw new LocalTranscriptUnavailable("Local journal changed during read");
     if (diskLength < length) {
       const tail = active2?.read(start + diskLength, length - diskLength);
@@ -69370,7 +69867,7 @@ function localRange(snapshot, messageId, offset2, maxBytes) {
       tail.copy(bytes, diskLength);
     }
   } finally {
-    (0, import_node_fs25.closeSync)(file2);
+    (0, import_node_fs26.closeSync)(file2);
   }
   if (message.role === "user") {
     const parsed = JSON.parse(bytes.toString());
@@ -69937,7 +70434,7 @@ var BindingSwitchGitError = class extends Error {
 // src/git/repo.ts
 var import_node_child_process8 = require("child_process");
 var import_node_crypto15 = require("crypto");
-var import_node_fs26 = require("fs");
+var import_node_fs27 = require("fs");
 var import_node_os15 = require("os");
 var import_node_path29 = require("path");
 var import_node_url = require("url");
@@ -69970,12 +70467,12 @@ function networkGitTimeoutMs() {
 async function waitForCheckpointTestBarrier() {
   const barrierDir = process.env.NODE_ENV === "test" ? process.env.ALAN_TEST_GIT_CHECKPOINT_BARRIER_DIR : void 0;
   if (!barrierDir) return;
-  (0, import_node_fs26.mkdirSync)(barrierDir, { recursive: true });
+  (0, import_node_fs27.mkdirSync)(barrierDir, { recursive: true });
   const readyPath = (0, import_node_path29.join)(barrierDir, "ready");
   const releasePath = (0, import_node_path29.join)(barrierDir, "release");
-  (0, import_node_fs26.writeFileSync)(readyPath, "ready\n");
+  (0, import_node_fs27.writeFileSync)(readyPath, "ready\n");
   const deadline = Date.now() + 5e3;
-  while (!(0, import_node_fs26.existsSync)(releasePath)) {
+  while (!(0, import_node_fs27.existsSync)(releasePath)) {
     if (Date.now() >= deadline) {
       throw new BindingSwitchGitError(
         "checkpoint_prepare_timeout",
@@ -69988,12 +70485,12 @@ async function waitForCheckpointTestBarrier() {
 async function waitForCheckpointFinalizeTestBarrier() {
   const barrierDir = process.env.NODE_ENV === "test" ? process.env.ALAN_TEST_GIT_CHECKPOINT_FINALIZE_BARRIER_DIR : void 0;
   if (!barrierDir) return;
-  (0, import_node_fs26.mkdirSync)(barrierDir, { recursive: true });
+  (0, import_node_fs27.mkdirSync)(barrierDir, { recursive: true });
   const readyPath = (0, import_node_path29.join)(barrierDir, "ready");
   const releasePath = (0, import_node_path29.join)(barrierDir, "release");
-  (0, import_node_fs26.writeFileSync)(readyPath, "ready\n");
+  (0, import_node_fs27.writeFileSync)(readyPath, "ready\n");
   const deadline = Date.now() + 5e3;
-  while (!(0, import_node_fs26.existsSync)(releasePath)) {
+  while (!(0, import_node_fs27.existsSync)(releasePath)) {
     if (Date.now() >= deadline) {
       throw new BindingSwitchGitError(
         "checkpoint_finalize_timeout",
@@ -70106,7 +70603,7 @@ function sourceChangedDuringCheckpoint(message) {
 }
 function acquireCheckpointHeadLock(locks) {
   try {
-    (0, import_node_fs26.writeFileSync)(locks.headLockPath, "", { flag: "wx" });
+    (0, import_node_fs27.writeFileSync)(locks.headLockPath, "", { flag: "wx" });
     locks.headLockHeld = true;
   } catch {
     throw sourceChangedDuringCheckpoint(
@@ -70116,7 +70613,7 @@ function acquireCheckpointHeadLock(locks) {
 }
 function releaseCheckpointHeadLock(locks) {
   if (!locks.headLockHeld) return;
-  (0, import_node_fs26.rmSync)(locks.headLockPath, { force: true });
+  (0, import_node_fs27.rmSync)(locks.headLockPath, { force: true });
   locks.headLockHeld = false;
 }
 function acquireCheckpointRepositoryLocks(repoRoot) {
@@ -70138,13 +70635,13 @@ function acquireCheckpointRepositoryLocks(repoRoot) {
     indexPath
   };
   try {
-    (0, import_node_fs26.writeFileSync)(locks.indexLockPath, "", { flag: "wx" });
+    (0, import_node_fs27.writeFileSync)(locks.indexLockPath, "", { flag: "wx" });
     locks.indexLockHeld = true;
     acquireCheckpointHeadLock(locks);
     return locks;
   } catch {
     if (locks.indexLockHeld) {
-      (0, import_node_fs26.rmSync)(locks.indexLockPath, { force: true });
+      (0, import_node_fs27.rmSync)(locks.indexLockPath, { force: true });
       locks.indexLockHeld = false;
     }
     throw sourceChangedDuringCheckpoint(
@@ -70155,7 +70652,7 @@ function acquireCheckpointRepositoryLocks(repoRoot) {
 function releaseCheckpointRepositoryLocks(locks) {
   releaseCheckpointHeadLock(locks);
   if (locks.indexLockHeld) {
-    (0, import_node_fs26.rmSync)(locks.indexLockPath, { force: true });
+    (0, import_node_fs27.rmSync)(locks.indexLockPath, { force: true });
     locks.indexLockHeld = false;
   }
 }
@@ -70173,7 +70670,7 @@ function assertCheckpointHead(repoRoot, expectedRef, expectedHeadSha) {
   }
 }
 function createCheckpointIndexBaseline(repoRoot, checkpointSha) {
-  const tempDir = (0, import_node_fs26.mkdtempSync)((0, import_node_path29.join)((0, import_node_os15.tmpdir)(), "alan-checkpoint-index-"));
+  const tempDir = (0, import_node_fs27.mkdtempSync)((0, import_node_path29.join)((0, import_node_os15.tmpdir)(), "alan-checkpoint-index-"));
   const indexPath = (0, import_node_path29.join)(tempDir, "index");
   try {
     runGitWithOptions(
@@ -70184,14 +70681,14 @@ function createCheckpointIndexBaseline(repoRoot, checkpointSha) {
     );
     return { indexPath, tempDir };
   } catch (error61) {
-    (0, import_node_fs26.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_node_fs27.rmSync)(tempDir, { recursive: true, force: true });
     throw error61;
   }
 }
 function installCheckpointIndexBaseline(locks, baselineIndexPath) {
   try {
-    (0, import_node_fs26.copyFileSync)(baselineIndexPath, locks.indexLockPath);
-    (0, import_node_fs26.renameSync)(locks.indexLockPath, locks.indexPath);
+    (0, import_node_fs27.copyFileSync)(baselineIndexPath, locks.indexLockPath);
+    (0, import_node_fs27.renameSync)(locks.indexLockPath, locks.indexPath);
     locks.indexLockHeld = false;
   } catch (error61) {
     throw new BindingSwitchGitError(
@@ -70354,7 +70851,7 @@ function inspectedRemoteUrl(repoRoot, params) {
 function canonicalPathWithMissingTail(path2) {
   const missingSegments = [];
   let cursor = (0, import_node_path29.resolve)(path2);
-  while (!(0, import_node_fs26.existsSync)(cursor)) {
+  while (!(0, import_node_fs27.existsSync)(cursor)) {
     const parent = (0, import_node_path29.dirname)(cursor);
     if (parent === cursor) {
       throw new BindingSwitchGitError(
@@ -70365,10 +70862,10 @@ function canonicalPathWithMissingTail(path2) {
     missingSegments.unshift((0, import_node_path29.basename)(cursor));
     cursor = parent;
   }
-  return (0, import_node_path29.join)(import_node_fs26.realpathSync.native(cursor), ...missingSegments);
+  return (0, import_node_path29.join)(import_node_fs27.realpathSync.native(cursor), ...missingSegments);
 }
 function resolveRepositoryRoot(requestedPath) {
-  if (!(0, import_node_fs26.existsSync)(requestedPath)) {
+  if (!(0, import_node_fs27.existsSync)(requestedPath)) {
     throw new BindingSwitchGitError(
       "repository_not_found",
       `The selected repository path does not exist: ${requestedPath}`
@@ -70381,7 +70878,7 @@ function resolveRepositoryRoot(requestedPath) {
       "The selected folder is not inside a Git repository"
     );
   }
-  return import_node_fs26.realpathSync.native((0, import_node_path29.resolve)(root.stdout.trim()));
+  return import_node_fs27.realpathSync.native((0, import_node_path29.resolve)(root.stdout.trim()));
 }
 function listWorktrees(repoRoot) {
   return runGit(repoRoot, ["worktree", "list", "--porcelain"]).split("\n\n").flatMap((entry) => {
@@ -70437,7 +70934,7 @@ function updateLengthPrefixed(hash2, value2) {
   hash2.update("\0");
 }
 function proposedTreeSha(repoRoot, headSha) {
-  const tempDir = (0, import_node_fs26.mkdtempSync)((0, import_node_path29.join)((0, import_node_os15.tmpdir)(), "alan-switch-index-"));
+  const tempDir = (0, import_node_fs27.mkdtempSync)((0, import_node_path29.join)((0, import_node_os15.tmpdir)(), "alan-switch-index-"));
   const indexPath = (0, import_node_path29.join)(tempDir, "index");
   const options = { env: { GIT_INDEX_FILE: indexPath } };
   try {
@@ -70451,7 +70948,7 @@ function proposedTreeSha(repoRoot, headSha) {
     assertCommitSha(treeSha, "proposedTreeSha");
     return treeSha;
   } finally {
-    (0, import_node_fs26.rmSync)(tempDir, { recursive: true, force: true });
+    (0, import_node_fs27.rmSync)(tempDir, { recursive: true, force: true });
   }
 }
 function statusFingerprint(repoRoot, porcelain, proposedTree) {
@@ -70686,7 +71183,7 @@ async function checkout(params) {
 }
 
 // src/git/checkpoint.ts
-var import_node_fs27 = require("fs");
+var import_node_fs28 = require("fs");
 async function checkpoint(params) {
   const { switchId, repoKey } = commonRequest(params);
   const repoRoot = resolveAuthorizedRepository(params, true);
@@ -70711,7 +71208,7 @@ async function checkpoint(params) {
       return { repoRoot, sha: status2.headSha, replayed: true };
     } finally {
       if (locks2) releaseCheckpointRepositoryLocks(locks2);
-      (0, import_node_fs27.rmSync)(baseline2.tempDir, { recursive: true, force: true });
+      (0, import_node_fs28.rmSync)(baseline2.tempDir, { recursive: true, force: true });
     }
   }
   assertSourcePreconditions(status2, expectedHeadSha, expectedStatusFingerprint, expectedBranch);
@@ -70819,7 +71316,7 @@ Alan-Repository-Id: ${repoKey}`;
       runGitResult(repoRoot, ["update-ref", expectedRef, expectedHeadSha, sha]);
     }
     if (locks) releaseCheckpointRepositoryLocks(locks);
-    (0, import_node_fs27.rmSync)(baseline.tempDir, { recursive: true, force: true });
+    (0, import_node_fs28.rmSync)(baseline.tempDir, { recursive: true, force: true });
   }
 }
 
@@ -71025,7 +71522,7 @@ async function stopBackgroundTaskForRun(deps, payload) {
 }
 
 // src/daemon/sweep.ts
-var import_node_fs28 = require("fs");
+var import_node_fs29 = require("fs");
 var import_node_path30 = require("path");
 function retiredPaths(configPath) {
   const directory = (0, import_node_path30.dirname)(configPath);
@@ -71044,9 +71541,9 @@ function retiredPaths(configPath) {
 function sweepRetiredArtifacts(configPath) {
   const removed = [];
   for (const path2 of retiredPaths(configPath)) {
-    if (!(0, import_node_fs28.existsSync)(path2)) continue;
+    if (!(0, import_node_fs29.existsSync)(path2)) continue;
     try {
-      (0, import_node_fs28.rmSync)(path2, { recursive: true, force: true });
+      (0, import_node_fs29.rmSync)(path2, { recursive: true, force: true });
       removed.push(path2);
     } catch {
     }
@@ -71056,6 +71553,8 @@ function sweepRetiredArtifacts(configPath) {
 
 // src/daemon/start.ts
 var RUNTIME_TOKEN_RENEWAL_WINDOW_MS2 = 24 * 60 * 60 * 1e3;
+var TRANSCRIPT_BACKLOG_TTL_MS = 1e4;
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 async function startDaemon(args) {
   bindConfigPath(args);
   const stored = readConfig();
@@ -71431,6 +71930,33 @@ async function startDaemon(args) {
   });
   const persistWorkspaceRelocations = relocationTracker.persist;
   const flushWorkspaceRelocations = relocationTracker.flush;
+  let transcriptBacklog = {
+    readAtMs: 0,
+    runs: []
+  };
+  const transcriptSyncPending = () => {
+    const nowMs = Date.now();
+    if (nowMs - transcriptBacklog.readAtMs < TRANSCRIPT_BACKLOG_TTL_MS)
+      return transcriptBacklog.runs;
+    try {
+      const runs = readTranscriptSyncBacklog(
+        configPath,
+        (runId) => activeAgents.has(runId) || pendingRunStarts.has(runId)
+      ).filter(
+        (entry) => UUID_PATTERN.test(entry.runId) && UUID_PATTERN.test(entry.conversationId)
+      ).slice(0, MAX_REPORTED_TRANSCRIPT_SYNC_RUNS).map((entry) => ({
+        runId: entry.runId,
+        conversationId: entry.conversationId,
+        ...entry.problem?.status !== void 0 ? { problemStatus: entry.problem.status } : {},
+        ...entry.problem ? { problemPermanent: entry.problem.permanent } : {}
+      }));
+      transcriptBacklog = { readAtMs: nowMs, runs };
+    } catch (error61) {
+      pushLog(`transcript-backlog-scan-failed ${String(error61)}`);
+      transcriptBacklog = { ...transcriptBacklog, readAtMs: nowMs };
+    }
+    return transcriptBacklog.runs;
+  };
   const runnerStatusInput = () => ({
     connected: socket.connected,
     activeAgents,
@@ -71439,6 +71965,7 @@ async function startDaemon(args) {
     daemonEpoch,
     heartbeatSeq,
     interruptedRunIds: runJournal.recoveredRunIds(),
+    transcriptSyncPending: transcriptSyncPending(),
     endpointProfile,
     configPath,
     runtimeId,
@@ -71460,6 +71987,19 @@ async function startDaemon(args) {
   let transcriptReplayEnabled = false;
   let transcriptReplay = null;
   let transcriptReplayRequested = false;
+  let transcriptCooldownTimer;
+  const scheduleCooldownReplay = (retryAt) => {
+    if (retryAt === void 0 || shutdownAbort.signal.aborted) return;
+    if (transcriptCooldownTimer) clearTimeout(transcriptCooldownTimer);
+    transcriptCooldownTimer = setTimeout(
+      () => {
+        transcriptCooldownTimer = void 0;
+        replayTranscripts();
+      },
+      Math.max(0, retryAt - Date.now())
+    );
+    transcriptCooldownTimer.unref?.();
+  };
   const replayTranscripts = () => {
     if (!transcriptReplayEnabled || shutdownAbort.signal.aborted || terminalAuthFailureCode) return;
     if (transcriptReplay) {
@@ -71474,7 +72014,7 @@ async function startDaemon(args) {
       canReplay: () => !terminalAuthFailureCode,
       signal: shutdownAbort.signal,
       onProblem: pushLog
-    }).catch((error61) => pushLog(`transcript-replay-failed ${String(error61)}`)).finally(() => {
+    }).then(scheduleCooldownReplay).catch((error61) => pushLog(`transcript-replay-failed ${String(error61)}`)).finally(() => {
       transcriptReplay = null;
       if (transcriptReplayRequested) {
         transcriptReplayRequested = false;
@@ -71519,6 +72059,11 @@ async function startDaemon(args) {
     socket.on("connect", () => {
       disconnectedSinceMs = null;
       clearConnectErrors();
+      try {
+        if (releasePermanentTranscriptCooldowns(configPath) > 0) replayTranscripts();
+      } catch (error61) {
+        pushLog(`transcript-cooldown-release-failed ${String(error61)}`);
+      }
       deniedRedialAttempt = 0;
       if (deniedRedialTimer) {
         clearTimeout(deniedRedialTimer);
@@ -71845,6 +72390,7 @@ async function startDaemon(args) {
   );
   const abortStartup = async (error61, closeServer = false) => {
     clearInterval(heartbeat);
+    if (transcriptCooldownTimer) clearTimeout(transcriptCooldownTimer);
     clearInterval(versionRefresh);
     leaseMonitor.stop();
     suspensionDetector.stop();
@@ -71883,6 +72429,7 @@ async function startDaemon(args) {
     let shutdownComplete = false;
     try {
       clearInterval(heartbeat);
+      if (transcriptCooldownTimer) clearTimeout(transcriptCooldownTimer);
       clearInterval(versionRefresh);
       leaseMonitor.stop();
       clearInterval(skillSyncInterval);
@@ -71945,7 +72492,7 @@ async function startDaemon(args) {
 // src/service-manager.ts
 var import_node_child_process9 = require("child_process");
 var import_node_crypto17 = require("crypto");
-var import_node_fs29 = require("fs");
+var import_node_fs30 = require("fs");
 var import_node_os17 = require("os");
 var import_node_path32 = require("path");
 var SERVICE_LABEL = "ai.tryalan.agent";
@@ -72383,19 +72930,19 @@ function currentServicePlan(args, runtime, options = {}) {
   });
 }
 function writeManifestAtomic(path2, contents) {
-  (0, import_node_fs29.mkdirSync)((0, import_node_path32.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs30.mkdirSync)((0, import_node_path32.dirname)(path2), { recursive: true, mode: 448 });
   const pendingPath = `${path2}.pending-${process.pid}`;
   try {
-    (0, import_node_fs29.writeFileSync)(pendingPath, contents, { mode: 384 });
-    (0, import_node_fs29.chmodSync)(pendingPath, 384);
-    (0, import_node_fs29.renameSync)(pendingPath, path2);
+    (0, import_node_fs30.writeFileSync)(pendingPath, contents, { mode: 384 });
+    (0, import_node_fs30.chmodSync)(pendingPath, 384);
+    (0, import_node_fs30.renameSync)(pendingPath, path2);
   } finally {
-    (0, import_node_fs29.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs30.rmSync)(pendingPath, { force: true });
   }
 }
 function defaultReadManifest(path2) {
-  if (!(0, import_node_fs29.existsSync)(path2)) return null;
-  return (0, import_node_fs29.readFileSync)(path2, "utf8");
+  if (!(0, import_node_fs30.existsSync)(path2)) return null;
+  return (0, import_node_fs30.readFileSync)(path2, "utf8");
 }
 function runServiceCommand(command, options = {}) {
   return new Promise((resolveCommand2, reject2) => {
@@ -72594,9 +73141,9 @@ function createHostContext(options = {}) {
   };
   const readManifest = options.readManifest ?? defaultReadManifest;
   const writeManifest = options.writeManifest ?? writeManifestAtomic;
-  const removeManifest = options.removeManifest ?? ((path2) => (0, import_node_fs29.rmSync)(path2, { force: true }));
+  const removeManifest = options.removeManifest ?? ((path2) => (0, import_node_fs30.rmSync)(path2, { force: true }));
   const ensureLogDir = options.ensureLogDir ?? (() => {
-    if (plan.logDirectory) (0, import_node_fs29.mkdirSync)(plan.logDirectory, { recursive: true, mode: 448 });
+    if (plan.logDirectory) (0, import_node_fs30.mkdirSync)(plan.logDirectory, { recursive: true, mode: 448 });
   });
   return {
     args,
@@ -72918,7 +73465,7 @@ ${result.output}
 
 // src/mcp-config-adapters.ts
 var import_node_crypto18 = require("crypto");
-var import_node_fs30 = require("fs");
+var import_node_fs31 = require("fs");
 var import_node_os18 = require("os");
 var import_node_path33 = require("path");
 var log2 = {
@@ -72945,22 +73492,22 @@ function parseJsonSafe(content) {
   throw new MalformedToolConfigError("Existing tool config is malformed");
 }
 function readFileOr(path2) {
-  return (0, import_node_fs30.existsSync)(path2) ? (0, import_node_fs30.readFileSync)(path2, "utf-8") : null;
+  return (0, import_node_fs31.existsSync)(path2) ? (0, import_node_fs31.readFileSync)(path2, "utf-8") : null;
 }
 function acquireConfigLock(path2) {
-  (0, import_node_fs30.mkdirSync)((0, import_node_path33.dirname)(path2), { recursive: true });
+  (0, import_node_fs31.mkdirSync)((0, import_node_path33.dirname)(path2), { recursive: true });
   const lockPath = `${path2}.alan-lock`;
   const startedAt = Date.now();
   while (true) {
     try {
-      (0, import_node_fs30.mkdirSync)(lockPath);
-      return () => (0, import_node_fs30.rmSync)(lockPath, { recursive: true, force: true });
+      (0, import_node_fs31.mkdirSync)(lockPath);
+      return () => (0, import_node_fs31.rmSync)(lockPath, { recursive: true, force: true });
     } catch (error61) {
       const code = error61 && typeof error61 === "object" && "code" in error61 ? error61.code : void 0;
       if (code !== "EEXIST") throw error61;
       try {
-        if (Date.now() - (0, import_node_fs30.statSync)(lockPath).mtimeMs > 3e4) {
-          (0, import_node_fs30.rmSync)(lockPath, { recursive: true, force: true });
+        if (Date.now() - (0, import_node_fs31.statSync)(lockPath).mtimeMs > 3e4) {
+          (0, import_node_fs31.rmSync)(lockPath, { recursive: true, force: true });
           continue;
         }
       } catch {
@@ -72974,19 +73521,19 @@ function acquireConfigLock(path2) {
   }
 }
 function writeFileSafe(path2, content) {
-  (0, import_node_fs30.mkdirSync)((0, import_node_path33.dirname)(path2), { recursive: true });
+  (0, import_node_fs31.mkdirSync)((0, import_node_path33.dirname)(path2), { recursive: true });
   const pendingPath = `${path2}.alan-pending-${process.pid}-${(0, import_node_crypto18.randomBytes)(6).toString("hex")}`;
   try {
-    (0, import_node_fs30.writeFileSync)(pendingPath, content, { encoding: "utf8", mode: 384, flag: "wx" });
-    (0, import_node_fs30.renameSync)(pendingPath, path2);
+    (0, import_node_fs31.writeFileSync)(pendingPath, content, { encoding: "utf8", mode: 384, flag: "wx" });
+    (0, import_node_fs31.renameSync)(pendingPath, path2);
   } finally {
-    (0, import_node_fs30.rmSync)(pendingPath, { force: true });
+    (0, import_node_fs31.rmSync)(pendingPath, { force: true });
   }
 }
 function saveMalformedBackup(path2, content) {
   const hash2 = (0, import_node_crypto18.createHash)("sha256").update(content).digest("hex").slice(0, 16);
   const backupPath = `${path2}.alan-backup-${hash2}`;
-  if (!(0, import_node_fs30.existsSync)(backupPath)) (0, import_node_fs30.copyFileSync)(path2, backupPath);
+  if (!(0, import_node_fs31.existsSync)(backupPath)) (0, import_node_fs31.copyFileSync)(path2, backupPath);
   return backupPath;
 }
 var claudeAdapter = {
@@ -73359,6 +73906,95 @@ var commandCodeAdapter = {
     return JSON.stringify(config4, null, 2);
   }
 };
+var copilotAdapter = {
+  cli: "GitHub Copilot CLI",
+  get configPath() {
+    return (0, import_node_path33.join)(homeDirectory(), ".copilot", "mcp-config.json");
+  },
+  get guardDir() {
+    return (0, import_node_path33.join)(homeDirectory(), ".copilot");
+  },
+  merge(existing, servers) {
+    const config4 = parseJsonSafe(existing);
+    const mcpServers = config4.mcpServers ?? {};
+    for (const s of servers) {
+      if (s.kind === "http") {
+        mcpServers[s.name] = {
+          type: "http",
+          url: s.url,
+          tools: ["*"],
+          headers: s.headers
+        };
+      } else {
+        mcpServers[s.name] = {
+          type: "stdio",
+          command: s.command,
+          tools: ["*"],
+          ...s.args?.length ? { args: s.args } : {},
+          ...s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}
+        };
+      }
+    }
+    config4.mcpServers = mcpServers;
+    return JSON.stringify(config4, null, 2);
+  },
+  remove(existing, serverNames) {
+    const config4 = parseJsonSafe(existing);
+    const mcpServers = config4.mcpServers ?? {};
+    for (const name of serverNames) delete mcpServers[name];
+    config4.mcpServers = mcpServers;
+    return JSON.stringify(config4, null, 2);
+  }
+};
+var grokAdapter = {
+  cli: "Grok CLI",
+  get configPath() {
+    return (0, import_node_path33.join)(homeDirectory(), ".grok", "config.toml");
+  },
+  get guardDir() {
+    return (0, import_node_path33.join)(homeDirectory(), ".grok");
+  },
+  merge(existing, servers) {
+    let config4 = {};
+    if (existing) {
+      try {
+        config4 = parse4(existing);
+      } catch {
+        throw new MalformedToolConfigError("Existing tool config is malformed");
+      }
+    }
+    const mcpServers = config4.mcp_servers ?? {};
+    for (const s of servers) {
+      if (s.kind === "http") {
+        mcpServers[s.name] = {
+          url: s.url,
+          ...Object.keys(s.headers).length > 0 ? { headers: s.headers } : {}
+        };
+      } else {
+        mcpServers[s.name] = {
+          command: s.command,
+          ...s.args?.length ? { args: s.args } : {},
+          ...s.env && Object.keys(s.env).length > 0 ? { env: s.env } : {}
+        };
+      }
+    }
+    config4.mcp_servers = mcpServers;
+    return stringify(config4);
+  },
+  remove(existing, serverNames) {
+    if (!existing) return "";
+    let config4 = {};
+    try {
+      config4 = parse4(existing);
+    } catch {
+      return existing;
+    }
+    const mcpServers = config4.mcp_servers ?? {};
+    for (const name of serverNames) delete mcpServers[name];
+    config4.mcp_servers = mcpServers;
+    return stringify(config4);
+  }
+};
 var ALL_ADAPTERS = [
   claudeAdapter,
   codexAdapter,
@@ -73369,10 +74005,12 @@ var ALL_ADAPTERS = [
   commandCodeAdapter,
   opencodeAdapter,
   factoryAdapter,
-  ampAdapter
+  ampAdapter,
+  copilotAdapter,
+  grokAdapter
 ];
 function serverEntry(adapter, content, name) {
-  if (adapter === codexAdapter) {
+  if (adapter === codexAdapter || adapter === grokAdapter) {
     const parsed2 = parse4(content);
     const servers2 = parsed2.mcp_servers;
     return servers2 && typeof servers2 === "object" ? servers2[name] : void 0;
@@ -73551,7 +74189,7 @@ function syncMcpToAllClis(servers, oldManagedServers = []) {
   const written = [];
   const failures = [];
   for (const adapter of ALL_ADAPTERS) {
-    if (!(0, import_node_fs30.existsSync)(adapter.guardDir)) {
+    if (!(0, import_node_fs31.existsSync)(adapter.guardDir)) {
       log2.debug("MCP Adapters", `Skipping ${adapter.cli} \u2014 guard dir not found`, {
         guardDir: adapter.guardDir
       });
@@ -73631,7 +74269,7 @@ function removeMcpFromAllClis(managedServers) {
   if (managedServers.length === 0) return;
   const ownershipKnown = isManagedServerList(managedServers);
   for (const adapter of ALL_ADAPTERS) {
-    if (!(0, import_node_fs30.existsSync)(adapter.guardDir)) continue;
+    if (!(0, import_node_fs31.existsSync)(adapter.guardDir)) continue;
     const releaseLock = acquireConfigLock(adapter.configPath);
     try {
       const existing = readFileOr(adapter.configPath);
@@ -73670,7 +74308,7 @@ function inspectAlanMcpPresence(expectedServers = [], candidateNames = DEFAULT_A
   ]);
   const expectedByName = new Map(expectedServers.map((server) => [server.name, server]));
   for (const adapter of ALL_ADAPTERS) {
-    if (!(0, import_node_fs30.existsSync)(adapter.guardDir)) continue;
+    if (!(0, import_node_fs31.existsSync)(adapter.guardDir)) continue;
     inspectedClis.push(adapter.cli);
     const existing = readFileOr(adapter.configPath);
     if (!existing) continue;
@@ -73781,11 +74419,11 @@ var McpSyncService = class {
 };
 
 // src/cli/ingestion-hooks.ts
-var import_node_fs32 = require("fs");
+var import_node_fs33 = require("fs");
 var import_node_path35 = require("path");
 
 // src/native/hook-config.ts
-var import_node_fs31 = require("fs");
+var import_node_fs32 = require("fs");
 var import_node_os19 = require("os");
 var import_node_path34 = require("path");
 var INGESTION_HOOK_MARKER = "# alan-session-ingest";
@@ -73854,9 +74492,9 @@ function hookHandler(provider, event, options) {
   return { type: "command", command: posixCommand(argv, environment), timeout: 5 };
 }
 function readSettings2(path2, backupWhenMalformed) {
-  if (!(0, import_node_fs31.existsSync)(path2)) return {};
+  if (!(0, import_node_fs32.existsSync)(path2)) return {};
   try {
-    const value2 = JSON.parse((0, import_node_fs31.readFileSync)(path2, "utf8"));
+    const value2 = JSON.parse((0, import_node_fs32.readFileSync)(path2, "utf8"));
     if (!isRecord7(value2)) throw new Error("settings root must be an object");
     if (value2.hooks !== void 0 && !isRecord7(value2.hooks)) {
       throw new Error("settings `hooks` must be an object");
@@ -73866,7 +74504,7 @@ function readSettings2(path2, backupWhenMalformed) {
     const reason = error61 instanceof Error ? error61.message : String(error61);
     if (!backupWhenMalformed) throw new Error(`${path2} is malformed: ${reason}`);
     const backup = `${path2}.malformed-${Date.now()}.bak`;
-    (0, import_node_fs31.copyFileSync)(path2, backup);
+    (0, import_node_fs32.copyFileSync)(path2, backup);
     throw new Error(`${path2} is malformed and was copied to ${backup}: ${reason}`);
   }
 }
@@ -73874,14 +74512,14 @@ function hooksOf(settings2) {
   return isRecord7(settings2.hooks) ? settings2.hooks : {};
 }
 function writeSettings2(path2, settings2) {
-  (0, import_node_fs31.mkdirSync)((0, import_node_path34.dirname)(path2), { recursive: true, mode: 448 });
+  (0, import_node_fs32.mkdirSync)((0, import_node_path34.dirname)(path2), { recursive: true, mode: 448 });
   const temporary = `${path2}.${process.pid}.tmp`;
   try {
-    (0, import_node_fs31.writeFileSync)(temporary, `${JSON.stringify(settings2, null, 2)}
+    (0, import_node_fs32.writeFileSync)(temporary, `${JSON.stringify(settings2, null, 2)}
 `, { mode: 384 });
-    (0, import_node_fs31.renameSync)(temporary, path2);
+    (0, import_node_fs32.renameSync)(temporary, path2);
   } finally {
-    (0, import_node_fs31.rmSync)(temporary, { force: true });
+    (0, import_node_fs32.rmSync)(temporary, { force: true });
   }
 }
 function isIngestionHandler(handler) {
@@ -73926,7 +74564,7 @@ function installIngestionHooks(provider, options) {
 }
 function removeIngestionHooks(provider, options = {}) {
   const path2 = providerHookSettingsPath(provider, options);
-  if (!(0, import_node_fs31.existsSync)(path2)) return { provider, path: path2, changed: false };
+  if (!(0, import_node_fs32.existsSync)(path2)) return { provider, path: path2, changed: false };
   const settings2 = readSettings2(path2, true);
   const hooks = hooksOf(settings2);
   const nextHooks = {};
@@ -73968,7 +74606,7 @@ function systemNodeProbe(env) {
     pathEntries: (env.PATH ?? "").split(import_node_path35.delimiter),
     realpath: (path2) => {
       try {
-        return (0, import_node_fs32.realpathSync)(path2);
+        return (0, import_node_fs33.realpathSync)(path2);
       } catch {
         return null;
       }
@@ -74357,7 +74995,7 @@ var agentProbeAckSchema = external_exports.object({
 });
 
 // src/resource-diagnostics.ts
-var import_node_fs33 = require("fs");
+var import_node_fs34 = require("fs");
 var import_node_os20 = require("os");
 var import_node_path36 = require("path");
 var import_node_perf_hooks = require("perf_hooks");
@@ -74365,7 +75003,7 @@ var MAX_RESOURCE_FILE_BYTES = 16384;
 var RESOURCE_READ_TIMEOUT_MS = 500;
 async function readResourceFile(path2) {
   try {
-    const stream = (0, import_node_fs33.createReadStream)(path2, {
+    const stream = (0, import_node_fs34.createReadStream)(path2, {
       encoding: "utf8",
       start: 0,
       end: MAX_RESOURCE_FILE_BYTES,
@@ -75503,7 +76141,7 @@ var ExecutionLeaseClient = class {
         }
         const takeoverPending = response.status === 409 && code === "EXECUTION_LEASE_TAKEOVER_PENDING";
         const mixedVersionUnavailable = (response.status === 401 || response.status === 403 || response.status === 404) && !code?.startsWith("EXECUTION_LEASE_");
-        const retryable = takeoverPending || mixedVersionUnavailable || isRetryableStatus(response.status);
+        const retryable = takeoverPending || mixedVersionUnavailable || isRetryableStatus2(response.status);
         if (!retryable || attempt === this.retryDelaysMs.length) {
           if (response.status === 404 && !code && this.isCurrentRun(activity, activityGeneration)) {
             this.protectionMode = "legacy";
@@ -75559,7 +76197,7 @@ async function readProtectionBody(response) {
     return {};
   }
 }
-function isRetryableStatus(status2) {
+function isRetryableStatus2(status2) {
   return status2 === 408 || status2 === 429 || status2 >= 500;
 }
 async function readErrorBody(response) {