archymedes-cli 2.0.0 → 2.1.0

package/dist/archymedes-main.mjs

@@ -34,7 +34,7 @@ import {
   turnFromChatResponse,
   wanderGradeCounts,
   wanderPlannerInstructions
-} from "./archymedes-h2x8ct7s.mjs";
+} from "./archymedes-76z6n643.mjs";
 import {
   BrailleCanvas,
   StreamSeries,
@@ -116,16 +116,242 @@ import {
 
 // packages/archymedes-cli/src/archymedes.ts
 import { createInterface as createInterface4 } from "readline/promises";
-import path25 from "path";
+import path27 from "path";
 import { realpathSync } from "fs";
 import { pathToFileURL } from "url";
 
+// packages/core/src/cli/hosted-recovery.ts
+import { createHash, randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+function digest(value) {
+  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function savedRequest(request) {
+  return JSON.parse(JSON.stringify({
+    requestId: request.requestId ?? `cli_${randomUUID()}`,
+    messages: request.messages,
+    tools: request.tools,
+    maxOutputTokens: request.maxOutputTokens,
+    safetyIdentifier: request.safetyIdentifier,
+    ...request.effort ? { effort: request.effort } : {}
+  }));
+}
+function validateBatch(value, sessionId) {
+  const batch = value;
+  if (!batch || batch.version !== 1 || batch.sessionId !== sessionId || typeof batch.id !== "string" || typeof batch.scope !== "string" || !Number.isSafeInteger(batch.baseTotalRwf) || batch.baseTotalRwf < 0 || !Array.isArray(batch.entries)) {
+    throw new Error("Invalid hosted recovery snapshot; preserve the file for inspection.");
+  }
+  const ids = new Set;
+  for (const entry of batch.entries) {
+    if (!entry || !entry.request || typeof entry.request.requestId !== "string" || ids.has(entry.request.requestId) || !Array.isArray(entry.request.messages) || !Array.isArray(entry.request.tools) || digest(entry.request) !== entry.fingerprint || !["pending", "completed", "failed", "ambiguous", "cancelled"].includes(entry.state) || typeof entry.kind !== "string" || !entry.prices || entry.state === "completed" && !entry.response) {
+      throw new Error("Invalid hosted recovery request; refusing to replay changed content.");
+    }
+    ids.add(entry.request.requestId);
+  }
+  return batch;
+}
+
+class HostedRecoveryStore {
+  sessionId;
+  batch;
+  tail = Promise.resolve();
+  file;
+  constructor(root, sessionId) {
+    this.sessionId = sessionId;
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(sessionId))
+      throw new Error("Unsafe recovery session id");
+    this.file = path.join(root, ".archymedes", "recovery", `${sessionId}.json`);
+  }
+  async read() {
+    let text;
+    try {
+      text = await fs.readFile(this.file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return;
+      throw error;
+    }
+    const parsed = JSON.parse(text);
+    if (digest(parsed.batch) !== parsed.integrity)
+      throw new Error("Hosted recovery snapshot integrity check failed");
+    return validateBatch(parsed.batch, this.sessionId);
+  }
+  async write(batch) {
+    await fs.mkdir(path.dirname(this.file), { recursive: true, mode: 448 });
+    const temporary = `${this.file}.${randomUUID()}.tmp`;
+    try {
+      const handle = await fs.open(temporary, "wx", 384);
+      try {
+        await handle.writeFile(JSON.stringify({ batch, integrity: digest(batch) }));
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await fs.rename(temporary, this.file);
+      const directory = await fs.open(path.dirname(this.file), "r").catch(() => null);
+      if (directory) {
+        try {
+          await directory.sync();
+        } finally {
+          await directory.close();
+        }
+      }
+    } finally {
+      await fs.unlink(temporary).catch(() => {
+        return;
+      });
+    }
+  }
+  wrap(provider, session, prices, kind) {
+    if (!provider.recoveryScope)
+      return provider;
+    return {
+      capabilities: provider.capabilities,
+      complete: (request) => {
+        const operation = this.tail.then(() => this.complete(provider, session(), prices, kind, request));
+        this.tail = operation.catch(() => {
+          return;
+        });
+        return operation;
+      }
+    };
+  }
+  async complete(provider, session, prices, kind, request) {
+    request.signal?.throwIfAborted();
+    if (!this.batch) {
+      if (await this.read())
+        throw new Error("Recover the interrupted hosted request before starting new work.");
+      this.batch = { version: 1, id: randomUUID(), sessionId: this.sessionId, scope: provider.recoveryScope, baseTotalRwf: session.totalRwf, entries: [] };
+    }
+    if (this.batch.scope !== provider.recoveryScope)
+      throw new Error("Hosted recovery provider configuration changed");
+    const saved = savedRequest(request);
+    let entry = this.batch.entries.find((item) => item.request.requestId === saved.requestId);
+    if (entry && entry.fingerprint !== digest(saved))
+      throw new Error("Hosted request identity reused with changed content");
+    if (!entry) {
+      entry = { request: saved, fingerprint: digest(saved), kind, prices: { ...prices }, state: "pending" };
+      this.batch.entries.push(entry);
+      await this.write(this.batch);
+    }
+    await this.write(this.batch);
+    return this.dispatch(provider, this.batch, entry, request.signal);
+  }
+  async dispatch(provider, batch, entry, signal, recoveryOnly = false) {
+    if (entry.response) {
+      await this.write(batch);
+      return entry.response;
+    }
+    if (entry.state === "failed")
+      throw new Error("Hosted request was previously confirmed failed");
+    if (!recoveryOnly && signal?.aborted) {
+      entry.state = "failed";
+      await this.write(batch);
+      signal.throwIfAborted();
+    }
+    try {
+      const method = recoveryOnly && provider.recoverComplete ? provider.recoverComplete : provider.complete;
+      const response = await method.call(provider, { ...entry.request, signal });
+      entry.response = JSON.parse(JSON.stringify(response));
+      entry.state = "completed";
+      await this.write(batch);
+      return response;
+    } catch (error) {
+      if (!entry.response) {
+        entry.state = error?.code === "request_previously_failed" ? "failed" : signal?.aborted ? "cancelled" : "ambiguous";
+        await this.write(batch);
+      }
+      throw error;
+    }
+  }
+  responses() {
+    return (this.batch?.entries ?? []).flatMap((entry) => entry.response ? [{ requestId: entry.request.requestId, turn: entry.response }] : []);
+  }
+  settledBatchId() {
+    return this.batch?.entries.every((entry) => entry.state === "completed" || entry.state === "failed") ? this.batch.id : undefined;
+  }
+  async cleanup(committedId) {
+    const batch = this.batch ?? await this.read();
+    if (batch && batch.id === committedId) {
+      await fs.unlink(this.file).catch((error) => {
+        if (error.code !== "ENOENT")
+          throw error;
+      });
+      this.batch = undefined;
+    }
+  }
+  async recover(provider, session, signal) {
+    const batch = await this.read();
+    if (!batch)
+      return null;
+    if (session.hostedRecoveryBatchId === batch.id) {
+      await this.cleanup(batch.id);
+      return null;
+    }
+    if (!provider.recoveryScope || batch.scope !== provider.recoveryScope) {
+      throw new Error("An interrupted hosted request belongs to a different provider, credential or routing configuration. Resume with the original configuration to recover it.");
+    }
+    for (const entry of batch.entries) {
+      if (entry.state === "failed" || entry.response)
+        continue;
+      try {
+        await this.dispatch(provider, batch, entry, signal, true);
+      } catch (error) {
+        if (error?.code === "request_previously_failed")
+          continue;
+        const failure = new Error(`Hosted request ${entry.request.requestId} remains unresolved. Its identity is preserved; resume again to reconcile it.`, { cause: error });
+        throw failure;
+      }
+    }
+    this.batch = batch;
+    const main = batch.entries.filter((entry) => entry.kind === "main").at(-1);
+    const messages = main ? [...main.request.messages] : [...session.messages];
+    if (main?.response) {
+      const response = main.response;
+      if (response.toolCalls.length) {
+        messages.push({ role: "assistant", content: response.content, toolCalls: response.toolCalls });
+        for (const call of response.toolCalls)
+          messages.push({
+            role: "tool",
+            toolCallId: call.id,
+            name: call.name,
+            content: "Interrupted execution: the tool outcome is unknown. Do not repeat this action without inspecting the current state. Recovery did not replay the tool."
+          });
+      } else
+        messages.push({ role: "assistant", content: response.content || response.refusal || "Recovered hosted response with no text." });
+    }
+    for (const entry of batch.entries.filter((item) => item.kind !== "main" && item.response)) {
+      messages.push({ role: "assistant", content: `[Recovered ${entry.kind.startsWith("delegate") ? "delegated work" : "compaction"}]
+${entry.response.content}` });
+    }
+    messages.push({ role: "user", internal: true, content: "The previous run was interrupted. Hosted responses and usage were recovered. Tool execution may be incomplete; inspect the workspace and verify before repeating side effects or claiming completion." });
+    const groups = new Map;
+    for (const entry of batch.entries)
+      if (entry.response) {
+        const group = groups.get(entry.kind) ?? { input: 0, output: 0, prices: entry.prices };
+        group.input += entry.response.usage.inputTokens;
+        group.output += entry.response.usage.outputTokens;
+        groups.set(entry.kind, group);
+      }
+    const cost = [...groups.values()].reduce((sum, group) => sum + priceActualModelUsage(group.input, group.output, group.prices), 0);
+    return {
+      ...session,
+      messages,
+      totalRwf: batch.baseTotalRwf + cost,
+      hostedRecoveryBatchId: batch.id,
+      routingReceipts: mergeRoutingReceipts(session.routingReceipts, batch.entries.flatMap((entry) => entry.response?.routingReceipt ? [{ ...entry.response.routingReceipt, taskId: entry.response.routingReceipt.taskId ?? entry.request.requestId }] : []))
+    };
+  }
+}
+
 // packages/core/src/cli/agent.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import path12 from "node:path";
+import { randomUUID as randomUUID6 } from "node:crypto";
+import path14 from "node:path";
+import { access as access3 } from "node:fs/promises";
 
 // packages/core/src/agent-runtime.ts
-import { createHash, randomUUID } from "node:crypto";
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 function agentMessagePromptParts(message) {
   const parts = [message.content ?? ""];
   if ("toolCalls" in message && Array.isArray(message.toolCalls)) {
@@ -436,7 +662,7 @@ class BoundedAgentRuntime {
       if (maximumOutputTokens < 1)
         return stop("iteration_limit", "Run reached its approved model budget before another provider call.", iteration - 1);
       const modelRequest = {
-        requestId: `cli_${randomUUID()}`,
+        requestId: `cli_${randomUUID2()}`,
         ...request.effort ? { effort: request.effort } : {},
         messages: [...messages],
         tools: definitions,
@@ -493,7 +719,7 @@ class BoundedAgentRuntime {
       actualModelRwf = priceActualModelUsage(usage.inputTokens, usage.outputTokens, this.dependencies.prices);
       if (actualModelRwf > request.modelReservationRwf)
         throw new Error("Actual model usage exceeds the reserved model budget");
-      await this.dependencies.control.persistEvent({ type: "model_turn", iteration, responseId: turn.responseId, model: turn.model, toolCallCount: turn.toolCalls.length, usage: turn.usage });
+      await this.dependencies.control.persistEvent({ type: "model_turn", requestId: modelRequest.requestId, iteration, responseId: turn.responseId, model: turn.model, toolCallCount: turn.toolCalls.length, usage: turn.usage });
       if (turn.finishReason === "refusal")
         return stop("blocked", turn.refusal?.trim() || "Model refused the task.", iteration);
       if (turn.finishReason === "length") {
@@ -623,8 +849,8 @@ class BoundedAgentRuntime {
         let artifact;
         let content = truncate(raw, budget);
         const withinTwiceBudget = raw.length <= budget * 2 && raw.length <= remaining;
-        const digest = raw.length >= DEDUPE_MIN_CHARS ? createHash("sha256").update(raw).digest("hex") : undefined;
-        const alreadySent = digest ? sentResults.get(digest) : undefined;
+        const digest2 = raw.length >= DEDUPE_MIN_CHARS ? createHash2("sha256").update(raw).digest("hex") : undefined;
+        const alreadySent = digest2 ? sentResults.get(digest2) : undefined;
         if (alreadySent) {
           content = `[Identical to the earlier ${alreadySent.toolName} result in this conversation${alreadySent.path ? `, saved at ${alreadySent.path}` : ""}. Unchanged since then; re-read it there if you need it again.]`;
         } else if (withinTwiceBudget) {
@@ -638,8 +864,8 @@ class BoundedAgentRuntime {
             content = evictedToolResult(raw, stored, Math.min(budget, Math.max(EXCERPT_FLOOR, Math.round(budget * EXCERPT_SHARE))));
           }
         }
-        if (digest && !alreadySent)
-          sentResults.set(digest, { toolName: call.name, path: artifact?.path });
+        if (digest2 && !alreadySent)
+          sentResults.set(digest2, { toolName: call.name, path: artifact?.path });
         totalToolResultChars += content.length;
         iterationChars += content.length;
         messages.push({ role: "tool", content, toolCallId: call.id, name: call.name });
@@ -661,8 +887,9 @@ class BoundedAgentRuntime {
 
 // packages/core/src/cli/checkpoints.ts
 import { spawn } from "node:child_process";
-import { promises as fs } from "node:fs";
-import path from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
 var EXCLUDE_ARCHYMEDES = [".", ":(exclude).archymedes"];
 var runGit = (args, options) => new Promise((resolve) => {
   const child = spawn("git", args, {
@@ -679,7 +906,7 @@ var runGit = (args, options) => new Promise((resolve) => {
     stderr += String(chunk);
   });
   child.on("error", (error) => resolve({ exitCode: 127, stdout, stderr: error.message }));
-  child.on("close", (code) => resolve({ exitCode: code ?? 0, stdout, stderr }));
+  child.on("close", (code) => resolve({ exitCode: code ?? 1, stdout, stderr }));
 });
 
 class CheckpointStore {
@@ -700,7 +927,7 @@ class CheckpointStore {
     return result.exitCode === 0;
   }
   async capture(label, turnId, messageCount) {
-    await fs.mkdir(path.dirname(this.indexFile), { recursive: true }).catch(() => {
+    await fs2.mkdir(path2.dirname(this.indexFile), { recursive: true }).catch(() => {
       return;
     });
     const env = { GIT_INDEX_FILE: this.indexFile };
@@ -728,26 +955,38 @@ class CheckpointStore {
     return this.checkpoints[this.checkpoints.length - 1];
   }
   async diffPatch() {
-    const checkpoint = this.latest();
-    if (!checkpoint)
-      return "";
-    const result = await this.git(["diff", "--unified=3", "--no-color", checkpoint.tree, "--", ...EXCLUDE_ARCHYMEDES], { cwd: this.root });
-    return result.exitCode === 0 ? result.stdout : "";
+    return this.diff(["--unified=3", "--no-color"]);
   }
   async diffStat() {
+    return (await this.diff(["--stat"])).trim();
+  }
+  async diff(format) {
     const checkpoint = this.latest();
     if (!checkpoint)
       return "";
-    const result = await this.git(["diff", "--stat", checkpoint.tree, "--", ...EXCLUDE_ARCHYMEDES], { cwd: this.root });
-    return result.exitCode === 0 ? result.stdout.trim() : "";
+    const index = `${this.indexFile}.diff-${randomUUID3()}`;
+    const options = { cwd: this.root, env: { GIT_INDEX_FILE: index } };
+    try {
+      if ((await this.git(["read-tree", checkpoint.tree], options)).exitCode !== 0)
+        return "";
+      if ((await this.git(["add", "--all", "--", ...EXCLUDE_ARCHYMEDES], options)).exitCode !== 0)
+        return "";
+      const result = await this.git(["diff", "--cached", ...format, checkpoint.tree, "--", ...EXCLUDE_ARCHYMEDES], options);
+      return result.exitCode === 0 ? result.stdout : "";
+    } finally {
+      await fs2.unlink(index).catch(() => {
+        return;
+      });
+    }
   }
 }
 
 // packages/core/src/cli/permissions.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 
 // packages/core/src/cli/command.ts
 import { spawn as spawn2 } from "node:child_process";
+import { constants } from "node:os";
 var ARCHYMEDES_CREDENTIAL_ENV_NAMES = [
   "ANTHROPIC_API_KEY",
   "OPENAI_API_KEY",
@@ -773,7 +1012,8 @@ function tokenizeCommand(command, platform = process.platform) {
   let quote = null;
   let escaped = false;
   let hasToken = false;
-  for (const character of command) {
+  for (let index = 0;index < command.length; index++) {
+    const character = command[index];
     if (escaped) {
       current += character;
       escaped = false;
@@ -781,8 +1021,16 @@ function tokenizeCommand(command, platform = process.platform) {
       continue;
     }
     if (character === "\\" && quote !== "'" && platform !== "win32") {
-      escaped = true;
-      hasToken = true;
+      if (quote === '"' && !["$", "`", '"', "\\", `
+`].includes(command[index + 1])) {
+        current += character;
+      } else if (command[index + 1] === `
+`) {
+        index++;
+      } else {
+        escaped = true;
+        hasToken = true;
+      }
       continue;
     }
     if (quote) {
@@ -864,11 +1112,15 @@ function isFindDelete(command) {
 }
 var SHELL_METACHARACTERS = /[|&;><`$()]|\|\||&&/;
 function hasShellSyntax(command) {
+  if (/^\s*(?:[A-Za-z_][A-Za-z0-9_]*=|(?:cd|export|unset|set|source|\.|umask|alias|unalias|read|eval|exec|exit|return)\s)/.test(command))
+    return true;
   let quote = null;
   let escaped = false;
+  let tokenStart = true;
   for (const character of command) {
     if (escaped) {
       escaped = false;
+      tokenStart = false;
       continue;
     }
     if (character === "\\" && quote !== "'") {
@@ -878,14 +1130,23 @@ function hasShellSyntax(command) {
     if (quote) {
       if (character === quote)
         quote = null;
+      else if (quote === '"' && (character === "$" || character === "`"))
+        return true;
       continue;
     }
     if (character === '"' || character === "'") {
       quote = character;
+      tokenStart = false;
       continue;
     }
+    if (character === `
+` || /[*?\[]/.test(character))
+      return true;
+    if (tokenStart && (character === "~" || character === "#"))
+      return true;
     if (SHELL_METACHARACTERS.test(character))
       return true;
+    tokenStart = /\s/.test(character);
   }
   return false;
 }
@@ -951,6 +1212,8 @@ var runLocalCommand = async (command, options) => {
     argv = [...CONTAINMENT_ARGS, ...inner];
     throughShell = false;
   }
+  if (options.signal?.aborted)
+    return { exitCode: 130, stdout: "", stderr: "Command cancelled before start." };
   return new Promise((resolve) => {
     const child = spawn2(program, argv, {
       cwd: options.cwd,
@@ -1029,8 +1292,8 @@ Command exceeded the ${maximumOutputBytes}-byte output limit and was killed.`;
       stderr += error.message;
       finish(127);
     });
-    child.on("close", (code) => {
-      closedCode = code;
+    child.on("close", (code, signal) => {
+      closedCode = code ?? (signal ? 128 + (constants.signals[signal] ?? 1) : 1);
       finishWhenDrained();
     });
     abort = () => {
@@ -1089,10 +1352,10 @@ function assessToolSafety(call, tool) {
     add("destructive", "recursive, forced file removal");
   if (isFindDelete(command))
     add("destructive", "find with -delete, as thorough a wipe as rm -rf");
-  const path2 = typeof args.path === "string" ? args.path : "";
-  if (SENSITIVE_PATH.test(path2))
+  const path3 = typeof args.path === "string" ? args.path : "";
+  if (SENSITIVE_PATH.test(path3))
     add("credentials", "sensitive credential or environment file");
-  if (PRODUCTION_PATH.test(path2))
+  if (PRODUCTION_PATH.test(path3))
     add("production", "production configuration file");
   const content = [args.content, args.replacement, args.newText].filter((value) => typeof value === "string").join(`
 `);
@@ -1158,7 +1421,7 @@ function actionDigest(call, tool) {
     provenance: tool.provenance ?? { kind: "built-in" },
     arguments: call.arguments ?? {}
   }));
-  return createHash2("sha256").update(action).digest("hex");
+  return createHash3("sha256").update(action).digest("hex");
 }
 class PermissionLedger {
   mode;
@@ -1242,9 +1505,9 @@ function describeToolCall(call, tool) {
 }
 
 // packages/core/src/cli/memory.ts
-import { promises as fs2 } from "node:fs";
+import { promises as fs3 } from "node:fs";
 import os from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 var MEMORY_LIMITS = { project: 6000, user: 2500 };
 var DEFAULT_RECALL_CHARS = 2200;
 var MEMORY_HEADER = "# Archymedes memory";
@@ -1258,15 +1521,15 @@ var PREAMBLE = [
 `);
 function archymedesConfigDirectory(environment, platform = process.platform) {
   if (environment.ARCHYMEDES_CONFIG_DIR?.trim())
-    return path2.resolve(environment.ARCHYMEDES_CONFIG_DIR);
+    return path3.resolve(environment.ARCHYMEDES_CONFIG_DIR);
   if (platform === "win32")
-    return path2.join(environment.APPDATA?.trim() || path2.join(os.homedir(), "AppData", "Roaming"), "Archymedes");
+    return path3.join(environment.APPDATA?.trim() || path3.join(os.homedir(), "AppData", "Roaming"), "Archymedes");
   if (platform === "darwin")
-    return path2.join(os.homedir(), "Library", "Application Support", "Archymedes");
-  return path2.join(environment.XDG_CONFIG_HOME?.trim() || path2.join(os.homedir(), ".config"), "archymedes");
+    return path3.join(os.homedir(), "Library", "Application Support", "Archymedes");
+  return path3.join(environment.XDG_CONFIG_HOME?.trim() || path3.join(os.homedir(), ".config"), "archymedes");
 }
 function memoryFile(scope, root, environment) {
-  return scope === "project" ? path2.join(root, ".archymedes", "memory.md") : path2.join(archymedesConfigDirectory(environment), "memory.md");
+  return scope === "project" ? path3.join(root, ".archymedes", "memory.md") : path3.join(archymedesConfigDirectory(environment), "memory.md");
 }
 function parseMemoryFile(contents, scope) {
   const entries = [];
@@ -1312,7 +1575,7 @@ function validateMemoryText(text) {
 }
 async function readScope(scope, root, environment) {
   try {
-    return parseMemoryFile(await fs2.readFile(memoryFile(scope, root, environment), "utf8"), scope);
+    return parseMemoryFile(await fs3.readFile(memoryFile(scope, root, environment), "utf8"), scope);
   } catch {
     return [];
   }
@@ -1323,10 +1586,10 @@ async function loadMemories(root, environment) {
 }
 async function writeScope(scope, entries, root, environment) {
   const file = memoryFile(scope, root, environment);
-  await fs2.mkdir(path2.dirname(file), { recursive: true, mode: 448 });
+  await fs3.mkdir(path3.dirname(file), { recursive: true, mode: 448 });
   const temporary = `${file}.${process.pid}.tmp`;
-  await fs2.writeFile(temporary, formatMemoryFile(entries), { encoding: "utf8", mode: 384 });
-  await fs2.rename(temporary, file);
+  await fs3.writeFile(temporary, formatMemoryFile(entries), { encoding: "utf8", mode: 384 });
+  await fs3.rename(temporary, file);
   return file;
 }
 async function addMemory(scope, text, root, environment, options = {}) {
@@ -1523,14 +1786,14 @@ function describeEnvironment(report) {
 }
 
 // packages/core/src/cli/prompt.ts
-import { createHash as createHash3 } from "node:crypto";
-import { promises as fs4 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { promises as fs5 } from "node:fs";
 import os3 from "node:os";
-import path4 from "node:path";
+import path5 from "node:path";
 
 // packages/core/src/cli/workspace.ts
-import { promises as fs3 } from "node:fs";
-import path3 from "node:path";
+import { promises as fs4 } from "node:fs";
+import path4 from "node:path";
 var DEFAULT_WORKSPACE_LIMITS = {
   maxReadBytes: 512000,
   maxWriteBytes: 512000,
@@ -1546,27 +1809,27 @@ class WorkspaceViolation extends Error {
 function resolveInWorkspace(root, candidate) {
   if (typeof candidate !== "string" || !candidate.trim())
     throw new WorkspaceViolation("path must be a non-empty string");
-  const absoluteRoot = path3.resolve(root);
-  const resolved = path3.resolve(absoluteRoot, candidate);
-  if (resolved !== absoluteRoot && !resolved.startsWith(absoluteRoot + path3.sep)) {
+  const absoluteRoot = path4.resolve(root);
+  const resolved = path4.resolve(absoluteRoot, candidate);
+  if (resolved !== absoluteRoot && !resolved.startsWith(absoluteRoot + path4.sep)) {
     throw new WorkspaceViolation(`path escapes the workspace root: ${candidate}`);
   }
   return resolved;
 }
 async function realPathWithin(root, candidate) {
   const resolved = resolveInWorkspace(root, candidate);
-  const absoluteRoot = await fs3.realpath(path3.resolve(root)).catch(() => path3.resolve(root));
-  const real = await fs3.realpath(resolved).catch(() => null);
+  const absoluteRoot = await fs4.realpath(path4.resolve(root)).catch(() => path4.resolve(root));
+  const real = await fs4.realpath(resolved).catch(() => null);
   if (real === null)
     return resolved;
-  if (real !== absoluteRoot && !real.startsWith(absoluteRoot + path3.sep)) {
+  if (real !== absoluteRoot && !real.startsWith(absoluteRoot + path4.sep)) {
     throw new WorkspaceViolation(`path resolves outside the workspace root: ${candidate}`);
   }
   return resolved;
 }
 function displayPath(root, absolute) {
-  const relative = path3.relative(path3.resolve(root), absolute);
-  return relative === "" ? "." : relative.split(path3.sep).join("/");
+  const relative = path4.relative(path4.resolve(root), absolute);
+  return relative === "" ? "." : relative.split(path4.sep).join("/");
 }
 var BINARY_SNIFF_BYTES = 4096;
 function looksBinary(buffer) {
@@ -1575,7 +1838,7 @@ function looksBinary(buffer) {
 async function readTextFile(root, candidate, options = {}) {
   const limits = options.limits ?? DEFAULT_WORKSPACE_LIMITS;
   const absolute = await realPathWithin(root, candidate);
-  const stat = await fs3.stat(absolute).catch((error) => {
+  const stat = await fs4.stat(absolute).catch((error) => {
     if (error.code === "ENOENT")
       throw new WorkspaceViolation(`${displayPath(root, absolute)} does not exist`);
     throw error;
@@ -1585,7 +1848,7 @@ async function readTextFile(root, candidate, options = {}) {
   if (stat.size > limits.maxReadBytes) {
     throw new WorkspaceViolation(`${displayPath(root, absolute)} is ${stat.size} bytes, above the ${limits.maxReadBytes}-byte read limit`);
   }
-  const buffer = await fs3.readFile(absolute);
+  const buffer = await fs4.readFile(absolute);
   if (looksBinary(buffer))
     throw new WorkspaceViolation(`${displayPath(root, absolute)} looks like a binary file`);
   const text = buffer.toString("utf8");
@@ -1613,9 +1876,9 @@ async function writeTextFile(root, candidate, content, limits = DEFAULT_WORKSPAC
   if (bytes > limits.maxWriteBytes)
     throw new WorkspaceViolation(`content is ${bytes} bytes, above the ${limits.maxWriteBytes}-byte write limit`);
   const absolute = resolveInWorkspace(root, candidate);
-  await realPathWithin(root, path3.dirname(candidate));
-  await fs3.mkdir(path3.dirname(absolute), { recursive: true });
-  await fs3.writeFile(absolute, content, "utf8");
+  await realPathWithin(root, path4.dirname(candidate));
+  await fs4.mkdir(path4.dirname(absolute), { recursive: true });
+  await fs4.writeFile(absolute, content, "utf8");
   return { path: displayPath(root, absolute), bytesWritten: bytes };
 }
 async function editTextFile(root, candidate, oldText, newText, options = {}) {
@@ -1639,7 +1902,7 @@ async function editTextFile(root, candidate, oldText, newText, options = {}) {
 var WALK_CONCURRENCY = 32;
 var GREP_CONCURRENCY = 32;
 async function* walkWorkspace(root, limits = DEFAULT_WORKSPACE_LIMITS, maxEntries = 20000) {
-  const absoluteRoot = path3.resolve(root);
+  const absoluteRoot = path4.resolve(root);
   const ignored = new Set(limits.ignoredDirectories);
   let level = [absoluteRoot];
   let seen = 0;
@@ -1649,7 +1912,7 @@ async function* walkWorkspace(root, limits = DEFAULT_WORKSPACE_LIMITS, maxEntrie
       const batch = level.slice(start, start + WALK_CONCURRENCY);
       const reads = await Promise.all(batch.map(async (directory) => {
         try {
-          return { directory, entries: await fs3.readdir(directory, { withFileTypes: true }) };
+          return { directory, entries: await fs4.readdir(directory, { withFileTypes: true }) };
         } catch {
           return { directory, entries: [] };
         }
@@ -1658,7 +1921,7 @@ async function* walkWorkspace(root, limits = DEFAULT_WORKSPACE_LIMITS, maxEntrie
         for (const entry of entries) {
           if (seen >= maxEntries)
             return;
-          const absolute = path3.join(directory, entry.name);
+          const absolute = path4.join(directory, entry.name);
           const isDirectory = entry.isDirectory();
           if (isDirectory && ignored.has(entry.name))
             continue;
@@ -1734,10 +1997,10 @@ async function grepWorkspace(root, query, options = {}) {
   const scan = async (entry) => {
     let buffer;
     try {
-      const stat = await fs3.stat(entry.absolute);
+      const stat = await fs4.stat(entry.absolute);
       if (stat.size > limits.maxReadBytes)
         return [];
-      buffer = await fs3.readFile(entry.absolute);
+      buffer = await fs4.readFile(entry.absolute);
     } catch {
       return [];
     }
@@ -2488,13 +2751,13 @@ function playbookFor(id) {
 // packages/core/src/cli/prompt.ts
 var INSTRUCTION_FILES = ["AGENTS.override.md", "ARCHYMEDES.md", "AGENTS.md", "CLAUDE.md", ".archymedesrules"];
 async function instructionBoundary(root) {
-  const requestedRoot = path4.resolve(root);
-  const temporaryRoot = path4.resolve(os3.tmpdir());
-  let current = path4.resolve(root);
+  const requestedRoot = path5.resolve(root);
+  const temporaryRoot = path5.resolve(os3.tmpdir());
+  let current = path5.resolve(root);
   while (true) {
-    if (current !== temporaryRoot && await fs4.stat(path4.join(current, ".git")).then(() => true).catch(() => false))
+    if (current !== temporaryRoot && await fs5.stat(path5.join(current, ".git")).then(() => true).catch(() => false))
       return current;
-    const parent = path4.dirname(current);
+    const parent = path5.dirname(current);
     if (current === temporaryRoot || parent === current)
       return requestedRoot;
     current = parent;
@@ -2504,7 +2767,7 @@ async function collectProjectContext(root, maxInstructionChars = 8000) {
   const context = { root, instructions: null, instructionsFile: null, instructionSources: [], layout: [], packageScripts: [], gitBranch: null };
   const boundary = await instructionBoundary(root);
   const directories = [];
-  for (let current = path4.resolve(root);; current = path4.dirname(current)) {
+  for (let current = path5.resolve(root);; current = path5.dirname(current)) {
     directories.unshift(current);
     if (current === boundary)
       break;
@@ -2513,9 +2776,9 @@ async function collectProjectContext(root, maxInstructionChars = 8000) {
   for (const directory of directories) {
     for (const candidate of INSTRUCTION_FILES) {
       try {
-        const file = path4.join(directory, candidate);
-        const text = await fs4.readFile(file, "utf8");
-        discovered.push({ file, relative: path4.relative(boundary, file).split(path4.sep).join("/") || candidate, text });
+        const file = path5.join(directory, candidate);
+        const text = await fs5.readFile(file, "utf8");
+        discovered.push({ file, relative: path5.relative(boundary, file).split(path5.sep).join("/") || candidate, text });
         break;
       } catch {}
     }
@@ -2529,7 +2792,7 @@ async function collectProjectContext(root, maxInstructionChars = 8000) {
     selected.unshift({
       path: item.relative,
       content,
-      sha256: createHash3("sha256").update(item.text).digest("hex"),
+      sha256: createHash4("sha256").update(item.text).digest("hex"),
       truncated: content.length < item.text.length
     });
     remaining -= content.length;
@@ -2543,16 +2806,16 @@ ${source.content}`).join(`
     context.instructionSources = selected.map(({ path: sourcePath, sha256, truncated }) => ({ path: sourcePath, sha256, truncated }));
   }
   try {
-    const entries = await fs4.readdir(root, { withFileTypes: true });
+    const entries = await fs5.readdir(root, { withFileTypes: true });
     const ignored = new Set([...DEFAULT_WORKSPACE_LIMITS.ignoredDirectories ?? [], "coverage", "test-results", "tmp", ".turbo"]);
     context.layout = entries.filter((entry) => !entry.name.startsWith(".") || entry.name === ".github").filter((entry) => !(entry.isDirectory() && ignored.has(entry.name))).map((entry) => entry.isDirectory() ? `${entry.name}/` : entry.name).sort().slice(0, 60);
   } catch {}
   try {
-    const manifest = JSON.parse(await fs4.readFile(path4.join(root, "package.json"), "utf8"));
+    const manifest = JSON.parse(await fs5.readFile(path5.join(root, "package.json"), "utf8"));
     context.packageScripts = Object.keys(manifest.scripts ?? {}).slice(0, 30);
   } catch {}
   try {
-    const head = await fs4.readFile(path4.join(boundary, ".git", "HEAD"), "utf8");
+    const head = await fs5.readFile(path5.join(boundary, ".git", "HEAD"), "utf8");
     const match = head.match(/ref:\s*refs\/heads\/(.+)/);
     context.gitBranch = match?.[1]?.trim() ?? null;
   } catch {}
@@ -2703,9 +2966,97 @@ ${context.instructions.trim()}`);
 }
 
 // packages/core/src/cli/protocol.ts
-import { createHash as createHash4 } from "node:crypto";
-import { promises as fs5 } from "node:fs";
-import path5 from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import { promises as fs7 } from "node:fs";
+import path7 from "node:path";
+
+// packages/core/src/cli/file-ownership.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { promises as fs6 } from "node:fs";
+import os4 from "node:os";
+import path6 from "node:path";
+async function processStart(pid) {
+  if (process.platform !== "linux")
+    return;
+  try {
+    const stat = await fs6.readFile(`/proc/${pid}/stat`, "utf8");
+    const boot = await fs6.readFile("/proc/sys/kernel/random/boot_id", "utf8");
+    return `${boot.trim()}:${stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]}`;
+  } catch {
+    return;
+  }
+}
+async function readOwner(file) {
+  try {
+    const owner = JSON.parse(await fs6.readFile(file, "utf8"));
+    if (!owner || typeof owner.token !== "string" || !Number.isSafeInteger(owner.pid) || owner.pid < 1 || typeof owner.host !== "string") {
+      throw new Error(`Invalid ownership record: ${file}`);
+    }
+    return owner;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}
+async function isAlive(owner) {
+  if (owner.host !== os4.hostname())
+    return true;
+  try {
+    process.kill(owner.pid, 0);
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+  const started = await processStart(owner.pid);
+  return !owner.started || !started || owner.started === started;
+}
+async function acquireFileOwnership(file, depth = 0) {
+  if (depth > 8)
+    throw new Error(`Ownership recovery requires inspection: ${file}`);
+  await fs6.mkdir(path6.dirname(file), { recursive: true });
+  const owner = { token: randomUUID4(), pid: process.pid, host: os4.hostname(), started: await processStart(process.pid) };
+  const candidate = `${file}.${owner.token}.tmp`;
+  const handle = await fs6.open(candidate, "wx", 384);
+  try {
+    await handle.writeFile(JSON.stringify(owner));
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  try {
+    for (let attempt = 0;attempt < 8; attempt++) {
+      try {
+        await fs6.link(candidate, file);
+        return async () => {
+          if ((await readOwner(file))?.token === owner.token)
+            await fs6.unlink(file);
+        };
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+      const current = await readOwner(file);
+      if (!current)
+        continue;
+      if (await isAlive(current))
+        throw new Error(`Session is already owned by process ${current.pid}; close or detach the other writer first.`);
+      const release = await acquireFileOwnership(`${file}.reap`, depth + 1);
+      try {
+        if ((await readOwner(file))?.token === current.token)
+          await fs6.unlink(file);
+      } finally {
+        await release();
+      }
+    }
+    throw new Error(`Could not acquire session ownership: ${file}`);
+  } finally {
+    await fs6.unlink(candidate).catch(() => {
+      return;
+    });
+  }
+}
+
+// packages/core/src/cli/protocol.ts
 var ARCHYMEDES_PROTOCOL_VERSION = 1;
 var JOURNAL_GENESIS_HASH = "0".repeat(64);
 var TRANSITIONS = {
@@ -2737,9 +3088,9 @@ function boundedJournalValue(value, key = "") {
     const redacted = redactJournalString(value);
     if (redacted.length <= 4000)
       return redacted;
-    const digest = createHash4("sha256").update(value).digest("hex");
+    const digest2 = createHash5("sha256").update(value).digest("hex");
     return `${redacted.slice(0, 4000)}
-...[${redacted.length - 4000} chars omitted; original sha256=${digest}]`;
+...[${redacted.length - 4000} chars omitted; original sha256=${digest2}]`;
   }
   if (Array.isArray(value))
     return value.map((item) => boundedJournalValue(item));
@@ -2761,12 +3112,12 @@ function runtimeEventForJournal(event) {
   return event;
 }
 function hashEnvelope(envelope) {
-  return createHash4("sha256").update(JSON.stringify(envelope)).digest("hex");
+  return createHash5("sha256").update(JSON.stringify(envelope)).digest("hex");
 }
 function eventJournalPath(root, sessionId) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(sessionId))
     throw new Error("Session id contains unsafe characters");
-  return path5.join(root, ".archymedes", "events", `${sessionId}.jsonl`);
+  return path7.join(root, ".archymedes", "events", `${sessionId}.jsonl`);
 }
 async function readEventJournal(root, sessionId) {
   return (await readJournalFile(root, sessionId)).events;
@@ -2775,7 +3126,7 @@ async function readJournalFile(root, sessionId) {
   const file = eventJournalPath(root, sessionId);
   let text;
   try {
-    text = await fs5.readFile(file, "utf8");
+    text = await fs7.readFile(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return { events: [], text: "", completeText: "" };
@@ -2806,6 +3157,8 @@ class EventJournal {
   root;
   sessionId;
   handle = null;
+  releaseOwnership;
+  closed = false;
   sequence = 0;
   previousHash = JOURNAL_GENESIS_HASH;
   initialized = null;
@@ -2815,20 +3168,34 @@ class EventJournal {
     this.sessionId = sessionId;
   }
   async initialize() {
-    const { events, text, completeText } = await readJournalFile(this.root, this.sessionId);
-    this.sequence = events.length;
-    this.previousHash = events.at(-1)?.hash ?? JOURNAL_GENESIS_HASH;
-    const file = eventJournalPath(this.root, this.sessionId);
-    await fs5.mkdir(path5.dirname(file), { recursive: true });
-    if (text.length !== completeText.length)
-      await fs5.truncate(file, Buffer.byteLength(completeText, "utf8"));
-    this.handle = await fs5.open(file, "a", 384);
+    this.releaseOwnership = await acquireFileOwnership(`${eventJournalPath(this.root, this.sessionId)}.owner`);
+    try {
+      const { events, text, completeText } = await readJournalFile(this.root, this.sessionId);
+      this.sequence = events.length;
+      this.previousHash = events.at(-1)?.hash ?? JOURNAL_GENESIS_HASH;
+      const file = eventJournalPath(this.root, this.sessionId);
+      await fs7.mkdir(path7.dirname(file), { recursive: true });
+      if (text.length !== completeText.length)
+        await fs7.truncate(file, Buffer.byteLength(completeText, "utf8"));
+      this.handle = await fs7.open(file, "a", 384);
+    } catch (error) {
+      await this.releaseOwnership();
+      this.releaseOwnership = undefined;
+      throw error;
+    }
+  }
+  async open() {
+    if (this.closed)
+      throw new Error("Session journal is closed");
+    this.initialized ??= this.initialize();
+    await this.initialized;
   }
   append(payload, options = {}) {
+    if (this.closed)
+      return Promise.reject(new Error("Session journal is closed"));
     let written;
     const operation = this.tail.then(async () => {
-      this.initialized ??= this.initialize();
-      await this.initialized;
+      await this.open();
       const withoutHash = {
         protocolVersion: ARCHYMEDES_PROTOCOL_VERSION,
         sequence: this.sequence + 1,
@@ -2853,19 +3220,29 @@ class EventJournal {
     await this.handle?.sync();
   }
   async close() {
-    await this.flush();
-    await this.handle?.close();
-    this.handle = null;
+    try {
+      await this.initialized;
+      await this.flush();
+    } finally {
+      this.closed = true;
+      try {
+        await this.handle?.close();
+      } finally {
+        this.handle = null;
+        await this.releaseOwnership?.();
+        this.releaseOwnership = undefined;
+      }
+    }
   }
 }
 
 // packages/core/src/cli/session.ts
-import { createHash as createHash5, randomUUID as randomUUID2 } from "node:crypto";
-import { promises as fs6 } from "node:fs";
-import path6 from "node:path";
+import { createHash as createHash6, randomUUID as randomUUID5 } from "node:crypto";
+import { promises as fs8 } from "node:fs";
+import path8 from "node:path";
 var SESSION_SCHEMA_VERSION = 2;
 function sessionDirectory(root) {
-  return path6.join(root, ".archymedes", "sessions");
+  return path8.join(root, ".archymedes", "sessions");
 }
 function newSessionId(now = new Date) {
   const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
@@ -2887,26 +3264,26 @@ function canonicalize2(value) {
   return null;
 }
 function integrityFor(record) {
-  return createHash5("sha256").update(JSON.stringify(canonicalize2(record))).digest("hex");
+  return createHash6("sha256").update(JSON.stringify(canonicalize2(record))).digest("hex");
 }
 async function acquireSessionLock(lockFile) {
   for (let attempt = 0;attempt < 40; attempt += 1) {
     try {
-      const handle = await fs6.open(lockFile, "wx", 384);
+      const handle = await fs8.open(lockFile, "wx", 384);
       await handle.writeFile(`${process.pid}
 `, "utf8");
       await handle.close();
       return async () => {
-        await fs6.unlink(lockFile).catch(() => {
+        await fs8.unlink(lockFile).catch(() => {
           return;
         });
       };
     } catch (error) {
       if (error.code !== "EEXIST")
         throw error;
-      const stat = await fs6.stat(lockFile).catch(() => null);
+      const stat = await fs8.stat(lockFile).catch(() => null);
       if (stat && Date.now() - stat.mtimeMs > 30000) {
-        await fs6.unlink(lockFile).catch(() => {
+        await fs8.unlink(lockFile).catch(() => {
           return;
         });
         continue;
@@ -2919,13 +3296,13 @@ async function acquireSessionLock(lockFile) {
 async function saveSession(record) {
   assertSessionId(record.id);
   const directory = sessionDirectory(record.root);
-  await fs6.mkdir(directory, { recursive: true });
-  const file = path6.join(directory, `${record.id}.json`);
+  await fs8.mkdir(directory, { recursive: true });
+  const file = path8.join(directory, `${record.id}.json`);
   const lockFile = `${file}.lock`;
   const release = await acquireSessionLock(lockFile);
-  const temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
+  const temporary = `${file}.${process.pid}.${randomUUID5()}.tmp`;
   try {
-    const fileExists = await fs6.stat(file).then(() => true).catch(() => false);
+    const fileExists = await fs8.stat(file).then(() => true).catch(() => false);
     const current = await loadSession(record.root, record.id);
     if (fileExists && !current)
       throw new Error("Existing session is corrupt or incompatible; refusing to overwrite it");
@@ -2940,7 +3317,7 @@ async function saveSession(record) {
     };
     delete withoutIntegrity.integrity;
     const next = { ...withoutIntegrity, integrity: integrityFor(withoutIntegrity) };
-    const handle = await fs6.open(temporary, "wx", 384);
+    const handle = await fs8.open(temporary, "wx", 384);
     try {
       await handle.writeFile(`${JSON.stringify(next, null, 2)}
 `, "utf8");
@@ -2948,8 +3325,8 @@ async function saveSession(record) {
     } finally {
       await handle.close();
     }
-    await fs6.rename(temporary, file);
-    const directoryHandle = await fs6.open(directory, "r").catch(() => null);
+    await fs8.rename(temporary, file);
+    const directoryHandle = await fs8.open(directory, "r").catch(() => null);
     if (directoryHandle) {
       await directoryHandle.sync().catch(() => {
         return;
@@ -2959,7 +3336,7 @@ async function saveSession(record) {
     Object.assign(record, next);
     return file;
   } finally {
-    await fs6.unlink(temporary).catch(() => {
+    await fs8.unlink(temporary).catch(() => {
       return;
     });
     await release();
@@ -2968,10 +3345,10 @@ async function saveSession(record) {
 async function loadSession(root, id) {
   try {
     assertSessionId(id);
-    const parsed = JSON.parse(await fs6.readFile(path6.join(sessionDirectory(root), `${id}.json`), "utf8"));
+    const parsed = JSON.parse(await fs8.readFile(path8.join(sessionDirectory(root), `${id}.json`), "utf8"));
     if (!parsed || typeof parsed !== "object" || parsed.id !== id || typeof parsed.root !== "string")
       return null;
-    const [storedRoot, requestedRoot] = await Promise.all([parsed.root, root].map(async (candidate) => fs6.realpath(path6.resolve(candidate)).catch(() => path6.resolve(candidate))));
+    const [storedRoot, requestedRoot] = await Promise.all([parsed.root, root].map(async (candidate) => fs8.realpath(path8.resolve(candidate)).catch(() => path8.resolve(candidate))));
     const rootsMatch = process.platform === "win32" ? storedRoot.toLocaleLowerCase("en-US") === requestedRoot.toLocaleLowerCase("en-US") : storedRoot === requestedRoot;
     if (!rootsMatch)
       return null;
@@ -3214,6 +3591,7 @@ class McpConnection {
   nextId = 1;
   pending = new Map;
   initializePromise = null;
+  closedError;
   toolsPromise;
   constructor(config, requestTimeoutMs = REQUEST_TIMEOUT_MS) {
     this.config = config;
@@ -3222,11 +3600,17 @@ class McpConnection {
       env: { ...sanitizeCommandEnvironment(process.env), ...config.env },
       stdio: ["pipe", "pipe", "pipe"]
     });
-    this.child.on("error", (error) => this.rejectAllPending(error));
-    this.child.on("exit", (code) => this.rejectAllPending(new Error(`MCP server '${config.id}' exited (code ${code})`)));
+    this.child.on("error", (error) => this.fail(error));
+    this.child.stdin.on("error", (error) => this.fail(error));
+    this.child.on("close", (code) => this.fail(new Error(`MCP server '${config.id}' exited (code ${code})`)));
+    this.child.stderr.resume();
     const lines = createInterface({ input: this.child.stdout });
     lines.on("line", (line) => this.handleLine(line));
   }
+  fail(error) {
+    this.closedError ??= error;
+    this.rejectAllPending(this.closedError);
+  }
   rejectAllPending(error) {
     for (const { reject } of this.pending.values())
       reject(error);
@@ -3258,6 +3642,8 @@ class McpConnection {
       waiting.resolve(parsed.result);
   }
   request(method, params) {
+    if (this.closedError)
+      return Promise.reject(this.closedError);
     const id = this.nextId++;
     const line = `${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
 `;
@@ -3280,10 +3666,14 @@ class McpConnection {
     });
   }
   notify(method, params) {
+    if (this.closedError)
+      throw this.closedError;
     this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
 `);
   }
   initialize() {
+    if (this.closedError)
+      return Promise.reject(this.closedError);
     this.initializePromise ??= (async () => {
       await this.request("initialize", {
         protocolVersion: MCP_PROTOCOL_VERSION,
@@ -3320,7 +3710,7 @@ class McpConnection {
     return { content: text || "(no output)", isError: result.isError };
   }
   close() {
-    this.rejectAllPending(new Error(`MCP server '${this.config.id}' connection closed`));
+    this.fail(new Error(`MCP server '${this.config.id}' connection closed`));
     this.child.kill();
   }
 }
@@ -5790,7 +6180,7 @@ class CostLedger {
 }
 
 // packages/core/src/cli/backends.ts
-import path8 from "node:path";
+import path10 from "node:path";
 
 // packages/core/src/sandbox-search.ts
 var DEFAULT_IGNORED_DIRECTORIES = [".git", "node_modules", ".next", "dist", "build", "target", "__pycache__", ".venv", "venv", ".pytest_cache", ".mypy_cache", ".ruff_cache", ".turbo", "vendor", ".archymedes"];
@@ -5871,7 +6261,7 @@ import { spawn as spawn4 } from "node:child_process";
 import { stat } from "node:fs/promises";
 import http from "node:http";
 import net from "node:net";
-import path7 from "node:path";
+import path9 from "node:path";
 var MAX_LOG_BYTES = 128 * 1024;
 var DEFAULT_READY_TIMEOUT_MS = 20000;
 function appendBounded(current, chunk) {
@@ -5937,9 +6327,9 @@ class LocalApplicationSupervisor {
     if (await portIsOpen(request.port))
       throw new Error(`Port ${request.port} is already in use by another process.`);
     const relativeDirectory = request.directory?.trim() || ".";
-    const directory = path7.resolve(this.root, relativeDirectory);
-    const relative = path7.relative(path7.resolve(this.root), directory);
-    if (relative.startsWith("..") || path7.isAbsolute(relative))
+    const directory = path9.resolve(this.root, relativeDirectory);
+    const relative = path9.relative(path9.resolve(this.root), directory);
+    if (relative.startsWith("..") || path9.isAbsolute(relative))
       throw new Error("directory must stay inside the project workspace");
     const info = await stat(directory).catch(() => null);
     if (!info?.isDirectory())
@@ -6072,14 +6462,14 @@ class LocalWorkspace {
   get label() {
     return this.root;
   }
-  readFile(path9, options = {}) {
-    return readTextFile(this.root, path9, { ...options, limits: this.limits });
+  readFile(path11, options = {}) {
+    return readTextFile(this.root, path11, { ...options, limits: this.limits });
   }
-  writeFile(path9, content) {
-    return writeTextFile(this.root, path9, content, this.limits);
+  writeFile(path11, content) {
+    return writeTextFile(this.root, path11, content, this.limits);
   }
-  editFile(path9, oldText, newText, options = {}) {
-    return editTextFile(this.root, path9, oldText, newText, { ...options, limits: this.limits });
+  editFile(path11, oldText, newText, options = {}) {
+    return editTextFile(this.root, path11, oldText, newText, { ...options, limits: this.limits });
   }
   async list(prefix, depth) {
     const entries = [];
@@ -6100,8 +6490,8 @@ class LocalWorkspace {
   }
   async listConfigFiles(prefix) {
     const files = [];
-    const base = path8.resolve(this.root, prefix);
-    if (!base.startsWith(path8.resolve(this.root)))
+    const base = path10.resolve(this.root, prefix);
+    if (!base.startsWith(path10.resolve(this.root)))
       return [];
     for await (const entry of walkWorkspace(base, { ...this.limits, ignoredDirectories: [] }, CONFIG_FILE_SCAN_LIMIT)) {
       if (!entry.isDirectory)
@@ -6138,7 +6528,7 @@ class LocalWorkspace {
 }
 
 // packages/core/src/cli/artifacts.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 var ARTIFACT_DIRECTORY = ".archymedes/artifacts";
 var MAX_ARTIFACT_BYTES = 480000;
 function safeToolName(toolName) {
@@ -6146,8 +6536,8 @@ function safeToolName(toolName) {
   return cleaned || "tool";
 }
 function artifactPathFor(toolName, content) {
-  const digest = createHash6("sha256").update(content).digest("hex").slice(0, 12);
-  return `${ARTIFACT_DIRECTORY}/${safeToolName(toolName)}-${digest}.txt`;
+  const digest2 = createHash7("sha256").update(content).digest("hex").slice(0, 12);
+  return `${ARTIFACT_DIRECTORY}/${safeToolName(toolName)}-${digest2}.txt`;
 }
 
 class WorkspaceArtifactStore {
@@ -6159,16 +6549,16 @@ class WorkspaceArtifactStore {
     this.maxBytes = maxBytes;
   }
   async put(input) {
-    const path9 = artifactPathFor(input.toolName, input.content);
+    const path11 = artifactPathFor(input.toolName, input.content);
     const full = Buffer.byteLength(input.content, "utf8");
     const elided = full > this.maxBytes;
     const body = elided ? `${input.content.slice(0, this.maxBytes)}
 ...[artifact truncated at ${this.maxBytes} bytes; the tool produced ${full}]` : input.content;
-    if (!this.written.has(path9)) {
-      await this.workspace.writeFile(path9, body);
-      this.written.add(path9);
+    if (!this.written.has(path11)) {
+      await this.workspace.writeFile(path11, body);
+      this.written.add(path11);
     }
-    return { path: path9, bytes: full, lines: countLines(input.content), elided };
+    return { path: path11, bytes: full, lines: countLines(input.content), elided };
   }
 }
 function countLines(content) {
@@ -6183,14 +6573,14 @@ function countLines(content) {
 
 // packages/core/src/cli/defender-brain.ts
 import { access as access2 } from "node:fs/promises";
-import path11 from "node:path";
+import path13 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // packages/core/src/cli/state-client.ts
 import { spawn as spawn5 } from "node:child_process";
 import { access } from "node:fs/promises";
 import { createRequire } from "node:module";
-import path9 from "node:path";
+import path11 from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 var ARCHYMEDES_STATE_PROTOCOL_VERSION = 1;
 
@@ -6235,7 +6625,7 @@ async function executable(pathname) {
 }
 async function resolveArchymedesStateBinary(environment = process.env) {
   if (environment.ARCHYMEDES_STATE_BINARY) {
-    const explicit = path9.resolve(environment.ARCHYMEDES_STATE_BINARY);
+    const explicit = path11.resolve(environment.ARCHYMEDES_STATE_BINARY);
     if (!await executable(explicit))
       throw new Error(`ARCHYMEDES_STATE_BINARY is not executable: ${explicit}`);
     return explicit;
@@ -6245,14 +6635,14 @@ async function resolveArchymedesStateBinary(environment = process.env) {
     try {
       const require2 = createRequire(import.meta.url);
       const manifest = require2.resolve(`${packageName}/package.json`);
-      const candidate = path9.join(path9.dirname(manifest), "bin", process.platform === "win32" ? "archymedes-state.exe" : "archymedes-state");
+      const candidate = path11.join(path11.dirname(manifest), "bin", process.platform === "win32" ? "archymedes-state.exe" : "archymedes-state");
       if (await executable(candidate))
         return candidate;
     } catch {}
   }
   const filename = process.platform === "win32" ? "archymedes-state.exe" : "archymedes-state";
   for (const profile of ["release", "debug"]) {
-    const candidate = path9.resolve(process.cwd(), "packages", "archymedes-state", "target", profile, filename);
+    const candidate = path11.resolve(process.cwd(), "packages", "archymedes-state", "target", profile, filename);
     if (await executable(candidate))
       return candidate;
   }
@@ -6401,25 +6791,25 @@ async function tryConnectArchymedesState(options = {}) {
 }
 
 // packages/core/src/cli/defender-feed.ts
-import { createHash as createHash7, createPublicKey, verify as verifySignature } from "node:crypto";
-import { promises as fs7 } from "node:fs";
-import path10 from "node:path";
+import { createHash as createHash8, createPublicKey, verify as verifySignature } from "node:crypto";
+import { promises as fs9 } from "node:fs";
+import path12 from "node:path";
 var DEFENDER_FEED_INTERVAL_MS = 6 * 60 * 60 * 1000;
 var DEFENDER_FEED_MAX_BYTES = 8 * 1024 * 1024;
 var DEFENDER_FEED_MAX_MANIFEST_BYTES = 64 * 1024;
 var DEFENDER_FEED_FILENAME = "knowledge-v1.jsonl";
 function feedRoot(environment) {
-  return path10.join(archymedesConfigDirectory(environment), "defender-brain");
+  return path12.join(archymedesConfigDirectory(environment), "defender-brain");
 }
 function statePath(environment) {
-  return path10.join(feedRoot(environment), "feed-state.json");
+  return path12.join(feedRoot(environment), "feed-state.json");
 }
 function validDigest(value) {
   return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
 }
 async function readDefenderFeedState(environment) {
   try {
-    const value = JSON.parse(await fs7.readFile(statePath(environment), "utf8"));
+    const value = JSON.parse(await fs9.readFile(statePath(environment), "utf8"));
     if (value.schemaVersion !== 1 || !Number.isFinite(value.lastCheckedAt))
       return null;
     return {
@@ -6522,19 +6912,19 @@ async function boundedResponseBody(response, maximum, label) {
   return Buffer.concat(chunks, total);
 }
 async function atomicJson(file, value) {
-  await fs7.mkdir(path10.dirname(file), { recursive: true });
+  await fs9.mkdir(path12.dirname(file), { recursive: true });
   const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
-  await fs7.writeFile(temporary, `${JSON.stringify(value, null, 2)}
+  await fs9.writeFile(temporary, `${JSON.stringify(value, null, 2)}
 `, { encoding: "utf8", mode: 384 });
-  await fs7.rename(temporary, file);
+  await fs9.rename(temporary, file);
 }
 async function activeDirectory(environment, state) {
   const current = state ?? await readDefenderFeedState(environment);
   if (!current?.activeDigest)
     return;
-  const directory = path10.join(feedRoot(environment), "replicas", current.activeDigest);
+  const directory = path12.join(feedRoot(environment), "replicas", current.activeDigest);
   try {
-    await fs7.access(path10.join(directory, DEFENDER_FEED_FILENAME));
+    await fs9.access(path12.join(directory, DEFENDER_FEED_FILENAME));
     return directory;
   } catch {
     return;
@@ -6595,26 +6985,26 @@ async function refreshDefenderFeed(options) {
     const bytes = await boundedResponseBody(corpusResponse, manifest.corpus.bytes, "corpus");
     if (bytes.byteLength !== manifest.corpus.bytes)
       throw new Error("corpus byte count does not match manifest");
-    if (createHash7("sha256").update(bytes).digest("hex") !== manifest.corpus.sha256)
+    if (createHash8("sha256").update(bytes).digest("hex") !== manifest.corpus.sha256)
       throw new Error("corpus digest does not match manifest");
     const records = bytes.toString("utf8").split(`
 `).filter((line) => line.trim()).length;
     if (records !== manifest.corpus.records)
       throw new Error("corpus record count does not match manifest");
-    const replica = path10.join(feedRoot(options.environment), "replicas", manifest.corpus.sha256);
-    await fs7.mkdir(replica, { recursive: true });
-    const corpusFile = path10.join(replica, DEFENDER_FEED_FILENAME);
+    const replica = path12.join(feedRoot(options.environment), "replicas", manifest.corpus.sha256);
+    await fs9.mkdir(replica, { recursive: true });
+    const corpusFile = path12.join(replica, DEFENDER_FEED_FILENAME);
     try {
-      await fs7.access(corpusFile);
+      await fs9.access(corpusFile);
     } catch {
       const temporary = `${corpusFile}.${process.pid}.${Date.now()}.tmp`;
-      await fs7.writeFile(temporary, bytes, { mode: 384, flag: "wx" });
+      await fs9.writeFile(temporary, bytes, { mode: 384, flag: "wx" });
       try {
-        await fs7.rename(temporary, corpusFile);
+        await fs9.rename(temporary, corpusFile);
       } catch (error) {
-        await fs7.rm(temporary, { force: true });
+        await fs9.rm(temporary, { force: true });
         try {
-          await fs7.access(corpusFile);
+          await fs9.access(corpusFile);
         } catch {
           throw error;
         }
@@ -6640,10 +7030,10 @@ async function existingDirectory(candidates) {
   return null;
 }
 function defenderKnowledgeCandidates(moduleUrl = import.meta.url) {
-  const directory = path11.dirname(fileURLToPath(moduleUrl));
+  const directory = path13.dirname(fileURLToPath(moduleUrl));
   return [
-    path11.join(directory, "defender-knowledge"),
-    path11.resolve(directory, "../../../archymedes-state/defender-knowledge")
+    path13.join(directory, "defender-knowledge"),
+    path13.resolve(directory, "../../../archymedes-state/defender-knowledge")
   ];
 }
 
@@ -6758,6 +7148,8 @@ class ArchymedesAgent {
   workspace;
   permissions;
   checkpoints;
+  recovery;
+  ownershipReady;
   artifacts;
   budgets;
   messages = [];
@@ -6793,8 +7185,8 @@ class ArchymedesAgent {
     this.workspace = options.workspace ?? new LocalWorkspace(options.root, options.limits);
     this.nestedInstructions = new NestedInstructionTracker(this.workspace);
     this.artifacts = new WorkspaceArtifactStore(this.workspace);
-    this.defenderBrain = new DefenderBrain(path12.join(options.root, ".archymedes", "security-brain"));
-    this.checkpoints = new CheckpointStore(options.root, path12.join(options.root, ".archymedes", "checkpoint-index"), options.git);
+    this.defenderBrain = new DefenderBrain(path14.join(options.root, ".archymedes", "security-brain"));
+    this.checkpoints = new CheckpointStore(options.root, path14.join(options.root, ".archymedes", `checkpoint-index-${randomUUID6()}`), options.git);
     this.session = {
       schemaVersion: 2,
       revision: 0,
@@ -6810,6 +7202,7 @@ class ArchymedesAgent {
       totalRwf: 0
     };
     this.journal = new EventJournal(options.root, this.session.id);
+    this.recovery = new HostedRecoveryStore(options.root, this.session.id);
     this.permissions = new PermissionLedger(options.mode, async (request) => {
       const turnId = this.activeTurnId ?? "turn_unbound";
       await this.activeTransition?.("waiting_approval", true);
@@ -6844,6 +7237,8 @@ class ArchymedesAgent {
     return structuredClone(this.session);
   }
   resume(record) {
+    if (this.ownershipReady)
+      throw new Error("Relinquish the current agent before resuming another session");
     this.session = { ...record, routingReceipts: mergeRoutingReceipts(record.routingReceipts), mode: this.options.mode };
     this.messages = [...record.messages];
     this.recalledMemoryKeys.clear();
@@ -6852,6 +7247,62 @@ class ArchymedesAgent {
     this.openingObjective = record.messages.find((message) => message.role === "user" && !message.internal && !message.content.startsWith(STANDING_CONSTRAINTS_HEADING) && !message.content.startsWith("[Earlier conversation, summarized]"))?.content ?? (record.title === "Untitled session" ? null : record.title);
     this.permissions.restore(record.approvals ?? {});
     this.journal = new EventJournal(this.options.root, record.id);
+    this.recovery = new HostedRecoveryStore(this.options.root, record.id);
+  }
+  async acquireOwnership() {
+    this.ownershipReady ??= (async () => {
+      await this.journal.open();
+      const current = await loadSession(this.options.root, this.session.id);
+      const exists = current || await access3(path14.join(this.options.root, ".archymedes", "sessions", `${this.session.id}.json`)).then(() => true).catch((error) => {
+        if (error.code === "ENOENT")
+          return false;
+        throw error;
+      });
+      if (!current && (exists || this.session.revision > 0)) {
+        await this.journal.close();
+        throw new Error("Session snapshot is missing, corrupt or incompatible; refusing to start work.");
+      }
+      if (current && current.revision !== this.session.revision) {
+        await this.journal.close();
+        throw new Error("Session changed since it was loaded; resume it again before writing.");
+      }
+    })();
+    await this.ownershipReady;
+  }
+  async recordHostedUsage() {
+    const responses = this.recovery.responses();
+    if (!responses.length)
+      return;
+    const events = await readEventJournal(this.options.root, this.session.id);
+    const recorded = new Set(events.flatMap(({ payload }) => payload.type === "runtime" && payload.event.type === "model_turn" && payload.event.requestId ? [payload.event.requestId] : []));
+    for (const { requestId, turn } of responses) {
+      if (recorded.has(requestId))
+        continue;
+      await this.journal.append({ type: "runtime", turnId: `recovered_${requestId}`, event: {
+        type: "model_turn",
+        requestId,
+        iteration: 0,
+        responseId: turn.responseId,
+        model: turn.model,
+        toolCallCount: turn.toolCalls.length,
+        usage: turn.usage
+      } }, { durable: true });
+      recorded.add(requestId);
+    }
+  }
+  async recoverPending(signal) {
+    if (this.turnAbort && signal !== this.turnAbort.signal)
+      throw new Error("Cannot recover while a turn is running");
+    await this.acquireOwnership();
+    const recovered = await this.recovery.recover(this.options.model, this.session, signal);
+    if (!recovered)
+      return false;
+    await this.recordHostedUsage();
+    await saveSession(recovered);
+    this.session = recovered;
+    this.messages = [...recovered.messages];
+    await this.recovery.cleanup(recovered.hostedRecoveryBatchId);
+    return true;
   }
   cancel() {
     this.cancelled = true;
@@ -6883,8 +7334,8 @@ class ArchymedesAgent {
   listFiles(pattern = "**/*") {
     return this.workspace.glob(pattern);
   }
-  readFile(path13, options = {}) {
-    return this.workspace.readFile(path13, options);
+  readFile(path15, options = {}) {
+    return this.workspace.readFile(path15, options);
   }
   scanSecrets(include) {
     return scanWorkspaceForSecrets(this.workspace, include);
@@ -6974,6 +7425,9 @@ class ArchymedesAgent {
     return { initialInputTokens, toolCount: scoped.length };
   }
   async undo(scope = "both") {
+    if (this.turnAbort)
+      throw new Error("Cannot undo while a turn is running");
+    await this.acquireOwnership();
     const checkpoint = this.checkpoints.latest();
     if (!checkpoint)
       return;
@@ -6995,7 +7449,7 @@ class ArchymedesAgent {
       const systemPrompt = buildArchymedesSystemPrompt(context, this.options.mode, subTools.map((tool) => tool.name), this.workspace, await this.loadEnvironment());
       const reservation = Math.max(0, Math.min(remainingRwf(), this.budgets.maxRwf / 2));
       const runtime = new BoundedAgentRuntime({
-        model: this.options.model,
+        model: this.recovery.wrap(this.options.model, () => this.session, this.options.prices, `delegate:${randomUUID6()}`),
         tools: subTools,
         prices: this.options.prices,
         artifacts: this.artifacts,
@@ -7009,7 +7463,7 @@ class ArchymedesAgent {
       const result = await runtime.execute({
         taskId: `${this.session.id}_delegate`,
         runId: this.session.id,
-        stepId: `delegate_${randomUUID3()}`,
+        stepId: `delegate_${randomUUID6()}`,
         objective: task,
         history: [],
         systemPrompt,
@@ -7036,10 +7490,19 @@ class ArchymedesAgent {
   async send(objective) {
     if (!objective.trim())
       throw new Error("A request is required");
+    if (this.turnAbort)
+      throw new Error("A turn is already running in this session");
     this.cancelled = false;
     const turnAbort = new AbortController;
     this.turnAbort = turnAbort;
-    const turnId = `turn_${randomUUID3()}`;
+    try {
+      await this.recoverPending(turnAbort.signal);
+      turnAbort.signal.throwIfAborted();
+    } catch (error) {
+      this.turnAbort = null;
+      throw error;
+    }
+    const turnId = `turn_${randomUUID6()}`;
     this.activeTurnId = turnId;
     let turnStatus = "queued";
     const transition = async (to, durable = false) => {
@@ -7049,6 +7512,10 @@ class ArchymedesAgent {
     };
     this.activeTransition = transition;
     try {
+      if (this.options.model.recoveryScope) {
+        this.session.title = this.session.title === "Untitled session" ? titleFromObjective(objective) : this.session.title;
+        await saveSession(this.session);
+      }
       await transition("running");
       this.openingObjective ??= objective;
       this.context = await collectProjectContext(this.options.root);
@@ -7090,7 +7557,7 @@ ${objective}` : objective;
       const compaction = await this.compactIfNeeded(turnId, objective, turnAbort.signal);
       compactionActualRwf = compaction.actualRwf;
       const runtime = new BoundedAgentRuntime({
-        model: this.options.model,
+        model: this.recovery.wrap(this.options.model, () => this.session, this.options.prices, "main"),
         tools: scoped,
         prices: this.options.prices,
         artifacts: this.artifacts,
@@ -7135,12 +7602,15 @@ ${objective}` : objective;
         recalledMemoryKeys: [...this.recalledMemoryKeys],
         approvals: this.permissions.snapshot(),
         totalRwf: this.session.totalRwf + combinedRwf,
-        routingReceipts: mergeRoutingReceipts(this.session.routingReceipts, result.routingReceipts),
+        routingReceipts: mergeRoutingReceipts(this.session.routingReceipts, result.routingReceipts, this.recovery.responses().flatMap(({ requestId, turn }) => turn.routingReceipt ? [{ ...turn.routingReceipt, taskId: turn.routingReceipt.taskId ?? requestId }] : [])),
+        hostedRecoveryBatchId: this.recovery.settledBatchId() ?? this.session.hostedRecoveryBatchId,
         updatedAt: Date.now()
       };
       const terminalStatus = runtimeStatusToTurnStatus(result.status);
       await transition(terminalStatus, true);
+      await this.recordHostedUsage();
       await saveSession(this.session);
+      await this.recovery.cleanup(this.session.hostedRecoveryBatchId);
       return { ...result, usage: combinedUsage, actualModelRwf: combinedRwf, checkpoint };
     } catch (error) {
       if (isActiveTurnStatus(turnStatus)) {
@@ -7166,7 +7636,7 @@ ${objective}` : objective;
     const maximumOutputTokens = affordableOutputTokens([...plan.toSummarize.map((message) => message.content), COMPACTION_INSTRUCTION], Math.min(this.budgets.maxOutputTokens, 4000), this.budgets.maxRwf, this.options.prices);
     if (maximumOutputTokens < 1)
       return { usage: emptyModelUsage(), actualRwf: 0 };
-    const turn = await this.options.model.complete({
+    const turn = await this.recovery.wrap(this.options.model, () => this.session, this.options.prices, "compaction").complete({
       effort: "low",
       messages: [...plan.toSummarize, { role: "user", content: COMPACTION_INSTRUCTION }],
       tools: [],
@@ -7481,8 +7951,9 @@ function toolCallTitle(toolName, argumentsValue) {
 }
 
 // packages/core/src/cli/agent.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import path13 from "node:path";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import path15 from "node:path";
+import { access as access4 } from "node:fs/promises";
 var DEFAULT_ARCHYMEDES_BUDGETS2 = {
   maxIterations: 100,
   maxToolCalls: 500,
@@ -7502,6 +7973,8 @@ class ArchymedesAgent2 {
   workspace;
   permissions;
   checkpoints;
+  recovery;
+  ownershipReady;
   artifacts;
   budgets;
   messages = [];
@@ -7537,8 +8010,8 @@ class ArchymedesAgent2 {
     this.workspace = options.workspace ?? new LocalWorkspace(options.root, options.limits);
     this.nestedInstructions = new NestedInstructionTracker(this.workspace);
     this.artifacts = new WorkspaceArtifactStore(this.workspace);
-    this.defenderBrain = new DefenderBrain(path13.join(options.root, ".archymedes", "security-brain"));
-    this.checkpoints = new CheckpointStore(options.root, path13.join(options.root, ".archymedes", "checkpoint-index"), options.git);
+    this.defenderBrain = new DefenderBrain(path15.join(options.root, ".archymedes", "security-brain"));
+    this.checkpoints = new CheckpointStore(options.root, path15.join(options.root, ".archymedes", `checkpoint-index-${randomUUID7()}`), options.git);
     this.session = {
       schemaVersion: 2,
       revision: 0,
@@ -7554,6 +8027,7 @@ class ArchymedesAgent2 {
       totalRwf: 0
     };
     this.journal = new EventJournal(options.root, this.session.id);
+    this.recovery = new HostedRecoveryStore(options.root, this.session.id);
     this.permissions = new PermissionLedger(options.mode, async (request) => {
       const turnId = this.activeTurnId ?? "turn_unbound";
       await this.activeTransition?.("waiting_approval", true);
@@ -7588,6 +8062,8 @@ class ArchymedesAgent2 {
     return structuredClone(this.session);
   }
   resume(record) {
+    if (this.ownershipReady)
+      throw new Error("Relinquish the current agent before resuming another session");
     this.session = { ...record, routingReceipts: mergeRoutingReceipts(record.routingReceipts), mode: this.options.mode };
     this.messages = [...record.messages];
     this.recalledMemoryKeys.clear();
@@ -7596,6 +8072,62 @@ class ArchymedesAgent2 {
     this.openingObjective = record.messages.find((message) => message.role === "user" && !message.internal && !message.content.startsWith(STANDING_CONSTRAINTS_HEADING) && !message.content.startsWith("[Earlier conversation, summarized]"))?.content ?? (record.title === "Untitled session" ? null : record.title);
     this.permissions.restore(record.approvals ?? {});
     this.journal = new EventJournal(this.options.root, record.id);
+    this.recovery = new HostedRecoveryStore(this.options.root, record.id);
+  }
+  async acquireOwnership() {
+    this.ownershipReady ??= (async () => {
+      await this.journal.open();
+      const current = await loadSession(this.options.root, this.session.id);
+      const exists = current || await access4(path15.join(this.options.root, ".archymedes", "sessions", `${this.session.id}.json`)).then(() => true).catch((error) => {
+        if (error.code === "ENOENT")
+          return false;
+        throw error;
+      });
+      if (!current && (exists || this.session.revision > 0)) {
+        await this.journal.close();
+        throw new Error("Session snapshot is missing, corrupt or incompatible; refusing to start work.");
+      }
+      if (current && current.revision !== this.session.revision) {
+        await this.journal.close();
+        throw new Error("Session changed since it was loaded; resume it again before writing.");
+      }
+    })();
+    await this.ownershipReady;
+  }
+  async recordHostedUsage() {
+    const responses = this.recovery.responses();
+    if (!responses.length)
+      return;
+    const events = await readEventJournal(this.options.root, this.session.id);
+    const recorded = new Set(events.flatMap(({ payload }) => payload.type === "runtime" && payload.event.type === "model_turn" && payload.event.requestId ? [payload.event.requestId] : []));
+    for (const { requestId, turn } of responses) {
+      if (recorded.has(requestId))
+        continue;
+      await this.journal.append({ type: "runtime", turnId: `recovered_${requestId}`, event: {
+        type: "model_turn",
+        requestId,
+        iteration: 0,
+        responseId: turn.responseId,
+        model: turn.model,
+        toolCallCount: turn.toolCalls.length,
+        usage: turn.usage
+      } }, { durable: true });
+      recorded.add(requestId);
+    }
+  }
+  async recoverPending(signal) {
+    if (this.turnAbort && signal !== this.turnAbort.signal)
+      throw new Error("Cannot recover while a turn is running");
+    await this.acquireOwnership();
+    const recovered = await this.recovery.recover(this.options.model, this.session, signal);
+    if (!recovered)
+      return false;
+    await this.recordHostedUsage();
+    await saveSession(recovered);
+    this.session = recovered;
+    this.messages = [...recovered.messages];
+    await this.recovery.cleanup(recovered.hostedRecoveryBatchId);
+    return true;
   }
   cancel() {
     this.cancelled = true;
@@ -7627,8 +8159,8 @@ class ArchymedesAgent2 {
   listFiles(pattern = "**/*") {
     return this.workspace.glob(pattern);
   }
-  readFile(path14, options = {}) {
-    return this.workspace.readFile(path14, options);
+  readFile(path16, options = {}) {
+    return this.workspace.readFile(path16, options);
   }
   scanSecrets(include) {
     return scanWorkspaceForSecrets(this.workspace, include);
@@ -7718,6 +8250,9 @@ class ArchymedesAgent2 {
     return { initialInputTokens, toolCount: scoped.length };
   }
   async undo(scope = "both") {
+    if (this.turnAbort)
+      throw new Error("Cannot undo while a turn is running");
+    await this.acquireOwnership();
     const checkpoint = this.checkpoints.latest();
     if (!checkpoint)
       return;
@@ -7739,7 +8274,7 @@ class ArchymedesAgent2 {
       const systemPrompt = buildArchymedesSystemPrompt(context, this.options.mode, subTools.map((tool) => tool.name), this.workspace, await this.loadEnvironment());
       const reservation = Math.max(0, Math.min(remainingRwf(), this.budgets.maxRwf / 2));
       const runtime = new BoundedAgentRuntime({
-        model: this.options.model,
+        model: this.recovery.wrap(this.options.model, () => this.session, this.options.prices, `delegate:${randomUUID7()}`),
         tools: subTools,
         prices: this.options.prices,
         artifacts: this.artifacts,
@@ -7753,7 +8288,7 @@ class ArchymedesAgent2 {
       const result = await runtime.execute({
         taskId: `${this.session.id}_delegate`,
         runId: this.session.id,
-        stepId: `delegate_${randomUUID4()}`,
+        stepId: `delegate_${randomUUID7()}`,
         objective: task,
         history: [],
         systemPrompt,
@@ -7780,10 +8315,19 @@ class ArchymedesAgent2 {
   async send(objective) {
     if (!objective.trim())
       throw new Error("A request is required");
+    if (this.turnAbort)
+      throw new Error("A turn is already running in this session");
     this.cancelled = false;
     const turnAbort = new AbortController;
     this.turnAbort = turnAbort;
-    const turnId = `turn_${randomUUID4()}`;
+    try {
+      await this.recoverPending(turnAbort.signal);
+      turnAbort.signal.throwIfAborted();
+    } catch (error) {
+      this.turnAbort = null;
+      throw error;
+    }
+    const turnId = `turn_${randomUUID7()}`;
     this.activeTurnId = turnId;
     let turnStatus = "queued";
     const transition = async (to, durable = false) => {
@@ -7793,6 +8337,10 @@ class ArchymedesAgent2 {
     };
     this.activeTransition = transition;
     try {
+      if (this.options.model.recoveryScope) {
+        this.session.title = this.session.title === "Untitled session" ? titleFromObjective(objective) : this.session.title;
+        await saveSession(this.session);
+      }
       await transition("running");
       this.openingObjective ??= objective;
       this.context = await collectProjectContext(this.options.root);
@@ -7834,7 +8382,7 @@ ${objective}` : objective;
       const compaction = await this.compactIfNeeded(turnId, objective, turnAbort.signal);
       compactionActualRwf = compaction.actualRwf;
       const runtime = new BoundedAgentRuntime({
-        model: this.options.model,
+        model: this.recovery.wrap(this.options.model, () => this.session, this.options.prices, "main"),
         tools: scoped,
         prices: this.options.prices,
         artifacts: this.artifacts,
@@ -7879,12 +8427,15 @@ ${objective}` : objective;
         recalledMemoryKeys: [...this.recalledMemoryKeys],
         approvals: this.permissions.snapshot(),
         totalRwf: this.session.totalRwf + combinedRwf,
-        routingReceipts: mergeRoutingReceipts(this.session.routingReceipts, result.routingReceipts),
+        routingReceipts: mergeRoutingReceipts(this.session.routingReceipts, result.routingReceipts, this.recovery.responses().flatMap(({ requestId, turn }) => turn.routingReceipt ? [{ ...turn.routingReceipt, taskId: turn.routingReceipt.taskId ?? requestId }] : [])),
+        hostedRecoveryBatchId: this.recovery.settledBatchId() ?? this.session.hostedRecoveryBatchId,
         updatedAt: Date.now()
       };
       const terminalStatus = runtimeStatusToTurnStatus2(result.status);
       await transition(terminalStatus, true);
+      await this.recordHostedUsage();
       await saveSession(this.session);
+      await this.recovery.cleanup(this.session.hostedRecoveryBatchId);
       return { ...result, usage: combinedUsage, actualModelRwf: combinedRwf, checkpoint };
     } catch (error) {
       if (isActiveTurnStatus2(turnStatus)) {
@@ -7910,7 +8461,7 @@ ${objective}` : objective;
     const maximumOutputTokens = affordableOutputTokens([...plan.toSummarize.map((message) => message.content), COMPACTION_INSTRUCTION], Math.min(this.budgets.maxOutputTokens, 4000), this.budgets.maxRwf, this.options.prices);
     if (maximumOutputTokens < 1)
       return { usage: emptyModelUsage2(), actualRwf: 0 };
-    const turn = await this.options.model.complete({
+    const turn = await this.recovery.wrap(this.options.model, () => this.session, this.options.prices, "compaction").complete({
       effort: "low",
       messages: [...plan.toSummarize, { role: "user", content: COMPACTION_INSTRUCTION }],
       tools: [],
@@ -8248,7 +8799,7 @@ class AnthropicAgentTurnProvider {
 }
 
 // packages/core/src/providers/archymedes-cloud-agent.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { createHash as createHash9, randomUUID as randomUUID8 } from "node:crypto";
 
 // packages/core/src/providers/routing-plan.ts
 function isRecord(value) {
@@ -8379,6 +8930,7 @@ class ArchymedesCloudError extends Error {
 class ArchymedesCloudTurnProvider {
   options;
   capabilities;
+  recoveryScope;
   fetchImpl;
   completionUrl;
   planUrl;
@@ -8422,6 +8974,18 @@ class ArchymedesCloudTurnProvider {
     this.planUrl = base.endsWith("/v1") ? `${base}/routes/plan` : `${base}/v1/routes/plan`;
     this.balanceUrl = base.endsWith("/v1") ? `${base}/credits/balance` : `${base}/v1/credits/balance`;
     this.capabilities = capabilitiesFor(this.model);
+    this.recoveryScope = createHash9("sha256").update(JSON.stringify({
+      version: 1,
+      endpoint: this.completionUrl,
+      token: options.token,
+      model: this.model,
+      maximum: this.maximumMicros,
+      currency: this.currency,
+      policy: this.dataPolicy,
+      quality: this.qualityFloor,
+      kind: this.taskKind,
+      region: options.region
+    })).digest("hex");
   }
   async plan(input) {
     if (!Number.isSafeInteger(input.estimatedInputTokens) || input.estimatedInputTokens < 1) {
@@ -8485,9 +9049,15 @@ class ArchymedesCloudTurnProvider {
     return parseCreditBalance(body);
   }
   async complete(request) {
+    return this.exchange(request, false);
+  }
+  async recoverComplete(request) {
+    return this.exchange(request, true);
+  }
+  async exchange(request, recoveryOnly) {
     if (!request.safetyIdentifier.trim())
       throw new Error("safetyIdentifier is required");
-    const taskId = request.requestId ?? `cli_${randomUUID5()}`;
+    const taskId = request.requestId ?? `cli_${randomUUID8()}`;
     if (!/^[A-Za-z0-9_-]{1,160}$/.test(taskId))
       throw new Error("requestId must contain 1 to 160 letters, numbers, underscores or hyphens");
     request.signal?.throwIfAborted();
@@ -8495,7 +9065,7 @@ class ArchymedesCloudTurnProvider {
       AbortSignal.timeout(this.options.timeoutMs ?? 180000),
       ...request.signal ? [request.signal] : []
     ]);
-    const response = await this.fetchImpl(this.completionUrl, {
+    const response = await this.fetchImpl(recoveryOnly ? `${this.completionUrl}/recover` : this.completionUrl, {
       method: "POST",
       headers: {
         authorization: `Bearer ${this.options.token}`,
@@ -8768,11 +9338,11 @@ class ExaSearchClient {
     this.fetchImpl = options.fetchImpl ?? fetch;
     this.timeoutMs = options.timeoutMs ?? 30000;
   }
-  async post(path14, body, timeoutMs) {
+  async post(path16, body, timeoutMs) {
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
-      const response = await this.fetchImpl(`${this.baseUrl}${path14}`, {
+      const response = await this.fetchImpl(`${this.baseUrl}${path16}`, {
         method: "POST",
         headers: {
           "content-type": "application/json",
@@ -8783,7 +9353,7 @@ class ExaSearchClient {
       });
       if (!response.ok) {
         const text = await response.text();
-        throw new Error(`Exa ${path14} failed (${response.status}): ${text.slice(0, 240)}`);
+        throw new Error(`Exa ${path16} failed (${response.status}): ${text.slice(0, 240)}`);
       }
       return await response.json();
     } finally {
@@ -11156,18 +11726,18 @@ async function askModelForSuggestions(model, signals, context = {}) {
 }
 
 // packages/core/src/cli/daemon.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 var ARCHYMEDES_DAEMON_PROTOCOL_VERSION = 1;
 function previewFor(request) {
   const args = request.call.arguments ?? {};
-  const path14 = typeof args.path === "string" ? args.path : undefined;
-  if (!path14)
+  const path16 = typeof args.path === "string" ? args.path : undefined;
+  if (!path16)
     return;
   if (request.tool.name === "write_file" && typeof args.content === "string") {
-    return { toolName: "write_file", path: path14, content: args.content };
+    return { toolName: "write_file", path: path16, content: args.content };
   }
   if (request.tool.name === "edit_file" && typeof args.oldText === "string" && typeof args.newText === "string") {
-    return { toolName: "edit_file", path: path14, oldText: args.oldText, newText: args.newText };
+    return { toolName: "edit_file", path: path16, oldText: args.oldText, newText: args.newText };
   }
   return;
 }
@@ -11184,7 +11754,7 @@ class ArchymedesSessionDaemon {
   sessions = new Map;
   pendingApprovals = new Map;
   connect(options = {}) {
-    const id = options.id ?? `client_${randomUUID6()}`;
+    const id = options.id ?? `client_${randomUUID9()}`;
     assertSafeId(id, "Client id");
     if (this.clients.has(id))
       throw new Error(`Daemon client already connected: ${id}`);
@@ -11203,7 +11773,7 @@ class ArchymedesSessionDaemon {
   }
   async requestApproval(sessionId, request) {
     const publicRequest = {
-      id: `approval_${randomUUID6()}`,
+      id: `approval_${randomUUID9()}`,
       sessionId,
       summary: request.summary,
       actionDigest: request.actionDigest,
@@ -11241,8 +11811,17 @@ class ArchymedesSessionDaemon {
       onEvent: (event) => this.publish(sessionId, { type: "agent_event", sessionId, event }),
       approve: (request) => this.requestApproval(sessionId, request)
     });
-    if (record)
+    if (record) {
       agent.resume(record);
+      try {
+        await agent.recoverPending();
+      } catch (error) {
+        await agent.relinquish().catch(() => {
+          return;
+        });
+        throw error;
+      }
+    }
     sessionId = agent.sessionId;
     const live = {
       agent,
@@ -11360,6 +11939,9 @@ class ArchymedesSessionDaemon {
   inspectTools(clientId, sessionId) {
     return this.requireAttached(clientId, sessionId).agent.inspectTools();
   }
+  snapshot(clientId, sessionId) {
+    return this.requireAttached(clientId, sessionId).agent.snapshot();
+  }
   routingReceipts(clientId, sessionId) {
     return this.requireAttached(clientId, sessionId).agent.routingReceipts;
   }
@@ -11453,13 +12035,16 @@ class ArchymedesDaemonClient {
     this.info = info;
     return info;
   }
+  snapshot() {
+    return this.daemon.snapshot(this.id, this.sessionId);
+  }
   get routingReceipts() {
     return this.daemon.routingReceipts(this.id, this.sessionId);
   }
   planRoute(objective, signal) {
     return this.daemon.planRoute(this.id, this.sessionId, objective, signal);
   }
-  send(objective, commandId = `turn_${randomUUID6()}`) {
+  send(objective, commandId = `turn_${randomUUID9()}`) {
     return this.daemon.send(this.id, this.sessionId, objective, commandId);
   }
   cancel() {
@@ -11541,12 +12126,12 @@ function assessTaskSafety(objective) {
 }
 
 // packages/core/src/cli/session.ts
-import { createHash as createHash8, randomUUID as randomUUID7 } from "node:crypto";
-import { promises as fs8 } from "node:fs";
-import path14 from "node:path";
+import { createHash as createHash10, randomUUID as randomUUID10 } from "node:crypto";
+import { promises as fs10 } from "node:fs";
+import path16 from "node:path";
 var SESSION_SCHEMA_VERSION2 = 2;
 function sessionDirectory2(root) {
-  return path14.join(root, ".archymedes", "sessions");
+  return path16.join(root, ".archymedes", "sessions");
 }
 function assertSessionId2(id) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(id) || id === "." || id === "..") {
@@ -11564,15 +12149,15 @@ function canonicalize3(value) {
   return null;
 }
 function integrityFor2(record) {
-  return createHash8("sha256").update(JSON.stringify(canonicalize3(record))).digest("hex");
+  return createHash10("sha256").update(JSON.stringify(canonicalize3(record))).digest("hex");
 }
 async function loadSession2(root, id) {
   try {
     assertSessionId2(id);
-    const parsed = JSON.parse(await fs8.readFile(path14.join(sessionDirectory2(root), `${id}.json`), "utf8"));
+    const parsed = JSON.parse(await fs10.readFile(path16.join(sessionDirectory2(root), `${id}.json`), "utf8"));
     if (!parsed || typeof parsed !== "object" || parsed.id !== id || typeof parsed.root !== "string")
       return null;
-    const [storedRoot, requestedRoot] = await Promise.all([parsed.root, root].map(async (candidate) => fs8.realpath(path14.resolve(candidate)).catch(() => path14.resolve(candidate))));
+    const [storedRoot, requestedRoot] = await Promise.all([parsed.root, root].map(async (candidate) => fs10.realpath(path16.resolve(candidate)).catch(() => path16.resolve(candidate))));
     const rootsMatch = process.platform === "win32" ? storedRoot.toLocaleLowerCase("en-US") === requestedRoot.toLocaleLowerCase("en-US") : storedRoot === requestedRoot;
     if (!rootsMatch)
       return null;
@@ -11599,7 +12184,7 @@ async function loadSession2(root, id) {
 }
 async function listSessions(root, limit = 20) {
   try {
-    const files = await fs8.readdir(sessionDirectory2(root));
+    const files = await fs10.readdir(sessionDirectory2(root));
     const records = await Promise.all(files.filter((file) => file.endsWith(".json")).map(async (file) => {
       try {
         const record = await loadSession2(root, file.slice(0, -5));
@@ -11926,11 +12511,11 @@ class ExaSearchClient2 {
     this.fetchImpl = options.fetchImpl ?? fetch;
     this.timeoutMs = options.timeoutMs ?? 30000;
   }
-  async post(path15, body, timeoutMs) {
+  async post(path17, body, timeoutMs) {
     const controller = new AbortController;
     const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
-      const response = await this.fetchImpl(`${this.baseUrl}${path15}`, {
+      const response = await this.fetchImpl(`${this.baseUrl}${path17}`, {
         method: "POST",
         headers: {
           "content-type": "application/json",
@@ -11941,7 +12526,7 @@ class ExaSearchClient2 {
       });
       if (!response.ok) {
         const text = await response.text();
-        throw new Error(`Exa ${path15} failed (${response.status}): ${text.slice(0, 240)}`);
+        throw new Error(`Exa ${path17} failed (${response.status}): ${text.slice(0, 240)}`);
       }
       return await response.json();
     } finally {
@@ -12044,7 +12629,7 @@ function createExaClient2(environment, fetchImpl) {
 }
 
 // packages/core/src/cli/backends.ts
-import path15 from "node:path";
+import path17 from "node:path";
 var CONFIG_FILE_SCAN_LIMIT2 = 500;
 
 class LocalWorkspace2 {
@@ -12064,14 +12649,14 @@ class LocalWorkspace2 {
   get label() {
     return this.root;
   }
-  readFile(path16, options = {}) {
-    return readTextFile(this.root, path16, { ...options, limits: this.limits });
+  readFile(path18, options = {}) {
+    return readTextFile(this.root, path18, { ...options, limits: this.limits });
   }
-  writeFile(path16, content) {
-    return writeTextFile(this.root, path16, content, this.limits);
+  writeFile(path18, content) {
+    return writeTextFile(this.root, path18, content, this.limits);
   }
-  editFile(path16, oldText, newText, options = {}) {
-    return editTextFile(this.root, path16, oldText, newText, { ...options, limits: this.limits });
+  editFile(path18, oldText, newText, options = {}) {
+    return editTextFile(this.root, path18, oldText, newText, { ...options, limits: this.limits });
   }
   async list(prefix, depth) {
     const entries = [];
@@ -12092,8 +12677,8 @@ class LocalWorkspace2 {
   }
   async listConfigFiles(prefix) {
     const files = [];
-    const base = path15.resolve(this.root, prefix);
-    if (!base.startsWith(path15.resolve(this.root)))
+    const base = path17.resolve(this.root, prefix);
+    if (!base.startsWith(path17.resolve(this.root)))
       return [];
     for await (const entry of walkWorkspace(base, { ...this.limits, ignoredDirectories: [] }, CONFIG_FILE_SCAN_LIMIT2)) {
       if (!entry.isDirectory)
@@ -12165,8 +12750,8 @@ class SandboxWorkspace {
   relative(absolute) {
     return absolute.startsWith(`${this.options.workspaceRoot}/`) ? absolute.slice(this.options.workspaceRoot.length + 1) : absolute;
   }
-  async readFile(path16, options = {}) {
-    const absolute = this.absolute(path16);
+  async readFile(path18, options = {}) {
+    const absolute = this.absolute(path18);
     const text = await this.options.sandbox.readFile(this.options.sandboxId, absolute);
     if (looksBinary(Buffer.from(text.slice(0, 4096), "utf8")))
       throw new WorkspaceViolation(`${this.relative(absolute)} looks like a binary file`);
@@ -12189,24 +12774,24 @@ class SandboxWorkspace {
       truncated: startLine > 1 || options.limit !== undefined && startLine - 1 + options.limit < lines.length
     };
   }
-  async writeFile(path16, content) {
+  async writeFile(path18, content) {
     if (typeof content !== "string")
       throw new WorkspaceViolation("content must be a string");
     const bytes = Buffer.byteLength(content, "utf8");
     if (bytes > this.limits.maxWriteBytes)
       throw new WorkspaceViolation(`content is ${bytes} bytes, above the ${this.limits.maxWriteBytes}-byte write limit`);
-    const absolute = this.absolute(path16);
+    const absolute = this.absolute(path18);
     await this.options.sandbox.writeFile(this.options.sandboxId, absolute, content);
     return { path: this.relative(absolute), bytesWritten: bytes };
   }
-  async editFile(path16, oldText, newText, options = {}) {
+  async editFile(path18, oldText, newText, options = {}) {
     if (typeof oldText !== "string" || oldText === "")
       throw new WorkspaceViolation("oldText must be a non-empty string");
     if (typeof newText !== "string")
       throw new WorkspaceViolation("newText must be a string");
     if (oldText === newText)
       throw new WorkspaceViolation("oldText and newText are identical");
-    const existing = await this.readFile(path16);
+    const existing = await this.readFile(path18);
     const occurrences = existing.content.split(oldText).length - 1;
     if (occurrences === 0)
       throw new WorkspaceViolation(`oldText was not found in ${existing.path}`);
@@ -12214,7 +12799,7 @@ class SandboxWorkspace {
       throw new WorkspaceViolation(`oldText appears ${occurrences} times in ${existing.path}; include more surrounding context or set replaceAll`);
     }
     const updated = options.replaceAll ? existing.content.split(oldText).join(newText) : existing.content.replace(oldText, newText);
-    await this.writeFile(path16, updated);
+    await this.writeFile(path18, updated);
     return { path: existing.path, replacements: options.replaceAll ? occurrences : 1 };
   }
   async allFiles() {
@@ -12339,13 +12924,13 @@ async function downloadProject(workspace, localRoot, options = {}) {
   const limits = options.limits ?? DEFAULT_WORKSPACE_LIMITS;
   const written = [];
   const failed2 = [];
-  for (const path16 of await workspace.glob("**/*")) {
+  for (const path18 of await workspace.glob("**/*")) {
     try {
-      const file = await workspace.readFile(path16);
-      await writeTextFile(localRoot, path16, file.content, limits);
-      written.push(displayPath(localRoot, `${localRoot}/${path16}`));
+      const file = await workspace.readFile(path18);
+      await writeTextFile(localRoot, path18, file.content, limits);
+      written.push(displayPath(localRoot, `${localRoot}/${path18}`));
     } catch {
-      failed2.push(path16);
+      failed2.push(path18);
     }
   }
   return { written, failed: failed2 };
@@ -13077,21 +13662,77 @@ function detectColorDepth(environment, isTTY) {
 var STAR_GLYPHS2 = UNICODE_GLYPHS.starGlyphs;
 
 // packages/archymedes-cli/src/identity.ts
-var INSTRUMENT = ["    ╭───╮    ", "  ╭─┴───┴─╮  ", "  │       │  ", "  ├── ● ──┤  ", "  ╰─┬───┬─╯  ", "    ╰───╯    "];
-var ASCII_INSTRUMENT = ["    .---.    ", "  .-+---+-.  ", "  |       |  ", "  +-- O --+  ", "  '-+---+-'  ", "    '---'    "];
+function renderGeometry(angle = 0, ascii = false) {
+  const width = 23;
+  const height = 11;
+  const cells = Array.from({ length: height }, () => Array(width).fill(" "));
+  const vertices = [[0, 1.15, 0], [-1, -0.7, 0.65], [1, -0.7, 0.65], [0, -0.7, -1]];
+  const project = ([x, y, z], scale) => {
+    const yaw = angle + 0.25;
+    const rx = (x * Math.cos(yaw) + z * Math.sin(yaw)) * scale;
+    const rz = (-x * Math.sin(yaw) + z * Math.cos(yaw)) * scale;
+    const ry = y * scale;
+    return [Math.round(11 + rx * 9), Math.round(5 - (ry * 0.94 - rz * 0.34) * 4)];
+  };
+  const outer = vertices.map((point) => project(point, 1));
+  const inner = vertices.map((point) => project(point, 0.43));
+  const line = (a, b, faint = false) => {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const steps = Math.max(Math.abs(dx), Math.abs(dy));
+    const glyph = faint ? "." : Math.abs(dx) > Math.abs(dy) * 2 ? "-" : dx === 0 ? "|" : dx * dy > 0 ? "\\" : "/";
+    for (let step = 1;step < steps; step++) {
+      const x = Math.round(a[0] + dx * step / steps);
+      const y = Math.round(a[1] + dy * step / steps);
+      if (cells[y]?.[x] !== undefined && (!faint || cells[y][x] === " "))
+        cells[y][x] = glyph;
+    }
+  };
+  for (let i = 0;i < 4; i++)
+    line(outer[i], inner[i], true);
+  for (const points of [outer, inner]) {
+    for (let i = 0;i < 4; i++)
+      for (let j = i + 1;j < 4; j++)
+        line(points[i], points[j], j === 3);
+  }
+  for (const [x, y] of [...outer, ...inner])
+    cells[y][x] = ascii ? "+" : "◇";
+  return cells.map((row) => row.join(""));
+}
+async function writeIdentity(options, output, motion) {
+  output.write(`${renderIdentity(options)}
+`);
+  if (!motion.enabled || motion.signal?.aborted || options.width < 64 || options.rows < 24)
+    return;
+  const frames = 12;
+  for (let frame = 1;frame <= frames; frame++) {
+    await new Promise((resolve) => setTimeout(resolve, 45));
+    if (motion.signal?.aborted)
+      return;
+    const size = motion.size();
+    if (size.width !== options.width || size.rows !== options.rows)
+      return;
+    const rendered = renderIdentity({ ...options, angle: Math.sin(frame / frames * Math.PI) * 0.65 });
+    output.write(`\x1B[11F${rendered.split(`
+`).map((line) => `\x1B[2K${line}`).join(`
+`)}
+`);
+  }
+}
 function renderIdentity(options) {
   const { palette } = options;
   const glyphs = options.glyphs ?? UNICODE_GLYPHS;
   const width = Math.max(1, Math.floor(options.width));
   const ascii = glyphs.boxHorizontal === ASCII_GLYPHS.boxHorizontal;
-  const mark = ascii ? "::" : "∴";
+  const mark = ascii ? "/\\" : "△";
   const text = [
     `ARCHYMEDES  ${options.version}`,
     "A place to think. The tools to build.",
     "",
     `${options.mode} ${glyphs.middot} ${options.workspace}`,
     options.model,
-    `/help ${glyphs.middot} /guide ${glyphs.middot} /workspace`
+    `/help ${glyphs.middot} /guide ${glyphs.middot} /workspace`,
+    ""
   ];
   const codes = [palette.primary + BOLD, palette.text, "", palette.secondary, palette.muted, palette.primary];
   const clean = (value) => value.replace(/[\x00-\x1f\x7f-\x9f]/g, " ");
@@ -13100,13 +13741,13 @@ function renderIdentity(options) {
     return lines.map((line, index) => paint(clipTo(clean(line), width, glyphs), index === 0 ? codes[0] : palette.muted, palette.depth)).join(`
 `);
   }
-  const instrument = ascii ? ASCII_INSTRUMENT : INSTRUMENT;
-  const artWidth = Math.max(...instrument.map(visibleWidth));
+  const geometry = renderGeometry(options.angle, ascii);
+  const artWidth = Math.max(...geometry.map(visibleWidth));
   const gap = 3;
   const margin = 2;
-  return instrument.map((line, index) => {
+  return geometry.map((line, index) => {
     const drawing = line + " ".repeat(artWidth - visibleWidth(line));
-    return " ".repeat(margin) + paint(drawing, palette.primary, palette.depth) + " ".repeat(gap) + paint(clipTo(clean(text[index]), width - margin - artWidth - gap, glyphs), codes[index], palette.depth);
+    return " ".repeat(margin) + paint(drawing, palette.primary, palette.depth) + " ".repeat(gap) + paint(clipTo(clean(text[index] ?? ""), width - margin - artWidth - gap, glyphs), codes[index] ?? "", palette.depth);
   }).join(`
 `);
 }
@@ -14382,12 +15023,12 @@ function countOf(value) {
 function describeToolCall2(toolName, args) {
   switch (toolName) {
     case "read_file": {
-      const path16 = asString(args.path) ?? "";
+      const path18 = asString(args.path) ?? "";
       const offset = typeof args.offset === "number" ? args.offset : undefined;
       const limit = typeof args.limit === "number" ? args.limit : undefined;
       if (offset === undefined)
-        return path16;
-      return limit === undefined ? `${path16}:${offset}+` : `${path16}:${offset}-${offset + limit - 1}`;
+        return path18;
+      return limit === undefined ? `${path18}:${offset}+` : `${path18}:${offset}-${offset + limit - 1}`;
     }
     case "write_file":
     case "edit_file":
@@ -15980,7 +16621,7 @@ function renderTask(context) {
   return renderTaskView({
     request: context.request,
     plan: context.plan.map((todo) => ({ text: todo.text, status: todo.status })),
-    files: [...context.files].sort(([a], [b]) => a.localeCompare(b)).map(([path16, delta]) => ({ path: path16, added: delta.added, removed: delta.removed })),
+    files: [...context.files].sort(([a], [b]) => a.localeCompare(b)).map(([path18, delta]) => ({ path: path18, added: delta.added, removed: delta.removed })),
     checks: context.checks.map(([kind, passed]) => ({ kind, passed })),
     lastTurnStatus: context.turnsTaken ? context.lastTurnStatus : undefined
   }, context.style);
@@ -16210,8 +16851,8 @@ function fallbackSetting(preference) {
 }
 
 // packages/archymedes-cli/src/session-export.ts
-import { promises as fs9 } from "node:fs";
-import path16 from "node:path";
+import { promises as fs11 } from "node:fs";
+import path18 from "node:path";
 function redactText(value) {
   let redacted = value.replace(/-----BEGIN (?:RSA |EC |OPENSSH |PGP |DSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |PGP |DSA )?PRIVATE KEY-----/g, "[REDACTED PRIVATE KEY]").replace(/([a-z][a-z0-9+.-]*:\/\/)([^/\s:@]+):([^@\s/]+)@/gi, "$1[REDACTED]@");
   for (const pattern of SECRET_PATTERNS)
@@ -16237,7 +16878,7 @@ function sessionExportPayload(record, format) {
     updatedAt: new Date(record.updatedAt).toISOString(),
     mode: record.mode,
     totalRwf: record.totalRwf,
-    workspace: path16.basename(record.root)
+    workspace: path18.basename(record.root)
   };
   return format === "support" ? { ...base, messageCount: messages.length, recentMessages: messages.slice(-20) } : { ...base, messages };
 }
@@ -16252,14 +16893,14 @@ function markdownExport(record) {
 `;
 }
 async function exportSession(record, format) {
-  const directory = path16.join(record.root, ".archymedes", "exports");
-  await fs9.mkdir(directory, { recursive: true, mode: 448 });
+  const directory = path18.join(record.root, ".archymedes", "exports");
+  await fs11.mkdir(directory, { recursive: true, mode: 448 });
   const extension = format === "markdown" ? "md" : "json";
-  const file = path16.join(directory, `${record.id}-${format}.${extension}`);
+  const file = path18.join(directory, `${record.id}-${format}.${extension}`);
   const body = format === "markdown" ? markdownExport(record) : `${JSON.stringify(sessionExportPayload(record, format), null, 2)}
 `;
-  await fs9.writeFile(file, body, { encoding: "utf8", mode: 384 });
-  await fs9.chmod(file, 384).catch(() => {
+  await fs11.writeFile(file, body, { encoding: "utf8", mode: 384 });
+  await fs11.chmod(file, 384).catch(() => {
     return;
   });
   return file;
@@ -16660,7 +17301,7 @@ import { createInterface as createInterface3 } from "node:readline/promises";
 // packages/archymedes-cli/package.json
 var package_default = {
   name: "archymedes-cli",
-  version: "2.0.0",
+  version: "2.1.0",
   description: "Archymedes CLI — a coding agent that shows its work. Runs against your working tree or an isolated remote sandbox, with guarded approvals, git checkpoints, and exact, measured cost accounting.",
   keywords: [
     "cli",
@@ -16940,8 +17581,8 @@ async function runSelfUpdate(options = {}) {
 }
 
 // packages/archymedes-cli/src/auto-update.ts
-import { promises as fs10 } from "node:fs";
-import path17 from "node:path";
+import { promises as fs12 } from "node:fs";
+import path19 from "node:path";
 var AUTO_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1000;
 function isContinuousIntegration(environment) {
   return ["CI", "CONTINUOUS_INTEGRATION", "GITHUB_ACTIONS", "GITLAB_CI", "BUILDKITE", "JENKINS_URL", "TEAMCITY_VERSION"].some((name) => Boolean(environment[name]?.trim()));
@@ -16986,11 +17627,11 @@ function isNewer(candidate, current) {
   return false;
 }
 function stateFile(environment) {
-  return path17.join(archymedesConfigDirectory(environment), "update-check.json");
+  return path19.join(archymedesConfigDirectory(environment), "update-check.json");
 }
 async function readAutoUpdateState(environment) {
   try {
-    const parsed = JSON.parse(await fs10.readFile(stateFile(environment), "utf8"));
+    const parsed = JSON.parse(await fs12.readFile(stateFile(environment), "utf8"));
     if (typeof parsed.lastCheckedAt !== "number" || !Number.isFinite(parsed.lastCheckedAt))
       return null;
     return {
@@ -17005,8 +17646,8 @@ async function readAutoUpdateState(environment) {
 async function writeAutoUpdateState(environment, state) {
   try {
     const file = stateFile(environment);
-    await fs10.mkdir(path17.dirname(file), { recursive: true });
-    await fs10.writeFile(file, `${JSON.stringify(state, null, 2)}
+    await fs12.mkdir(path19.dirname(file), { recursive: true });
+    await fs12.writeFile(file, `${JSON.stringify(state, null, 2)}
 `, "utf8");
   } catch {}
 }
@@ -17900,9 +18541,9 @@ function renderReliabilityStatus(width, separator, snapshot = BUNDLED_RELIABILIT
 }
 
 // packages/archymedes-cli/src/settings.ts
-import { promises as fs11 } from "node:fs";
-import os4 from "node:os";
-import path18 from "node:path";
+import { promises as fs13 } from "node:fs";
+import os5 from "node:os";
+import path20 from "node:path";
 
 // packages/archymedes-cli/src/local-currency.ts
 var COUNTRY_CURRENCIES2 = {
@@ -18086,15 +18727,15 @@ var SETTING_FIELDS = [
 ];
 function settingsDirectory(environment = process.env, platform = process.platform) {
   if (environment.ARCHYMEDES_CONFIG_DIR?.trim())
-    return path18.resolve(environment.ARCHYMEDES_CONFIG_DIR);
+    return path20.resolve(environment.ARCHYMEDES_CONFIG_DIR);
   if (platform === "win32")
-    return path18.join(environment.APPDATA?.trim() || path18.join(os4.homedir(), "AppData", "Roaming"), "Archymedes");
+    return path20.join(environment.APPDATA?.trim() || path20.join(os5.homedir(), "AppData", "Roaming"), "Archymedes");
   if (platform === "darwin")
-    return path18.join(os4.homedir(), "Library", "Application Support", "Archymedes");
-  return path18.join(environment.XDG_CONFIG_HOME?.trim() || path18.join(os4.homedir(), ".config"), "archymedes");
+    return path20.join(os5.homedir(), "Library", "Application Support", "Archymedes");
+  return path20.join(environment.XDG_CONFIG_HOME?.trim() || path20.join(os5.homedir(), ".config"), "archymedes");
 }
 function settingsFile(environment = process.env, platform = process.platform) {
-  return path18.join(settingsDirectory(environment, platform), "settings.json");
+  return path20.join(settingsDirectory(environment, platform), "settings.json");
 }
 function cleanSettings(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
@@ -18110,7 +18751,7 @@ function cleanSettings(value) {
 }
 async function loadSettings(environment = process.env, platform = process.platform) {
   try {
-    return cleanSettings(JSON.parse(await fs11.readFile(settingsFile(environment, platform), "utf8")));
+    return cleanSettings(JSON.parse(await fs13.readFile(settingsFile(environment, platform), "utf8")));
   } catch {
     return {};
   }
@@ -18118,15 +18759,15 @@ async function loadSettings(environment = process.env, platform = process.platfo
 async function saveSettings(settings, environment = process.env, platform = process.platform) {
   const directory = settingsDirectory(environment, platform);
   const file = settingsFile(environment, platform);
-  await fs11.mkdir(directory, { recursive: true, mode: 448 });
+  await fs13.mkdir(directory, { recursive: true, mode: 448 });
   const temporary = `${file}.${process.pid}.tmp`;
-  await fs11.writeFile(temporary, `${JSON.stringify(cleanSettings(settings), null, 2)}
+  await fs13.writeFile(temporary, `${JSON.stringify(cleanSettings(settings), null, 2)}
 `, { encoding: "utf8", mode: 384 });
-  await fs11.chmod(temporary, 384).catch(() => {
+  await fs13.chmod(temporary, 384).catch(() => {
     return;
   });
-  await fs11.rename(temporary, file);
-  await fs11.chmod(file, 384).catch(() => {
+  await fs13.rename(temporary, file);
+  await fs13.chmod(file, 384).catch(() => {
     return;
   });
   return file;
@@ -18331,12 +18972,12 @@ Archymedes ${controlLabel(language, "settings")}
 }
 
 // packages/archymedes-cli/src/history.ts
-import { promises as fs12 } from "node:fs";
-import path20 from "node:path";
+import { promises as fs14 } from "node:fs";
+import path22 from "node:path";
 
 // packages/archymedes-cli/src/settings.ts
-import os5 from "node:os";
-import path19 from "node:path";
+import os6 from "node:os";
+import path21 from "node:path";
 var LANGUAGE_NAMES2 = {
   en: "English",
   zh: "中文",
@@ -18470,12 +19111,12 @@ var SETTING_FIELDS2 = [
 ];
 function settingsDirectory2(environment = process.env, platform = process.platform) {
   if (environment.ARCHYMEDES_CONFIG_DIR?.trim())
-    return path19.resolve(environment.ARCHYMEDES_CONFIG_DIR);
+    return path21.resolve(environment.ARCHYMEDES_CONFIG_DIR);
   if (platform === "win32")
-    return path19.join(environment.APPDATA?.trim() || path19.join(os5.homedir(), "AppData", "Roaming"), "Archymedes");
+    return path21.join(environment.APPDATA?.trim() || path21.join(os6.homedir(), "AppData", "Roaming"), "Archymedes");
   if (platform === "darwin")
-    return path19.join(os5.homedir(), "Library", "Application Support", "Archymedes");
-  return path19.join(environment.XDG_CONFIG_HOME?.trim() || path19.join(os5.homedir(), ".config"), "archymedes");
+    return path21.join(os6.homedir(), "Library", "Application Support", "Archymedes");
+  return path21.join(environment.XDG_CONFIG_HOME?.trim() || path21.join(os6.homedir(), ".config"), "archymedes");
 }
 var PROVIDER_REQUIRED_NAMES2 = new Set(PROVIDER_IDS.flatMap((id) => PROVIDER_INFO[id].requires));
 var PROVIDER_KEY_FIELDS2 = SETTING_FIELDS2.filter((field) => PROVIDER_REQUIRED_NAMES2.has(field.key));
@@ -18484,7 +19125,7 @@ var PROVIDER_KEY_FIELDS2 = SETTING_FIELDS2.filter((field) => PROVIDER_REQUIRED_N
 var MAX_HISTORY = 200;
 var SENSITIVE = /(?:api[_-]?key|authorization|password|secret|token)\s*[:=]/i;
 function historyFile(environment) {
-  return path20.join(settingsDirectory2(environment), "history.json");
+  return path22.join(settingsDirectory2(environment), "history.json");
 }
 function sanitizeHistory(lines) {
   const result = [];
@@ -18501,7 +19142,7 @@ function sanitizeHistory(lines) {
 }
 async function loadHistory(environment) {
   try {
-    const parsed = JSON.parse(await fs12.readFile(historyFile(environment), "utf8"));
+    const parsed = JSON.parse(await fs14.readFile(historyFile(environment), "utf8"));
     return Array.isArray(parsed) ? sanitizeHistory(parsed.filter((item) => typeof item === "string")) : [];
   } catch {
     return [];
@@ -18509,12 +19150,12 @@ async function loadHistory(environment) {
 }
 async function saveHistory(lines, environment) {
   const file = historyFile(environment);
-  await fs12.mkdir(path20.dirname(file), { recursive: true, mode: 448 });
+  await fs14.mkdir(path22.dirname(file), { recursive: true, mode: 448 });
   const temporary = `${file}.${process.pid}.tmp`;
-  await fs12.writeFile(temporary, `${JSON.stringify(sanitizeHistory(lines), null, 2)}
+  await fs14.writeFile(temporary, `${JSON.stringify(sanitizeHistory(lines), null, 2)}
 `, { encoding: "utf8", mode: 384 });
-  await fs12.rename(temporary, file);
-  await fs12.chmod(file, 384).catch(() => {
+  await fs14.rename(temporary, file);
+  await fs14.chmod(file, 384).catch(() => {
     return;
   });
 }
@@ -18962,8 +19603,8 @@ function paintSegments2(text, segments, colour, depth) {
 }
 
 // packages/core/src/providers/model-fetch.ts
-import { promises as fs13 } from "node:fs";
-import path21 from "node:path";
+import { promises as fs15 } from "node:fs";
+import path23 from "node:path";
 async function fetchProviderModels(provider, environment, fetchImpl, timeoutMs = 4000) {
   const endpoint = modelsEndpoint(provider, environment);
   if (!endpoint)
@@ -18983,7 +19624,7 @@ async function fetchProviderModels(provider, environment, fetchImpl, timeoutMs =
 }
 var MODEL_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
 function modelCacheFile(environment) {
-  return path21.join(archymedesConfigDirectory(environment), "models.json");
+  return path23.join(archymedesConfigDirectory(environment), "models.json");
 }
 function isCacheFresh(cache, now = Date.now(), ttlMs = MODEL_CACHE_TTL_MS) {
   if (!cache)
@@ -18992,7 +19633,7 @@ function isCacheFresh(cache, now = Date.now(), ttlMs = MODEL_CACHE_TTL_MS) {
 }
 async function readModelCache(environment) {
   try {
-    const parsed = JSON.parse(await fs13.readFile(modelCacheFile(environment), "utf8"));
+    const parsed = JSON.parse(await fs15.readFile(modelCacheFile(environment), "utf8"));
     return typeof parsed?.fetchedAt === "number" && parsed.models ? parsed : undefined;
   } catch {
     return;
@@ -19001,11 +19642,11 @@ async function readModelCache(environment) {
 async function writeModelCache(environment, cache) {
   const file = modelCacheFile(environment);
   try {
-    await fs13.mkdir(path21.dirname(file), { recursive: true });
+    await fs15.mkdir(path23.dirname(file), { recursive: true });
     const temporary = `${file}.${process.pid}.tmp`;
-    await fs13.writeFile(temporary, `${JSON.stringify(cache, null, 2)}
+    await fs15.writeFile(temporary, `${JSON.stringify(cache, null, 2)}
 `, { mode: 384 });
-    await fs13.rename(temporary, file);
+    await fs15.rename(temporary, file);
   } catch {}
 }
 async function loadLiveModels(providers, environment, options = {}) {
@@ -19899,23 +20540,23 @@ function parseThemeCommand(input) {
 }
 
 // packages/archymedes-cli/src/theme-files.ts
-import { promises as fs14 } from "node:fs";
-import path22 from "node:path";
+import { promises as fs16 } from "node:fs";
+import path24 from "node:path";
 function themeDirectory(scope, root, environment) {
-  return scope === "project" ? path22.join(root, ".archymedes", "themes") : path22.join(settingsDirectory2(environment), "themes");
+  return scope === "project" ? path24.join(root, ".archymedes", "themes") : path24.join(settingsDirectory2(environment), "themes");
 }
 async function readThemeDirectory(directory, source) {
   let entries;
   try {
-    entries = await fs14.readdir(directory);
+    entries = await fs16.readdir(directory);
   } catch {
     return [];
   }
   const themes = [];
   for (const entry of entries.filter((name) => name.endsWith(".tss")).sort()) {
-    const file = path22.join(directory, entry);
+    const file = path24.join(directory, entry);
     try {
-      const contents = await fs14.readFile(file, "utf8");
+      const contents = await fs16.readFile(file, "utf8");
       for (const theme of parseThemeSource(contents))
         themes.push({ ...theme, source, file });
     } catch {}
@@ -20216,18 +20857,20 @@ function describe(job, now) {
   return job.cadence ? `${job.cadence} schedule` : "";
 }
 // packages/core/src/cli/job-store.ts
-import { promises as fs15 } from "node:fs";
-import path23 from "node:path";
+import { promises as fs17 } from "node:fs";
+import path25 from "node:path";
 function jobStoreFile(root) {
-  return path23.join(root, ".archymedes", "jobs.json");
+  return path25.join(root, ".archymedes", "jobs.json");
 }
 function jobLogPath(root, id) {
-  return path23.join(root, ".archymedes", "jobs", `${id}.log`);
+  return path25.join(root, ".archymedes", "jobs", `${id}.log`);
 }
 async function readStore(file) {
   try {
-    const parsed = JSON.parse(await fs15.readFile(file, "utf8"));
-    return Array.isArray(parsed?.jobs) ? { jobs: parsed.jobs } : emptyStore();
+    const parsed = JSON.parse(await fs17.readFile(file, "utf8"));
+    if (!Array.isArray(parsed?.jobs))
+      throw new Error('expected an object with a "jobs" array');
+    return { jobs: parsed.jobs };
   } catch (error) {
     if (error.code === "ENOENT")
       return emptyStore();
@@ -20237,21 +20880,21 @@ async function readStore(file) {
 async function acquireLock(lockFile) {
   for (let attempt = 0;attempt < 80; attempt += 1) {
     try {
-      const handle = await fs15.open(lockFile, "wx", 384);
+      const handle = await fs17.open(lockFile, "wx", 384);
       await handle.writeFile(`${process.pid}
 `, "utf8");
       await handle.close();
       return async () => {
-        await fs15.unlink(lockFile).catch(() => {
+        await fs17.unlink(lockFile).catch(() => {
           return;
         });
       };
     } catch (error) {
       if (error.code !== "EEXIST")
         throw error;
-      const stat2 = await fs15.stat(lockFile).catch(() => null);
+      const stat2 = await fs17.stat(lockFile).catch(() => null);
       if (stat2 && Date.now() - stat2.mtimeMs > 1e4) {
-        await fs15.unlink(lockFile).catch(() => {
+        await fs17.unlink(lockFile).catch(() => {
           return;
         });
         continue;
@@ -20264,13 +20907,13 @@ async function acquireLock(lockFile) {
 async function withJobs(root, mutate) {
   const file = jobStoreFile(root);
   const lockFile = `${file}.lock`;
-  await fs15.mkdir(path23.dirname(file), { recursive: true });
+  await fs17.mkdir(path25.dirname(file), { recursive: true });
   const release = await acquireLock(lockFile);
   try {
     const current = await readStore(file);
     const { store, result } = mutate(current, Date.now());
     const temporary = `${file}.${process.pid}.tmp`;
-    const handle = await fs15.open(temporary, "w", 384);
+    const handle = await fs17.open(temporary, "w", 384);
     try {
       await handle.writeFile(`${JSON.stringify(store, null, 2)}
 `, "utf8");
@@ -20278,7 +20921,7 @@ async function withJobs(root, mutate) {
     } finally {
       await handle.close();
     }
-    await fs15.rename(temporary, file);
+    await fs17.rename(temporary, file);
     return result;
   } finally {
     await release();
@@ -20353,13 +20996,13 @@ function newJobId(now = new Date) {
 }
 async function appendJobLog(root, id, line) {
   const file = jobLogPath(root, id);
-  await fs15.mkdir(path23.dirname(file), { recursive: true });
-  await fs15.appendFile(file, `${line}
+  await fs17.mkdir(path25.dirname(file), { recursive: true });
+  await fs17.appendFile(file, `${line}
 `, "utf8");
 }
 async function readJobLog(root, id, fromByte = 0) {
   try {
-    const handle = await fs15.open(jobLogPath(root, id), "r");
+    const handle = await fs17.open(jobLogPath(root, id), "r");
     try {
       const stat2 = await handle.stat();
       if (fromByte >= stat2.size)
@@ -20377,7 +21020,7 @@ async function readJobLog(root, id, fromByte = 0) {
   }
 }
 // packages/archymedes-cli/src/job-worker.ts
-import os6 from "node:os";
+import os7 from "node:os";
 // packages/archymedes-cli/src/transcript.ts
 function truncateMiddle2(value, maximum) {
   const clean = value.replace(/\s+/g, " ").trim();
@@ -20398,12 +21041,12 @@ function countOf2(value) {
 function describeToolCall3(toolName, args) {
   switch (toolName) {
     case "read_file": {
-      const path24 = asString2(args.path) ?? "";
+      const path26 = asString2(args.path) ?? "";
       const offset = typeof args.offset === "number" ? args.offset : undefined;
       const limit = typeof args.limit === "number" ? args.limit : undefined;
       if (offset === undefined)
-        return path24;
-      return limit === undefined ? `${path24}:${offset}+` : `${path24}:${offset}-${offset + limit - 1}`;
+        return path26;
+      return limit === undefined ? `${path26}:${offset}+` : `${path26}:${offset}-${offset + limit - 1}`;
     }
     case "write_file":
     case "edit_file":
@@ -20613,7 +21256,7 @@ function resolveWanderJobTopic(objective, seed) {
 }
 
 // packages/archymedes-cli/src/job-worker.ts
-function workerId(hostname = os6.hostname(), pid = process.pid) {
+function workerId(hostname = os7.hostname(), pid = process.pid) {
   return `${hostname}:${pid}`;
 }
 var DEFAULT_LEASE_MS = 4 * 60000;
@@ -21050,17 +21693,17 @@ function renderTools(view, style = plain) {
 
 // packages/archymedes-cli/src/voice.ts
 import { spawn as spawn6 } from "node:child_process";
-import { promises as fs16 } from "node:fs";
-import os7 from "node:os";
-import path24 from "node:path";
+import { promises as fs18 } from "node:fs";
+import os8 from "node:os";
+import path26 from "node:path";
 function recordingArgs(outputFile, platform = process.platform, device) {
   const head = ["-hide_banner", "-loglevel", "error", "-y"];
   const input = platform === "darwin" ? ["-f", "avfoundation", "-i", device?.trim() || ":0"] : platform === "win32" ? ["-f", "dshow", "-i", `audio=${device?.trim() || "default"}`] : ["-f", "pulse", "-i", device?.trim() || "default"];
   return [...head, ...input, "-ac", "1", "-ar", "16000", outputFile];
 }
 async function startRecording(environment, platform = process.platform, spawnImpl = spawn6) {
-  const directory = await fs16.mkdtemp(path24.join(os7.tmpdir(), "archymedes-voice-"));
-  const file = path24.join(directory, "prompt.wav");
+  const directory = await fs18.mkdtemp(path26.join(os8.tmpdir(), "archymedes-voice-"));
+  const file = path26.join(directory, "prompt.wav");
   const executable2 = environment.ARCHYMEDES_FFMPEG_PATH?.trim() || "ffmpeg";
   const child = spawnImpl(executable2, recordingArgs(file, platform, environment.VOICE_INPUT_DEVICE), {
     shell: false,
@@ -21084,7 +21727,7 @@ async function startRecording(environment, platform = process.platform, spawnImp
       }
     });
   }).catch(async (error) => {
-    await fs16.rm(directory, { recursive: true, force: true });
+    await fs18.rm(directory, { recursive: true, force: true });
     throw error;
   });
   return {
@@ -21109,13 +21752,13 @@ async function transcribeAudio(file, environment, fetchImpl = fetch) {
   const apiKey = environment.OPENAI_API_KEY?.trim();
   if (!apiKey)
     throw new Error("Voice input needs OPENAI_API_KEY. Add it in archymedes settings or set it in your environment.");
-  const bytes = await fs16.readFile(file);
+  const bytes = await fs18.readFile(file);
   if (bytes.byteLength === 0)
     throw new Error("The audio recording is empty.");
   if (bytes.byteLength > 25 * 1024 * 1024)
     throw new Error("Audio must be 25 MB or smaller.");
   const form = new FormData;
-  form.append("file", new Blob([bytes]), path24.basename(file));
+  form.append("file", new Blob([bytes]), path26.basename(file));
   form.append("model", environment.VOICE_MODEL?.trim() || "gpt-4o-mini-transcribe");
   form.append("response_format", "json");
   const response = await fetchImpl(transcriptionEndpoint(environment), {
@@ -21132,7 +21775,7 @@ async function transcribeAudio(file, environment, fetchImpl = fetch) {
   return result.text.trim();
 }
 async function removeRecording(file) {
-  await fs16.rm(path24.dirname(file), { recursive: true, force: true });
+  await fs18.rm(path26.dirname(file), { recursive: true, force: true });
 }
 
 // packages/archymedes-cli/src/i18n.ts
@@ -23040,7 +23683,7 @@ function parseArgs(argv) {
       } else
         parsed.resume = "latest";
     } else if (argument === "--cwd") {
-      parsed.root = path25.resolve(argv[index + 1] ?? ".");
+      parsed.root = path27.resolve(argv[index + 1] ?? ".");
       index += 1;
     } else if (argument === "--sandbox") {
       const value = argv[index + 1];
@@ -23258,22 +23901,22 @@ function writeFoldable(label, rendered) {
   }
 }
 function renderWrittenCode(toolName, args) {
-  const path26 = typeof args.path === "string" ? args.path : "";
-  if (!path26)
+  const path28 = typeof args.path === "string" ? args.path : "";
+  if (!path28)
     return;
   const style_ = sectionStyle();
   if (toolName === "write_file") {
     const content = typeof args.content === "string" ? args.content : "";
     if (content === "")
       return;
-    writeFoldable(path26, renderFileChange({ path: path26, kind: "write", content }, style_, { maxLines: FOLD_AFTER_LINES }));
+    writeFoldable(path28, renderFileChange({ path: path28, kind: "write", content }, style_, { maxLines: FOLD_AFTER_LINES }));
     return;
   }
   const before = typeof args.oldText === "string" ? args.oldText : "";
   const after = typeof args.newText === "string" ? args.newText : "";
   if (before === "" && after === "")
     return;
-  writeFoldable(path26, renderFileChange({ path: path26, kind: "edit", before, after }, style_, { maxLines: FOLD_AFTER_LINES }));
+  writeFoldable(path28, renderFileChange({ path: path28, kind: "edit", before, after }, style_, { maxLines: FOLD_AFTER_LINES }));
 }
 function renderCommandOutput(content) {
   const style_ = sectionStyle();
@@ -23404,9 +24047,9 @@ ${rule2(sectionStyle(), { label: "tool activity", tone: "neutral" })}
       if (runtime.toolName === "write_file" || runtime.toolName === "edit_file") {
         toolLines.forget();
         renderWrittenCode(runtime.toolName, pending.arguments);
-        const path26 = typeof pending.arguments.path === "string" ? pending.arguments.path : undefined;
-        if (path26)
-          touchedFiles.add(path26);
+        const path28 = typeof pending.arguments.path === "string" ? pending.arguments.path : undefined;
+        if (path28)
+          touchedFiles.add(path28);
         let addedDelta = 0;
         let removedDelta = 0;
         if (runtime.toolName === "write_file") {
@@ -23423,9 +24066,9 @@ ${rule2(sectionStyle(), { label: "tool activity", tone: "neutral" })}
         }
         turnLineDelta.added += addedDelta;
         turnLineDelta.removed += removedDelta;
-        if (path26) {
-          const prior = sessionFiles.get(path26) ?? { added: 0, removed: 0 };
-          sessionFiles.set(path26, { added: prior.added + addedDelta, removed: prior.removed + removedDelta });
+        if (path28) {
+          const prior = sessionFiles.get(path28) ?? { added: 0, removed: 0 };
+          sessionFiles.set(path28, { added: prior.added + addedDelta, removed: prior.removed + removedDelta });
         }
       } else if (runtime.toolName === "run_command") {
         toolLines.forget();
@@ -23626,7 +24269,7 @@ async function spawnJobWorker(root, jobId) {
   const { spawn: spawn7 } = await import("child_process");
   const { openSync, mkdirSync } = await import("fs");
   const logFile = jobLogPath(root, jobId);
-  mkdirSync(path25.dirname(logFile), { recursive: true });
+  mkdirSync(path27.dirname(logFile), { recursive: true });
   const fd = openSync(logFile, "a");
   try {
     const child = spawn7(process.execPath, [process.argv[1], "--archymedes-job-worker", root, jobId], {
@@ -24079,7 +24722,7 @@ Setup cancelled.
     const minutes = Math.max(1, Math.min(args.sandboxMinutes, 60));
     if (request.backend === "e2b") {
       const { findWorkspacePreset } = await import("./sandbox-templates-8sd1psez.mjs");
-      const { createE2BProvider } = await import("./factory-0z4he0ev.mjs");
+      const { createE2BProvider } = await import("./factory-96yy6mxr.mjs");
       const preset = findWorkspacePreset(request.preset ?? args.preset);
       const sandbox = createE2BProvider(environment, preset.templateAlias);
       if (!sandbox)
@@ -24105,7 +24748,7 @@ Setup cancelled.
       return { workspace: created };
     }
     if (request.backend === "docker") {
-      const { createDockerProvider } = await import("./factory-0z4he0ev.mjs");
+      const { createDockerProvider } = await import("./factory-96yy6mxr.mjs");
       const image = request.dockerImage || args.dockerImage || environment.DOCKER_CODING_IMAGE;
       const sandbox = createDockerProvider({ ...environment, DOCKER_CODING_IMAGE: image });
       if (!sandbox)
@@ -24314,7 +24957,7 @@ Setup cancelled.
 `);
   }
   const firstSink = new TabSink(terminalStream2, { live: true });
-  tabs.adopt(path25.basename(args.root) || "archymedes", {
+  tabs.adopt(path27.basename(args.root) || "archymedes", {
     agent,
     ledger,
     mode,
@@ -24525,11 +25168,11 @@ Setup cancelled.
       if (record.mode && !args.modeExplicit)
         mode = record.mode;
       agent = await openClient(record);
-      await carryResumedSpend(record);
+      await carryResumedSpend(agent.snapshot());
       out.write(style.dim(`Resumed ${record.id} \u2014 ${record.title}
 `));
       if (interactive && !args.prompt)
-        out.write(`${renderReplay(record, sectionStyle(), { turns: 2 })}
+        out.write(`${renderReplay(agent.snapshot(), sectionStyle(), { turns: 2 })}
 `);
     } else if (args.resume === "latest") {
       out.write(style.yellow(`No matching session; starting a new one.
@@ -24997,7 +25640,7 @@ ${style.yellow(`Stopped at the ${formatMoney2(fromUnits2(args.budget, display))}
     });
     const ran = await runTurn(args.prompt);
     if (ran && workspace.kind === "e2b") {
-      const destination = path25.resolve(args.root, "archymedes-pull");
+      const destination = path27.resolve(args.root, "archymedes-pull");
       const pulled = await downloadProject(workspace, destination);
       out.write(style.dim(`  pulled ${pulled.written.length} files into ${destination}
 `));
@@ -25007,18 +25650,30 @@ ${style.yellow(`Stopped at the ${formatMoney2(fromUnits2(args.budget, display))}
     exitCleanly();
     return args.json ? exitCodeForStatus(lastTurnStatus) : ran ? 0 : 1;
   }
-  const where = workspace.kind === "e2b" ? `sandbox ${workspace.label.split(":")[1]}` : path25.basename(args.root);
-  out.write(`${renderIdentity({
-    width: process.stdout.columns ?? 80,
-    rows: process.stdout.rows ?? 24,
-    version: ARCHYMEDES_CLI_VERSION,
-    workspace: where,
-    model: `${spec.label} ${resolvedModelId}`,
-    mode,
-    palette,
-    glyphs
-  })}
-`);
+  const where = workspace.kind === "e2b" ? `sandbox ${workspace.label.split(":")[1]}` : path27.basename(args.root);
+  const identityMotion = new AbortController;
+  const stopIdentityMotion = () => identityMotion.abort();
+  if (ttyMode)
+    process.stdin.on("data", stopIdentityMotion);
+  try {
+    await writeIdentity({
+      width: process.stdout.columns ?? 80,
+      rows: process.stdout.rows ?? 24,
+      version: ARCHYMEDES_CLI_VERSION,
+      workspace: where,
+      model: `${spec.label} ${resolvedModelId}`,
+      mode,
+      palette,
+      glyphs
+    }, out, {
+      enabled: ttyMode && !readline.line && environment.TERM !== "dumb" && environment.NO_COLOR === undefined && environment.ARCHYMEDES_NO_MOTION !== "1",
+      signal: identityMotion.signal,
+      size: () => ({ width: process.stdout.columns ?? 80, rows: process.stdout.rows ?? 24 })
+    });
+  } finally {
+    if (ttyMode)
+      process.stdin.off("data", stopIdentityMotion);
+  }
   const context = [
     renderReliabilityStatus(999, glyphs.middot),
     `costs ${display}${preference.countryCode ? ` ${glyphs.middot} location ${preference.countryCode}` : ""} (${preference.source === "location" ? "auto-detected" : preference.source})`
@@ -25046,7 +25701,7 @@ ${style.yellow(`Stopped at the ${formatMoney2(fromUnits2(args.budget, display))}
 `);
   }
   if (interactive && !args.prompt) {
-    const starters = renderStarters(navContext(), sectionStyle(), path25.basename(args.root));
+    const starters = renderStarters(navContext(), sectionStyle(), path27.basename(args.root));
     if (starters)
       out.write(`
 ${starters}
@@ -25870,8 +26525,8 @@ ${note4(`you     ${glyphs.middot} ${files.user}`, style_)}
           rows: process.stdout.rows ?? 24,
           paths: projectFiles,
           palette,
-          readFile: async (path26) => {
-            const result = await workspace.readFile(path26, { limit: 200 });
+          readFile: async (path28) => {
+            const result = await workspace.readFile(path28, { limit: 200 });
             return { content: result.content, totalLines: result.totalLines, truncated: result.truncated };
           }
         });
@@ -26056,7 +26711,7 @@ ${note4(`you     ${glyphs.middot} ${files.user}`, style_)}
           if (record.mode)
             mode = record.mode;
           agent = await openClient(record);
-          await carryResumedSpend(record);
+          await carryResumedSpend(agent.snapshot());
           expandables.clear();
           out.write(`${renderReplay(record, style_, { turns: 2 })}
 `);
@@ -26563,7 +27218,7 @@ ${renderKeyboardShortcuts(language)}
 `));
         continue;
       }
-      const destination = path25.resolve(args.root, input.split(/\s+/)[1] ?? "archymedes-pull");
+      const destination = path27.resolve(args.root, input.split(/\s+/)[1] ?? "archymedes-pull");
       const pulled = await downloadProject(workspace, destination);
       out.write(style.green(`  pulled ${pulled.written.length} files into ${destination}
 `));
@@ -26584,7 +27239,7 @@ ${renderKeyboardShortcuts(language)}
     }
     if (input.startsWith("/voice")) {
       const supplied = input.slice("/voice".length).trim();
-      let audioFile = supplied ? path25.resolve(args.root, supplied) : "";
+      let audioFile = supplied ? path27.resolve(args.root, supplied) : "";
       let temporary = false;
       try {
         if (!audioFile) {