repoburg 1.3.266 → 1.3.267

package/agent-pane/backend/dist/index.js

@@ -757,7 +757,7 @@ var require_plugin = __commonJS({
       const name = this.name;
       let completed = false;
       this.options = typeof this.options === "function" ? this.options(this.server) : this.options;
-      let timer = null;
+      let timer2 = null;
       const done = (execErr) => {
         if (completed) {
           debug("loading complete", name);
@@ -770,16 +770,16 @@ var require_plugin = __commonJS({
           debug("exec completed", name);
         }
         completed = true;
-        if (timer) {
-          clearTimeout(timer);
+        if (timer2) {
+          clearTimeout(timer2);
         }
         callback(execErr);
       };
       if (this.timeout > 0) {
         debug("setting up timeout", name, this.timeout);
-        timer = setTimeout(function() {
+        timer2 = setTimeout(function() {
           debug("timed out", name);
-          timer = null;
+          timer2 = null;
           const readyTimeoutErr = new AVV_ERR_PLUGIN_EXEC_TIMEOUT(name);
           readyTimeoutErr.fn = func;
           done(readyTimeoutErr);
@@ -1366,9 +1366,9 @@ var require_avvio = __commonJS({
     function timeoutCall(func, rootErr, context, cb) {
       const name = func.unwrappedName ?? func.name;
       debug("setting up ready timeout", name, this._opts.timeout);
-      let timer = setTimeout(() => {
+      let timer2 = setTimeout(() => {
         debug("timed out", name);
-        timer = null;
+        timer2 = null;
         const toutErr = new AVV_ERR_READY_TIMEOUT(name);
         toutErr.fn = func;
         this._error = toutErr;
@@ -1380,9 +1380,9 @@ var require_avvio = __commonJS({
         func(rootErr, context, timeoutCb.bind(this));
       }
       function timeoutCb(err) {
-        if (timer) {
-          clearTimeout(timer);
-          timer = null;
+        if (timer2) {
+          clearTimeout(timer2);
+          timer2 = null;
           this._error = err;
           process.nextTick(cb, this._error);
         } else {
@@ -13402,7 +13402,7 @@ var require_context = __commonJS({
     function Context({
       schema,
       handler,
-      config,
+      config: config2,
       childLoggerFactory,
       errorHandler,
       bodyLimit,
@@ -13432,7 +13432,7 @@ var require_context = __commonJS({
       this.onResponse = null;
       this.preSerialization = null;
       this.onRequestAbort = null;
-      this.config = config;
+      this.config = config2;
       this.errorHandler = errorHandler || server[kErrorHandler];
       this.childLoggerFactory = childLoggerFactory || server[kChildLoggerFactory];
       this._middie = null;
@@ -33623,7 +33623,7 @@ var require_route = __commonJS({
             }
           }
           const constraints = opts.constraints || {};
-          const config = {
+          const config2 = {
             ...opts.config,
             url,
             method: opts.method
@@ -33631,7 +33631,7 @@ var require_route = __commonJS({
           const context = new Context({
             schema: opts.schema,
             handler: opts.handler.bind(this),
-            config,
+            config: config2,
             errorHandler: opts.errorHandler,
             childLoggerFactory: opts.childLoggerFactory,
             bodyLimit: opts.bodyLimit,
@@ -41006,7 +41006,6 @@ function initDb(path9 = "data.db") {
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
   createTables(db);
-  cleanupStaleState(db);
   return db;
 }
 function getDb() {
@@ -41015,17 +41014,6 @@ function getDb() {
   }
   return db;
 }
-function cleanupStaleState(database) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const staleItems = database.prepare(
-    "UPDATE items SET status = 'failed', updated_at = ? WHERE status = 'in_progress'"
-  ).run(now);
-  const staleSessions = database.prepare("UPDATE sessions SET is_running = 0, status = ?, updated_at = ? WHERE is_running = 1").run("active", now);
-  const staleTurns = database.prepare("UPDATE turns SET status = 'failed', error = ?, updated_at = ? WHERE status = 'running'").run("Backend restarted while turn was running", now);
-  if (staleSessions.changes > 0 || staleTurns.changes > 0 || staleItems.changes > 0) {
-    console.log(`[db] Cleaned up stale state: ${staleSessions.changes} sessions, ${staleTurns.changes} turns, ${staleItems.changes} items`);
-  }
-}
 function createTables(database) {
   database.exec(`
     CREATE TABLE IF NOT EXISTS sessions (
@@ -41169,6 +41157,18 @@ CREATE INDEX IF NOT EXISTS idx_workspaces_path ON workspaces(path);
   if (!turnColumns.some((c) => c.name === "runtime_input_ids")) {
     database.exec("ALTER TABLE turns ADD COLUMN runtime_input_ids TEXT");
   }
+  if (!turnColumns.some((c) => c.name === "interrupted_at")) {
+    database.exec("ALTER TABLE turns ADD COLUMN interrupted_at TEXT");
+  }
+  if (!turnColumns.some((c) => c.name === "interrupt_reason")) {
+    database.exec("ALTER TABLE turns ADD COLUMN interrupt_reason TEXT");
+  }
+  if (!turnColumns.some((c) => c.name === "resume_state")) {
+    database.exec("ALTER TABLE turns ADD COLUMN resume_state TEXT");
+  }
+  if (!turnColumns.some((c) => c.name === "resume_attempts")) {
+    database.exec("ALTER TABLE turns ADD COLUMN resume_attempts INTEGER NOT NULL DEFAULT 0");
+  }
   const threadColumns = database.prepare("PRAGMA table_info(discussion_threads)").all();
   if (!threadColumns.some((c) => c.name === "external_thread_id")) {
     database.exec("ALTER TABLE discussion_threads ADD COLUMN external_thread_id TEXT");
@@ -41793,8 +41793,13 @@ function isSessionBusy(db2, session, opts) {
   return false;
 }
 function recomputeSessionRunning(db2, sessionId, idleStatus = "active", hasUnreviewed = false) {
-  const live = db2.prepare(`SELECT COUNT(*) AS c FROM turns WHERE session_id = ? AND status IN ('pending', 'running')`).get(sessionId);
+  const live = db2.prepare(
+    `SELECT COUNT(*) AS c,
+              COALESCE(SUM(CASE WHEN status = 'pending' AND resume_state = 'waiting' THEN 1 ELSE 0 END), 0) AS w
+       FROM turns WHERE session_id = ? AND status IN ('pending', 'running')`
+  ).get(sessionId);
   const isRunning = live.c > 0 ? 1 : 0;
+  const liveStatus = live.c > 0 && live.w === live.c ? "interrupted" : "running";
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (hasUnreviewed && isRunning === 0) {
     db2.prepare("UPDATE sessions SET is_running = ?, status = ?, has_unreviewed = 1, updated_at = ? WHERE id = ?").run(
@@ -41806,13 +41811,406 @@ function recomputeSessionRunning(db2, sessionId, idleStatus = "active", hasUnrev
   } else {
     db2.prepare("UPDATE sessions SET is_running = ?, status = ?, updated_at = ? WHERE id = ?").run(
       isRunning,
-      isRunning ? "running" : idleStatus,
+      isRunning ? liveStatus : idleStatus,
       now,
       sessionId
     );
   }
 }
 
+// src/resume/interruptions.ts
+var HOST_RESTART_ERROR = "Backend restarted while turn was running";
+var listeners = /* @__PURE__ */ new Set();
+function onTurnInterrupted(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function getTurn(db2, turnId) {
+  return db2.prepare(
+    `SELECT id, session_id, status, thread_id, interrupted_at, interrupt_reason, resume_state, resume_attempts, updated_at
+       FROM turns WHERE id = ?`
+  ).get(turnId);
+}
+function isLive(status) {
+  return status === "pending" || status === "running";
+}
+function addInterruptionItem(db2, sessionId, turnId, data) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const item = {
+    id: v4_default(),
+    turn_id: turnId,
+    external_item_id: `interruption-${v4_default()}`,
+    type: "interruption",
+    data,
+    status: "completed",
+    created_at: now,
+    updated_at: now
+  };
+  db2.prepare(
+    "INSERT INTO items (id, turn_id, external_item_id, type, data, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
+  ).run(item.id, turnId, item.external_item_id, item.type, JSON.stringify(data), item.status, now, now);
+  broadcast("item:completed", { sessionId, turnId, item });
+  return item;
+}
+function updateLatestInterruptionItem(db2, sessionId, turnId, patch) {
+  const row = db2.prepare(
+    "SELECT id, external_item_id, data, created_at FROM items WHERE turn_id = ? AND type = 'interruption' ORDER BY created_at DESC, rowid DESC LIMIT 1"
+  ).get(turnId);
+  if (!row) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const data = { ...row.data ? JSON.parse(row.data) : {}, ...patch };
+  db2.prepare("UPDATE items SET data = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(data), now, row.id);
+  const item = {
+    id: row.id,
+    turn_id: turnId,
+    external_item_id: row.external_item_id,
+    type: "interruption",
+    data,
+    status: "completed",
+    created_at: row.created_at,
+    updated_at: now
+  };
+  broadcast("item:completed", { sessionId, turnId, item });
+}
+function markTurnInterrupted(db2, turnId, reason, opts = {}) {
+  const turn = getTurn(db2, turnId);
+  if (!turn || !isLive(turn.status)) return false;
+  if (turn.status === "pending" && turn.resume_state === "waiting") return false;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const detail = opts.detail ?? null;
+  const retry = turn.resume_state === "resuming";
+  const at = retry ? turn.interrupted_at ?? now : opts.at ?? now;
+  db2.prepare(
+    `UPDATE turns SET status = 'pending', resume_state = 'waiting', interrupt_reason = ?, interrupted_at = ?, error = NULL, updated_at = ?
+     WHERE id = ?`
+  ).run(reason, at, now, turnId);
+  if (retry) {
+    updateLatestInterruptionItem(db2, turn.session_id, turnId, { reason, outcome: "waiting", detail });
+  } else {
+    addInterruptionItem(db2, turn.session_id, turnId, {
+      reason,
+      interrupted_at: at,
+      resumed_at: null,
+      outcome: "waiting",
+      detail
+    });
+  }
+  recomputeSessionRunning(db2, turn.session_id);
+  broadcast("turn:interrupted", {
+    sessionId: turn.session_id,
+    turnId,
+    reason,
+    interruptedAt: at,
+    attempts: turn.resume_attempts,
+    detail
+  });
+  if (opts.notify !== false) {
+    for (const listener of listeners) {
+      try {
+        listener({ sessionId: turn.session_id, turnId, reason });
+      } catch (err) {
+        console.error("[resume] interruption listener failed:", err);
+      }
+    }
+  }
+  return true;
+}
+function markTurnResuming(db2, turnId, opts = {}) {
+  const turn = getTurn(db2, turnId);
+  if (!turn || !isResumable(turn, !!opts.manual)) return null;
+  const counted = opts.countAttempt ?? !opts.manual;
+  const attempt = turn.resume_attempts + (counted ? 1 : 0);
+  const reason = turn.interrupt_reason ?? "host_restart";
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db2.prepare(
+    `UPDATE turns SET status = 'running', resume_state = 'resuming', resume_attempts = ?, error = NULL, updated_at = ?
+     WHERE id = ?`
+  ).run(attempt, now, turnId);
+  updateLatestInterruptionItem(db2, turn.session_id, turnId, { outcome: "resuming" });
+  recomputeSessionRunning(db2, turn.session_id);
+  broadcast("turn:resuming", { sessionId: turn.session_id, turnId, attempt, reason, manual: !!opts.manual });
+  return { sessionId: turn.session_id, attempt, reason };
+}
+function isResumable(turn, manual) {
+  if (turn.status === "pending" && turn.resume_state === "waiting") return true;
+  return manual && turn.status === "failed" && (turn.resume_state === "gave_up" || turn.resume_state === "skipped");
+}
+function markTurnResumed(db2, turnId, opts = {}) {
+  const turn = getTurn(db2, turnId);
+  if (!turn) return;
+  if (turn.resume_state !== "resuming" && !(opts.settle && turn.resume_state === "waiting")) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db2.prepare("UPDATE turns SET resume_state = 'resumed', updated_at = ? WHERE id = ?").run(now, turnId);
+  updateLatestInterruptionItem(db2, turn.session_id, turnId, { outcome: "resumed", resumed_at: now });
+  broadcast("turn:resumed", { sessionId: turn.session_id, turnId, resumedAt: now });
+}
+function finalizeInterruptedTurn(db2, turnId, state, error) {
+  const turn = getTurn(db2, turnId);
+  if (!turn || !isLive(turn.status)) return false;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db2.prepare("UPDATE turns SET status = 'failed', resume_state = ?, error = ?, updated_at = ? WHERE id = ?").run(
+    state,
+    error,
+    now,
+    turnId
+  );
+  updateLatestInterruptionItem(db2, turn.session_id, turnId, { outcome: state });
+  recomputeSessionRunning(db2, turn.session_id, "failed");
+  broadcast("turn:failed", { sessionId: turn.session_id, turnId, error, resumeState: state });
+  return true;
+}
+function markResumeCancelled(db2, turnId) {
+  const turn = getTurn(db2, turnId);
+  if (!turn || turn.resume_state !== "waiting" && turn.resume_state !== "resuming") return;
+  db2.prepare("UPDATE turns SET resume_state = 'cancelled' WHERE id = ?").run(turnId);
+  updateLatestInterruptionItem(db2, turn.session_id, turnId, { outcome: "cancelled" });
+}
+function recoverInterruptedTurns(db2, opts) {
+  const live = db2.prepare(
+    `SELECT t.id, t.session_id, t.status, t.thread_id, t.interrupted_at, t.interrupt_reason, t.resume_state,
+              t.resume_attempts, t.updated_at, s.runtime_type,
+              (SELECT MAX(i.updated_at) FROM items i WHERE i.turn_id = t.id AND i.type != 'interruption') AS last_item_at
+       FROM turns t JOIN sessions s ON s.id = t.session_id
+       WHERE t.status IN ('pending', 'running')
+       ORDER BY t.created_at ASC`
+  ).all();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const items = db2.prepare("UPDATE items SET status = 'failed', updated_at = ? WHERE status = 'in_progress'").run(now);
+  let waiting = 0;
+  let failed = 0;
+  for (const turn of live) {
+    const lastActivity = turn.last_item_at && turn.last_item_at > turn.updated_at ? turn.last_item_at : turn.updated_at;
+    if (turn.thread_id || !opts.canResume(turn.runtime_type)) {
+      if (turn.resume_state !== "waiting") {
+        markTurnInterrupted(db2, turn.id, "host_restart", { at: lastActivity, notify: false });
+      }
+      finalizeInterruptedTurn(db2, turn.id, "unsupported", HOST_RESTART_ERROR);
+      failed++;
+      continue;
+    }
+    if (turn.status === "pending" && turn.resume_state === "waiting") {
+      recomputeSessionRunning(db2, turn.session_id);
+      waiting++;
+      continue;
+    }
+    markTurnInterrupted(db2, turn.id, "host_restart", { at: lastActivity, notify: false });
+    waiting++;
+  }
+  const flagged = db2.prepare("SELECT id FROM sessions WHERE is_running = 1").all();
+  for (const s of flagged) recomputeSessionRunning(db2, s.id);
+  if (waiting > 0 || failed > 0 || items.changes > 0) {
+    console.log(
+      `[resume] recovered interrupted state: ${waiting} turns waiting to resume, ${failed} failed, ${items.changes} items closed`
+    );
+  }
+  return { waiting, failed, items: items.changes };
+}
+
+// src/resume/net-probe.ts
+var DEFAULT_API_URL = "https://api.anthropic.com";
+function probeTarget(env = process.env) {
+  if (env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy) return null;
+  if (env.CLAUDE_CODE_USE_BEDROCK === "1" || env.CLAUDE_CODE_USE_VERTEX === "1") return null;
+  return env.ANTHROPIC_BASE_URL || DEFAULT_API_URL;
+}
+async function probeApi(opts = {}) {
+  const url = opts.url ?? probeTarget(opts.env);
+  if (!url) return true;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  try {
+    const res = await fetchImpl(url, {
+      method: "HEAD",
+      redirect: "manual",
+      signal: AbortSignal.timeout(opts.timeoutMs ?? 5e3)
+    });
+    await res.body?.cancel().catch(() => {
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/resume/resume-manager.ts
+var HOUR = 60 * 60 * 1e3;
+function envNumber(env, name, fallback) {
+  const raw = env[name];
+  if (raw === void 0 || raw === "") return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function readAutoResumeConfig(env = process.env) {
+  return {
+    enabled: env.AGENT_PANE_AUTO_RESUME !== "0",
+    maxAgeMs: envNumber(env, "AGENT_PANE_AUTO_RESUME_MAX_AGE_MS", 24 * HOUR),
+    maxAttempts: envNumber(env, "AGENT_PANE_AUTO_RESUME_MAX_ATTEMPTS", 3),
+    delayMs: envNumber(env, "AGENT_PANE_AUTO_RESUME_DELAY_MS", 3e3),
+    networkDelayMs: envNumber(env, "AGENT_PANE_AUTO_RESUME_NETWORK_DELAY_MS", 15e3),
+    staggerMs: 1500,
+    probeMaxDelayMs: 6e4,
+    probeFailuresBeforeForce: 10
+  };
+}
+var config = null;
+var probe = () => probeApi();
+var unsubscribe = null;
+var timer = null;
+var timerDue = 0;
+var scanning = null;
+var rescanDelay = null;
+var probeFailures = 0;
+function canResumeRuntime(runtimeType) {
+  return hasProvider(runtimeType) && typeof getProvider(runtimeType).resumeInterruptedTurn === "function";
+}
+function startAutoResume(opts = {}) {
+  if (config) return null;
+  const cfg = { ...readAutoResumeConfig(), ...opts.config };
+  config = cfg;
+  probe = opts.probe ?? (() => probeApi());
+  probeFailures = 0;
+  const summary = recoverInterruptedTurns(getDb(), { canResume: canResumeRuntime });
+  unsubscribe = onTurnInterrupted((event) => {
+    scheduleScan(event.reason === "network" ? cfg.networkDelayMs : cfg.delayMs);
+  });
+  if (!cfg.enabled) console.log("[resume] automatic resume is off (AGENT_PANE_AUTO_RESUME=0)");
+  scheduleScan(cfg.delayMs);
+  return summary;
+}
+function stopAutoResume() {
+  if (timer) clearTimeout(timer);
+  timer = null;
+  unsubscribe?.();
+  unsubscribe = null;
+  config = null;
+  rescanDelay = null;
+}
+function scheduleScan(delayMs) {
+  if (!config) return;
+  if (scanning) {
+    rescanDelay = rescanDelay === null ? delayMs : Math.min(rescanDelay, delayMs);
+    return;
+  }
+  const due = Date.now() + delayMs;
+  if (timer && timerDue <= due) return;
+  if (timer) clearTimeout(timer);
+  timerDue = due;
+  timer = setTimeout(() => {
+    timer = null;
+    void runScan();
+  }, delayMs);
+  timer.unref?.();
+}
+async function runScan() {
+  if (scanning) return scanning;
+  scanning = (async () => {
+    try {
+      await scan();
+    } catch (err) {
+      console.error("[resume] scan failed:", err);
+    } finally {
+      scanning = null;
+      const again = rescanDelay;
+      rescanDelay = null;
+      if (again !== null) scheduleScan(again);
+    }
+  })();
+  return scanning;
+}
+async function scan() {
+  const cfg = config;
+  if (!cfg || !cfg.enabled) return;
+  const db2 = getDb();
+  const waiting = db2.prepare(
+    `SELECT id, session_id, interrupted_at, resume_attempts FROM turns
+       WHERE status = 'pending' AND resume_state = 'waiting'
+       ORDER BY interrupted_at ASC, created_at ASC`
+  ).all();
+  const due = [];
+  for (const turn of waiting) {
+    const at = turn.interrupted_at ? Date.parse(turn.interrupted_at) : NaN;
+    if (Number.isFinite(at) && Date.now() - at > cfg.maxAgeMs) {
+      finalizeInterruptedTurn(db2, turn.id, "skipped", "Interrupted too long ago to resume automatically");
+    } else if (turn.resume_attempts >= cfg.maxAttempts) {
+      finalizeInterruptedTurn(
+        db2,
+        turn.id,
+        "gave_up",
+        `Automatic resume stopped after ${turn.resume_attempts} attempts`
+      );
+    } else {
+      due.push(turn);
+    }
+  }
+  if (due.length === 0) {
+    probeFailures = 0;
+    return;
+  }
+  let countAttempt = true;
+  if (!await probe()) {
+    probeFailures++;
+    if (probeFailures < cfg.probeFailuresBeforeForce) {
+      const delay = Math.min(cfg.networkDelayMs * 2 ** (probeFailures - 1), cfg.probeMaxDelayMs);
+      console.log(`[resume] model API unreachable \u2014 ${due.length} turn(s) wait, next check in ${delay}ms`);
+      scheduleScan(Math.max(delay, 1e3));
+      return;
+    }
+    console.log(`[resume] model API still unreachable after ${probeFailures} checks \u2014 resuming anyway`);
+    countAttempt = false;
+  }
+  probeFailures = 0;
+  for (let i = 0; i < due.length; i++) {
+    if (config !== cfg) return;
+    if (i > 0) await new Promise((resolve) => setTimeout(resolve, cfg.staggerMs));
+    const result = await resumeTurn(due[i].id, { manual: false, countAttempt });
+    if (!result.ok && result.status === 409) {
+      finalizeInterruptedTurn(db2, due[i].id, "skipped", result.error);
+    }
+  }
+}
+function resumeBlocker(db2, session, turn, manual) {
+  if (turn.thread_id) return { status: 409, error: "Discussion-thread turns cannot be resumed" };
+  if (!isResumable(turn, manual)) return { status: 409, error: "Turn is not waiting to be resumed" };
+  if (!canResumeRuntime(session.runtime_type)) {
+    return { status: 409, error: `The ${session.runtime_type} runtime cannot resume turns` };
+  }
+  const latest = db2.prepare("SELECT id FROM turns WHERE session_id = ? AND thread_id IS NULL ORDER BY created_at DESC, rowid DESC LIMIT 1").get(session.id);
+  if (latest?.id !== turn.id) return { status: 409, error: "Only the latest turn of a session can be resumed" };
+  const other = db2.prepare(
+    "SELECT 1 FROM turns WHERE session_id = ? AND thread_id IS NULL AND id != ? AND status IN ('pending', 'running') LIMIT 1"
+  ).get(session.id, turn.id);
+  if (other) return { status: 409, error: "Another turn is running in this session" };
+  return null;
+}
+async function resumeTurn(turnId, opts) {
+  const db2 = getDb();
+  const turn = db2.prepare("SELECT * FROM turns WHERE id = ?").get(turnId);
+  if (!turn) return { ok: false, status: 404, error: "Turn not found" };
+  const session = db2.prepare("SELECT * FROM sessions WHERE id = ?").get(turn.session_id);
+  if (!session) return { ok: false, status: 404, error: "Session not found" };
+  const blocker = resumeBlocker(db2, session, turn, opts.manual);
+  if (blocker) return { ok: false, ...blocker };
+  const resuming = markTurnResuming(db2, turnId, { manual: opts.manual, countAttempt: opts.countAttempt });
+  if (!resuming) return { ok: false, status: 409, error: "Turn is not waiting to be resumed" };
+  console.log(
+    `[resume] resuming turn ${turnId} of session ${session.id} (${resuming.reason}, attempt ${resuming.attempt}${opts.manual ? ", manual" : ""})`
+  );
+  try {
+    await getProvider(session.runtime_type).resumeInterruptedTurn(session, turn, { reason: resuming.reason });
+  } catch (err) {
+    const message = err.message;
+    console.error(`[resume] could not resume turn ${turnId}:`, message);
+    markTurnInterrupted(db2, turnId, resuming.reason, { detail: `Resume failed: ${message}` });
+    return { ok: false, status: 500, error: message };
+  }
+  return { ok: true };
+}
+async function resumeNow(sessionId, turnId) {
+  const db2 = getDb();
+  const row = db2.prepare("SELECT session_id FROM turns WHERE id = ?").get(turnId);
+  if (!row || row.session_id !== sessionId) return { ok: false, status: 404, error: "Turn not found" };
+  return resumeTurn(turnId, { manual: true });
+}
+
 // src/routes/turns.ts
 async function registerTurnRoutes(fastify) {
   fastify.post(
@@ -41910,6 +42308,22 @@ async function registerTurnRoutes(fastify) {
     }
     return { success: true };
   });
+  fastify.post(
+    "/api/sessions/:id/turns/:turnId/resume",
+    async (request, reply) => {
+      const { id, turnId } = request.params;
+      const db2 = getDb();
+      const session = db2.prepare("SELECT id FROM sessions WHERE id = ?").get(id);
+      if (!session) {
+        return reply.code(404).send({ error: "Session not found" });
+      }
+      const result = await resumeNow(id, turnId);
+      if (!result.ok) {
+        return reply.code(result.status).send({ error: result.error });
+      }
+      return reply.code(202).send({ success: true });
+    }
+  );
 }
 
 // src/routes/threads.ts
@@ -42620,14 +43034,14 @@ var AppServerClient = class {
       }
       const id = this.nextId++;
       const message = JSON.stringify({ id, method, params }) + "\n";
-      const timer = setTimeout(() => {
+      const timer2 = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`Request '${method}' (id=${id}) timed out after ${REQUEST_TIMEOUT_MS}ms`));
       }, REQUEST_TIMEOUT_MS);
       this.pending.set(id, {
         resolve,
         reject,
-        timer
+        timer: timer2
       });
       this.write(message);
     });
@@ -43317,14 +43731,14 @@ var VscodeWebManager = class {
   waitForReady(inst) {
     const deadline = this.deps.now() + STARTUP_TIMEOUT_MS;
     return new Promise((resolve) => {
-      const timer = setInterval(async () => {
+      const timer2 = setInterval(async () => {
         if (inst.state !== "starting") {
-          clearInterval(timer);
+          clearInterval(timer2);
           resolve();
           return;
         }
         if (this.deps.now() > deadline) {
-          clearInterval(timer);
+          clearInterval(timer2);
           inst.state = "error";
           inst.error = `serve-web did not become ready within ${STARTUP_TIMEOUT_MS / 1e3}s`;
           inst.stopping = true;
@@ -43336,7 +43750,7 @@ var VscodeWebManager = class {
         }
         try {
           await this.deps.probe(inst.port, inst.token);
-          clearInterval(timer);
+          clearInterval(timer2);
           if (inst.state === "starting") {
             inst.state = "running";
             this.markAccessed(inst.id);
@@ -43724,8 +44138,8 @@ function startAppsWatch(onAppChange) {
       const file = segs[segs.length - 1];
       if (!appId || appId === path3.basename(root) || !APP_ID_RE.test(appId) || file === "state.json") return;
       if (segs.length === 1 && isRegularFile(path3.join(root, appId))) return;
-      const timer = pendingChanges.get(appId);
-      if (timer) clearTimeout(timer);
+      const timer2 = pendingChanges.get(appId);
+      if (timer2) clearTimeout(timer2);
       pendingChanges.set(
         appId,
         setTimeout(() => {
@@ -43743,7 +44157,7 @@ function stopAppsWatch() {
     watcher.close();
     watcher = null;
   }
-  for (const timer of pendingChanges.values()) clearTimeout(timer);
+  for (const timer2 of pendingChanges.values()) clearTimeout(timer2);
   pendingChanges.clear();
 }
 
@@ -44139,7 +44553,7 @@ function getHeadlessToolHandler(appId, workspace = "") {
 function dispatchHeadlessToolCall(handler, tool, args) {
   const callId = v4_default();
   const result = new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
+    const timer2 = setTimeout(() => {
       pendingCalls.delete(callId);
       reject(
         new Error(
@@ -44147,7 +44561,7 @@ function dispatchHeadlessToolCall(handler, tool, args) {
         )
       );
     }, HEADLESS_TOOL_TIMEOUT_MS);
-    pendingCalls.set(callId, { resolve, reject, timer });
+    pendingCalls.set(callId, { resolve, reject, timer: timer2 });
   });
   try {
     handler("tool_call", { callId, tool, name: tool, args: args ?? {} });
@@ -44225,7 +44639,7 @@ function dispatchAppTool(toolName, args, workspace = "") {
   }
   const callId = v4_default();
   const result = new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
+    const timer2 = setTimeout(() => {
       pendingCalls2.delete(callId);
       reject(
         new Error(
@@ -44233,7 +44647,7 @@ function dispatchAppTool(toolName, args, workspace = "") {
         )
       );
     }, TOOL_CALL_TIMEOUT_MS);
-    pendingCalls2.set(callId, { resolve, reject, timer, appId });
+    pendingCalls2.set(callId, { resolve, reject, timer: timer2, appId });
     broadcast("app:tool_call", { appId, callId, tool: localName, args: args ?? {} });
   });
   return { callId, result };
@@ -44795,8 +45209,8 @@ function parseRuntimeConfig(session) {
     return null;
   }
 }
-function sandboxType(config) {
-  switch (config?.sandboxMode) {
+function sandboxType(config2) {
+  switch (config2?.sandboxMode) {
     case "read-only":
       return "read-only";
     case "danger-full-access":
@@ -44857,8 +45271,8 @@ async function getOrCreateThread(session) {
   if (session.origin_app_id) {
     autoApproveToolUserInput(client);
   }
-  const config = parseRuntimeConfig(session);
-  const sandbox = sandboxType(config);
+  const config2 = parseRuntimeConfig(session);
+  const sandbox = sandboxType(config2);
   const instructions = threadInstructionParams(cwd);
   let threadId;
   if (session.external_thread_id) {
@@ -44916,8 +45330,8 @@ async function startTurn(session, turn) {
   setSessionStatus(db2, session.id, 1, "running", now);
   broadcast("turn:started", { sessionId: session.id, turnId: turn.id });
   const { client, threadId } = entry;
-  const config = parseRuntimeConfig(session);
-  const sandbox = sandboxType(config);
+  const config2 = parseRuntimeConfig(session);
+  const sandbox = sandboxType(config2);
   let turnDone = false;
   const handleItemStarted = (params) => {
     if (turnDone) return;
@@ -45591,6 +46005,42 @@ async function refreshContext(entry, sessionId, db2) {
   publish(entry, sessionId, db2);
 }
 
+// src/claude/api-errors.ts
+var FATAL_ERRORS = /* @__PURE__ */ new Set([
+  "authentication_failed",
+  "oauth_org_not_allowed",
+  "account_on_hold",
+  "verification_required",
+  "billing_error",
+  "rate_limit",
+  "invalid_request",
+  "model_not_found",
+  "max_output_tokens",
+  "cloud_credential_error"
+]);
+var TRANSIENT_ERRORS = /* @__PURE__ */ new Set(["server_error", "overloaded"]);
+var NETWORK_TEXTS = [
+  /connection (error|lost|dropped|closed|refused|reset)/i,
+  /unable to connect/i,
+  /request timed out/i,
+  /check your internet connection/i,
+  /no response from (the )?api/i,
+  /\b(ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|EPIPE)\b/,
+  /socket hang up|fetch failed|network error/i,
+  /overloaded/i
+];
+function classifyApiError({ error, status, text }) {
+  if (error && FATAL_ERRORS.has(error)) return "fatal";
+  if (error && TRANSIENT_ERRORS.has(error)) return "network";
+  if (typeof status === "number") {
+    if (status === 408 || status >= 500) return "network";
+    return "fatal";
+  }
+  if (text && NETWORK_TEXTS.some((re) => re.test(text))) return "network";
+  if (status === null && (!error || error === "unknown")) return "network";
+  return "fatal";
+}
+
 // src/claude/claude-provider.ts
 var PromptQueue = class {
   buffer = [];
@@ -45688,10 +46138,153 @@ function setSessionStatus2(db2, sessionId, isRunning, status, now, hasUnreviewed
     );
   }
 }
-async function ensureSessionStarted(session, mapKey, resumeSessionId) {
+var CONTINUE_PROMPT = "Continue from where you left off.";
+function rescueWaitMs() {
+  const ms = Number(process.env.AGENT_PANE_RESCUE_WAIT_MS);
+  return Number.isFinite(ms) && ms > 0 ? ms : 15e3;
+}
+var RESCUE_ENV = ["CLAUDE_CODE_RESUME_INTERRUPTED_TURN", "CLAUDE_CODE_RESUME_REASON"];
+function spawnEnv(resume) {
+  const inherited = RESCUE_ENV.some((k) => k in process.env);
+  if (!resume && !inherited) return void 0;
+  const env = { ...process.env };
+  for (const k of RESCUE_ENV) delete env[k];
+  if (resume) {
+    env.CLAUDE_CODE_RESUME_INTERRUPTED_TURN = "1";
+    env.CLAUDE_CODE_RESUME_REASON = resume.reason;
+  }
+  return env;
+}
+function isSignalExit(message) {
+  if (/terminated by signal SIG/.test(message)) return true;
+  const m = /exited with code (\d+)/.exec(message);
+  if (!m) return false;
+  const code = Number(m[1]);
+  return code > 128 && code < 160;
+}
+function clearResume(entry) {
+  if (entry.resume?.watchdog) clearTimeout(entry.resume.watchdog);
+  entry.resume = null;
+}
+function pushPrompt(entry, content) {
+  entry.promptQueue.push({
+    type: "user",
+    message: { role: "user", content },
+    parent_tool_use_id: null
+  });
+}
+function armRescueWatchdog(entry, ms = rescueWaitMs()) {
+  const r = entry.resume;
+  if (!r || r.phase !== "awaiting_rescue") return;
+  if (r.watchdog) clearTimeout(r.watchdog);
+  r.watchdog = setTimeout(() => {
+    r.watchdog = null;
+    if (entry.resume !== r || r.phase !== "awaiting_rescue" || entry.closeReason) return;
+    let content = CONTINUE_PROMPT;
+    try {
+      const db2 = getDb();
+      const turn = db2.prepare("SELECT * FROM turns WHERE id = ?").get(r.turnId);
+      if (!turn || turn.status !== "running") return;
+      const produced = db2.prepare("SELECT 1 FROM items WHERE turn_id = ? AND type NOT IN ('interruption', 'error') LIMIT 1").get(r.turnId);
+      if (!produced) content = buildUserContent(turn);
+    } catch (err) {
+      console.error("[claude] resume fallback failed:", err.message);
+      return;
+    }
+    console.log(`[claude] no interrupted-turn rescue for turn ${r.turnId} \u2014 continuing it with a prompt`);
+    r.phase = "continuing";
+    pushPrompt(entry, content);
+  }, ms);
+  r.watchdog.unref?.();
+}
+function isModelFrame(message) {
+  if (message.parent_tool_use_id) return false;
+  if (message.type === "stream_event") return true;
+  if (message.type === "assistant") return message.message?.model !== "<synthetic>";
+  return false;
+}
+function trackResumeFrame(entry, message, db2) {
+  const r = entry.resume;
+  if (!r) return true;
+  if (r.turnId !== entry.turnId) {
+    clearResume(entry);
+    return true;
+  }
+  if (r.phase === "awaiting_rescue") {
+    if (message.resume_reason) {
+      if (r.watchdog) clearTimeout(r.watchdog);
+      r.watchdog = null;
+      r.phase = "continuing";
+    } else {
+      if (message.type === "result") return false;
+      if (message.type === "system") {
+        const sub = message.subtype;
+        if (sub === "api_retry" || sub === "status") armRescueWatchdog(entry);
+      }
+      return true;
+    }
+  }
+  if (isModelFrame(message)) {
+    clearResume(entry);
+    markTurnResumed(db2, r.turnId);
+  } else if (message.type === "result") {
+    clearResume(entry);
+  }
+  return true;
+}
+function failTurn(db2, sessionId, turnId, error) {
+  const row = db2.prepare("SELECT resume_state FROM turns WHERE id = ?").get(turnId);
+  if (row?.resume_state === "waiting" || row?.resume_state === "resuming") {
+    if (finalizeInterruptedTurn(db2, turnId, "gave_up", error)) return;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db2.prepare("UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?").run("failed", error, now, turnId);
+  recomputeSessionRunning(db2, sessionId, "failed");
+  broadcast("turn:failed", { sessionId, turnId, error });
+}
+function handleLoopError(entry, sessionId, errMsg, db2) {
+  if (!entry.turnId) return;
+  const turnId = entry.turnId;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const staleItems = db2.prepare(
+    "UPDATE items SET status = 'failed', updated_at = ? WHERE status = 'in_progress' AND turn_id IN (SELECT id FROM turns WHERE session_id = ?)"
+  ).run(now, sessionId);
+  const turn = db2.prepare("SELECT status FROM turns WHERE id = ?").get(turnId);
+  if (turn && (turn.status === "pending" || turn.status === "running")) {
+    if (!entry.threadId && !entry.closeReason && isSignalExit(errMsg)) {
+      markTurnInterrupted(db2, turnId, "process_exit", { detail: errMsg });
+    } else {
+      failTurn(db2, sessionId, turnId, errMsg);
+    }
+  }
+  if (staleItems.changes > 0) {
+    const staleRows = db2.prepare(
+      "SELECT id, turn_id, external_item_id, type, data, created_at FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?) AND status = 'failed' AND updated_at = ?"
+    ).all(sessionId, now);
+    for (const row of staleRows) {
+      broadcast("item:completed", {
+        sessionId,
+        turnId: row.turn_id,
+        item: {
+          id: row.id,
+          turn_id: row.turn_id,
+          external_item_id: row.external_item_id,
+          type: row.type,
+          data: row.data ? JSON.parse(row.data) : {},
+          status: "failed",
+          created_at: row.created_at,
+          updated_at: now
+        }
+      });
+    }
+  }
+}
+async function ensureSessionStarted(session, mapKey, resumeSessionId, resume) {
   const db2 = getDb();
   const key = mapKey ?? session.id;
   const resumeId = mapKey !== void 0 ? resumeSessionId : resumeSessionId ?? session.external_thread_id ?? void 0;
+  const rescue = resume && resumeId ? resume : void 0;
+  const env = spawnEnv(rescue);
   const options = {
     cwd: session.cwd ?? process.cwd(),
     model: session.model ?? void 0,
@@ -45700,19 +46293,32 @@ async function ensureSessionStarted(session, mapKey, resumeSessionId) {
     includePartialMessages: true,
     ...CLI_OVERRIDE,
     ...session.model_reasoning_effort ? { effort: session.model_reasoning_effort } : {},
-    ...resumeId ? { resume: resumeId } : {}
+    ...resumeId ? { resume: resumeId } : {},
+    ...env ? { env } : {}
   };
   const promptQueue = new PromptQueue();
   const q = query({ prompt: promptQueue, options });
   const entry = {
     query: q,
     sessionId: null,
-    turnId: null,
+    turnId: resume?.turnId ?? null,
     cwd: session.cwd ?? process.cwd(),
     promptQueue,
-    messageLoop: null
+    messageLoop: null,
+    closeReason: null,
+    resume: resume ? { turnId: resume.turnId, phase: rescue ? "awaiting_rescue" : "continuing", watchdog: null } : null,
+    lastApiError: null
   };
   sessionMap2.set(key, entry);
+  if (rescue) {
+    armRescueWatchdog(entry, rescueWaitMs() * 4);
+    q.initializationResult().then(
+      () => armRescueWatchdog(entry),
+      () => {
+      }
+      // start failed — the message loop reports it
+    );
+  }
   entry.messageLoop = (async () => {
     try {
       for await (const message of q) {
@@ -45722,8 +46328,10 @@ async function ensureSessionStarted(session, mapKey, resumeSessionId) {
         }
         const currentTurnId = entry.turnId;
         if (!currentTurnId) continue;
+        if (entry.resume && !trackResumeFrame(entry, message, db2)) continue;
         await handleMessage(message, session.id, currentTurnId, entry, db2);
       }
+      if (entry.closeReason === "shutdown") return;
       if (entry.turnId) {
         const currentTurn = db2.prepare("SELECT status, token_usage FROM turns WHERE id = ?").get(entry.turnId);
         if (currentTurn && currentTurn.status === "running") {
@@ -45734,43 +46342,16 @@ async function ensureSessionStarted(session, mapKey, resumeSessionId) {
       }
     } catch (err) {
       const errMsg = err.message;
+      clearResume(entry);
+      if (entry.closeReason === "shutdown") return;
       console.error(`[claude] message loop error for session ${session.id}:`, errMsg);
-      if (entry.turnId) {
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        const staleItems = db2.prepare(
-          "UPDATE items SET status = 'failed', updated_at = ? WHERE status = 'in_progress' AND turn_id IN (SELECT id FROM turns WHERE session_id = ?)"
-        ).run(now, session.id);
-        db2.prepare("UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?").run(
-          "failed",
-          errMsg,
-          now,
-          entry.turnId
-        );
-        recomputeSessionRunning(db2, session.id, "failed");
-        broadcast("turn:failed", { sessionId: session.id, turnId: entry.turnId, error: errMsg });
-        if (staleItems.changes > 0) {
-          const staleRows = db2.prepare(
-            "SELECT id, turn_id, external_item_id, type, data, created_at FROM items WHERE turn_id IN (SELECT id FROM turns WHERE session_id = ?) AND status = 'failed' AND updated_at = ?"
-          ).all(session.id, now);
-          for (const row of staleRows) {
-            broadcast("item:completed", {
-              sessionId: session.id,
-              turnId: row.turn_id,
-              item: {
-                id: row.id,
-                turn_id: row.turn_id,
-                external_item_id: row.external_item_id,
-                type: row.type,
-                data: row.data ? JSON.parse(row.data) : {},
-                status: "failed",
-                created_at: row.created_at,
-                updated_at: now
-              }
-            });
-          }
-        }
+      try {
+        handleLoopError(entry, session.id, errMsg, db2);
+      } catch (cleanupErr) {
+        console.error(`[claude] cleanup after loop error failed for session ${session.id}:`, cleanupErr);
       }
     } finally {
+      clearResume(entry);
       if (entry.turnId) {
         streamingMessageIds.delete(entry.turnId);
       }
@@ -45818,13 +46399,20 @@ async function startTurn2(session, turn) {
     streamingMessageIds.delete(entry.turnId);
   }
   entry.turnId = turn.id;
+  entry.lastApiError = null;
+  clearResume(entry);
   db2.prepare("UPDATE turns SET status = ?, updated_at = ? WHERE id = ?").run("running", now, turn.id);
   setSessionStatus2(db2, session.id, 1, "running", now);
   broadcast("turn:started", { sessionId: session.id, turnId: turn.id });
+  pushPrompt(entry, buildUserContent(turn));
+}
+function buildUserContent(turn) {
   let content;
   const rawAttachments = turn.attachments;
   let attachments = null;
-  if (rawAttachments) {
+  if (Array.isArray(rawAttachments)) {
+    attachments = rawAttachments;
+  } else if (rawAttachments) {
     try {
       attachments = JSON.parse(rawAttachments);
     } catch {
@@ -45860,11 +46448,7 @@ ${decoded}
   } else {
     content = turn.user_prompt;
   }
-  entry.promptQueue.push({
-    type: "user",
-    message: { role: "user", content },
-    parent_tool_use_id: null
-  });
+  return content;
 }
 async function handleMessage(message, sessionId, turnId, entry, db2) {
   switch (message.type) {
@@ -45915,6 +46499,17 @@ async function handleMessage(message, sessionId, turnId, entry, db2) {
             entry,
             db2
           );
+        } else if (sub === "api_retry") {
+          const m = message;
+          broadcast("turn:retrying", {
+            sessionId,
+            turnId,
+            attempt: m.attempt,
+            maxRetries: m.max_retries,
+            retryDelayMs: m.retry_delay_ms,
+            errorStatus: m.error_status ?? null,
+            error: m.error ?? null
+          });
         }
       }
       break;
@@ -45957,6 +46552,26 @@ function handleAssistantMessage(message, sessionId, turnId, entry, db2) {
   if (message.message?.model !== "<synthetic>") {
     recordApiUsage(entry, sessionId, db2, message.message?.id ?? null, message.message?.usage);
   }
+  const apiError = message.error;
+  if (apiError && message.message?.model === "<synthetic>") {
+    const blocks = Array.isArray(message.message?.content) ? message.message.content : [];
+    const text = blocks.map((b) => {
+      const block = b;
+      return block?.type === "text" && typeof block.text === "string" ? block.text : "";
+    }).join("").trim() || `API error (${apiError})`;
+    entry.lastApiError = { error: apiError, text };
+    thinkingAccumulator.delete(messageId);
+    streamingMessageIds.delete(turnId);
+    upsertItem(
+      db2,
+      { type: "error", data: { message: text, error: apiError }, externalId: `api-error-${messageId}` },
+      sessionId,
+      turnId,
+      "completed",
+      "item:completed"
+    );
+    return;
+  }
   const content = message.message.content;
   const anthropicMsgId = message.message?.id ?? messageId;
   const thinkingTexts = thinkingAccumulator.get(messageId);
@@ -46208,22 +46823,29 @@ async function handleResultMessage(message, sessionId, turnId, entry, db2) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     db2.prepare("UPDATE turns SET token_usage = ?, updated_at = ? WHERE id = ?").run(JSON.stringify(usage), now, turnId);
     broadcast("turn:tokenUsage", { sessionId, turnId, usage });
+    const apiError = entry.lastApiError;
+    entry.lastApiError = null;
+    if (message.is_error) {
+      const row = db2.prepare("SELECT status FROM turns WHERE id = ?").get(turnId);
+      if (row?.status !== "pending" && row?.status !== "running") return;
+      const text = (message.result || apiError?.text || "Claude API error").trim();
+      const kind = classifyApiError({ error: apiError?.error, status: message.api_error_status, text });
+      if (kind === "network" && !entry.threadId && markTurnInterrupted(db2, turnId, "network", { detail: text })) {
+        return;
+      }
+      failTurn(db2, sessionId, turnId, text);
+      return;
+    }
     await refreshContext(entry, sessionId, db2);
     completeTurn(db2, sessionId, turnId, usage);
   } else {
-    const errorMsg = message.errors?.join("; ") ?? "Claude turn failed";
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    db2.prepare("UPDATE turns SET status = ?, error = ?, updated_at = ? WHERE id = ?").run(
-      "failed",
-      errorMsg,
-      now,
-      turnId
-    );
-    recomputeSessionRunning(db2, sessionId, "failed");
-    broadcast("turn:failed", { sessionId, turnId, error: errorMsg });
+    entry.lastApiError = null;
+    const errorMsg = message.errors?.join("; ") || "Claude turn failed";
+    failTurn(db2, sessionId, turnId, errorMsg);
   }
 }
 function completeTurn(db2, sessionId, turnId, usage) {
+  markTurnResumed(db2, turnId, { settle: true });
   const now = (/* @__PURE__ */ new Date()).toISOString();
   if (usage) {
     db2.prepare("UPDATE turns SET status = ?, token_usage = ?, updated_at = ? WHERE id = ?").run(
@@ -46294,13 +46916,17 @@ async function interruptTurn2(sessionId, threadId) {
       await entry.query.interrupt();
       const db2 = getDb();
       const now = (/* @__PURE__ */ new Date()).toISOString();
+      clearResume(entry);
       db2.prepare("UPDATE turns SET status = ?, updated_at = ? WHERE id = ?").run("aborted", now, turnId);
+      markResumeCancelled(db2, turnId);
       recomputeSessionRunning(db2, sessionId);
       broadcast("turn:cancelled", { sessionId, turnId });
       streamingMessageIds.delete(turnId);
       entry.turnId = null;
       return true;
     } catch {
+      entry.closeReason = "clear";
+      clearResume(entry);
       entry.promptQueue.close();
       entry.query.close();
       streamingMessageIds.delete(turnId);
@@ -46316,6 +46942,7 @@ async function interruptTurn2(sessionId, threadId) {
     if (!orphan) return false;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     db2.prepare("UPDATE turns SET status = ?, updated_at = ? WHERE id = ?").run("aborted", now, orphan.id);
+    markResumeCancelled(db2, orphan.id);
     recomputeSessionRunning(db2, sessionId);
     broadcast("turn:cancelled", { sessionId, turnId: orphan.id });
     streamingMessageIds.delete(orphan.id);
@@ -46327,6 +46954,8 @@ async function interruptTurn2(sessionId, threadId) {
 function clearThread2(sessionId) {
   const entry = sessionMap2.get(sessionId);
   if (entry) {
+    entry.closeReason ??= "clear";
+    clearResume(entry);
     entry.promptQueue.close();
     entry.query.close();
     if (entry.turnId) {
@@ -46337,6 +46966,7 @@ function clearThread2(sessionId) {
   }
   for (const [key, threadEntry] of sessionMap2) {
     if (key.startsWith(`${sessionId}:thread:`)) {
+      threadEntry.closeReason ??= "clear";
       threadEntry.promptQueue.close();
       threadEntry.query.close();
       if (threadEntry.turnId) {
@@ -46352,6 +46982,7 @@ function clearThreadBranch(sessionId, threadId) {
   const key = `${sessionId}:thread:${threadId}`;
   const entry = sessionMap2.get(key);
   if (entry) {
+    entry.closeReason ??= "clear";
     entry.promptQueue.close();
     entry.query.close();
     if (entry.turnId) {
@@ -46363,6 +46994,8 @@ function clearThreadBranch(sessionId, threadId) {
 }
 function clearAllThreads2() {
   for (const [, entry] of sessionMap2) {
+    entry.closeReason ??= "clear";
+    clearResume(entry);
     entry.promptQueue.close();
     entry.query.close();
     entry.backgroundTasks = [];
@@ -46426,8 +47059,42 @@ function mapSdkCommands(commands) {
   }));
 }
 async function shutdown2() {
+  let db2 = null;
+  try {
+    db2 = getDb();
+  } catch {
+    db2 = null;
+  }
+  for (const entry of sessionMap2.values()) {
+    entry.closeReason = "shutdown";
+    clearResume(entry);
+    if (db2 && entry.turnId && !entry.threadId) {
+      try {
+        markTurnInterrupted(db2, entry.turnId, "host_shutdown", { notify: false });
+      } catch (err) {
+        console.error("[claude] could not park turn for resume:", err.message);
+      }
+    }
+  }
   clearAllThreads2();
 }
+async function resumeInterruptedTurn(session, turn, opts) {
+  if (turn.thread_id) throw new Error("Discussion-thread turns cannot be resumed");
+  const live = sessionMap2.get(session.id);
+  if (live && !live.closeReason) {
+    if (live.turnId && live.turnId !== turn.id) streamingMessageIds.delete(live.turnId);
+    clearResume(live);
+    live.turnId = turn.id;
+    live.threadId = null;
+    live.lastApiError = null;
+    live.resume = { turnId: turn.id, phase: "continuing", watchdog: null };
+    pushPrompt(live, CONTINUE_PROMPT);
+    return;
+  }
+  const entry = await ensureSessionStarted(session, void 0, void 0, { turnId: turn.id, reason: opts.reason });
+  entry.threadId = null;
+  if (entry.resume?.phase === "continuing") pushPrompt(entry, buildUserContent(turn));
+}
 function syncThreadTitle2(sessionId) {
   const db2 = getDb();
   const session = db2.prepare("SELECT title FROM sessions WHERE id = ?").get(sessionId);
@@ -46569,6 +47236,7 @@ var claudeProvider = {
   setModel,
   stopTask,
   listBackgroundTasks,
+  resumeInterruptedTurn,
   shutdown: shutdown2
 };
 
@@ -46678,12 +47346,12 @@ var HttpError = class extends Error {
 };
 async function fetchJson(url, init, timeoutMs = 5e3) {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const timer2 = setTimeout(() => controller.abort(), timeoutMs);
   let response;
   try {
     response = await fetch(url, { ...init, signal: controller.signal });
   } finally {
-    clearTimeout(timer);
+    clearTimeout(timer2);
   }
   const text = await response.text();
   if (!response.ok) {
@@ -47114,11 +47782,11 @@ async function readBody(body, onMessage, opts) {
 function reconnectDelay(delayMs, signal) {
   return new Promise((resolve) => {
     if (signal?.aborted) return resolve();
-    const timer = setTimeout(resolve, delayMs);
+    const timer2 = setTimeout(resolve, delayMs);
     signal?.addEventListener(
       "abort",
       () => {
-        clearTimeout(timer);
+        clearTimeout(timer2);
         resolve();
       },
       { once: true }
@@ -47503,7 +48171,7 @@ var TurnProjector = class {
       );
       throwawayId = created.id;
       const controller = new AbortController();
-      const timer = setTimeout(() => controller.abort(), TITLE_TIMEOUT_MS);
+      const timer2 = setTimeout(() => controller.abort(), TITLE_TIMEOUT_MS);
       try {
         await this.deps.client.createInput(throwawayId, {
           user_prompt: buildTitlePrompt(firstTurn.user_prompt, firstTurn.agent_response),
@@ -47530,7 +48198,7 @@ var TurnProjector = class {
         const title = cleanTitle(reply);
         if (title) this.applyTitle(title);
       } finally {
-        clearTimeout(timer);
+        clearTimeout(timer2);
       }
     } catch {
     } finally {
@@ -47866,7 +48534,7 @@ function failTurnBeforeStart(db2, sessionId, turnId, error) {
   recomputeSessionRunning(db2, sessionId, "failed");
   broadcast("turn:failed", { sessionId, turnId, error });
 }
-function failTurn(entry, error) {
+function failTurn2(entry, error) {
   const active = entry.activeTurn;
   if (!active) return;
   entry.activeTurn = null;
@@ -47909,7 +48577,7 @@ async function runStreamLoop(entry, projector) {
     if (stallTimer) clearTimeout(stallTimer);
     if (projector.isDone || entry.activeTurn?.projector !== projector) return;
     if (reason === "session-not-found") {
-      failTurn(entry, "Repoburg session no longer exists on the backend.");
+      failTurn2(entry, "Repoburg session no longer exists on the backend.");
       return;
     }
     if (reason === "aborted") {
@@ -48001,7 +48669,7 @@ async function startTurn3(session, turn) {
   void ensureContextWindow(entry);
   runStreamLoop(entry, projector).catch((err) => {
     console.error("[repoburg] stream loop crashed:", err);
-    failTurn(entry, `Stream loop failed: ${err.message}`);
+    failTurn2(entry, `Stream loop failed: ${err.message}`);
   });
   try {
     const images = turnImageDataUrls(turn);
@@ -48012,7 +48680,7 @@ async function startTurn3(session, turn) {
     });
   } catch (err) {
     if (isConnectionError(err)) invalidateBackend(entry.baseUrl);
-    failTurn(entry, err.message);
+    failTurn2(entry, err.message);
   }
 }
 async function interruptTurn3(sessionId, threadId) {
@@ -48238,8 +48906,10 @@ async function main() {
     fastify.log.error(err);
     process.exit(1);
   }
+  startAutoResume();
   async function gracefulShutdown(signal) {
     fastify.log.info(`Received ${signal}, shutting down...`);
+    stopAutoResume();
     await shutdownAllProviders();
     await fastify.close();
     process.exit(0);