@evident-ai/cli 3.1.1-dev.9ff0701 → 3.1.1-dev.b4e1c75

package/dist/index.js

@@ -11,8 +11,8 @@ import chalk2 from "chalk";
 
 // src/lib/config.ts
 import Conf from "conf";
-import { homedir } from "os";
-import { join } from "path";
+import { chmodSync, existsSync, statSync } from "fs";
+import { dirname } from "path";
 var PRODUCTION_API_URL = "https://api.production.evident.run/v1";
 var PRODUCTION_TUNNEL_URL = "wss://tunnel.production.evident.run";
 var defaults = {
@@ -47,8 +47,35 @@ var credentials = new Conf({
   projectName: "evident",
   projectSuffix: "",
   configName: "credentials",
-  defaults: {}
+  defaults: {},
+  configFileMode: 384
 });
+var CREDENTIALS_FILE_MODE = 384;
+var CREDENTIALS_DIR_MODE = 448;
+var permissionWarningEmitted = false;
+function hardenCredentialsPermissions() {
+  if (process.platform === "win32") {
+    return;
+  }
+  const file = credentials.path;
+  for (const [path, mode] of [
+    [file, CREDENTIALS_FILE_MODE],
+    [dirname(file), CREDENTIALS_DIR_MODE]
+  ]) {
+    try {
+      if (existsSync(path) && (statSync(path).mode & 511) !== mode) {
+        chmodSync(path, mode);
+      }
+    } catch (err) {
+      if (!permissionWarningEmitted) {
+        permissionWarningEmitted = true;
+        console.error(
+          `[config] could not restrict permissions on ${path}; the credentials file may be readable by other users on this machine: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  }
+}
 function getApiUrlConfig() {
   return getApiUrl();
 }
@@ -59,6 +86,7 @@ function credentialsKey() {
   return getApiUrl();
 }
 function getCredentials() {
+  hardenCredentialsPermissions();
   const byEndpoint = credentials.get("byEndpoint") ?? {};
   return byEndpoint[credentialsKey()] ?? {};
 }
@@ -70,14 +98,17 @@ function setCredentials(creds) {
     expiresAt: creds.expiresAt
   };
   credentials.set("byEndpoint", byEndpoint);
+  hardenCredentialsPermissions();
 }
 function clearCredentials() {
   const byEndpoint = credentials.get("byEndpoint") ?? {};
   delete byEndpoint[credentialsKey()];
   credentials.set("byEndpoint", byEndpoint);
+  hardenCredentialsPermissions();
 }
 function clearAllCredentials() {
   credentials.clear();
+  hardenCredentialsPermissions();
 }
 function getCliName() {
   const argv1 = process.argv[1] || "";
@@ -285,14 +316,14 @@ function blank() {
   console.log();
 }
 function waitForEnter(prompt = "Press Enter to continue...") {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     process.stdout.write(chalk.dim(prompt));
     const handler = () => {
       process.stdin.removeListener("data", handler);
       process.stdin.setRawMode?.(false);
       process.stdin.pause();
       console.log();
-      resolve2();
+      resolve3();
     };
     if (process.stdin.isTTY) {
       process.stdin.setRawMode?.(true);
@@ -302,7 +333,7 @@ function waitForEnter(prompt = "Press Enter to continue...") {
   });
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 
 // src/commands/login.ts
@@ -373,22 +404,23 @@ async function deviceFlowLogin(options) {
 }
 async function tokenLogin() {
   console.log("Token login mode.");
-  console.log("Visit your Evident dashboard to generate a CLI token.");
+  console.log("Run `evident login` on a machine with a browser to get a token.");
+  console.log("Manage or revoke existing tokens under Settings \u2192 CLI tokens.");
   blank();
   process.stdout.write("Paste token: ");
-  const token = await new Promise((resolve2) => {
+  const token = await new Promise((resolve3) => {
     let data = "";
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
     process.stdin.on("end", () => {
-      resolve2(data.trim());
+      resolve3(data.trim());
     });
     if (process.stdin.isTTY) {
       process.stdin.once("data", (chunk) => {
         process.stdin.pause();
-        resolve2(chunk.toString().trim());
+        resolve3(chunk.toString().trim());
       });
       process.stdin.resume();
     }
@@ -467,9 +499,9 @@ async function whoami() {
 }
 
 // src/commands/run.ts
+import { homedir as homedir2 } from "os";
+import { isAbsolute as isAbsolute2, join as join2, parse, resolve as resolvePath } from "path";
 import chalk6 from "chalk";
-import ora3 from "ora";
-import { select as select3 } from "@inquirer/prompts";
 
 // ../../packages/types/src/telemetry/index.ts
 var TelemetryEventTypes = {
@@ -485,6 +517,10 @@ var TelemetryEventTypes = {
 var MAX_FRAME_BYTES = 256 * 1024;
 var TUNNEL_DRAIN_PING_PATH = "/__evident/drain";
 
+// ../../packages/types/src/runner-files.ts
+var MAX_FILE_PUSH_BYTES = 64 * 1024;
+var MAX_FILE_SYNC_DIRECTORIES = 16;
+
 // ../../packages/types/src/logging/index.ts
 var CORRELATION_ID_HEADER = "x-evident-correlation-id";
 function log(level, event, fields) {
@@ -499,6 +535,12 @@ function log(level, event, fields) {
     );
   }
 }
+function errorFields(err) {
+  if (err instanceof Error) {
+    return { error: err.message, error_name: err.name };
+  }
+  return { error: String(err) };
+}
 function stripQuery(url) {
   try {
     return new URL(url).pathname;
@@ -508,6 +550,10 @@ function stripQuery(url) {
   }
 }
 
+// src/commands/run.ts
+import ora3 from "ora";
+import { select as select3 } from "@inquirer/prompts";
+
 // src/lib/telemetry.ts
 var CLI_VERSION = (true ? "3.0.0" : void 0) ?? process.env.npm_package_version ?? "unknown";
 function getCliVersion() {
@@ -645,14 +691,27 @@ var EventTypes = {
   // CLI lifecycle
   CLI_STARTED: "cli.started",
   CLI_COMMAND: "cli.command",
-  CLI_ERROR: "cli.error"
+  CLI_ERROR: "cli.error",
+  // Deprecation telemetry (#412) — usage of the old `--agent`/`EVIDENT_AGENT_KEY`
+  // names instead of the preferred `--runner`/`EVIDENT_RUNNER_KEY` (#409).
+  DEPRECATED_AGENT_FLAG_USED: "cli.deprecated_agent_flag_used",
+  DEPRECATED_AGENT_KEY_ENV_USED: "cli.deprecated_agent_key_env_used"
 };
 
 // src/lib/auth.ts
 async function getAuthCredentials() {
+  const runnerKey = process.env.EVIDENT_RUNNER_KEY;
   const agentKey = process.env.EVIDENT_AGENT_KEY;
+  if (runnerKey) {
+    return {
+      token: runnerKey,
+      authType: "agent_key",
+      keySource: "runner_key",
+      notice: agentKey ? "Both EVIDENT_RUNNER_KEY and EVIDENT_AGENT_KEY are set; using EVIDENT_RUNNER_KEY." : void 0
+    };
+  }
   if (agentKey) {
-    return { token: agentKey, authType: "agent_key" };
+    return { token: agentKey, authType: "agent_key", keySource: "agent_key" };
   }
   const userToken = process.env.EVIDENT_TOKEN;
   if (userToken) {
@@ -706,7 +765,7 @@ async function waitForOpenCodeHealth(port, timeoutMs = 3e4) {
     if (health.healthy) {
       return health;
     }
-    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    await new Promise((resolve3) => setTimeout(resolve3, 1e3));
   }
   return { healthy: false, error: "Timeout waiting for OpenCode to be healthy" };
 }
@@ -721,7 +780,7 @@ function buildOpenCodeVersionWarning(version2) {
   if (isQueueValidatedVersion(version2)) return null;
   const detected = version2 ? `v${version2}` : "unknown";
   const validated = QUEUE_VALIDATED_OPENCODE_VERSIONS.map((v) => `v${v}`).join(", ");
-  return `Warning: opencode ${detected} is not a queue-validated version (validated: ${validated}). Native message queuing \u2014 which channel (Slack/WhatsApp) message handling relies on \u2014 is unverified on this version; queued/follow-up messages may behave unexpectedly. Continuing anyway. Bumping the validated set requires re-running the queue validation.`;
+  return `Warning: opencode ${detected} is not a queue-validated version (validated: ${validated}). Native message queuing \u2014 which channel (Slack) message handling relies on \u2014 is unverified on this version; queued/follow-up messages may behave unexpectedly. Continuing anyway. Bumping the validated set requires re-running the queue validation.`;
 }
 
 // src/lib/opencode/process.ts
@@ -1013,6 +1072,12 @@ async function promptOpenCodeInstall(interactive) {
   return action;
 }
 
+// src/lib/opencode/provider-check.ts
+function buildNoProviderWarning(hasProvider) {
+  if (hasProvider !== false) return null;
+  return "Warning: opencode has no authenticated model provider configured, so it won't be able to answer prompts. Run `opencode auth login` to set one up (see https://opencode.ai for details).";
+}
+
 // src/lib/opencode/session.ts
 function opencodeBase(port) {
   return `http://127.0.0.1:${port}`;
@@ -1215,6 +1280,11 @@ async function getModelAttachmentCapability(port, model) {
     }
     const entry = provider.models[modelId];
     if (!entry || typeof entry !== "object") return null;
+    if (entry.capabilities && typeof entry.capabilities === "object") {
+      if (typeof entry.capabilities.attachment === "boolean") {
+        return entry.capabilities.attachment;
+      }
+    }
     return typeof entry.attachment === "boolean" ? entry.attachment : null;
   } catch (err) {
     console.error(
@@ -1243,6 +1313,16 @@ async function buildFileParts(attachments, capable) {
       );
       dataUrl = null;
     }
+    if (dataUrl !== null && typeof dataUrl === "object") {
+      outcomes.push({
+        index: a.index,
+        mime: a.mime,
+        filename: a.filename,
+        status: "failed",
+        reason: "needs_reauth"
+      });
+      continue;
+    }
     if (dataUrl == null) {
       outcomes.push({ index: a.index, mime: a.mime, filename: a.filename, status: "failed" });
       continue;
@@ -1324,7 +1404,7 @@ async function sendPromptAsync(port, sessionId, content, options, attachments) {
       }
     }
     if (attempt < READ_BACK_ATTEMPTS - 1) {
-      await new Promise((resolve2) => setTimeout(resolve2, READ_BACK_DELAY_MS));
+      await new Promise((resolve3) => setTimeout(resolve3, READ_BACK_DELAY_MS));
     }
   }
   return null;
@@ -1370,6 +1450,72 @@ function findLastAssistantReplyFor(messages, userMessageId) {
   }
   return lastOk ?? last;
 }
+function messageUsage(messages, userMessageId) {
+  if (!messages || messages.length === 0) return null;
+  const byParentAll = messages.filter(
+    (m) => roleOf(m) === "assistant" && parentIdOf(m) === userMessageId
+  );
+  const byParentNonErrored = byParentAll.filter((m) => errorOf(m) == null);
+  const byParent = byParentNonErrored.length > 0 ? byParentNonErrored : byParentAll;
+  let correlated;
+  if (byParent.length > 0) {
+    correlated = byParent;
+  } else {
+    const reply = findAssistantReplyAfter(messages, userMessageId);
+    correlated = reply ? [reply] : [];
+  }
+  if (correlated.length === 0) return null;
+  let sawAnyUsage = false;
+  let inputSum = 0;
+  let outputSum = 0;
+  let reasoningSum = 0;
+  let cacheReadSum = 0;
+  let cacheWriteSum = 0;
+  let costSum = 0;
+  let sawCost = false;
+  let modelId = null;
+  let providerId = null;
+  for (const m of correlated) {
+    const info = m.info;
+    if (!info) continue;
+    const tokens = info.tokens;
+    if (tokens) {
+      sawAnyUsage = true;
+      inputSum += tokens.input ?? 0;
+      outputSum += tokens.output ?? 0;
+      reasoningSum += tokens.reasoning ?? 0;
+      cacheReadSum += tokens.cache?.read ?? 0;
+      cacheWriteSum += tokens.cache?.write ?? 0;
+    }
+    if (typeof info.cost === "number") {
+      sawAnyUsage = true;
+      sawCost = true;
+      costSum += info.cost;
+    }
+    if (typeof info.modelID === "string") {
+      sawAnyUsage = true;
+      modelId = info.modelID;
+    }
+    if (typeof info.providerID === "string") {
+      sawAnyUsage = true;
+      providerId = info.providerID;
+    }
+  }
+  if (!sawAnyUsage) return null;
+  return {
+    usage_provider_id: providerId,
+    usage_model_id: modelId,
+    usage_tokens_input: inputSum,
+    usage_tokens_output: outputSum,
+    usage_tokens_reasoning: reasoningSum,
+    usage_tokens_cache_read: cacheReadSum,
+    usage_tokens_cache_write: cacheWriteSum,
+    // NULL means "OpenCode never reported a cost" (never inferred from
+    // tokens) — distinct from a genuine 0-cost turn, which would set
+    // `sawCost` true with `costSum === 0`.
+    usage_cost_usd: sawCost ? costSum : null
+  };
+}
 function messageRunState(messages, userMessageId) {
   if (!messages || messages.length === 0) return "unknown";
   const hasUser = messages.some((m) => idOf(m) === userMessageId);
@@ -1386,6 +1532,9 @@ function isPreamblePinnedRunning(messages, userMessageId) {
   const reply = findLastAssistantReplyFor(messages, userMessageId);
   return completedOf(reply) != null && finishOf(reply) === "tool-calls";
 }
+function isB2AbandonmentConfirmed(params) {
+  return params.pinnedForMs >= params.minPinnedMs && params.descendantOngoing === false;
+}
 function messageError(messages, userMessageId) {
   const reply = findLastAssistantReplyFor(messages, userMessageId);
   const error2 = errorOf(reply);
@@ -1405,6 +1554,37 @@ function hasRunningAssistantExcept(messages, exceptUserMessageId) {
     (m) => roleOf(m) === "assistant" && parentIdOf(m) !== exceptUserMessageId && isAssistantInFlight(m)
   );
 }
+async function hasAnyConfiguredProvider(port) {
+  try {
+    const res = await fetch(`${opencodeBase(port)}/config/providers`);
+    if (!res.ok) {
+      console.error(
+        `[hasAnyConfiguredProvider] GET /config/providers returned HTTP ${res.status} (port ${port})`
+      );
+      return null;
+    }
+    const body = await res.json();
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+      console.error(
+        `[hasAnyConfiguredProvider] GET /config/providers body was not a plain object (port ${port})`
+      );
+      return null;
+    }
+    const defaults2 = body.default;
+    if (!defaults2 || typeof defaults2 !== "object" || Array.isArray(defaults2)) {
+      console.error(
+        `[hasAnyConfiguredProvider] GET /config/providers body had no \`default\` object (port ${port})`
+      );
+      return null;
+    }
+    return Object.keys(defaults2).length > 0;
+  } catch (err) {
+    console.error(
+      `[hasAnyConfiguredProvider] GET /config/providers failed (port ${port}): ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
 
 // src/lib/opencode/session-cleanup.ts
 var DURATION_UNIT_MS = {
@@ -1563,10 +1743,11 @@ var StreamForwarder = class {
    * Abort every in-flight stream (e.g. on WebSocket close).
    */
   abortAll() {
-    for (const stream of this.inflight.values()) {
+    for (const [sid, stream] of this.inflight.entries()) {
       try {
         stream.abort();
-      } catch {
+      } catch (err) {
+        log("error", "forwarder_abort_failed", { sid, ...errorFields(err) });
       }
     }
     this.inflight.clear();
@@ -1600,12 +1781,12 @@ var StreamForwarder = class {
     let endBody;
     if (has_body) {
       const chunks = [];
-      bodyPromise = new Promise((resolve2) => {
+      bodyPromise = new Promise((resolve3) => {
         pushBody = (buf) => {
           chunks.push(buf);
         };
         endBody = () => {
-          resolve2(Buffer.concat(chunks));
+          resolve3(Buffer.concat(chunks));
         };
       });
     }
@@ -1716,31 +1897,20 @@ function connectTunnel(options) {
     onConnected,
     onDisconnected,
     onError,
-    onRequest,
     onResponse,
     onInfo,
     onDrainPing
   } = options;
   const tunnelUrl = getTunnelUrlConfig();
   const url = `${tunnelUrl}/tunnel/${agentId}/connect`;
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const ws = new WebSocket2(url, {
       headers: {
         Authorization: authHeader
       }
     });
-    const streamStartTimes = /* @__PURE__ */ new Map();
     const forwarder = new StreamForwarder(ws, port, {
-      onOpen: (sid, method, path) => {
-        if (path === TUNNEL_DRAIN_PING_PATH) return;
-        streamStartTimes.set(sid, Date.now());
-        onRequest?.(method, path, sid);
-      },
-      onHead: (sid, status) => {
-        const startedAt = streamStartTimes.get(sid);
-        streamStartTimes.delete(sid);
-        onResponse?.(status, startedAt ? Date.now() - startedAt : 0, sid);
-      },
+      onHead: () => onResponse?.(),
       onDrainPing: () => onDrainPing?.()
     });
     const connectionTimeout = setTimeout(() => {
@@ -1788,7 +1958,7 @@ function connectTunnel(options) {
           clearTimeout(connectionTimeout);
           const connectedAgentId = message.agent_id ?? agentId;
           onConnected?.(connectedAgentId);
-          resolve2({
+          resolve3({
             ws,
             close: () => ws.close(1e3, "CLI shutdown")
           });
@@ -1816,7 +1986,6 @@ function connectTunnel(options) {
     ws.on("close", (code, reason) => {
       const reasonStr = reason.toString() || upgradeRejection || (code === 1006 ? "abnormal closure" : "No reason provided");
       forwarder.abortAll();
-      streamStartTimes.clear();
       onDisconnected?.(code, reasonStr);
     });
   });
@@ -1851,7 +2020,11 @@ var RunnerConnection = class {
     if (this.connection) {
       try {
         this.connection.close();
-      } catch {
+      } catch (err) {
+        log("error", "runner_connection_close_failed", {
+          agent_id: this.resolvedAgentId,
+          ...errorFields(err)
+        });
       }
       this.connection = null;
     }
@@ -1903,6 +2076,416 @@ var RunnerConnection = class {
   }
 };
 
+// src/lib/tunnel/ready-marker.ts
+import { writeFileSync } from "fs";
+function writeTunnelReadyMarker(path, agentId) {
+  try {
+    writeFileSync(path, `${agentId}
+`);
+    return { ok: true };
+  } catch (error2) {
+    return { ok: false, error: error2 instanceof Error ? error2.message : String(error2) };
+  }
+}
+
+// src/lib/channels/driver.ts
+import { homedir } from "os";
+
+// src/lib/file-push.ts
+import { randomUUID } from "crypto";
+import { chmod, mkdir, open as open2, realpath, rename, unlink } from "fs/promises";
+import { basename, dirname as dirname2, isAbsolute, join, relative, resolve as resolve2, sep } from "path";
+var FILE_MODE = 384;
+var DIRECTORY_MODE = 448;
+async function writePushedFile(request) {
+  const { requestedPath, content, allowedDirectories, homeDir } = request;
+  const bytes = content.byteLength;
+  if (allowedDirectories.length === 0) {
+    return refuse("file_sync_disabled", "File sync is not enabled on this runner.", {
+      path: requestedPath,
+      bytes
+    });
+  }
+  if (bytes > MAX_FILE_PUSH_BYTES) {
+    return refuse(
+      "file_too_large",
+      `File is ${bytes} bytes; the limit is ${MAX_FILE_PUSH_BYTES}.`,
+      {
+        path: requestedPath,
+        bytes
+      }
+    );
+  }
+  const candidate = expandAndValidate(requestedPath, homeDir);
+  if (candidate === null) {
+    return refuse("invalid_path", "The requested path is not a valid absolute file path.", {
+      path: requestedPath,
+      bytes
+    });
+  }
+  try {
+    const { existingAncestor, missingSegments } = await resolveNearestExistingAncestor(
+      dirname2(candidate)
+    );
+    const realTarget = join(existingAncestor, ...missingSegments, basename(candidate));
+    const allowedDirectory = await findContainingAllowedDirectory(allowedDirectories, realTarget);
+    if (allowedDirectory === null) {
+      return refuse("path_not_allowed", "The runner does not allow writing to that location.", {
+        path: realTarget,
+        bytes
+      });
+    }
+    if (missingSegments.length > 0) {
+      await createMissingDirectories(existingAncestor, missingSegments);
+      const realParent = await realpath(dirname2(realTarget));
+      if (realParent !== dirname2(realTarget) || !contains(allowedDirectory, realTarget)) {
+        return refuse("path_not_allowed", "The runner does not allow writing to that location.", {
+          path: realTarget,
+          bytes,
+          reason: "parent_changed_after_create"
+        });
+      }
+    }
+    await writeAtomically(realTarget, content);
+    log("info", "file_push_written", { path: realTarget, bytes });
+    return { ok: true, path: realTarget };
+  } catch (err) {
+    const errno = err.code ?? "UNKNOWN";
+    return refuse("write_failed", `The runner could not write the file (${errno}).`, {
+      path: candidate,
+      bytes,
+      errno,
+      ...errorFields(err)
+    });
+  }
+}
+function expandAndValidate(requestedPath, homeDir) {
+  if (requestedPath.trim() === "" || requestedPath.includes("\0")) {
+    return null;
+  }
+  const expanded = requestedPath === "~" ? homeDir : requestedPath.startsWith("~/") ? join(homeDir, requestedPath.slice(2)) : requestedPath;
+  if (expanded.split(/[/\\]/).includes("..")) {
+    return null;
+  }
+  if (!isAbsolute(expanded)) {
+    return null;
+  }
+  const candidate = resolve2(expanded);
+  const name = basename(candidate);
+  return name === "" || name === "." || name === ".." ? null : candidate;
+}
+async function resolveNearestExistingAncestor(directory) {
+  const missingSegments = [];
+  let current = directory;
+  for (; ; ) {
+    try {
+      return { existingAncestor: await realpath(current), missingSegments };
+    } catch (err) {
+      const parent = dirname2(current);
+      if (err.code !== "ENOENT" || parent === current) {
+        throw err;
+      }
+      missingSegments.unshift(basename(current));
+      current = parent;
+    }
+  }
+}
+async function findContainingAllowedDirectory(allowedDirectories, realTarget) {
+  for (const directory of allowedDirectories) {
+    if (!isAbsolute(directory)) {
+      log("warn", "file_push_allowed_directory_skipped", { directory, reason: "not_absolute" });
+      continue;
+    }
+    const realDirectory = await realpathCreatingIfMissing(directory);
+    if (realDirectory !== null && contains(realDirectory, realTarget)) {
+      return realDirectory;
+    }
+  }
+  return null;
+}
+async function realpathCreatingIfMissing(directory) {
+  try {
+    return await realpath(directory);
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      log("warn", "file_push_allowed_directory_skipped", {
+        directory,
+        reason: "unresolvable",
+        ...errorFields(err)
+      });
+      return null;
+    }
+  }
+  try {
+    await mkdir(directory, { recursive: true, mode: DIRECTORY_MODE });
+    await chmod(directory, DIRECTORY_MODE);
+    return await realpath(directory);
+  } catch (err) {
+    log("warn", "file_push_allowed_directory_skipped", {
+      directory,
+      reason: "create_failed",
+      ...errorFields(err)
+    });
+    return null;
+  }
+}
+function contains(realDirectory, realTarget) {
+  const rel = relative(realDirectory, realTarget);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+async function createMissingDirectories(existingAncestor, missingSegments) {
+  let current = existingAncestor;
+  for (const segment of missingSegments) {
+    current = join(current, segment);
+    await mkdir(current, { recursive: true, mode: DIRECTORY_MODE });
+    await chmod(current, DIRECTORY_MODE);
+  }
+}
+async function writeAtomically(realTarget, content) {
+  const temporaryPath = join(dirname2(realTarget), `.evident-push-${randomUUID()}.tmp`);
+  let handle;
+  try {
+    handle = await open2(temporaryPath, "wx", FILE_MODE);
+    await handle.writeFile(content);
+    await handle.chmod(FILE_MODE);
+    await handle.close();
+    handle = void 0;
+    await rename(temporaryPath, realTarget);
+  } catch (err) {
+    await discardTemporaryFile(temporaryPath, handle);
+    throw err;
+  }
+}
+async function discardTemporaryFile(temporaryPath, handle) {
+  try {
+    await handle?.close();
+  } catch (err) {
+    log("warn", "file_push_temp_close_failed", { path: temporaryPath, ...errorFields(err) });
+  }
+  try {
+    await unlink(temporaryPath);
+  } catch (err) {
+    const errno = err.code;
+    if (errno !== "ENOENT" && errno !== "ENOTDIR") {
+      log("warn", "file_push_temp_cleanup_failed", { path: temporaryPath, ...errorFields(err) });
+    }
+  }
+}
+function refuse(code, message, fields) {
+  log(code === "write_failed" ? "error" : "warn", "file_push_refused", { code, ...fields });
+  return { ok: false, code, message };
+}
+
+// src/lib/runner-file-sync.ts
+var MAX_ACK_ATTEMPTS = 5;
+async function syncPendingRunnerFiles(options) {
+  const pending = await listPendingFiles(options);
+  const pendingIds = new Set(pending.map((file) => file.id));
+  for (const id of options.ackFailures.keys()) {
+    if (!pendingIds.has(id)) options.ackFailures.delete(id);
+  }
+  if (pending.length === 0) return 0;
+  options.log({
+    level: "info",
+    message: `Runner file sync: ${pending.length} file(s) queued for this runner`
+  });
+  let applied = 0;
+  for (const file of pending) {
+    if ((options.ackFailures.get(file.id) ?? 0) >= MAX_ACK_ATTEMPTS) continue;
+    if (await applyOne(options, file)) applied += 1;
+  }
+  return applied;
+}
+async function listPendingFiles(options) {
+  let res;
+  try {
+    res = await options.fetchImpl(`${options.apiUrl}/runners/${options.agentId}/files/pending`, {
+      headers: { Authorization: options.getAuthHeader() }
+    });
+  } catch (err) {
+    options.log({
+      level: "warn",
+      message: `Could not list pending runner files \u2014 retrying on the next drain: ${describe(err)}`
+    });
+    return [];
+  }
+  if (!res.ok) {
+    options.log({
+      level: res.status === 404 ? "debug" : "warn",
+      message: `Listing pending runner files returned HTTP ${res.status} \u2014 retrying on the next drain`
+    });
+    return [];
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch (err) {
+    options.log({
+      level: "warn",
+      message: `Pending runner file list was not readable JSON \u2014 retrying on the next drain: ${describe(err)}`
+    });
+    return [];
+  }
+  if (!Array.isArray(body)) {
+    options.log({
+      level: "warn",
+      message: "Pending runner file list was not an array \u2014 ignoring it for this drain"
+    });
+    return [];
+  }
+  const files = [];
+  for (const entry of body) {
+    const file = asPendingFile(entry);
+    if (file === null) {
+      options.log({
+        level: "warn",
+        message: "Ignoring a malformed pending runner file entry (expected id, path and size)"
+      });
+      continue;
+    }
+    files.push(file);
+  }
+  return files;
+}
+function asPendingFile(entry) {
+  if (entry === null || typeof entry !== "object") return null;
+  const { id, path, size } = entry;
+  if (typeof id !== "string" || id === "") return null;
+  if (typeof path !== "string" || path === "") return null;
+  if (typeof size !== "number" || !Number.isFinite(size) || size < 0) return null;
+  return { id, path, size };
+}
+async function applyOne(options, file) {
+  const label = `${file.id.slice(0, 8)} (${file.path})`;
+  if (options.allowedDirectories.length === 0) {
+    options.log({
+      level: "warn",
+      message: `Runner file ${label} rejected: file sync is not enabled on this runner (start it with --enable-file-sync-to)`
+    });
+    await ack(options, file, "rejected", "file_sync_disabled");
+    return false;
+  }
+  if (file.size > MAX_FILE_PUSH_BYTES) {
+    options.log({
+      level: "warn",
+      message: `Runner file ${label} rejected: declared ${file.size} bytes, the limit is ${MAX_FILE_PUSH_BYTES}`
+    });
+    await ack(options, file, "rejected", "file_too_large");
+    return false;
+  }
+  const download = await downloadContent(options, file, label);
+  if (!download.ok) {
+    if (download.terminal) await ack(options, file, "rejected", download.code);
+    return false;
+  }
+  let outcome;
+  try {
+    outcome = await writePushedFile({
+      requestedPath: file.path,
+      content: download.content,
+      allowedDirectories: options.allowedDirectories,
+      homeDir: options.homeDir
+    });
+  } catch (err) {
+    options.log({
+      level: "error",
+      message: `Runner file ${label} could not be written: ${describe(err)}`
+    });
+    await ack(options, file, "rejected", "write_failed");
+    return false;
+  }
+  if (!outcome.ok) {
+    options.log({
+      level: "warn",
+      message: `Runner file ${label} rejected (${outcome.code}): ${outcome.message}`
+    });
+    await ack(options, file, "rejected", outcome.code);
+    return false;
+  }
+  options.log({
+    level: "info",
+    message: `Runner file ${label} applied (${download.content.byteLength} bytes)`
+  });
+  await ack(options, file, "applied");
+  return true;
+}
+function durableDownloadCode(status) {
+  return status === 413 ? "file_too_large" : "write_failed";
+}
+async function downloadContent(options, file, label) {
+  try {
+    const res = await options.fetchImpl(
+      `${options.apiUrl}/runners/${options.agentId}/files/${file.id}/content`,
+      { headers: { Authorization: options.getAuthHeader() } }
+    );
+    if (!res.ok) {
+      const terminal = res.status >= 400 && res.status < 500 && res.status !== 401 && res.status !== 403 && res.status !== 408 && res.status !== 429;
+      if (!terminal) {
+        options.log({
+          level: "warn",
+          message: `Downloading runner file ${label} returned HTTP ${res.status} \u2014 retrying on the next drain`
+        });
+        return { ok: false, terminal: false };
+      }
+      const code = durableDownloadCode(res.status);
+      options.log({
+        level: "error",
+        message: `Downloading runner file ${label} returned HTTP ${res.status} \u2014 rejecting it as ${code} (the bytes never reached the writer)`
+      });
+      return { ok: false, terminal: true, code };
+    }
+    return { ok: true, content: Buffer.from(await res.arrayBuffer()) };
+  } catch (err) {
+    options.log({
+      level: "warn",
+      message: `Downloading runner file ${label} failed \u2014 retrying on the next drain: ${describe(err)}`
+    });
+    return { ok: false, terminal: false };
+  }
+}
+async function ack(options, file, status, reason) {
+  const outcome = `${status}${reason ? ` (${reason})` : ""}`;
+  try {
+    const res = await options.fetchImpl(
+      `${options.apiUrl}/runners/${options.agentId}/files/${file.id}/ack`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: options.getAuthHeader(),
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(reason ? { status, reason } : { status })
+      }
+    );
+    if (!res.ok) {
+      recordAckFailure(
+        options,
+        file,
+        `Acking runner file ${file.id.slice(0, 8)} as ${outcome} returned HTTP ${res.status}`
+      );
+      return;
+    }
+    options.ackFailures.delete(file.id);
+  } catch (err) {
+    recordAckFailure(
+      options,
+      file,
+      `Acking runner file ${file.id.slice(0, 8)} as ${outcome} failed: ${describe(err)}`
+    );
+  }
+}
+function recordAckFailure(options, file, what) {
+  const attempts = (options.ackFailures.get(file.id) ?? 0) + 1;
+  options.ackFailures.set(file.id, attempts);
+  options.log({
+    level: "error",
+    message: attempts >= MAX_ACK_ATTEMPTS ? `${what} \u2014 giving up after ${attempts} attempts. It stays pending until the server expires it; restart the runner to retry.` : `${what} \u2014 it stays pending until a later drain re-acks it (attempt ${attempts} of ${MAX_ACK_ATTEMPTS})`
+  });
+}
+function describe(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
 // src/lib/channels/driver.ts
 function messageIdOf(m) {
   if (!m || typeof m !== "object") return void 0;
@@ -1931,7 +2514,10 @@ var DEFAULT_PAUSED_MAX_WAIT_MS = 10 * 60 * 1e3;
 var DEFAULT_STUCK_QUEUED_MS = 6e4;
 var HEARTBEAT_MS = 6e4;
 var ABSOLUTE_MAX_PROCESSING_MS = 6 * 60 * 60 * 1e3;
+var B2_ABANDONMENT_MIN_PINNED_MS = 3 * 6e4;
+var B2_ABANDONMENT_RECHECK_MS = HEARTBEAT_MS;
 var POLL_MISS_GRACE_MS = HEARTBEAT_MS;
+var MAX_SUPERSEDED_CONVERSATIONS = 256;
 var ChannelAuthError = class extends Error {
   constructor(message) {
     super(message);
@@ -1954,7 +2540,7 @@ function backoffDelay(attempt, policy) {
 function isRetryableStatus(status) {
   return status === 429 || status >= 500 && status <= 599;
 }
-var ChannelDriver = class {
+var ChannelDriver = class _ChannelDriver {
   agentId;
   port;
   apiUrl;
@@ -1968,8 +2554,38 @@ var ChannelDriver = class {
   pausedMaxWaitMs;
   stuckQueuedMs;
   now;
+  fileSyncDirectories;
+  homeDir;
   /** Cache of conversationId → opencode sessionId. */
   sessions = /* @__PURE__ */ new Map();
+  /**
+   * conversationId → the opencode session this runner has ABANDONED as that
+   * conversation's binding (#553), after a genuine (`sessionExists === true`)
+   * dispatch failure: the session still exists but is wedged, so #485's self-heal
+   * must bind a fresh one.
+   *
+   * Dropping the local binding + clearing the server row is not enough on its own:
+   * a SIBLING message dispatched earlier in the same drain is still in-flight under
+   * the same session, and its watcher's routine status writes carry
+   * `opencode_session_id`, RESURRECTING the wedged id server-side after the clear —
+   * and `ensureSession`'s persisted-id fallback then reuses it, defeating the
+   * self-heal. This map makes the runner authoritative instead of racing those
+   * writes: *`ensureSession` never reuses an abandoned id for that conversation,
+   * whatever the server row says* — which holds even when the resurrecting write
+   * is one we deliberately keep (see `markDone`).
+   *
+   * Bounded by construction, on both axes: keyed by CONVERSATION, so N failures on
+   * one conversation hold ONE entry (the newest abandonment replaces the older), and
+   * hard-capped at `MAX_SUPERSEDED_CONVERSATIONS` with FIFO eviction. Only the
+   * NEWEST abandoned id per conversation is guarded: after a second abandonment a
+   * late sibling of the FIRST session can write that id back and `ensureSession`
+   * will reuse it — costing ONE repeat failure, which re-supersedes it. Deliberately
+   * NOT dropped when the session's watcher tears down: `markDone` still writes the
+   * abandoned id back (it must, or the reply is lost), so the guard has to outlive
+   * the turn that resurrects it. In-memory only — a restart forgets it, at the same
+   * bounded cost.
+   */
+  supersededSessions = /* @__PURE__ */ new Map();
   /**
    * Per-opencode-session dispatch lock (Task 2.1a). `sendPromptAsync` is no
    * longer idempotent (no caller-supplied `messageID`), and its read-back picks
@@ -2079,9 +2695,12 @@ var ChannelDriver = class {
   sessionParents = /* @__PURE__ */ new Map();
   /**
    * Per-session OpenCode title cache (#310), keyed by sessionId. Only a resolved
-   * NON-EMPTY name is stored (terminal — a real session name won't later un-name),
-   * so we do NOT re-GET `/session/:id` every tick. A missing entry = not yet
-   * resolved OR resolved-but-still-empty → re-fetch on next need, since OpenCode
+   * NON-EMPTY, non-placeholder name is stored (terminal — a real session name
+   * won't later un-name), so we do NOT re-GET `/session/:id` every tick. "Non-empty"
+   * excludes OpenCode's synchronous default title (see
+   * `OPENCODE_DEFAULT_TITLE_PREFIX`, #549) — that placeholder is treated the same
+   * as an empty title so it never latches. A missing entry = not yet resolved OR
+   * resolved-but-still-empty/placeholder → re-fetch on next need, since OpenCode
    * names sessions asynchronously mid-turn. Driver-level (not per-watcher) so both
    * the watcher completion path AND the restart-recovery re-adopt path (which has
    * no watcher) can resolve the title.
@@ -2089,6 +2708,24 @@ var ChannelDriver = class {
   sessionTitles = /* @__PURE__ */ new Map();
   /** Serialises drains so a reconnect during a drain doesn't double-process. */
   draining = false;
+  /**
+   * Serialises runner-file syncs (#559) so the ~2s poll tick and a concurrent
+   * drain ping don't download, write and ack the same file twice.
+   */
+  syncingFiles = false;
+  /**
+   * Consecutive failed acks per pending file (#559). Lives on the driver so it
+   * survives across drains — without it, a file whose ack keeps failing is
+   * re-downloaded and re-written every ~2s until the server expires it.
+   */
+  fileAckFailures = /* @__PURE__ */ new Map();
+  /**
+   * Monotonic count of files this runner has pulled and written (#559). Only
+   * ever increases, so `run.ts` detects work by comparing it against the value
+   * it saw on the previous cycle — including work that landed mid-sleep, the
+   * same trick `lastProxiedActivityAt` uses.
+   */
+  appliedFileCount = 0;
   /**
    * The currently-executing `drainPending()` promise, or null when idle. Lets a
    * graceful shutdown (`waitForInFlight`) await an in-progress drain so a turn it
@@ -2119,6 +2756,8 @@ var ChannelDriver = class {
     this.pausedMaxWaitMs = config2.pausedMaxWaitMs ?? DEFAULT_PAUSED_MAX_WAIT_MS;
     this.stuckQueuedMs = config2.stuckQueuedMs ?? DEFAULT_STUCK_QUEUED_MS;
     this.now = config2.now ?? (() => Date.now());
+    this.fileSyncDirectories = config2.fileSyncDirectories ?? [];
+    this.homeDir = config2.homeDir ?? homedir();
   }
   /** The IPv4-loopback base URL for the local `opencode serve`. */
   get opencodeBase() {
@@ -2146,6 +2785,47 @@ var ChannelDriver = class {
     );
     return run2;
   }
+  /**
+   * Pull-and-apply any files Evident has queued for this runner (#559), riding
+   * the EXISTING drain cycle — `run.ts` calls it from the same ~2s channel poll
+   * and drain ping that call `drainPending()`. There is deliberately no channel,
+   * control frame or poll loop of its own: worst-case latency is one poll tick.
+   *
+   * NEVER throws and never surfaces a `ChannelAuthError`: a file failure must not
+   * cost a conversation turn. Failures are logged and either acked as a terminal
+   * outcome or left pending for the next drain (see `runner-file-sync.ts`).
+   *
+   * Re-entrant calls are skipped (the poll tick and a drain ping can overlap).
+   *
+   * @returns the number of files written to disk.
+   */
+  async syncPendingFiles() {
+    if (this.stopped) return 0;
+    if (this.syncingFiles) return 0;
+    this.syncingFiles = true;
+    try {
+      const applied = await syncPendingRunnerFiles({
+        agentId: this.agentId,
+        apiUrl: this.apiUrl,
+        getAuthHeader: this.getAuthHeader,
+        fetchImpl: this.fetchImpl,
+        allowedDirectories: this.fileSyncDirectories,
+        homeDir: this.homeDir,
+        ackFailures: this.fileAckFailures,
+        log: this.log
+      });
+      this.appliedFileCount += applied;
+      return applied;
+    } catch (err) {
+      this.log({
+        level: "error",
+        message: `Runner file sync failed unexpectedly (message processing is unaffected): ${err instanceof Error ? err.message : String(err)}`
+      });
+      return 0;
+    } finally {
+      this.syncingFiles = false;
+    }
+  }
   async runDrain() {
     let dispatched = 0;
     try {
@@ -2179,6 +2859,28 @@ var ChannelDriver = class {
     }
     return false;
   }
+  /**
+   * File-pull work, for `run.ts`'s idle accounting (#559).
+   *
+   * Pulling a file is real work that `drainPending()` knows nothing about, so
+   * without this a near-idle runner counts a credential pull as an empty tick
+   * and `--idle-timeout` can `process.exit` mid-pull — leaving a
+   * `.evident-push-*.tmp` behind — or immediately after the write, before the
+   * browser has run the authorize/callback that activates it (the user then sees
+   * `saved_not_activated` for a runner that was fine).
+   *
+   * Two signals because one cannot cover both cases: `inFlight` is the pull
+   * happening RIGHT NOW (it may outlive the tick that started it), and
+   * `appliedFiles` is monotonic so a pull that started AND finished between two
+   * idle checks still shows up as an advance.
+   *
+   * CALLER CONTRACT: sample `inFlight` BEFORE calling `syncPendingFiles()` for
+   * the cycle. `syncPendingFiles` sets the flag synchronously, so a caller that
+   * samples afterwards reads `true` every single cycle and can never idle out.
+   */
+  fileSyncActivity() {
+    return { appliedFiles: this.appliedFileCount, inFlight: this.syncingFiles };
+  }
   /**
    * OpenCode session ids the session-cleanup sweep (issue #190) must NOT delete:
    * exactly those with a live (dispatched-but-not-done / paused) turn, i.e. a
@@ -2240,7 +2942,7 @@ var ChannelDriver = class {
         await this.sleep(step);
       }
     }
-    while (this.hasInFlightWatchers()) {
+    while (this.hasInFlightWatchers() || this.syncingFiles) {
       if (this.now() >= deadline) return false;
       await this.sleep(step);
     }
@@ -2275,10 +2977,15 @@ var ChannelDriver = class {
    * @returns the count of messages NEWLY dispatched (not already in-flight).
    */
   async processConversation(conv) {
-    const sessionId = await this.ensureSession(conv);
+    const { sessionId, refusedSessionId } = await this.ensureSession(conv);
     const messages = await this.getPendingMessages(conv.id);
     let dispatched = 0;
     let skippedAlreadyDispatched = 0;
+    if (refusedSessionId && messages.length > 0) {
+      void this.postSignal(conv.id, messages[0].id, "session_superseded", {
+        superseded_session_id: refusedSessionId
+      });
+    }
     for (const message of messages) {
       if (this.stopped) break;
       if (this.dispatched.has(message.id)) {
@@ -2305,7 +3012,8 @@ var ChannelDriver = class {
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         this.dispatched.delete(message.id);
-        if (await sessionExists(this.port, sessionId) === false) {
+        const exists = await sessionExists(this.port, sessionId);
+        if (exists === false) {
           this.sessions.delete(conv.id);
           this.log({
             level: "warn",
@@ -2315,15 +3023,39 @@ var ChannelDriver = class {
           });
           break;
         }
-        await this.markFailed(conv.id, message.id).catch(() => {
+        if (exists === null) {
+          this.log({
+            level: "warn",
+            message: `Message ${message.id.slice(0, 8)} dispatch failed and session (${sessionId.slice(0, 8)}) existence could not be confirmed (opencode momentarily unreachable) \u2014 deferring this and later messages for conversation ${conv.id.slice(0, 8)} to the next tick rather than treating it as a genuine failure.`,
+            conversation_id: conv.id,
+            message_id: message.id
+          });
+          break;
+        }
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        this.sessions.delete(conv.id);
+        this.supersede(conv.id, sessionId);
+        this.log({
+          level: "warn",
+          message: `Abandoning OpenCode session ${sessionId.slice(0, 8)} as the binding for conversation ${conv.id.slice(0, 8)} (it exists but failed to run a turn) \u2014 a fresh session is created on the next tick, whatever the persisted binding says by then.`,
+          conversation_id: conv.id,
+          message_id: message.id
+        });
+        await this.markFailed(conv.id, message.id, null, errorMessage).catch((markErr) => {
+          this.log({
+            level: "warn",
+            message: `markFailed PATCH for message ${message.id.slice(0, 8)} (conversation ${conv.id.slice(0, 8)}) failed (best-effort, not retried): ${markErr instanceof Error ? markErr.message : String(markErr)}`,
+            conversation_id: conv.id,
+            message_id: message.id
+          });
         });
         this.log({
           level: "error",
-          message: `Message ${message.id.slice(0, 8)} dispatch failed: ${err instanceof Error ? err.message : String(err)}`,
+          message: `Message ${message.id.slice(0, 8)} dispatch failed: ${errorMessage}`,
           conversation_id: conv.id,
           message_id: message.id
         });
-        continue;
+        break;
       }
       if (opencodeMessageId === null) {
         this.log({
@@ -2342,15 +3074,49 @@ var ChannelDriver = class {
     if (messages.length > 0 && dispatched === 0 && skippedAlreadyDispatched === messages.length) {
       this.log({
         level: "warn",
-        message: `Conversation ${conv.id.slice(0, 8)} has ${messages.length} pending message(s) but ALL are already marked dispatched locally (in-flight set: ${this.dispatched.size}) \u2014 none sent to OpenCode this tick. If this repeats, a message may be stuck acknowledged-but-never-dispatched (its watcher never settled).`,
+        message: `Conversation ${conv.id.slice(0, 8)} has ${messages.length} pending message(s) but ALL are already marked dispatched locally (in-flight set: ${this.dispatched.size}) \u2014 none sent to OpenCode this tick. If this repeats, a message may be stuck acknowledged-but-never-dispatched (its watcher never settled).`,
+        conversation_id: conv.id
+      });
+    }
+    this.ensureWatcherRunning(sessionId);
+    return dispatched;
+  }
+  /**
+   * Record that `sessionId` is no longer a valid binding for `conversationId`
+   * (#553). Keyed by conversation and hard-capped, so it cannot grow with the
+   * number of failures — see the `supersededSessions` field doc.
+   */
+  supersede(conversationId, sessionId) {
+    this.supersededSessions.delete(conversationId);
+    this.supersededSessions.set(conversationId, sessionId);
+    while (this.supersededSessions.size > MAX_SUPERSEDED_CONVERSATIONS) {
+      const oldest = this.supersededSessions.keys().next().value;
+      if (oldest === void 0) return;
+      this.supersededSessions.delete(oldest);
+    }
+  }
+  /** Whether `sessionId` is the session this conversation has abandoned (#553). */
+  isSuperseded(conversationId, sessionId) {
+    return this.supersededSessions.get(conversationId) === sessionId;
+  }
+  /**
+   * Resolve the opencode session to run this conversation's turns in.
+   *
+   * `refusedSessionId` is set when the #553 guard fired — i.e. the persisted
+   * binding was an id this runner had abandoned, so a resurrection genuinely
+   * happened and a fresh session was bound instead. The caller reports it.
+   */
+  async ensureSession(conv) {
+    const bound = this.sessions.get(conv.id) ?? conv.opencode_session_id ?? null;
+    if (bound && this.isSuperseded(conv.id, bound)) {
+      this.log({
+        level: "warn",
+        message: `OpenCode session ${bound.slice(0, 8)} was abandoned for conversation ${conv.id.slice(0, 8)} after a failed dispatch but is still bound to it (the persisted id was written back by a turn already in flight) \u2014 ignoring it and binding a fresh session.`,
         conversation_id: conv.id
       });
+      this.sessions.delete(conv.id);
+      return { sessionId: await this.createAndBindSession(conv.id), refusedSessionId: bound };
     }
-    this.ensureWatcherRunning(sessionId);
-    return dispatched;
-  }
-  async ensureSession(conv) {
-    const bound = this.sessions.get(conv.id) ?? conv.opencode_session_id ?? null;
     if (bound) {
       const exists = await sessionExists(this.port, bound);
       if (exists === false) {
@@ -2360,12 +3126,12 @@ var ChannelDriver = class {
           conversation_id: conv.id
         });
         this.sessions.delete(conv.id);
-        return this.createAndBindSession(conv.id);
+        return { sessionId: await this.createAndBindSession(conv.id) };
       }
       this.sessions.set(conv.id, bound);
-      return bound;
+      return { sessionId: bound };
     }
-    return this.createAndBindSession(conv.id);
+    return { sessionId: await this.createAndBindSession(conv.id) };
   }
   /**
    * Create a fresh OpenCode session for a conversation, cache the binding, and
@@ -2445,7 +3211,7 @@ var ChannelDriver = class {
   }
   /**
    * Fetch ONE inbound image's bytes through Evident's WI-6 endpoint
-   * (`GET {apiUrl}/agents/{agentId}/attachments/{messageId}/{index}`) using the
+   * (`GET {apiUrl}/runners/{agentId}/attachments/{messageId}/{index}`) using the
    * existing authenticated fetch, and base64-encode into a
    * `data:<mime>;base64,<…>` URL for the opencode `file` part's `url`.
    *
@@ -2453,15 +3219,38 @@ var ChannelDriver = class {
    * (not-owned / out-of-range / deleted-at-source / workspace gone) / 413
    * (over-cap). On ANY non-2xx or thrown failure we return `null` so the caller
    * OMITS that one image and the text turn still sends — NEVER throws the turn.
-   * Failures are logged with context (no silent swallow).
+   * A 404 body carrying `{ reason: 'needs_reauth' }` (#547 — the server CONFIRMED
+   * a Slack `files:read` scope problem via `files.info`) instead resolves the
+   * `AttachmentFetchNeedsReauth` sentinel, so the in-thread note can steer the
+   * user to reconnect Slack instead of a generic "unavailable". Failures are
+   * logged with context (no silent swallow).
    */
   async fetchAttachmentDataUrl(messageId, index, mime) {
     try {
       const res = await this.fetchImpl(
-        `${this.apiUrl}/agents/${this.agentId}/attachments/${messageId}/${index}`,
+        `${this.apiUrl}/runners/${this.agentId}/attachments/${messageId}/${index}`,
         { headers: { Authorization: this.getAuthHeader() } }
       );
       if (!res.ok) {
+        let reason;
+        try {
+          const body = await res.json();
+          if (body && typeof body.reason === "string") reason = body.reason;
+        } catch (parseErr) {
+          this.log({
+            level: "debug",
+            message: `Attachment fetch for message ${messageId.slice(0, 8)} index ${index}: error body was not JSON (${parseErr instanceof Error ? parseErr.message : String(parseErr)}) \u2014 treating as a plain failure`,
+            message_id: messageId
+          });
+        }
+        if (reason === "needs_reauth") {
+          this.log({
+            level: "error",
+            message: `Attachment fetch for message ${messageId.slice(0, 8)} index ${index} returned HTTP ${res.status} \u2014 server confirmed a Slack reauth/scope problem \u2014 omitting this image (text turn proceeds)`,
+            message_id: messageId
+          });
+          return { needsReauth: true };
+        }
         this.log({
           level: "error",
           message: `Attachment fetch for message ${messageId.slice(0, 8)} index ${index} returned HTTP ${res.status} \u2014 omitting this image (text turn proceeds)`,
@@ -2501,6 +3290,9 @@ var ChannelDriver = class {
     if (this.attachmentsSkippedSignalled.has(messageId)) return;
     this.attachmentsSkippedSignalled.add(messageId);
     const skippedReason = capabilityUnknown ? "unknown" : "unsupported";
+    const failedReason = outcomes.some(
+      (o) => o.status === "failed" && o.reason === "needs_reauth"
+    ) ? "needs_reauth" : void 0;
     this.log({
       level: "info",
       message: `Message ${messageId.slice(0, 8)}: ${skipped} image(s) skipped (${capabilityUnknown ? "capability was unreadable \u2014 failed open to text-only" : "model not attachment-capable"}), ${failed} image(s) unavailable (deleted-at-source or fetch failure) \u2014 noting to Evident`,
@@ -2510,7 +3302,8 @@ var ChannelDriver = class {
     void this.postSignal(conversationId, messageId, "attachments_skipped", {
       skipped,
       failed,
-      ...skipped > 0 ? { skipped_reason: skippedReason } : {}
+      ...skipped > 0 ? { skipped_reason: skippedReason } : {},
+      ...failedReason ? { failed_reason: failedReason } : {}
     });
   }
   /** Register a freshly-dispatched message with its session's watcher state. */
@@ -2541,12 +3334,17 @@ var ChannelDriver = class {
       stuckReported: false,
       lastAliveAt: 0,
       aliveInFlight: false,
+      titleSynced: false,
+      titleSyncInFlight: false,
       awaitingHumanLatched: false,
       pausedOnQuestion: false,
       pausedOnPermission: false,
       pausedClearConfirmed: false,
       pausedInFlight: false,
-      deliveryDeadlineAnchored: false
+      deliveryDeadlineAnchored: false,
+      b2PinnedSinceMs: 0,
+      b2LastDescendantCheckMs: 0,
+      b2AbandonedSignalled: false
     });
   }
   /**
@@ -2614,12 +3412,17 @@ var ChannelDriver = class {
       // with no extra `re_adopted` signal needed (folds old WI-6).
       lastAliveAt: 0,
       aliveInFlight: false,
+      titleSynced: false,
+      titleSyncInFlight: false,
       awaitingHumanLatched: false,
       pausedOnQuestion: false,
       pausedOnPermission: false,
       pausedClearConfirmed: false,
       pausedInFlight: false,
-      deliveryDeadlineAnchored: false
+      deliveryDeadlineAnchored: false,
+      b2PinnedSinceMs: 0,
+      b2LastDescendantCheckMs: 0,
+      b2AbandonedSignalled: false
     });
   }
   /**
@@ -2781,56 +3584,7 @@ var ChannelDriver = class {
       }
     }
     if (state === "done") {
-      this.anchorDeliveryDeadline(inFlight);
-      if (!inFlight.done) {
-        this.log({
-          level: "info",
-          message: `Message ${inFlight.evidentMessageId.slice(0, 8)} completed \u2014 marking done`,
-          conversation_id: conv.id,
-          message_id: inFlight.evidentMessageId
-        });
-        const title = await this.resolveSessionTitle(sessionId, watcher.conv.id);
-        try {
-          await this.markDone(
-            conv.id,
-            inFlight.evidentMessageId,
-            sessionId,
-            inFlight.opencodeMessageId,
-            title
-          );
-        } catch (err) {
-          if (err instanceof ChannelAuthError) throw err;
-          if (err instanceof ChannelTerminalError) {
-            this.log({
-              level: "warn",
-              message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done (terminal HTTP ${err.status}) \u2014 leaving for the cron safety net: ${err.message}`,
-              conversation_id: conv.id,
-              message_id: inFlight.evidentMessageId
-            });
-            this.removeInFlight(watcher, inFlight.evidentMessageId);
-            return;
-          }
-          if (this.now() >= inFlight.deadline) {
-            this.log({
-              level: "warn",
-              message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done within the watch window \u2014 leaving for the cron safety net: ${err instanceof Error ? err.message : String(err)}`,
-              conversation_id: conv.id,
-              message_id: inFlight.evidentMessageId
-            });
-            this.removeInFlight(watcher, inFlight.evidentMessageId);
-            return;
-          }
-          this.log({
-            level: "warn",
-            message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done (will retry next tick): ${err instanceof Error ? err.message : String(err)}`,
-            conversation_id: conv.id,
-            message_id: inFlight.evidentMessageId
-          });
-          return;
-        }
-        inFlight.done = true;
-      }
-      this.removeInFlight(watcher, inFlight.evidentMessageId);
+      await this.settleMessageDone(sessionId, watcher, inFlight, messages);
       return;
     }
     if (state === "failed") {
@@ -2843,8 +3597,9 @@ var ChannelDriver = class {
           conversation_id: conv.id,
           message_id: inFlight.evidentMessageId
         });
+        const usage = messageUsage(messages, inFlight.opencodeMessageId);
         try {
-          await this.markFailed(conv.id, inFlight.evidentMessageId, sessionId, error2);
+          await this.markFailed(conv.id, inFlight.evidentMessageId, sessionId, error2, usage);
         } catch (err) {
           if (err instanceof ChannelAuthError) throw err;
           if (err instanceof ChannelTerminalError) {
@@ -2889,6 +3644,44 @@ var ChannelDriver = class {
       });
     }
     const activelyRunning = state === "running" && !awaitingHuman;
+    const pinnedNow = activelyRunning && isPreamblePinnedRunning(messages, inFlight.opencodeMessageId);
+    const snapshotReadable = messages != null && messages.length > 0;
+    if (!pinnedNow) {
+      if (snapshotReadable) {
+        inFlight.b2PinnedSinceMs = 0;
+        inFlight.b2LastDescendantCheckMs = 0;
+        inFlight.b2AbandonedSignalled = false;
+      }
+    } else {
+      if (inFlight.b2AbandonedSignalled) {
+        await this.settleMessageDone(sessionId, watcher, inFlight, messages);
+        return;
+      }
+      if (inFlight.b2PinnedSinceMs === 0) inFlight.b2PinnedSinceMs = this.now();
+      const pinnedForMs = this.now() - inFlight.b2PinnedSinceMs;
+      if (pinnedForMs >= B2_ABANDONMENT_MIN_PINNED_MS && this.now() - inFlight.b2LastDescendantCheckMs >= B2_ABANDONMENT_RECHECK_MS) {
+        inFlight.b2LastDescendantCheckMs = this.now();
+        const descendantOngoing = await this.isAnyDescendantSessionOngoing(sessionId);
+        if (isB2AbandonmentConfirmed({
+          pinnedForMs,
+          minPinnedMs: B2_ABANDONMENT_MIN_PINNED_MS,
+          descendantOngoing
+        })) {
+          inFlight.b2AbandonedSignalled = true;
+          this.log({
+            level: "warn",
+            message: `Message ${id.slice(0, 8)} b2-pinned for ${Math.round(pinnedForMs / 1e3)}s with no ongoing descendant sub-agent session (status-map confirmed) \u2014 treating the delegated/tool turn as abandoned, resolving done`,
+            conversation_id: conv.id,
+            message_id: id
+          });
+          void this.postSignal(conv.id, id, "b2_abandoned_resolved", {
+            watched_for_ms: pinnedForMs
+          });
+          await this.settleMessageDone(sessionId, watcher, inFlight, messages);
+          return;
+        }
+      }
+    }
     if (activelyRunning && this.now() - inFlight.processingAnchorMs >= ABSOLUTE_MAX_PROCESSING_MS) {
       this.log({
         level: "warn",
@@ -2908,6 +3701,18 @@ var ChannelDriver = class {
         inFlight.aliveInFlight = false;
         if (ok) inFlight.lastAliveAt = this.now();
       });
+      if (!inFlight.titleSynced && !inFlight.titleSyncInFlight) {
+        inFlight.titleSyncInFlight = true;
+        void this.resolveSessionTitle(sessionId, conv.id).then(async (title) => {
+          if (!title) {
+            inFlight.titleSyncInFlight = false;
+            return;
+          }
+          const ok = await this.patchConversationTitle(conv.id, title);
+          inFlight.titleSyncInFlight = false;
+          if (ok) inFlight.titleSynced = true;
+        });
+      }
     }
     if (awaitingHuman) {
       if (!inFlight.awaitingHumanLatched) {
@@ -2945,6 +3750,70 @@ var ChannelDriver = class {
       this.removeInFlight(watcher, inFlight.evidentMessageId);
     }
   }
+  /**
+   * Settle a message whose run-state has resolved `'done'` — extracted verbatim
+   * (pure refactor, no behavior change) from `serviceInFlightMessage`'s former
+   * inline `state === 'done'` branch body, so a SECOND caller (the #721
+   * b2-abandonment resolution) can reach the exact same completion behavior
+   * (delivery-deadline anchoring, title resolution, usage extraction, and
+   * `markDone`'s auth/terminal/transient-retry discipline) without duplicating it
+   * and risking the two copies silently drifting apart.
+   */
+  async settleMessageDone(sessionId, watcher, inFlight, messages) {
+    const conv = watcher.conv;
+    this.anchorDeliveryDeadline(inFlight);
+    if (!inFlight.done) {
+      this.log({
+        level: "info",
+        message: `Message ${inFlight.evidentMessageId.slice(0, 8)} completed \u2014 marking done`,
+        conversation_id: conv.id,
+        message_id: inFlight.evidentMessageId
+      });
+      const title = await this.resolveSessionTitle(sessionId, watcher.conv.id);
+      const usage = messageUsage(messages, inFlight.opencodeMessageId);
+      try {
+        await this.markDone(
+          conv.id,
+          inFlight.evidentMessageId,
+          sessionId,
+          inFlight.opencodeMessageId,
+          title,
+          usage
+        );
+      } catch (err) {
+        if (err instanceof ChannelAuthError) throw err;
+        if (err instanceof ChannelTerminalError) {
+          this.log({
+            level: "warn",
+            message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done (terminal HTTP ${err.status}) \u2014 leaving for the cron safety net: ${err.message}`,
+            conversation_id: conv.id,
+            message_id: inFlight.evidentMessageId
+          });
+          this.removeInFlight(watcher, inFlight.evidentMessageId);
+          return;
+        }
+        if (this.now() >= inFlight.deadline) {
+          this.log({
+            level: "warn",
+            message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done within the watch window \u2014 leaving for the cron safety net: ${err instanceof Error ? err.message : String(err)}`,
+            conversation_id: conv.id,
+            message_id: inFlight.evidentMessageId
+          });
+          this.removeInFlight(watcher, inFlight.evidentMessageId);
+          return;
+        }
+        this.log({
+          level: "warn",
+          message: `Failed to mark message ${inFlight.evidentMessageId.slice(0, 8)} done (will retry next tick): ${err instanceof Error ? err.message : String(err)}`,
+          conversation_id: conv.id,
+          message_id: inFlight.evidentMessageId
+        });
+        return;
+      }
+      inFlight.done = true;
+    }
+    this.removeInFlight(watcher, inFlight.evidentMessageId);
+  }
   // Restart recovery: re-adopt `processing` messages (ADR-0046, WI-3/4/5)
   /**
    * Re-adopt this agent's `processing` messages on drain (ADR-0046 Decision §1).
@@ -3081,7 +3950,8 @@ var ChannelDriver = class {
       });
       try {
         const title = await this.resolveSessionTitle(sessionId, row.conversation_id);
-        await this.markDone(row.conversation_id, row.id, sessionId, ocId, title);
+        const usage = messageUsage(messages, ocId ?? "");
+        await this.markDone(row.conversation_id, row.id, sessionId, ocId, title, usage);
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         if (err instanceof ChannelTerminalError) {
@@ -3109,6 +3979,7 @@ var ChannelDriver = class {
     }
     if (state === "failed") {
       const error2 = messageError(messages, ocId ?? "") ?? void 0;
+      const usage = messageUsage(messages, ocId ?? "");
       this.log({
         level: "error",
         message: `Re-adopt: message ${row.id.slice(0, 8)} errored while unwatched \u2014 marking failed: ${error2 ?? "(no error text)"}`,
@@ -3116,7 +3987,7 @@ var ChannelDriver = class {
         message_id: row.id
       });
       try {
-        await this.markFailed(row.conversation_id, row.id, sessionId, error2);
+        await this.markFailed(row.conversation_id, row.id, sessionId, error2, usage);
       } catch (err) {
         if (err instanceof ChannelAuthError) throw err;
         if (err instanceof ChannelTerminalError) {
@@ -3522,6 +4393,47 @@ var ChannelDriver = class {
     }
     return false;
   }
+  /**
+   * Tri-state variant of the upward parentID membership walk (#721), used ONLY
+   * by `isAnyDescendantSessionOngoing`. Walks the SAME cached
+   * `resolveSessionParent` chain `sessionBelongsTo` uses above, but — unlike
+   * `sessionBelongsTo`, which deliberately collapses "confirmed not a
+   * descendant" and "the walk's fetch failed" into the same `false` (safe for
+   * its OTHER callers: interaction attribution and the recovery-path
+   * `isAnyDescendantSessionAlive`, both of which just retry next tick with no
+   * safety consequence either way) — this variant keeps those two outcomes
+   * SEPARATE, because `isAnyDescendantSessionOngoing`'s caller
+   * (`isB2AbandonmentConfirmed`) must never treat "couldn't tell" as "confirmed
+   * not ongoing".
+   *
+   * Return contract:
+   *  - `true`  → the walk reached `rootSessionId` — `sessionId` IS a descendant.
+   *  - `false` → the walk reached a definitive, parent-less root session
+   *              WITHOUT ever matching `rootSessionId` — `sessionId` is
+   *              CONFIRMED NOT a descendant of it.
+   *  - `null`  → INDETERMINATE: a `GET /session/:id` fetch failed partway
+   *              through the walk (`resolveSessionParent` returned `undefined`),
+   *              or the depth cap (32) was hit without a definitive answer (a
+   *              pathological/cyclic chain proves nothing either way). NEVER
+   *              treat this the same as `false` — see `sessionBelongsTo`'s own
+   *              doc comment above for why that collapse is safe THERE but not
+   *              here.
+   *
+   * `sessionBelongsTo` itself is UNCHANGED — this is an additive helper scoped
+   * to the live-path descendant check, not a modification of shared code used
+   * by interaction attribution or the recovery path.
+   */
+  async resolveSessionMembership(sessionId, rootSessionId) {
+    let current = sessionId;
+    for (let depth = 0; current && depth < 32; depth++) {
+      if (current === rootSessionId) return true;
+      const parent = await this.resolveSessionParent(current);
+      if (parent === void 0) return null;
+      if (parent === null) return false;
+      current = parent;
+    }
+    return null;
+  }
   /**
    * Resolve (and cache) a session's `parentID` via `GET /session/:id`. Returns
    * `null` for a root session (no parent) and `undefined` when opencode is
@@ -3544,19 +4456,36 @@ var ChannelDriver = class {
     if (parent !== void 0) this.sessionParents.set(sessionId, parent);
     return parent;
   }
+  /**
+   * OpenCode's synchronous default session title (e.g.
+   * `"New session - 1737800000000"`), assigned immediately when a session is
+   * created — before OpenCode's async LLM-based auto-titling later renames it
+   * mid-turn (#549). Matched by this literal, case-sensitive prefix only; the
+   * timestamp suffix's exact format is deliberately NOT matched, since the prefix
+   * alone is the stable, cheap signal and over-anchoring on the timestamp
+   * representation risks silently breaking if OpenCode ever changes it. Accepted
+   * trade-off: a genuine LLM-assigned title that happens to literally start with
+   * this prefix would also fail to latch (see `resolveSessionTitle`) —
+   * vanishingly unlikely in practice, and deliberately not engineered around.
+   */
+  static OPENCODE_DEFAULT_TITLE_PREFIX = /^New session - /;
   /**
    * Resolve (and cache in `sessionTitles`) the OpenCode session TITLE (#310) so the
    * status PATCH can carry it into the "Live sessions" list. Driver-level cache so
    * BOTH the watcher completion path and the restart-recovery re-adopt path (which
    * has no watcher) can use it. `conversationId` is passed only for log context.
    * Best-effort:
-   *   - a resolved NON-EMPTY title is cached and terminal (a real session name
+   *   - a resolved NON-EMPTY title that does NOT match
+   *     `OPENCODE_DEFAULT_TITLE_PREFIX` is cached and terminal (a real session name
    *     won't later un-name), so we do NOT re-GET `/session/:id` every tick;
-   *   - while the title is still absent/empty we do NOT latch it — OpenCode names
-   *     sessions asynchronously mid-turn, so an early call (e.g. at `processing`)
-   *     must leave the cache unresolved and re-fetch on the next need so a later
-   *     call (e.g. at `done`) picks up the name assigned in the meantime. Such a
-   *     call returns `null` (omit the title on THIS PATCH) without caching;
+   *   - while the title is still absent, empty, or matches the OpenCode
+   *     placeholder prefix (#549) we do NOT latch it — OpenCode names sessions
+   *     asynchronously mid-turn, so an early call (e.g. at `processing`) must leave
+   *     the cache unresolved and re-fetch on the next need so a later call (e.g. at
+   *     `done`) picks up the name assigned in the meantime. Such a call returns
+   *     `null` (omit the title on THIS PATCH) without caching. If a session is
+   *     never renamed, the title is omitted forever rather than ever persisting
+   *     the placeholder as a last resort;
    *   - a failed request likewise leaves the cache unresolved (retry next need)
    *     and returns `null` — it must NEVER throw or block completion.
    * A failure is logged with agent/session context (no silent catch).
@@ -3569,7 +4498,7 @@ var ChannelDriver = class {
       if (res.ok) {
         const body = await res.json();
         const title = body && typeof body.title === "string" ? body.title.trim() : "";
-        if (title.length > 0) {
+        if (title.length > 0 && !_ChannelDriver.OPENCODE_DEFAULT_TITLE_PREFIX.test(title)) {
           this.sessionTitles.set(sessionId, title);
           return title;
         }
@@ -3589,6 +4518,54 @@ var ChannelDriver = class {
     }
     return null;
   }
+  /**
+   * Best-effort mid-turn title sync (#711 follow-up): PATCH a resolved OpenCode
+   * session title onto the conversation via the PLAIN conversation-update
+   * endpoint (`PATCH /runners/:agentId/conversations/:conversationId`) — NOT the
+   * message-status endpoint `markProcessing`/`markDone` use. Deliberately a
+   * separate, lighter call: it carries no `status`, so it cannot re-trigger the
+   * `processing`/`done` transition side effects (Slack notices, activity-log
+   * rows, delivery jobs) those PATCHes gate on `transitioned` — this call only
+   * ever touches `conversations.title`. That route (`routes/conversations.ts`)
+   * skips a title write matching the stored value, so a redundant call with the
+   * same title is a real no-op — it does not bump `updated_at`, which the
+   * conversation list sorts and paginates on. (Note this is a DIFFERENT guard
+   * from `threads.ts`'s "non-empty AND changed" one, which only covers the
+   * message-status PATCH; the non-empty half is enforced here instead, by
+   * `resolveSessionTitle` never returning an empty/placeholder title.)
+   *
+   * Telemetry-only / never blocks the caller, mirroring `postSignal`: a failure
+   * is logged and the title is simply retried on the next heartbeat tick (the
+   * caller only latches `titleSynced` on `true`).
+   */
+  async patchConversationTitle(conversationId, title) {
+    try {
+      const res = await this.fetchImpl(
+        `${this.apiUrl}/runners/${this.agentId}/conversations/${conversationId}`,
+        {
+          method: "PATCH",
+          headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
+          body: JSON.stringify({ title })
+        }
+      );
+      if (!res.ok) {
+        this.log({
+          level: "debug",
+          message: `Mid-turn title sync PATCH for conversation ${conversationId.slice(0, 8)} returned HTTP ${res.status} (best-effort, will retry next heartbeat)`,
+          conversation_id: conversationId
+        });
+        return false;
+      }
+      return true;
+    } catch (err) {
+      this.log({
+        level: "debug",
+        message: `Best-effort mid-turn title sync PATCH failed for conversation ${conversationId.slice(0, 8)} (will retry next heartbeat): ${err instanceof Error ? err.message : String(err)}`,
+        conversation_id: conversationId
+      });
+      return false;
+    }
+  }
   /**
    * DEFENSIVE cross-check for the restart-recovery path (WI-2): is any descendant
    * (`task` sub-agent) session under `rootSessionId` still genuinely doing work?
@@ -3647,6 +4624,84 @@ var ChannelDriver = class {
     }
     return false;
   }
+  /**
+   * LIVE-PATH descendant-liveness check (#721): is any descendant (`task`
+   * sub-agent) session under `rootSessionId` currently ONGOING per OpenCode's own
+   * in-memory status map (`isSessionOngoing` — `busy`/`retry`)?
+   *
+   * Deliberately NOT `isAnyDescendantSessionAlive` (the RECOVERY-path
+   * cross-check above): that method judges liveness from the child's OWN
+   * TRANSCRIPT (`isSessionActivelyGenerating`), which is the right (only) option
+   * on the recovery path because a restart WIPES `SessionStatus`. On the LIVE
+   * path the local opencode server IS running, so its in-memory status map is
+   * live and authoritative — and per ADR-0047 §4a ("the child has its own entry
+   * [in the map]"), a `task` descendant's OWN busy/retry entry reflects its
+   * ENTIRE turn (including any tool call it is itself executing), not a
+   * per-message transcript snapshot. This sidesteps the "child's own tool is
+   * executing, between its step's completion and the next generation step"
+   * transcript gap that a transcript-based check would need a second,
+   * sustained-window bound to guard against — it is simply not derived from
+   * message timestamps at all.
+   *
+   * Why not just check `isSessionOngoing(port, rootSessionId)` (the ROOT's own
+   * status, as the recovery path does per §4a)? Because on the LIVE path the
+   * root session can be shared: a SECOND, unrelated user message can land on the
+   * SAME session (issue #721's own root cause) and keep the root `busy` for a
+   * reason that has nothing to do with THIS message's delegation. A `task`
+   * descendant session is spawned for exactly one delegated turn and never
+   * reused, so its OWN status-map entry is unambiguous evidence about that one
+   * delegation — which the root's status is not.
+   *
+   * Why membership is checked via `resolveSessionMembership`, NOT
+   * `sessionBelongsTo`: `sessionBelongsTo` collapses a transient
+   * `GET /session/:id` fetch failure into "not a descendant", which would
+   * silently drop a genuinely-live candidate from consideration on the one
+   * unlucky tick its membership-walk fetch hiccups (#721).
+   * `resolveSessionMembership` keeps that failure mode as a distinct `null`
+   * (indeterminate) so it is folded into THIS method's own `indeterminate` flag
+   * instead.
+   *
+   * Return contract (note the DIFFERENT judge vs. `isAnyDescendantSessionAlive`):
+   *  - `true`  → some descendant session is `busy`/`retry` (genuinely ongoing).
+   *  - `false` → enumeration succeeded, EVERY candidate's MEMBERSHIP was
+   *              confirmed either way (`resolveSessionMembership` never
+   *              returned `null`), and every CONFIRMED descendant's status read
+   *              succeeded and is not ongoing (includes "no descendant session
+   *              exists at all" — e.g. a plain, non-`task` tool call).
+   *  - `null`  → INDETERMINATE: `listSessions` failed, OR at least one
+   *              candidate's MEMBERSHIP could not be confirmed
+   *              (`resolveSessionMembership` returned `null` — a fetch failure
+   *              or pathological chain partway through the parent walk), OR at
+   *              least one CONFIRMED descendant's `isSessionOngoing` read
+   *              failed — and no OTHER candidate was already confirmed `true`.
+   *              The caller MUST NOT treat `null` the same as `false` here
+   *              (unlike the recovery cross-check's contract) — see
+   *              `isB2AbandonmentConfirmed`.
+   */
+  async isAnyDescendantSessionOngoing(rootSessionId) {
+    const sessions = await listSessions(this.port);
+    if (!sessions) {
+      this.log({
+        level: "warn",
+        message: `Could not enumerate sessions to check descendant liveness for root ${rootSessionId} (listSessions failed) \u2014 treating descendant liveness as indeterminate`
+      });
+      return null;
+    }
+    let indeterminate = false;
+    for (const candidate of sessions) {
+      if (!candidate?.id || candidate.id === rootSessionId) continue;
+      const membership = await this.resolveSessionMembership(candidate.id, rootSessionId);
+      if (membership === null) {
+        indeterminate = true;
+        continue;
+      }
+      if (membership === false) continue;
+      const ongoing = await isSessionOngoing(this.port, candidate.id);
+      if (ongoing === true) return true;
+      if (ongoing === null) indeterminate = true;
+    }
+    return indeterminate ? null : false;
+  }
   /**
    * Cheap decision-telemetry label for a running row's LAST correlated reply
    * (WI-2 Task 2.2): which running SHAPE it is, for the status-gated recovery log.
@@ -3719,7 +4774,7 @@ var ChannelDriver = class {
   // Evident API calls (combinedAuth thread routes)
   async getPendingConversations() {
     const res = await this.fetchImpl(
-      `${this.apiUrl}/agents/${this.agentId}/conversations/pending`,
+      `${this.apiUrl}/runners/${this.agentId}/conversations/pending`,
       {
         headers: { Authorization: this.getAuthHeader() }
       }
@@ -3737,7 +4792,7 @@ var ChannelDriver = class {
   }
   async getPendingMessages(conversationId) {
     const res = await this.fetchImpl(
-      `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages?status=pending`,
+      `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}/messages?status=pending`,
       { headers: { Authorization: this.getAuthHeader() } }
     );
     this.assertAuth(res, "fetching pending messages");
@@ -3761,7 +4816,7 @@ var ChannelDriver = class {
    */
   async getProcessingMessages() {
     const res = await this.fetchImpl(
-      `${this.apiUrl}/agents/${this.agentId}/conversations/processing`,
+      `${this.apiUrl}/runners/${this.agentId}/conversations/processing`,
       { headers: { Authorization: this.getAuthHeader() } }
     );
     this.assertAuth(res, "fetching processing messages");
@@ -3775,6 +4830,32 @@ var ChannelDriver = class {
     }
     return messages;
   }
+  /**
+   * The `opencode_session_id` fragment of a status PATCH body — `{}` when this
+   * conversation has ABANDONED that session (#553). The field is optional
+   * server-side and an absent one leaves the persisted binding untouched, so
+   * omitting it is how a routine status write stops resurrecting it.
+   *
+   * ONLY for writes whose sole cost is a lost deep link. The `processing` notice
+   * degrades to no "View in Evident" link (the reaction swap still fires) and the
+   * turn-failure notice is built from the PATCH's own `error` text with a link off
+   * the persisted row — neither loses content the user came for. `markDone`
+   * deliberately does NOT use this helper: the server fetches the reply text
+   * THROUGH the session id it is given, so suppressing there would replace the
+   * agent's answer with a bare "✅ Done!" (the #183/#187 failure). The
+   * `ensureSession` guard, not this suppression, is what makes the self-heal
+   * stick.
+   */
+  sessionIdBody(sessionId, conversationId, messageId, status) {
+    if (!this.isSuperseded(conversationId, sessionId)) return { opencode_session_id: sessionId };
+    this.log({
+      level: "debug",
+      message: `Omitting the abandoned OpenCode session ${sessionId.slice(0, 8)} from the '${status}' update for message ${messageId.slice(0, 8)} so it is not re-bound to conversation ${conversationId.slice(0, 8)}`,
+      conversation_id: conversationId,
+      message_id: messageId
+    });
+    return {};
+  }
   /**
    * EXISTING combinedAuth route — now fired by the watcher on queued→running
    * (Task 3.3), NOT at dispatch/claim time. `{status:'processing',
@@ -3798,13 +4879,13 @@ var ChannelDriver = class {
    */
   async markProcessing(conversationId, messageId, sessionId, opencodeMessageId, title) {
     const res = await this.fetchImpl(
-      `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
+      `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
       {
         method: "PATCH",
         headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
         body: JSON.stringify({
           status: "processing",
-          opencode_session_id: sessionId,
+          ...this.sessionIdBody(sessionId, conversationId, messageId, "processing"),
           ...opencodeMessageId ? { opencode_message_id: opencodeMessageId } : {},
           ...title ? { title } : {}
         })
@@ -3845,17 +4926,23 @@ var ChannelDriver = class {
    *                                    watcher retries next tick within the
    *                                    deadline, Finding 4).
    */
-  async markDone(conversationId, messageId, sessionId, opencodeMessageId, title) {
+  async markDone(conversationId, messageId, sessionId, opencodeMessageId, title, usage) {
     const res = await this.fetchImpl(
-      `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
+      `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
       {
         method: "PATCH",
         headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
         body: JSON.stringify({
           status: "done",
+          // ALWAYS sent, even for a session this conversation has abandoned
+          // (#553): the server reads the reply text back out of THIS session id
+          // to deliver it. Omitting it would leave the user with "✅ Done!"
+          // instead of the answer — a worse regression than the resurrection it
+          // would prevent, which `ensureSession`'s guard handles anyway.
           opencode_session_id: sessionId,
           ...opencodeMessageId ? { opencode_message_id: opencodeMessageId } : {},
-          ...title ? { title } : {}
+          ...title ? { title } : {},
+          ...usage ? usage : {}
         })
       }
     );
@@ -3868,19 +4955,29 @@ var ChannelDriver = class {
   }
   /**
    * Mark a message `failed`. `sessionId` / `error` are threaded to the API ONLY
-   * when provided (issue #182): a bare `markFailed(conv, msg)` sends
-   * `{status:'failed'}` unchanged (the dispatch-failure path), while an errored
-   * OpenCode turn sends `{status:'failed', opencode_session_id, error}` so the
-   * failure reason reaches the channel.
+   * when provided (issue #182). Three states for `sessionId`:
+   *   - omitted (`undefined`)  → don't send the field, leave the persisted
+   *     session untouched (unused today; kept for API symmetry).
+   *   - a real id (`string`)   → send it, update the persisted session (the
+   *     turn-failure call sites: an errored OpenCode turn).
+   *   - explicit `null`        → send it, CLEAR the persisted session (issue
+   *     #485's dispatch-handoff-failure call site: the session id still
+   *     exists but is wedged, so the next attempt must get a fresh one
+   *     instead of reusing it — see WI-1's server-side null-clearing PATCH).
    */
-  async markFailed(conversationId, messageId, sessionId, error2) {
+  async markFailed(conversationId, messageId, sessionId, error2, usage) {
     const body = { status: "failed" };
-    if (sessionId !== void 0) body.opencode_session_id = sessionId;
+    if (sessionId === null) {
+      body.opencode_session_id = null;
+    } else if (sessionId !== void 0) {
+      Object.assign(body, this.sessionIdBody(sessionId, conversationId, messageId, "failed"));
+    }
     if (error2 !== void 0) body.error = error2;
+    if (usage) Object.assign(body, usage);
     await this.callWithRetry(
       "marking message as failed",
       () => this.fetchImpl(
-        `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
+        `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}/messages/${messageId}`,
         {
           method: "PATCH",
           headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
@@ -3907,7 +5004,7 @@ var ChannelDriver = class {
   async postSignal(conversationId, messageId, signal, extra) {
     try {
       const res = await this.fetchImpl(
-        `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/messages/${messageId}/signal`,
+        `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}/messages/${messageId}/signal`,
         {
           method: "POST",
           headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
@@ -3936,7 +5033,7 @@ var ChannelDriver = class {
   }
   async persistSession(conversationId, sessionId) {
     const res = await this.fetchImpl(
-      `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}`,
+      `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}`,
       {
         method: "PATCH",
         headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
@@ -3962,7 +5059,7 @@ var ChannelDriver = class {
       await this.callWithRetry(
         "reporting interactive event",
         () => this.fetchImpl(
-          `${this.apiUrl}/agents/${this.agentId}/threads/${conversationId}/interactive-event`,
+          `${this.apiUrl}/runners/${this.agentId}/threads/${conversationId}/interactive-event`,
           {
             method: "POST",
             headers: { Authorization: this.getAuthHeader(), "Content-Type": "application/json" },
@@ -4065,7 +5162,7 @@ async function ensureOpenCodeRunning(ctx) {
       console.log(chalk5.yellow("Tip: Run with the correct port:"));
       console.log(
         chalk5.dim(
-          `  ${getCliName()} run --agent ${ctx.agentId} --port ${runningInstances[0].port}`
+          `  ${getCliName()} run --runner ${ctx.agentId} --port ${runningInstances[0].port}`
         )
       );
     }
@@ -4195,19 +5292,21 @@ async function resolveAgentIdFromKey(authHeader) {
       return { agent_id: data.agent_id };
     }
     return {
-      error: "Cannot resolve runner ID: auth type is not agent_key. Please provide --agent explicitly."
+      error: "Cannot resolve runner ID: auth type is not agent_key. Please provide --runner explicitly."
     };
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : "Unknown error";
     return { error: `Failed to resolve runner from key: ${message}` };
   }
 }
+var BEST_EFFORT_NOTIFY_TIMEOUT_MS = 2e3;
 async function notifyAgentDisconnected(agentId, authHeader) {
   const apiUrl = getApiUrlConfig();
   try {
-    const response = await fetch(`${apiUrl}/agents/${agentId}/disconnect`, {
+    const response = await fetch(`${apiUrl}/runners/${agentId}/disconnect`, {
       method: "POST",
-      headers: { Authorization: authHeader }
+      headers: { Authorization: authHeader },
+      signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
     });
     if (!response.ok) {
       const serverMessage = await readErrorMessage(response);
@@ -4218,13 +5317,41 @@ async function notifyAgentDisconnected(agentId, authHeader) {
     }
     return { ok: true };
   } catch (error2) {
-    return { ok: false, error: error2 instanceof Error ? error2.message : String(error2) };
+    return { ok: false, error: describeBestEffortError(error2) };
+  }
+}
+function describeBestEffortError(error2) {
+  const name = error2?.name;
+  if (name === "TimeoutError" || name === "AbortError") {
+    return `timed out after ${BEST_EFFORT_NOTIFY_TIMEOUT_MS}ms`;
+  }
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+async function reportMicrovmId(agentId, authHeader, microvmId) {
+  try {
+    const apiUrl = getApiUrlConfig();
+    const response = await fetch(`${apiUrl}/runners/${agentId}/microvm`, {
+      method: "POST",
+      headers: { Authorization: authHeader, "Content-Type": "application/json" },
+      body: JSON.stringify({ microvm_id: microvmId }),
+      signal: AbortSignal.timeout(BEST_EFFORT_NOTIFY_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      const serverMessage = await readErrorMessage(response);
+      return {
+        ok: false,
+        error: `HTTP ${response.status}${serverMessage ? `: ${serverMessage}` : ""}`
+      };
+    }
+    return { ok: true };
+  } catch (error2) {
+    return { ok: false, error: describeBestEffortError(error2) };
   }
 }
 async function getAgentInfo(agentId, authHeader) {
   const apiUrl = getApiUrlConfig();
   try {
-    const response = await fetch(`${apiUrl}/agents/${agentId}`, {
+    const response = await fetch(`${apiUrl}/runners/${agentId}`, {
       headers: { Authorization: authHeader }
     });
     if (response.status === 401) {
@@ -4268,6 +5395,7 @@ var MAX_ACTIVITY_LOG_ENTRIES = 10;
 var CHANNEL_POLL_INTERVAL_MS = Number(process.env.EVIDENT_CHANNEL_POLL_INTERVAL_MS) || 2e3;
 var CHANNEL_STUCK_QUEUED_MS = Number(process.env.EVIDENT_STUCK_QUEUED_MS) || void 0;
 var SHUTDOWN_DRAIN_TIMEOUT_MS = Number(process.env.EVIDENT_SHUTDOWN_DRAIN_MS) || 25e3;
+var TELEMETRY_SHUTDOWN_TIMEOUT_MS = 5e3;
 function resolveLogLevel(options) {
   const accepted = Object.keys(LOG_LEVELS);
   const validate = (value, source) => {
@@ -4291,6 +5419,34 @@ function resolveLogLevel(options) {
   }
   return "info";
 }
+function resolveFileSyncDirectories(raw, homeDir) {
+  const directories = [];
+  for (const entry of raw ?? []) {
+    const trimmed = entry.trim();
+    if (trimmed === "") {
+      throw new Error("--enable-file-sync-to requires a directory path (got an empty value)");
+    }
+    const expanded = trimmed === "~" ? homeDir : trimmed.startsWith("~/") ? join2(homeDir, trimmed.slice(2)) : trimmed;
+    if (!isAbsolute2(expanded)) {
+      throw new Error(`--enable-file-sync-to requires an absolute directory path; got "${entry}"`);
+    }
+    const normalized = resolvePath(expanded);
+    if (parse(normalized).root === normalized) {
+      throw new Error(
+        `--enable-file-sync-to will not allow-list the filesystem root ("${entry}"); name the specific directory the credentials belong in (for example ~/.claude)`
+      );
+    }
+    if (!directories.includes(normalized)) {
+      directories.push(normalized);
+    }
+  }
+  if (directories.length > MAX_FILE_SYNC_DIRECTORIES) {
+    throw new Error(
+      `--enable-file-sync-to accepts at most ${MAX_FILE_SYNC_DIRECTORIES} directories; got ${directories.length}`
+    );
+  }
+  return directories;
+}
 function meetsThreshold(state, level) {
   return LOG_LEVELS[level] >= LOG_LEVELS[state.logLevel];
 }
@@ -4412,18 +5568,29 @@ async function handleAuthError(state, error2) {
 async function driveChannels(state, driver) {
   let idlePolls = 0;
   let lastSeenProxiedActivityAt = state.lastProxiedActivityAt;
+  let lastSeenAppliedFiles = driver.fileSyncActivity().appliedFiles;
   while (state.running) {
     if (state.connection?.reconnecting && state.connection.reconnectPromise) {
       logActivity(state, { type: "info", message: "Waiting for tunnel reconnection..." });
       if (state.interactive) displayStatus(state);
       await state.connection.reconnectPromise;
     }
+    const carriedOverFileSync = driver.fileSyncActivity().inFlight;
+    void driver.syncPendingFiles().catch(
+      (error2) => logActivity(state, {
+        type: "error",
+        error: `Runner file sync failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+      })
+    );
     try {
       const processed = await driver.drainPending();
       state.messageCount += processed;
       const proxiedActivity = state.lastProxiedActivityAt !== lastSeenProxiedActivityAt;
       lastSeenProxiedActivityAt = state.lastProxiedActivityAt;
-      if (processed > 0 || driver.hasInFlightWatchers() || proxiedActivity) {
+      const appliedFiles = driver.fileSyncActivity().appliedFiles;
+      const fileActivity = carriedOverFileSync || appliedFiles !== lastSeenAppliedFiles;
+      lastSeenAppliedFiles = appliedFiles;
+      if (processed > 0 || driver.hasInFlightWatchers() || proxiedActivity || fileActivity) {
         idlePolls = 0;
         if (processed > 0 && state.interactive) displayStatus(state);
       } else if (state.idleTimeout !== null) {
@@ -4452,7 +5619,7 @@ async function driveChannels(state, driver) {
       logActivity(state, { type: "error", error: `Channel processing error: ${errorMessage}` });
       if (state.interactive) displayStatus(state);
     }
-    await new Promise((resolve2) => setTimeout(resolve2, CHANNEL_POLL_INTERVAL_MS));
+    await new Promise((resolve3) => setTimeout(resolve3, CHANNEL_POLL_INTERVAL_MS));
     if (state.idleTimeout !== null && idlePolls >= 2) {
       const idleMs = idlePolls * CHANNEL_POLL_INTERVAL_MS;
       if (idleMs > state.idleTimeout * 1e3) {
@@ -4555,7 +5722,18 @@ async function notifyOffline(state) {
     if (state.interactive) displayStatus(state);
   }
 }
+async function timeShutdownPhase(state, durations, name, run2) {
+  const startedAt = Date.now();
+  try {
+    return await run2();
+  } finally {
+    const elapsedMs = Date.now() - startedAt;
+    durations[name] = elapsedMs;
+    log2(state, `Shutdown phase ${name}: ${elapsedMs}ms`);
+  }
+}
 async function cleanup(state, opts = {}) {
+  const durations = {};
   state.running = false;
   for (const timer of state.sessionCleanupTimers) {
     clearInterval(timer);
@@ -4569,7 +5747,13 @@ async function cleanup(state, opts = {}) {
       logActivity(state, { type: "info", message: "Draining in-flight work before shutdown..." });
       displayStatus(state);
     }
-    const settled = await state.channelDriver.waitForInFlight(SHUTDOWN_DRAIN_TIMEOUT_MS);
+    const driver = state.channelDriver;
+    const settled = await timeShutdownPhase(
+      state,
+      durations,
+      "drain",
+      () => driver.waitForInFlight(SHUTDOWN_DRAIN_TIMEOUT_MS)
+    );
     if (!settled) {
       logActivity(state, {
         type: "info",
@@ -4578,13 +5762,15 @@ async function cleanup(state, opts = {}) {
       if (state.interactive) displayStatus(state);
     }
   }
-  await notifyOffline(state);
+  await timeShutdownPhase(state, durations, "offline_notify", () => notifyOffline(state));
   if (state.connection) {
-    state.connection.close();
+    const connection = state.connection;
+    await timeShutdownPhase(state, durations, "tunnel_close", () => connection.close());
     state.connection = null;
   }
   if (state.opencodeProcess) {
-    stopOpenCode(state.opencodeProcess);
+    const opencodeProcess = state.opencodeProcess;
+    await timeShutdownPhase(state, durations, "opencode_stop", () => stopOpenCode(opencodeProcess));
     if (state.interactive) {
       logActivity(state, { type: "info", message: "Stopped OpenCode process" });
       displayStatus(state);
@@ -4593,12 +5779,15 @@ async function cleanup(state, opts = {}) {
     }
     state.opencodeProcess = null;
   }
+  return durations;
 }
 async function run(options) {
   const interactive = isInteractive(options.json);
   let logLevel;
+  let fileSyncDirectories;
   try {
     logLevel = resolveLogLevel(options);
+    fileSyncDirectories = resolveFileSyncDirectories(options.enableFileSyncTo, homedir2());
   } catch (error2) {
     const message = error2 instanceof Error ? error2.message : String(error2);
     if (options.json) {
@@ -4611,7 +5800,7 @@ async function run(options) {
     return;
   }
   const state = {
-    agentId: options.agent || "",
+    agentId: options.runner || options.agent || "",
     agentName: null,
     port: options.port ?? 4096,
     conversationFilter: options.conversation ?? null,
@@ -4633,6 +5822,24 @@ async function run(options) {
     sessionCleanupTimers: [],
     authHeader: ""
   };
+  if (fileSyncDirectories.length > 0) {
+    log2(state, `File sync enabled for: ${fileSyncDirectories.join(", ")}`);
+  } else {
+    log2(state, "File sync is disabled (no --enable-file-sync-to given)", "debug");
+  }
+  if (!options.runner && options.agent) {
+    telemetry.info(
+      EventTypes.DEPRECATED_AGENT_FLAG_USED,
+      "Deprecated --agent flag used instead of --runner",
+      { command: "run" },
+      state.agentId
+    );
+    const agentFlagNotice = "--agent is deprecated, use --runner instead; will be removed in a future release.";
+    log2(state, agentFlagNotice, "warn");
+    if (state.interactive && !state.json) {
+      logActivity(state, { type: "info", level: "warn", message: agentFlagNotice });
+    }
+  }
   if (state.idleTimeout === null && (process.env.GITHUB_ACTIONS || process.env.CI)) {
     log2(
       state,
@@ -4643,14 +5850,38 @@ async function run(options) {
   const handleSignal = async () => {
     if (state.shuttingDown) return;
     state.shuttingDown = true;
+    const shutdownStartedAt = Date.now();
     if (state.interactive) {
       logActivity(state, { type: "info", message: "Shutting down..." });
       displayStatus(state);
     } else {
       log2(state, "Shutting down...");
     }
-    await cleanup(state, { graceful: true });
-    await shutdownTelemetry();
+    const durations = await cleanup(state, { graceful: true });
+    const telemetryBudgetMs = Number(process.env.EVIDENT_TELEMETRY_SHUTDOWN_MS) || TELEMETRY_SHUTDOWN_TIMEOUT_MS;
+    await timeShutdownPhase(state, durations, "telemetry_flush", async () => {
+      let timer;
+      const flushed = shutdownTelemetry().then(
+        () => true,
+        (error2) => {
+          log2(
+            state,
+            `Telemetry flush failed during shutdown: ${error2 instanceof Error ? error2.message : String(error2)}`,
+            "warn"
+          );
+          return true;
+        }
+      );
+      const timedOut = new Promise((resolve3) => {
+        timer = setTimeout(() => resolve3(false), telemetryBudgetMs);
+      });
+      if (!await Promise.race([flushed, timedOut])) {
+        log2(state, `Telemetry flush exceeded ${telemetryBudgetMs}ms \u2014 exiting anyway`, "warn");
+      }
+      clearTimeout(timer);
+    });
+    const breakdown = Object.entries(durations).map(([phase, ms]) => `${phase}=${ms}ms`).join(" ");
+    log2(state, `Shutdown complete in ${Date.now() - shutdownStartedAt}ms (${breakdown})`);
     process.exit(0);
   };
   process.on("SIGINT", handleSignal);
@@ -4661,7 +5892,9 @@ async function run(options) {
       if (!interactive) {
         printError("Authentication required");
         blank();
-        console.log(chalk6.dim("Set EVIDENT_AGENT_KEY environment variable for CI"));
+        console.log(
+          chalk6.dim("Set EVIDENT_RUNNER_KEY (or EVIDENT_AGENT_KEY) environment variable for CI")
+        );
         console.log(chalk6.dim("Or run `evident login` for interactive authentication"));
         blank();
         process.exit(1);
@@ -4675,6 +5908,25 @@ async function run(options) {
       );
     }
     state.authHeader = getAuthHeader(credentials2);
+    if (credentials2.notice) {
+      log2(state, credentials2.notice, "warn");
+      if (state.interactive && !state.json) {
+        logActivity(state, { type: "info", level: "warn", message: credentials2.notice });
+      }
+    }
+    if (credentials2.keySource === "agent_key") {
+      telemetry.info(
+        EventTypes.DEPRECATED_AGENT_KEY_ENV_USED,
+        "Deprecated EVIDENT_AGENT_KEY env var used instead of EVIDENT_RUNNER_KEY",
+        { command: "run" },
+        state.agentId
+      );
+      const agentKeyNotice = "EVIDENT_AGENT_KEY is deprecated, use EVIDENT_RUNNER_KEY instead; will be removed in a future release.";
+      log2(state, agentKeyNotice, "warn");
+      if (state.interactive && !state.json) {
+        logActivity(state, { type: "info", level: "warn", message: agentKeyNotice });
+      }
+    }
     if (!state.agentId) {
       if (credentials2.authType === "agent_key") {
         const resolved = await resolveAgentIdFromKey(state.authHeader);
@@ -4692,9 +5944,15 @@ async function run(options) {
           process.exit(1);
         }
       } else {
-        printError("--agent is required when not using EVIDENT_AGENT_KEY");
+        printError(
+          "--runner (or --agent) is required when not using EVIDENT_RUNNER_KEY or EVIDENT_AGENT_KEY"
+        );
         blank();
-        console.log(chalk6.dim("Either provide --agent <id> or set EVIDENT_AGENT_KEY"));
+        console.log(
+          chalk6.dim(
+            "Either provide --runner/--agent <id> or set EVIDENT_RUNNER_KEY/EVIDENT_AGENT_KEY"
+          )
+        );
         blank();
         process.exit(1);
       }
@@ -4737,6 +5995,21 @@ async function run(options) {
     }
     spinner?.succeed(`Runner: ${validation.agent.name || state.agentId}`);
     state.agentName = validation.agent.name;
+    const microvmId = process.env.MICROVM_ID?.trim();
+    if (microvmId) {
+      const reported = await reportMicrovmId(state.agentId, state.authHeader, microvmId);
+      if (reported.ok) {
+        log2(state, "Reported MicroVM identity so this runner can be resumed rather than restarted");
+      } else {
+        const message = `Could not report MicroVM identity (future wakes will cold-start): ${reported.error}`;
+        log2(state, message, "warn");
+        if (state.interactive && !state.json) {
+          logActivity(state, { type: "info", level: "warn", message });
+        }
+      }
+    } else {
+      log2(state, "Not running in a MicroVM (MICROVM_ID unset) \u2014 nothing to report", "debug");
+    }
     const ocSpinner = interactive && !state.json ? ora3("Checking OpenCode...").start() : null;
     try {
       const oc = await ensureOpenCodeRunning({
@@ -4758,6 +6031,21 @@ async function run(options) {
           logActivity(state, { type: "info", level: "warn", message: versionWarning });
         }
       }
+      const noProviderWarning = buildNoProviderWarning(await hasAnyConfiguredProvider(state.port));
+      if (noProviderWarning) {
+        log2(state, noProviderWarning, "warn");
+        if (state.interactive && !state.json) {
+          logActivity(state, { type: "info", level: "warn", message: noProviderWarning });
+          blank();
+          console.log(chalk6.yellow("\u26A0 No OpenCode model provider is configured."));
+          console.log(
+            chalk6.dim(
+              `Run ${chalk6.cyan("opencode auth login")} to set one up \u2014 messages will fail until then.`
+            )
+          );
+          blank();
+        }
+      }
     } catch (error2) {
       ocSpinner?.fail(error2.message);
       throw error2;
@@ -4770,6 +6058,10 @@ async function run(options) {
       getAuthHeader: () => state.authHeader,
       conversationFilter: state.conversationFilter,
       stuckQueuedMs: CHANNEL_STUCK_QUEUED_MS,
+      // #559: the `--enable-file-sync-to` allow-list. Empty ⇒ pending files are
+      // REJECTED with `file_sync_disabled` on the ack, not silently ignored.
+      fileSyncDirectories,
+      homeDir: homedir2(),
       log: (entry) => (
         // Thread the driver's real level straight through so `debug`/`warn`
         // survive the sink filter (they no longer collapse to info). `type`
@@ -4796,6 +6088,18 @@ async function run(options) {
             type: "info",
             message: `Tunnel ${isReconnect ? "reconnected" : "connected"} (runner: ${agentId})`
           });
+          if (options.tunnelReadyFile) {
+            const marker = writeTunnelReadyMarker(options.tunnelReadyFile, agentId);
+            if (marker.ok) {
+              log2(state, `Wrote tunnel readiness marker to ${options.tunnelReadyFile}`, "debug");
+            } else {
+              log2(
+                state,
+                `Failed to write tunnel readiness marker to ${options.tunnelReadyFile}: ${marker.error}`,
+                "error"
+              );
+            }
+          }
           emitAgentConnected(state.agentId, {
             port: state.port,
             cli_version: getCliVersion(),
@@ -4851,6 +6155,12 @@ async function run(options) {
         onDrainPing: () => {
           if (!state.running) return;
           logActivity(state, { type: "info", message: "Drain ping received \u2014 draining" });
+          void channelDriver.syncPendingFiles().catch(
+            (error2) => logActivity(state, {
+              type: "error",
+              error: `Runner file sync failed on ping: ${error2 instanceof Error ? error2.message : String(error2)}`
+            })
+          );
           channelDriver.drainPending().then((processed) => {
             if (processed > 0) {
               state.messageCount += processed;
@@ -4909,7 +6219,7 @@ async function run(options) {
     }
     telemetry.error(EventTypes.CLI_ERROR, `Run command failed: ${message}`, {
       command: "run",
-      agentId: options.agent
+      agentId: options.runner || options.agent
     });
     await shutdownTelemetry();
     process.exit(1);
@@ -4934,7 +6244,10 @@ program.name("evident").description("Run OpenCode locally and connect it to Evid
 program.command("login").description("Authenticate with Evident").option("--token", "Use token-based authentication (for CI/CD)").option("--no-browser", "Do not open the browser automatically").action(login);
 program.command("logout").description("Remove stored credentials for the current endpoint").option("--all", "Remove stored credentials for all endpoints").action((options) => logout({ all: options.all }));
 program.command("whoami").description("Show the currently logged in user").action(whoami);
-program.command("run").description("Connect to Evident and process messages").option("-a, --agent [id]", "Runner ID to connect to (optional when EVIDENT_AGENT_KEY is set)").option("-p, --port <port>", "OpenCode port (default: 4096)", "4096").option(
+program.command("run").description("Connect to Evident and process messages").option("--runner [id]", "Runner ID to connect to (optional when EVIDENT_RUNNER_KEY is set)").option(
+  "-a, --agent [id]",
+  "Deprecated alias for --runner (still supported; --runner wins if both are given)"
+).option("-p, --port <port>", "OpenCode port (default: 4096)", "4096").option(
   "--log-level <level>",
   "Log verbosity: debug | info | warn | error (default: info). Env: EVIDENT_LOG_LEVEL"
 ).option("-v, --verbose", "Alias for --log-level debug (ignored if --log-level is set)").option("-c, --conversation <id>", "Process only this specific conversation").option("--idle-timeout <seconds>", "Exit after N seconds idle").option("--json", "Output in JSON format").option(
@@ -4946,10 +6259,19 @@ program.command("run").description("Connect to Evident and process messages").op
 ).option(
   "--session-cleanup-interval <duration>",
   "How often the cleanup sweep runs (default: 1h). Env: EVIDENT_SESSION_CLEANUP_INTERVAL"
+).option(
+  "--enable-file-sync-to <dir>",
+  "Allow Evident to write files into this directory (repeatable). Omit to disable file sync entirely.",
+  (value, previous) => previous.concat([value]),
+  []
+).option(
+  "--tunnel-ready-file <path>",
+  "Path to write once the tunnel is connected (set by the MicroVM hooks; unused on a developer machine)"
 ).action(
   (options) => {
     run({
       agent: options.agent,
+      runner: options.runner,
       port: parseInt(options.port, 10),
       // Raw string — validation/precedence is single-sourced in run.ts's
       // resolveLogLevel (flag > -v > EVIDENT_LOG_LEVEL > info).
@@ -4961,7 +6283,11 @@ program.command("run").description("Connect to Evident and process messages").op
       // Raw strings — the resolver in run.ts single-sources parsing (M1).
       sessionCleanupMaxAge: options.sessionCleanupMaxAge,
       sessionCleanupMaxCount: options.sessionCleanupMaxCount,
-      sessionCleanupInterval: options.sessionCleanupInterval
+      sessionCleanupInterval: options.sessionCleanupInterval,
+      // Raw values — expansion/validation is single-sourced in run.ts's
+      // resolveFileSyncDirectories.
+      enableFileSyncTo: options.enableFileSyncTo,
+      tunnelReadyFile: options.tunnelReadyFile
     });
   }
 );