@lesscap/baton-cli 0.7.10 → 0.8.0

package/dist/baton.mjs

@@ -5398,6 +5398,13 @@ var renderList = (items, fmt, json) => {
 var removed = (kind, id, json) => json ? toJson({ ok: true, deleted: id }) : `deleted ${kind} ${id}`;
 
 // src/client/request.ts
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
 var authHeaders = {};
 var loginGate = null;
 var setAuthHeaders = (h) => {
@@ -5414,7 +5421,8 @@ var request = async (url, init2) => {
     headers: { ...baseHeaders, ...authHeaders, ...init2.headers ?? {} },
     ...init2.body !== void 0 ? { body: JSON.stringify(init2.body) } : {}
   });
-  if (!res.ok) throw new Error(`${init2.method} ${url} \u2192 ${res.status}: ${await res.text()}`);
+  if (!res.ok)
+    throw new HttpError(res.status, `${init2.method} ${url} \u2192 ${res.status}: ${await res.text()}`);
   if (res.status === 204) return void 0;
   return await res.json();
 };
@@ -5425,11 +5433,32 @@ var rawRequest = async (url, init2) => {
     headers: { ...authHeaders, ...init2.headers ?? {} },
     ...init2.body !== void 0 ? { body: init2.body } : {}
   });
-  if (!res.ok) throw new Error(`${init2.method} ${url} \u2192 ${res.status}: ${await res.text()}`);
+  if (!res.ok)
+    throw new HttpError(res.status, `${init2.method} ${url} \u2192 ${res.status}: ${await res.text()}`);
   if (res.status === 204) return void 0;
   return await res.json();
 };
 
+// src/client/artifacts.ts
+var artifactsClient = (baseUrl) => {
+  const url = (path) => `${baseUrl}${path}`;
+  return {
+    publish: (projectId, input) => rawRequest(
+      url(`/artifacts?projectId=${projectId}&filename=${encodeURIComponent(input.filename)}`),
+      {
+        method: "POST",
+        body: input.body,
+        headers: {
+          "content-type": input.contentType,
+          "content-length": String(input.body.size)
+        }
+      }
+    ),
+    listByProject: (projectId) => request(url(`/artifacts?projectId=${projectId}`), { method: "GET" }),
+    remove: (id) => request(url(`/artifacts/${id}`), { method: "DELETE" })
+  };
+};
+
 // src/client/auth.ts
 var primed = false;
 var primeLogin = (baseUrl) => {
@@ -5457,26 +5486,6 @@ var primeLogin = (baseUrl) => {
   );
 };
 
-// src/client/artifacts.ts
-var artifactsClient = (baseUrl) => {
-  const url = (path) => `${baseUrl}${path}`;
-  return {
-    publish: (projectId, input) => rawRequest(
-      url(`/artifacts?projectId=${projectId}&filename=${encodeURIComponent(input.filename)}`),
-      {
-        method: "POST",
-        body: input.body,
-        headers: {
-          "content-type": input.contentType,
-          "content-length": String(input.body.size)
-        }
-      }
-    ),
-    listByProject: (projectId) => request(url(`/artifacts?projectId=${projectId}`), { method: "GET" }),
-    remove: (id) => request(url(`/artifacts/${id}`), { method: "DELETE" })
-  };
-};
-
 // src/client/loops.ts
 var loopsClient = (baseUrl) => {
   const u = (p) => `${baseUrl}${p}`;
@@ -5527,6 +5536,19 @@ var requirementClient = (baseUrl) => {
   };
 };
 
+// src/client/services.ts
+var servicesClient = (baseUrl) => {
+  const u = (path) => `${baseUrl}${path}`;
+  return {
+    listByProject: (projectId) => request(u(`/projects/${projectId}/services`), { method: "GET" }),
+    run: (workerId, input) => request(u(`/workers/${workerId}/services`), { method: "POST", body: input }),
+    stop: (workerId, name) => request(u(`/workers/${workerId}/services/${encodeURIComponent(name)}`), {
+      method: "DELETE"
+    }),
+    report: (input) => request(u("/workers/me/services"), { method: "PUT", body: input })
+  };
+};
+
 // src/client/retry.ts
 var sleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
 var withRetry = async (fn, opts = {}) => {
@@ -5546,16 +5568,40 @@ var withRetry = async (fn, opts = {}) => {
   throw lastErr;
 };
 
-// src/client/services.ts
-var servicesClient = (baseUrl) => {
-  const u = (path) => `${baseUrl}${path}`;
+// src/client/session-execution.ts
+var retry = async (call) => {
+  const result = await withRetry(async () => {
+    try {
+      return { value: await call() };
+    } catch (error) {
+      if (error instanceof HttpError && error.status >= 400 && error.status < 500) return { error };
+      throw error;
+    }
+  });
+  if ("error" in result) throw result.error;
+  return result.value;
+};
+var sessionExecutionClient = (baseUrl, sessionId, headers) => {
+  const base = `${baseUrl}/sessions/${sessionId}`;
+  const post = (path, body) => request(`${base}${path}`, { method: "POST", body, headers });
   return {
-    listByProject: (projectId) => request(u(`/projects/${projectId}/services`), { method: "GET" }),
-    run: (workerId, input) => request(u(`/workers/${workerId}/services`), { method: "POST", body: input }),
-    stop: (workerId, name) => request(u(`/workers/${workerId}/services/${encodeURIComponent(name)}`), {
-      method: "DELETE"
-    }),
-    report: (input) => request(u("/workers/me/services"), { method: "PUT", body: input })
+    claim: (input) => retry(() => post("/turns/claim", input)),
+    state: () => request(`${base}/execution`, { method: "GET", headers }),
+    stopped: (attemptId, runnerToken) => retry(() => post(`/attempts/${attemptId}/stopped`, { runnerToken })),
+    forAttempt: (attemptId, runnerToken) => {
+      const path = `/attempts/${attemptId}`;
+      return {
+        emitEvent: (type, payload) => post(`${path}/events`, { runnerToken, type, payload }),
+        heartbeat: (stopReason) => post(`${path}/heartbeat`, { runnerToken, stopReason }),
+        finish: (input) => retry(() => post(`${path}/finish`, { ...input, runnerToken })),
+        materialize: (input) => retry(
+          () => post(`${path}/materialize`, {
+            runnerToken,
+            agentSessionId: input.agentSessionId
+          })
+        )
+      };
+    }
   };
 };
 
@@ -5563,6 +5609,8 @@ var servicesClient = (baseUrl) => {
 var sessionsClient = (baseUrl) => {
   const u = (p) => `${baseUrl}${p}`;
   return {
+    execution: (id) => sessionExecutionClient(baseUrl, id).state(),
+    stopped: (id, attemptId, runnerToken) => sessionExecutionClient(baseUrl, id).stopped(attemptId, runnerToken),
     create: (input) => request(u("/sessions"), { method: "POST", body: input }),
     materialize: (id, input, workerToken) => request(u(`/sessions/${id}`), {
       method: "PATCH",
@@ -5687,34 +5735,14 @@ var clientFromBase = (baseUrl) => ({
   loops: loopsClient(baseUrl),
   workers: workersClient(baseUrl)
 });
-var BOUNDARY_EVENTS = /* @__PURE__ */ new Set([
-  "turn_start",
-  "turn_complete",
-  "turn_error"
-]);
-var emitRetries = () => Number(process.env.BATON_EMIT_RETRIES) || 4;
 var createWorkerClient = (baseUrl, workerToken, sessionId) => {
-  const u = (p) => `${baseUrl}${p}`;
-  const auth = { authorization: `Bearer ${workerToken}` };
+  const headers = { authorization: `Bearer ${workerToken}` };
   return {
-    emitEvent: (type, payload) => {
-      const post = () => request(u(`/sessions/${sessionId}/events`), {
-        method: "POST",
-        body: { type, payload },
-        headers: auth
-      });
-      return BOUNDARY_EVENTS.has(type) ? withRetry(post, { tries: emitRetries() }) : post();
-    },
-    setActive: (active) => request(u(`/sessions/${sessionId}/status`), {
+    ...sessionExecutionClient(baseUrl, sessionId, headers),
+    setActive: (active) => request(`${baseUrl}/sessions/${sessionId}/status`, {
       method: "POST",
       body: { active },
-      headers: auth
-    }),
-    listEvents: () => request(u(`/sessions/${sessionId}/events`), { method: "GET", headers: auth }),
-    materialize: (input) => request(u(`/sessions/${sessionId}`), {
-      method: "PATCH",
-      body: input,
-      headers: auth
+      headers
     })
   };
 };
@@ -6697,25 +6725,6 @@ var agentMessageText = (payload) => {
   const trimmed = text.trim();
   return trimmed ? { id, text: trimmed } : null;
 };
-var startedMessageIds = (events) => {
-  const ids = /* @__PURE__ */ new Set();
-  for (const e of events) {
-    if (e.type !== "turn_start") continue;
-    const id = e.payload?.messageId;
-    if (typeof id === "number") ids.add(id);
-  }
-  return ids;
-};
-var unstartedUserMessages = (events) => {
-  const started = startedMessageIds(events);
-  return events.filter((e) => e.type === "user_message" && !started.has(e.id));
-};
-var opensTurn = (e) => e.type === "user_message" || e.type === "turn_start";
-var closesTurn = (e) => e.type === "turn_complete" || e.type === "turn_error";
-var isAgentWorking = (events) => {
-  const last = events.findLast((e) => opensTurn(e) || closesTurn(e));
-  return last ? opensTurn(last) : false;
-};
 
 // src/commands/channel/listen.ts
 var PREVIEW = 280;
@@ -7864,55 +7873,9 @@ var sessionRmCommand = defineCommand({
 });
 
 // src/session/runner.ts
-import { spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
-// src/session/runner/log.ts
-var maskedEnvKeys = (env) => env ? Object.keys(env).sort().join(", ") : "(none)";
-
-// src/session/runner/sdk-env.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { isAbsolute } from "node:path";
-var buildSdkEnv = (overlay) => overlay ? { ...process.env, ...overlay } : void 0;
-var claudeExecutable = () => process.env.BATON_CLAUDE_BIN;
-var additionalDirs = () => {
-  const raw = process.env.BATON_ADD_DIRS;
-  if (!raw) return void 0;
-  const dirs = raw.split(":").map((s) => s.trim()).filter((s) => s !== "" && isAbsolute(s) && existsSync3(s));
-  return dirs.length > 0 ? dirs : void 0;
-};
-var truthy = (value) => {
-  if (value === void 0) return void 0;
-  const normalized = value.trim().toLowerCase();
-  if (["1", "true", "yes", "on"].includes(normalized)) return true;
-  if (["0", "false", "no", "off"].includes(normalized)) return false;
-  return void 0;
-};
-var codexNetworkAccess = () => truthy(process.env.BATON_CODEX_NETWORK_ACCESS);
-var codexSandboxMode = (planMode) => {
-  if (planMode) return "read-only";
-  const raw = process.env.BATON_CODEX_SANDBOX_MODE;
-  if (raw === "read-only" || raw === "workspace-write" || raw === "danger-full-access") return raw;
-  return "workspace-write";
-};
-var codexApprovalPolicy = () => {
-  const raw = process.env.BATON_CODEX_APPROVAL_POLICY;
-  if (raw === "never" || raw === "on-request" || raw === "on-failure" || raw === "untrusted")
-    return raw;
-  return "never";
-};
-var claudeEffort = (raw) => {
-  if (raw === "minimal") return "low";
-  if (raw === "low" || raw === "medium" || raw === "high" || raw === "xhigh" || raw === "max")
-    return raw;
-  return void 0;
-};
-var codexEffort = (raw) => {
-  if (raw === "minimal" || raw === "low" || raw === "medium" || raw === "high" || raw === "xhigh" || raw === "max")
-    return raw;
-  return void 0;
-};
-
 // src/session/runner/transcript.ts
 import { readdirSync, readFileSync as readFileSync4, statSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
@@ -7998,6 +7961,10 @@ var readFirstExchange = (agentSessionId) => {
   }
 };
 
+// src/session/runner/turn.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+
 // src/session/runner/attachments.ts
 import { createWriteStream } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
@@ -8051,6 +8018,51 @@ ${text}` : header;
 
 // src/session/runner/codex.ts
 import { Codex } from "@openai/codex-sdk";
+
+// src/session/runner/sdk-env.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { isAbsolute } from "node:path";
+var buildSdkEnv = (overlay) => overlay ? { ...process.env, ...overlay } : void 0;
+var claudeExecutable = () => process.env.BATON_CLAUDE_BIN;
+var additionalDirs = () => {
+  const raw = process.env.BATON_ADD_DIRS;
+  if (!raw) return void 0;
+  const dirs = raw.split(":").map((s) => s.trim()).filter((s) => s !== "" && isAbsolute(s) && existsSync3(s));
+  return dirs.length > 0 ? dirs : void 0;
+};
+var truthy = (value) => {
+  if (value === void 0) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return void 0;
+};
+var codexNetworkAccess = () => truthy(process.env.BATON_CODEX_NETWORK_ACCESS);
+var codexSandboxMode = (planMode) => {
+  if (planMode) return "read-only";
+  const raw = process.env.BATON_CODEX_SANDBOX_MODE;
+  if (raw === "read-only" || raw === "workspace-write" || raw === "danger-full-access") return raw;
+  return "workspace-write";
+};
+var codexApprovalPolicy = () => {
+  const raw = process.env.BATON_CODEX_APPROVAL_POLICY;
+  if (raw === "never" || raw === "on-request" || raw === "on-failure" || raw === "untrusted")
+    return raw;
+  return "never";
+};
+var claudeEffort = (raw) => {
+  if (raw === "minimal") return "low";
+  if (raw === "low" || raw === "medium" || raw === "high" || raw === "xhigh" || raw === "max")
+    return raw;
+  return void 0;
+};
+var codexEffort = (raw) => {
+  if (raw === "minimal" || raw === "low" || raw === "medium" || raw === "high" || raw === "xhigh" || raw === "max")
+    return raw;
+  return void 0;
+};
+
+// src/session/runner/codex.ts
 var isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var str = (v) => typeof v === "string" ? v : void 0;
 var compactEnv = (env) => {
@@ -8465,80 +8477,106 @@ async function* claudeToAgentEvents(messages) {
 }
 
 // src/session/runner/turn.ts
-var turnTimeoutMs = () => Number(process.env.BATON_TURN_TIMEOUT_MS) || 30 * 6e4;
-var heartbeatMs = () => Number(process.env.BATON_TURN_HEARTBEAT_MS) || 3e4;
-var TIMEOUT = /* @__PURE__ */ Symbol("turn-timeout");
-var ABORTED = /* @__PURE__ */ Symbol("turn-aborted");
-var finalizeTurn = async (result, worker2, log) => {
-  if (!result) {
-    log("[exit] stream ended with no result");
-    await worker2.emitEvent("turn_error", { message: "agent produced no result" });
-    await worker2.emitEvent("turn_complete", {});
-    return -1;
-  }
-  log(`[exit] subtype=${result.subtype} isError=${result.isError}`);
-  if (result.isError) {
-    await worker2.emitEvent("turn_error", {
-      message: result.resultText || `agent result: ${result.subtype}`,
-      subtype: result.subtype
-    });
-  }
-  await worker2.emitEvent("turn_complete", { subtype: result.subtype });
-  return result.isError ? 1 : 0;
+var UnsettledExecution = class extends Error {
+};
+var materializeImages = async (config, execution) => {
+  const images = execution.message.payload.images ?? [];
+  if (!images.length) return [];
+  const directory = join7(config.worktreePath, "attachments");
+  await mkdir2(directory, { recursive: true });
+  await writeFile2(join7(directory, ".gitignore"), "*\n");
+  return Promise.all(
+    images.map(async (image, index) => {
+      const match = /^data:image\/(png|jpeg|webp|gif);base64,([A-Za-z0-9+/=\r\n]+)$/.exec(image);
+      if (!match) throw new Error("unsupported pasted image");
+      const path = `attachments/pasted-${execution.message.id}-${index + 1}.${match[1]}`;
+      await writeFile2(join7(config.worktreePath, path), Buffer.from(match[2] ?? "", "base64"));
+      return path;
+    })
+  );
 };
-var buildPrompt = async (config, rawText, attachments, log, fetchImpl) => {
-  if (attachments.length === 0) return { text: rawText, input: rawText };
-  const relPaths = await materializeAttachments({
+var buildPrompt = async (config, execution, fetchImpl) => {
+  const { text: rawText, attachments = [] } = execution.message.payload;
+  const paths = attachments.length ? await materializeAttachments({
     worktreePath: config.worktreePath,
     serverBase: config.server,
     attachments,
     fetchImpl
-  });
-  log(`[attach] downloaded ${relPaths.length} file(s) \u2192 ${config.worktreePath}/attachments`);
-  const labels = labelAttachments(attachments);
-  const text = augmentPrompt(rawText, relPaths, labels);
-  const images = relPaths.flatMap((relPath, i) => {
-    const att = attachments[i];
-    return att?.contentType.startsWith("image/") ? [{ type: "local_image", path: `${config.worktreePath}/${relPath}` }] : [];
-  });
-  return images.length > 0 ? { text, input: [{ type: "text", text }, ...images] } : { text, input: text };
-};
-var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => console.log(m), envOverlay, fetchImpl, externalSignal) => {
-  await worker2.emitEvent("turn_start", { messageId: msg.id });
-  const payload = msg.payload;
-  const rawText = typeof payload?.text === "string" ? payload.text : "";
-  const attachments = Array.isArray(payload?.attachments) ? payload.attachments : [];
-  const planMode = payload?.planMode === true;
-  const model = typeof payload?.model === "string" ? payload.model : void 0;
-  const effort = typeof payload?.effort === "string" ? payload.effort : void 0;
-  if (rawText.length === 0 && attachments.length === 0) {
-    await worker2.emitEvent("turn_error", { message: "user_message missing text and attachments" });
-    return -1;
-  }
-  let built;
-  try {
-    built = await buildPrompt(config, rawText, attachments, log, fetchImpl);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    await worker2.emitEvent("turn_error", { message: `attachment download failed: ${message}` });
-    return -1;
-  }
+  }) : [];
+  const pasted = await materializeImages(config, execution);
+  const labels = [
+    ...labelAttachments(attachments),
+    ...pasted.map((_, index) => `pasted-image-${index + 1}`)
+  ];
+  const text = augmentPrompt(rawText, [...paths, ...pasted], labels);
+  const imagePaths = [
+    ...paths.filter((_, index) => attachments[index]?.contentType.startsWith("image/")),
+    ...pasted
+  ];
+  const images = imagePaths.map((path) => ({
+    type: "local_image",
+    path: join7(config.worktreePath, path)
+  }));
+  return { text, input: images.length ? [{ type: "text", text }, ...images] : text };
+};
+var runTurn = async (config, worker2, execution, resuming, queryFn, log, envOverlay, fetchImpl, externalSignal) => {
   const abort = new AbortController();
-  const ceiling = turnTimeoutMs();
-  let timer;
-  let heartbeat;
-  const timeout = new Promise((resolve3) => {
-    timer = setTimeout(() => resolve3(TIMEOUT), ceiling);
-  });
-  const interrupted = new Promise((resolve3) => {
-    if (externalSignal?.aborted) resolve3(ABORTED);
-    else externalSignal?.addEventListener("abort", () => resolve3(ABORTED), { once: true });
+  let timedOut = false;
+  let cleanupTimer;
+  let rejectCleanup = () => {
+  };
+  const cleanup = new Promise((_resolve, reject) => {
+    rejectCleanup = reject;
   });
-  try {
-    heartbeat = setInterval(() => {
-      void worker2.emitEvent("turn_heartbeat", {}).catch((e) => log(`[heartbeat] ${String(e)}`));
-    }, heartbeatMs());
-    const consume = config.agentKind === "codex" ? streamAgentEvents(
+  const interrupt = () => {
+    if (abort.signal.aborted) return;
+    abort.abort();
+    cleanupTimer = setTimeout(() => {
+      rejectCleanup(new UnsettledExecution("SDK did not stop within 10 seconds"));
+    }, 1e4);
+  };
+  externalSignal?.addEventListener("abort", interrupt, { once: true });
+  if (externalSignal?.aborted) interrupt();
+  const timeout = setTimeout(
+    () => {
+      timedOut = true;
+      void worker2.heartbeat("timeout").catch((error) => log(`[timeout] ${String(error)}`));
+      interrupt();
+    },
+    Number(process.env.BATON_TURN_TIMEOUT_MS) || 30 * 6e4
+  );
+  let heartbeatPending = false;
+  const heartbeat = setInterval(() => {
+    if (heartbeatPending || abort.signal.aborted) return;
+    heartbeatPending = true;
+    void worker2.heartbeat().then((result) => {
+      if (result.abortRequested) interrupt();
+    }).catch((error) => {
+      log(`[heartbeat] ${String(error)}`);
+      if (error instanceof HttpError && error.status === 409) interrupt();
+    }).finally(() => {
+      heartbeatPending = false;
+    });
+  }, Number(process.env.BATON_TURN_HEARTBEAT_MS) || 3e4);
+  const output = {
+    ...worker2,
+    emitEvent: async (type, payload) => {
+      try {
+        return await worker2.emitEvent(type, payload);
+      } catch (error) {
+        interrupt();
+        throw error;
+      }
+    }
+  };
+  const consume = async () => {
+    if (abort.signal.aborted) throw new Error("interrupted before SDK start");
+    if ((await worker2.heartbeat()).abortRequested) interrupt();
+    if (abort.signal.aborted) throw new Error("interrupted before SDK start");
+    const built = await buildPrompt(config, execution, fetchImpl);
+    if (abort.signal.aborted) throw new Error("interrupted before SDK start");
+    const { planMode, model, effort } = execution.message.payload;
+    return config.agentKind === "codex" ? streamAgentEvents(
       startCodexEvents(config, built.input, worker2, {
         envOverlay,
         planMode,
@@ -8547,7 +8585,7 @@ var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => conso
         signal: abort.signal,
         log
       }),
-      worker2
+      output
     ) : streamClaudeSdkEvents(
       startQuery(config, built.text, resuming, queryFn, abort, log, {
         envOverlay,
@@ -8555,199 +8593,156 @@ var runTurn = async (config, worker2, msg, resuming, queryFn, log = (m) => conso
         model,
         effort
       }),
-      worker2
+      output
     );
-    void consume.catch(() => {
-    });
-    const outcome = await Promise.race([consume, timeout, interrupted]);
-    if (outcome === ABORTED) {
-      log("[abort] interrupted by user");
-      abort.abort();
-      await worker2.emitEvent("turn_error", { message: "interrupted by user" });
-      await worker2.emitEvent("turn_complete", {});
-      return -1;
-    }
-    if (outcome === TIMEOUT) {
-      log(`[watchdog] turn exceeded ${ceiling}ms \u2014 aborting agent`);
-      abort.abort();
-      await worker2.emitEvent("turn_error", {
-        message: `turn exceeded ${ceiling}ms \u2014 agent aborted`
-      });
-      await worker2.emitEvent("turn_complete", {});
-      return -1;
+  };
+  const consuming = consume().then(
+    (value) => ({ kind: "result", value }),
+    (error) => {
+      log(`[agent] ${String(error)}`);
+      return { kind: "error", error };
     }
-    return await finalizeTurn(outcome, worker2, log);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    log(`[run] ${message}`);
-    await worker2.emitEvent("turn_error", { message });
-    await worker2.emitEvent("turn_complete", {});
-    return -1;
+  );
+  try {
+    const settled = await Promise.race([consuming, cleanup]);
+    const result = settled.kind === "result" ? settled.value : null;
+    const input = timedOut ? { outcome: "failed", message: "turn timeout" } : abort.signal.aborted ? { outcome: "aborted", message: "interrupted" } : settled.kind === "error" ? { outcome: "failed", message: String(settled.error) } : !result ? { outcome: "failed", message: "agent produced no result" } : result.isError ? { outcome: "failed", message: result.resultText, subtype: result.subtype } : { outcome: "completed", subtype: result.subtype };
+    const finished = await worker2.finish(input);
+    return finished.outcome === "completed" ? 0 : 1;
   } finally {
-    clearTimeout(timer);
+    clearTimeout(timeout);
+    clearTimeout(cleanupTimer);
     clearInterval(heartbeat);
+    externalSignal?.removeEventListener("abort", interrupt);
   }
 };
 
 // src/session/runner.ts
 var isAgentConversationResumable = (config, transcriptPath = findTranscriptPath) => config.agentKind === "codex" ? !config.agentSessionId.startsWith("pending:") : transcriptPath(config.agentSessionId) !== null;
-var subscribeStream = (url, ESCtor, seen, log, onUserMessage, onInterrupt, onReady) => {
-  const es = new ESCtor(url);
-  es.onopen = onReady;
-  es.onmessage = (e) => {
-    try {
-      const ev = JSON.parse(e.data);
-      if (seen.has(ev.sequence)) return;
-      seen.add(ev.sequence);
-      if (ev.type === "user_message") onUserMessage(ev);
-      else if (ev.type === "system" && ev.payload?.action === "interrupt")
-        onInterrupt();
-    } catch {
-    }
-  };
-  es.onerror = () => log("sse error (eventsource will retry)");
-  return es;
-};
-var waitForAbort = (signal) => new Promise((resolve3) => {
-  if (signal.aborted) return resolve3();
-  signal.addEventListener("abort", () => resolve3(), { once: true });
-});
 var shouldReap = (lastActivity, now, busy, queueLen, idleMs) => !busy && queueLen === 0 && now - lastActivity >= idleMs;
-var idleMsFromEnv = () => Number(process.env.BATON_SESSION_IDLE_MS) || 30 * 6e4;
-var restoreTty = () => {
-  if (!process.stdout.isTTY) return;
-  try {
-    spawnSync("reset", { stdio: "inherit" });
-  } catch {
-  }
-};
 var runDaemon = async (config, deps, signal) => {
-  const log = deps.log ?? ((m) => console.log(`[#${config.sessionId} ${config.name}] ${m}`));
-  const qf = deps.queryFn ?? query;
-  const ESCtor = deps.eventSourceImpl ?? EventSource;
-  log(`bin: ${claudeExecutable() ?? "(sdk bundled)"}  cwd: ${config.worktreePath}`);
-  log(`runtime env keys: ${maskedEnvKeys(deps.env)}`);
-  const state = { seen: /* @__PURE__ */ new Set() };
-  const pendingQueue = [];
-  let busy = false;
-  let reconciling = false;
+  const log = deps.log ?? console.log;
+  const Constructor = deps.eventSourceImpl ?? EventSource;
+  const stream = new Constructor(`${config.server}/sessions/${config.sessionId}/stream?live=1`);
+  let current;
+  let draining;
+  let stranded = false;
+  let closed = false;
+  let claimId = randomUUID();
   let lastActivity = Date.now();
-  let currentTurn;
+  let stop = () => {
+  };
+  const stopped = new Promise((resolve3) => {
+    stop = resolve3;
+  });
   const drain = async () => {
-    if (busy) return;
-    busy = true;
-    try {
-      while (pendingQueue.length > 0 && !signal.aborted) {
-        const msg = pendingQueue.shift();
-        if (!msg) break;
-        const resuming = isAgentConversationResumable(config);
-        log(`\u25B6 msg #${msg.sequence} (${resuming ? "resume" : "first"})`);
-        const turnAbort = new AbortController();
-        currentTurn = turnAbort;
-        const code = await runTurn(
-          config,
-          deps.worker,
-          msg,
-          resuming,
-          qf,
-          log,
-          deps.env,
-          deps.fetchImpl,
-          turnAbort.signal
-        );
-        currentTurn = void 0;
+    if (draining || closed || stranded) return;
+    const run2 = async () => {
+      while (!closed && !stranded && !signal.aborted) {
+        let claimed;
+        try {
+          claimed = await deps.worker.claim({ claimId, runnerToken: deps.runnerToken });
+        } catch (error) {
+          log(`[claim] ${String(error)}`);
+          return;
+        }
+        if (claimed.kind === "idle") return;
+        if (claimed.kind === "stopping") {
+          stranded = true;
+          return;
+        }
+        claimId = randomUUID();
+        if (claimed.kind === "settled") continue;
+        Object.assign(config, claimed.config);
+        current = { attemptId: claimed.attempt.id, abort: new AbortController() };
+        if (closed || signal.aborted) current.abort.abort();
         lastActivity = Date.now();
-        log(`\u2714 msg #${msg.sequence}${code === 0 ? "" : ` (exit ${code})`}`);
+        try {
+          await runTurn(
+            config,
+            deps.worker.forAttempt(claimed.attempt.id, deps.runnerToken),
+            claimed,
+            isAgentConversationResumable(config),
+            deps.queryFn ?? query,
+            log,
+            deps.env,
+            deps.fetchImpl,
+            current.abort.signal
+          );
+        } catch (error) {
+          stranded = true;
+          log(`[execution] ${String(error)}`);
+          if (process.connected)
+            process.send?.({ type: "execution-stuck", attemptId: claimed.attempt.id });
+        } finally {
+          current = void 0;
+          lastActivity = Date.now();
+        }
       }
+    };
+    draining = run2();
+    try {
+      await draining;
     } finally {
-      busy = false;
+      draining = void 0;
     }
   };
-  const closeOrphanedTurn = async (reason) => {
-    const events = await deps.worker.listEvents();
-    if (!isAgentWorking(events)) return;
-    await deps.worker.emitEvent("turn_error", { message: reason, synthetic: true });
-    log(`closed orphaned open turn (${reason})`);
+  const wake = () => {
+    void drain().catch((error) => log(`[drain] ${String(error)}`));
+  };
+  stream.onopen = () => {
+    void deps.worker.setActive(true).catch((error) => log(`[status] ${String(error)}`));
+    wake();
   };
-  const reconcile = async () => {
-    reconciling = true;
+  stream.onerror = () => log("[stream] disconnected; retrying");
+  stream.onmessage = ({ data }) => {
+    let event;
     try {
-      const events = await deps.worker.listEvents();
-      const pending = unstartedUserMessages(events);
-      let added = 0;
-      for (const ev of pending) {
-        if (state.seen.has(ev.sequence)) continue;
-        state.seen.add(ev.sequence);
-        pendingQueue.push(ev);
-        added++;
-      }
-      if (added > 0) {
-        log(`reconciled ${added} queued message(s) from transcript`);
-        lastActivity = Date.now();
-        void drain();
-      } else if (pendingQueue.length === 0 && !busy && !currentTurn && isAgentWorking(events)) {
-        await deps.worker.emitEvent("turn_error", {
-          message: "turn abandoned \u2014 runner restarted",
-          synthetic: true
-        });
-        log("reconcile: closed orphaned open turn from a prior child");
-      }
-    } catch (e) {
-      log(`reconcile failed: ${String(e)}`);
-    } finally {
-      reconciling = false;
+      event = JSON.parse(data);
+    } catch (error) {
+      log(`[stream] malformed event: ${String(error)}`);
+      return;
     }
-  };
-  const es = subscribeStream(
-    // live-only: the server now replays history to viewers, but the child must
-    // not re-receive (and re-run) past user_messages on connect/resume.
-    `${config.server}/sessions/${config.sessionId}/stream?live=1`,
-    ESCtor,
-    state.seen,
-    log,
-    (ev) => {
+    if (event.type === "queue_changed") {
       lastActivity = Date.now();
-      pendingQueue.push(ev);
-      void drain();
-    },
-    () => {
-      lastActivity = Date.now();
-      if (currentTurn) {
-        log("interrupt \u2014 aborting current turn");
-        currentTurn.abort();
-      } else {
-        log("interrupt \u2014 no live turn; closing any orphaned open turn");
-        void closeOrphanedTurn("interrupted by user").catch(
-          (e) => log(`orphan close failed: ${String(e)}`)
-        );
-      }
-    },
-    // Report active only now that we're subscribed — before this, a message
-    // sent right after spawn would be missed (no replay on the live stream).
-    // Then reconcile against the durable transcript to pick up anything that
-    // landed while we weren't subscribed (initial spawn or a reconnect gap).
-    () => {
-      void deps.worker.setActive(true).then(() => log("\u25B2 active (subscribed)")).catch((e) => log(`status(active) failed: ${String(e)}`));
-      void reconcile();
+      wake();
     }
-  );
-  const idleMs = idleMsFromEnv();
-  let idleTimer;
-  const reaped = new Promise((resolve3) => {
-    idleTimer = setInterval(
-      () => {
-        if (!reconciling && shouldReap(lastActivity, Date.now(), busy, pendingQueue.length, idleMs)) {
-          log("idle \u2014 shutting down (resumes on next message)");
-          resolve3();
-        }
-      },
-      Math.min(idleMs, 3e4)
-    );
-  });
-  await Promise.race([waitForAbort(signal), reaped]);
-  if (idleTimer) clearInterval(idleTimer);
-  es.close();
-  restoreTty();
+    if (event.type === "system") {
+      const payload = event.payload;
+      if (payload?.action === "interrupt" && payload.attemptId === current?.attemptId)
+        current?.abort.abort();
+    }
+  };
+  const onAbort = () => {
+    closed = true;
+    current?.abort.abort();
+    stop();
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  if (signal.aborted) onAbort();
+  const timer = setInterval(() => {
+    if (shouldReap(
+      lastActivity,
+      Date.now(),
+      !!draining || stranded,
+      0,
+      Number(process.env.BATON_SESSION_IDLE_MS) || 30 * 6e4
+    )) {
+      closed = true;
+      stop();
+      return;
+    }
+    wake();
+  }, 1e4);
+  try {
+    await stopped;
+    await draining;
+  } finally {
+    closed = true;
+    clearInterval(timer);
+    stream.close();
+    signal.removeEventListener("abort", onAbort);
+  }
 };
 
 // src/commands/session/run.ts
@@ -8774,9 +8769,27 @@ var authedEventSource = (token) => class extends EventSource {
 var sessionRunCommand = defineCommand({
   meta: { name: "run", description: "run a session child (spawned by the worker daemon)" },
   args: {
-    session: { type: "positional", required: true, description: "session int id" }
+    session: { type: "positional", required: true, description: "session int id" },
+    "runner-token": { type: "string", required: true, description: "internal process identity" }
   },
   run: async ({ args }) => {
+    if (!process.connected) throw new Error("session runner requires supervisor IPC");
+    await new Promise((resolve3, reject) => {
+      const onMessage = (message) => {
+        if (typeof message !== "object" || message === null || !("type" in message) || message.type !== "execute")
+          return;
+        process.off("message", onMessage);
+        process.off("disconnect", onDisconnect);
+        resolve3();
+      };
+      const onDisconnect = () => {
+        process.off("message", onMessage);
+        reject(new Error("supervisor disconnected before start"));
+      };
+      process.on("message", onMessage);
+      process.once("disconnect", onDisconnect);
+      process.send?.({ type: "ready" });
+    });
     const server = process.env.BATON_SERVER;
     const workerToken = process.env.BATON_WORKER_TOKEN;
     if (!server || !workerToken)
@@ -8801,10 +8814,13 @@ var sessionRunCommand = defineCommand({
     const stop = () => ac.abort();
     process.on("SIGINT", stop);
     process.on("SIGTERM", stop);
+    process.on("disconnect", stop);
+    if (!process.connected) stop();
     await runDaemon(
       config,
       {
         worker: worker2,
+        runnerToken: args["runner-token"],
         eventSourceImpl: authedEventSource(workerToken),
         fetchImpl: bearerFetch(workerToken)
       },
@@ -8839,7 +8855,7 @@ var sessionSendCommand = defineCommand({
     if (args.json) console.log(toJson(ev));
     else {
       const note = attachments ? ` +${attachments.length} attachment(s)` : "";
-      console.log(`sent (seq ${ev.sequence}) \u2192 ${s.name} (#${s.id})${note}: ${text}`);
+      console.log(`queued (input ${ev.input.id}) \u2192 ${s.name} (#${s.id})${note}: ${text}`);
     }
   }
 });
@@ -9078,11 +9094,11 @@ var task = defineCommand({
 import { hostname as osHostname } from "node:os";
 
 // src/session/worktree.ts
-import { execFile, execFileSync, spawnSync as spawnSync2 } from "node:child_process";
+import { execFile, execFileSync, spawnSync } from "node:child_process";
 import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "node:fs";
 import { dirname, isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
 import { promisify } from "node:util";
-var git = (repo, args) => spawnSync2("git", ["-C", repo, ...args], {
+var git = (repo, args) => spawnSync("git", ["-C", repo, ...args], {
   stdio: "pipe",
   encoding: "utf8"
 });
@@ -9100,7 +9116,7 @@ var asyncCommandError = (error, timeoutMs) => {
 };
 var validateBaseBranch = (branch) => {
   const normalized = branch.trim();
-  const valid = spawnSync2("git", ["check-ref-format", "--branch", normalized], {
+  const valid = spawnSync("git", ["check-ref-format", "--branch", normalized], {
     stdio: "pipe",
     encoding: "utf8"
   });
@@ -9111,7 +9127,7 @@ var validateBaseBranch = (branch) => {
 var createWorktree = (input) => {
   if (existsSync4(input.worktreePath))
     throw new Error(`worktree path already exists: ${input.worktreePath}`);
-  const head = spawnSync2("git", ["-C", input.repo, "rev-parse", "--verify", "-q", "HEAD"], {
+  const head = spawnSync("git", ["-C", input.repo, "rev-parse", "--verify", "-q", "HEAD"], {
     stdio: "pipe",
     encoding: "utf8"
   });
@@ -9121,7 +9137,7 @@ var createWorktree = (input) => {
     );
   mkdirSync3(dirname(input.worktreePath), { recursive: true });
   const branch = `baton/${input.sessionCode}`;
-  const r = spawnSync2(
+  const r = spawnSync(
     "git",
     ["-C", input.repo, "worktree", "add", "-b", branch, input.worktreePath, input.base],
     { stdio: "pipe", encoding: "utf8" }
@@ -9184,7 +9200,7 @@ var syncBaseBranch = async (repo, branch, options = {}) => {
 };
 var ensureExcluded = (repo, pattern) => {
   try {
-    const r = spawnSync2("git", ["-C", repo, "rev-parse", "--git-path", "info/exclude"], {
+    const r = spawnSync("git", ["-C", repo, "rev-parse", "--git-path", "info/exclude"], {
       stdio: "pipe",
       encoding: "utf8"
     });
@@ -9210,10 +9226,10 @@ var removeWorktree = (repo, worktreePath) => {
   }
 };
 var restoreWorktree = async (repo, worktreePath, sessionCode, baseBranch = repoHeadBranch(repo)) => {
-  spawnSync2("git", ["-C", repo, "worktree", "prune"], { stdio: "pipe" });
+  spawnSync("git", ["-C", repo, "worktree", "prune"], { stdio: "pipe" });
   mkdirSync3(dirname(worktreePath), { recursive: true });
   const branch = `baton/${sessionCode}`;
-  const reuse = spawnSync2("git", ["-C", repo, "worktree", "add", worktreePath, branch], {
+  const reuse = spawnSync("git", ["-C", repo, "worktree", "add", worktreePath, branch], {
     stdio: "pipe",
     encoding: "utf8"
   });
@@ -9227,24 +9243,24 @@ var restoreWorktree = async (repo, worktreePath, sessionCode, baseBranch = repoH
 };
 
 // src/worker/bundled-skills.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 import { cpSync, existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname2, join as join7 } from "node:path";
+import { dirname as dirname2, join as join8 } from "node:path";
 import { fileURLToPath } from "node:url";
 var SKILL_NAME = "baton-publish-artifact";
 var TARGETS = [`.claude/skills/${SKILL_NAME}`, `.agents/skills/${SKILL_NAME}`];
 var bundledSkillPath = () => {
   const here = dirname2(fileURLToPath(import.meta.url));
   const candidates = [
-    join7(here, "..", "skills", SKILL_NAME),
-    join7(here, "..", "..", "skills", SKILL_NAME)
+    join8(here, "..", "skills", SKILL_NAME),
+    join8(here, "..", "..", "skills", SKILL_NAME)
   ];
   const found = candidates.find(existsSync5);
   if (!found) throw new Error(`bundled skill missing: ${SKILL_NAME}`);
   return found;
 };
 var isTracked = (worktreePath, relativePath) => {
-  const result = spawnSync3("git", ["-C", worktreePath, "ls-files", "--", relativePath], {
+  const result = spawnSync2("git", ["-C", worktreePath, "ls-files", "--", relativePath], {
     encoding: "utf8",
     stdio: "pipe"
   });
@@ -9254,7 +9270,7 @@ var syncBundledArtifactSkill = (repo, worktreePath) => {
   const source = bundledSkillPath();
   TARGETS.filter((target) => !isTracked(worktreePath, target)).forEach((target) => {
     ensureExcluded(repo, `${target}/`);
-    cpSync(source, join7(worktreePath, target), { recursive: true, force: true });
+    cpSync(source, join8(worktreePath, target), { recursive: true, force: true });
   });
 };
 
@@ -9316,12 +9332,12 @@ var createLiveness = (deps) => {
 
 // src/worker/service-supervisor.ts
 import { mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/worker/service-process.ts
 import { spawn as spawn2 } from "node:child_process";
 import { closeSync, existsSync as existsSync6, openSync } from "node:fs";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { dirname as dirname3, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var START_TIMEOUT_MS = 1e4;
 var isWrapperMessage = (message) => {
@@ -9332,7 +9348,7 @@ var isWrapperMessage = (message) => {
 };
 var binPath = () => {
   const here = dirname3(fileURLToPath2(import.meta.url));
-  const devShim = join8(here, "..", "..", "bin", "baton.mjs");
+  const devShim = join9(here, "..", "..", "bin", "baton.mjs");
   return existsSync6(devShim) ? devShim : fileURLToPath2(import.meta.url);
 };
 var startServiceProcess = (input) => {
@@ -9435,8 +9451,8 @@ var createServiceSupervisor = (deps) => {
         error: "session is not materialized on this worker",
         status: 400
       });
-    const logDir = join9(session2.worktreePath, ".baton-services");
-    const logPath = join9(logDir, `${name}.log`);
+    const logDir = join10(session2.worktreePath, ".baton-services");
+    const logPath = join10(logDir, `${name}.log`);
     mkdirSync4(logDir, { recursive: true });
     const { wrapper, started } = startServiceProcess({ argv, cwd: session2.worktreePath, logPath });
     const entry = {
@@ -9469,7 +9485,7 @@ var createServiceSupervisor = (deps) => {
     log(`service ${name} started in ${session2.worktreePath}`);
     await report({ requestId, ok: true, service: service2, logPath });
   };
-  const run = async (requestId, sessionId, name, argv, publicUrl, note) => {
+  const run2 = async (requestId, sessionId, name, argv, publicUrl, note) => {
     try {
       await runOne(requestId, sessionId, name, argv, publicUrl, note);
     } catch (error) {
@@ -9492,14 +9508,14 @@ var createServiceSupervisor = (deps) => {
     matches.forEach(remove);
   };
   const killAll = () => entries.forEach(stopEntry);
-  return { run, stop, stopSession, report, killAll };
+  return { run: run2, stop, stopSession, report, killAll };
 };
 
 // src/worker/session-supervisor.ts
 import { spawn as spawn3 } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync7 } from "node:fs";
-import { dirname as dirname4, join as join11 } from "node:path";
+import { dirname as dirname4, join as join13 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
@@ -9593,7 +9609,7 @@ var generateTitle = async (input) => {
 // src/session/runner/title-codex.ts
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 import { Codex as Codex2 } from "@openai/codex-sdk";
 var generateTitleWithCodex = async (input) => {
   const { userText, assistantText } = input;
@@ -9602,7 +9618,7 @@ var generateTitleWithCodex = async (input) => {
   const timer = setTimeout(() => abort.abort(), TITLE_TIMEOUT_MS);
   let cwd = "";
   try {
-    cwd = await mkdtemp(join10(tmpdir3(), "baton-title-"));
+    cwd = await mkdtemp(join11(tmpdir3(), "baton-title-"));
     const client = input.client ?? new Codex2();
     const thread = client.startThread({
       workingDirectory: cwd,
@@ -9628,10 +9644,82 @@ var generateTitleWithCodex = async (input) => {
   }
 };
 
+// src/worker/session-process.ts
+import { execFile as execFile2 } from "node:child_process";
+import { readFile, rename, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+var run = promisify2(execFile2);
+var RUNNER_RECORD = ".baton-runner.json";
+var recordPath = (worktreePath) => join12(worktreePath, RUNNER_RECORD);
+var codeOf = (error) => typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+var readRunnerRecord = async (worktreePath) => {
+  let raw;
+  try {
+    raw = await readFile(recordPath(worktreePath), "utf8");
+  } catch (error) {
+    if (codeOf(error) === "ENOENT") return null;
+    throw error;
+  }
+  const value = JSON.parse(raw);
+  if (typeof value.server !== "string" || typeof value.runnerToken !== "string" || !value.runnerToken || !Number.isInteger(value.pid) || (value.pid ?? 0) < 2 || value.pgid !== value.pid || !Number.isInteger(value.workerId) || !Number.isInteger(value.sessionId))
+    throw new Error("invalid session process record");
+  return value;
+};
+var writeRunnerRecord = async (worktreePath, record) => {
+  const path = recordPath(worktreePath);
+  const temporary = `${path}.${record.runnerToken}.tmp`;
+  await writeFile3(temporary, JSON.stringify(record), { mode: 384, flag: "wx" });
+  await rename(temporary, path);
+};
+var groupExists = (pgid) => {
+  try {
+    process.kill(-pgid, 0);
+    return true;
+  } catch (error) {
+    if (codeOf(error) === "ESRCH") return false;
+    throw error;
+  }
+};
+var signalGroup = (pgid, signal) => {
+  try {
+    process.kill(-pgid, signal);
+  } catch (error) {
+    if (codeOf(error) !== "ESRCH") throw error;
+  }
+};
+var stopRecordedRunner = async (record, expected, graceMs = 5e3) => {
+  if (record.server !== expected.server || record.workerId !== expected.workerId || record.sessionId !== expected.sessionId)
+    throw new Error("session process record belongs to a different worker");
+  if (!groupExists(record.pgid)) return;
+  let stdout;
+  try {
+    const result = await run("ps", ["-ww", "-p", String(record.pid), "-o", "pgid=", "-o", "args="]);
+    stdout = result.stdout;
+  } catch (error) {
+    if (!groupExists(record.pgid)) return;
+    throw error;
+  }
+  const parts = stdout.trim().split(/\s+/);
+  const marker = parts.indexOf("--runner-token");
+  if (Number(parts[0]) !== record.pgid || marker < 0 || parts[marker + 1] !== record.runnerToken)
+    throw new Error("cannot verify old session process identity");
+  signalGroup(record.pgid, "SIGTERM");
+  const deadline = Date.now() + graceMs;
+  while (groupExists(record.pgid) && Date.now() < deadline)
+    await new Promise((resolve3) => setTimeout(resolve3, 50));
+  if (!groupExists(record.pgid)) return;
+  signalGroup(record.pgid, "SIGKILL");
+  const killDeadline = Date.now() + graceMs;
+  while (groupExists(record.pgid) && Date.now() < killDeadline)
+    await new Promise((resolve3) => setTimeout(resolve3, 50));
+  if (groupExists(record.pgid)) throw new Error("session process group has not exited");
+};
+
 // src/worker/session-supervisor.ts
 var binPath2 = () => {
   const here = dirname4(fileURLToPath3(import.meta.url));
-  const devShim = join11(here, "..", "..", "bin", "baton.mjs");
+  const devShim = join13(here, "..", "..", "bin", "baton.mjs");
   return existsSync7(devShim) ? devShim : fileURLToPath3(import.meta.url);
 };
 var createSessionSupervisor = (deps) => {
@@ -9651,27 +9739,95 @@ var createSessionSupervisor = (deps) => {
     return pending;
   };
   const children = /* @__PURE__ */ new Map();
+  const lifecycle = /* @__PURE__ */ new Map();
+  const enqueue = (id, action) => {
+    const previous = lifecycle.get(id);
+    const pending = previous ? previous.catch((error) => log(`previous lifecycle #${id}: ${String(error)}`)).then(action) : action();
+    lifecycle.set(id, pending);
+    const clear = () => {
+      if (lifecycle.get(id) === pending) lifecycle.delete(id);
+    };
+    void pending.then(clear, clear);
+    return pending;
+  };
   const starts = /* @__PURE__ */ new Map();
   const startEpochs = /* @__PURE__ */ new Map();
   const currentStartEpoch = (sessionId) => startEpochs.get(sessionId) ?? 0;
   const cancelStart = (sessionId) => {
     startEpochs.set(sessionId, currentStartEpoch(sessionId) + 1);
   };
-  const spawnChild = (sessionId, worktreePath) => {
+  const stopRecord = async (sessionId, worktreePath, token) => {
+    const record = await readRunnerRecord(worktreePath);
+    if (!record) {
+      if (token) throw new Error("missing record for an unfinished execution");
+      return;
+    }
+    if (token && token !== record.runnerToken)
+      throw new Error("runner identity does not match the attempt");
+    await stopRecordedRunner(record, { server: cfg.server, workerId: cfg.workerId, sessionId });
+  };
+  const spawnChild = async (sessionId, worktreePath, wasCanceled) => {
     if (children.has(sessionId)) return;
-    const child = spawn3(process.execPath, [binPath2(), "session", "run", String(sessionId)], {
-      detached: true,
-      stdio: "inherit",
-      env: { ...process.env, BATON_SERVER: cfg.server, BATON_WORKER_TOKEN: cfg.apiToken }
+    await stopRecord(sessionId, worktreePath);
+    const runnerToken = randomUUID2();
+    const child = spawn3(
+      process.execPath,
+      [binPath2(), "session", "run", String(sessionId), "--runner-token", runnerToken],
+      {
+        detached: true,
+        stdio: ["inherit", "inherit", "inherit", "ipc"],
+        env: { ...process.env, BATON_SERVER: cfg.server, BATON_WORKER_TOKEN: cfg.apiToken }
+      }
+    );
+    const entry = { child, worktreePath };
+    children.set(sessionId, entry);
+    let readyTimer;
+    const ready = new Promise((resolve3, reject) => {
+      child.on("message", (message) => {
+        if (typeof message === "object" && message !== null && "type" in message && message.type === "ready")
+          resolve3();
+      });
+      child.once("error", reject);
+      child.once("exit", () => reject(new Error("session child exited before ready")));
+      readyTimer = setTimeout(() => reject(new Error("session child readiness timeout")), 3e4);
     });
-    children.set(sessionId, { child, worktreePath });
-    log(`spawned session #${sessionId} (${worktreePath})`);
+    const readiness = ready.finally(() => clearTimeout(readyTimer));
+    void readiness.catch((error) => log(`[runner-ready] ${String(error)}`));
     child.on("exit", (code) => {
+      if (children.get(sessionId) !== entry) return;
       children.delete(sessionId);
-      log(`session #${sessionId} child exited (code=${code ?? -1})`);
-      void client.sessions.setStatus(sessionId, false, cfg.apiToken).catch(() => {
-      });
+      log(`session #${sessionId} exited (${code})`);
+      void client.sessions.setStatus(sessionId, false, cfg.apiToken).catch((error) => log(`inactive report failed: ${String(error)}`));
+    });
+    child.on("message", (message) => {
+      if (children.get(sessionId) !== entry) return;
+      if (typeof message === "object" && message !== null && "type" in message && message.type === "execution-stuck")
+        void stop(sessionId).catch((error) => log(`stuck execution cleanup failed: ${String(error)}`));
     });
+    try {
+      await new Promise((resolve3, reject) => {
+        child.once("spawn", resolve3);
+        child.once("error", reject);
+      });
+      if (!child.pid) throw new Error("session child has no PID");
+      const record = {
+        server: cfg.server,
+        workerId: cfg.workerId,
+        sessionId,
+        runnerToken,
+        pid: child.pid,
+        pgid: child.pid
+      };
+      await writeRunnerRecord(worktreePath, record);
+      await readiness;
+      if (wasCanceled()) return;
+      await new Promise(
+        (resolve3, reject) => child.send({ type: "execute" }, (error) => error ? reject(error) : resolve3())
+      );
+    } catch (error) {
+      killProcessGroup(child);
+      throw error;
+    }
   };
   const startOne = async (sessionId, name, epoch) => {
     const wasCanceled = () => currentStartEpoch(sessionId) !== epoch;
@@ -9680,12 +9836,15 @@ var createSessionSupervisor = (deps) => {
       return log(`session #${sessionId} has an open terminal \u2014 skipping headless start`);
     if (children.has(sessionId)) return log(`session #${sessionId} already running`);
     const session2 = await client.sessions.get(sessionId);
+    const execution = await client.sessions.execution(sessionId);
+    if (execution.paused || execution.contextResetRequested || execution.attempt?.status === "running" || execution.attempt?.status === "stopping")
+      return;
     if (wasCanceled()) return log(`session #${sessionId} start canceled before materializing`);
     let worktreePath = session2.worktreePath;
     if (!session2.agentSessionId || !worktreePath) {
-      const sessionCode = randomUUID();
+      const sessionCode = randomUUID2();
       const agentSessionId = session2.agentKind === "codex" ? `pending:${sessionCode}` : sessionCode;
-      worktreePath = join11(worktreeDir, slug(`${name}-${sessionCode.slice(0, 8)}`));
+      worktreePath = join13(worktreeDir, slug(`${name}-${sessionCode.slice(0, 8)}`));
       const base = await syncedBase();
       if (wasCanceled()) return log(`session #${sessionId} start canceled during git sync`);
       createWorktree({
@@ -9704,20 +9863,20 @@ var createSessionSupervisor = (deps) => {
     }
     ensureExcluded(repo, PROJECT_CONFIG_NAME);
     ensureExcluded(repo, ".baton-services/");
-    saveProjectConfig(join11(worktreePath, PROJECT_CONFIG_NAME), worktreeConfig(cfg, sessionId));
+    ensureExcluded(repo, RUNNER_RECORD);
+    ensureExcluded(repo, ".baton-runner.json.*.tmp");
+    saveProjectConfig(join13(worktreePath, PROJECT_CONFIG_NAME), worktreeConfig(cfg, sessionId));
     syncBundledArtifactSkill(repo, worktreePath);
     if (hasTerminal(sessionId))
       return log(`session #${sessionId} terminal opened mid-start \u2014 skipping headless start`);
-    spawnChild(sessionId, worktreePath);
+    if (wasCanceled()) return;
+    await spawnChild(sessionId, worktreePath, wasCanceled);
   };
   const start = (sessionId, name) => {
     const epoch = currentStartEpoch(sessionId);
     const existing = starts.get(sessionId);
     if (existing?.epoch === epoch) return existing.promise;
-    const pending = existing ? existing.promise.then(
-      () => startOne(sessionId, name, epoch),
-      () => startOne(sessionId, name, epoch)
-    ) : startOne(sessionId, name, epoch);
+    const pending = enqueue(sessionId, () => startOne(sessionId, name, epoch));
     starts.set(sessionId, { epoch, promise: pending });
     const clear = () => {
       if (starts.get(sessionId)?.promise === pending) starts.delete(sessionId);
@@ -9727,28 +9886,29 @@ var createSessionSupervisor = (deps) => {
   };
   const stop = (sessionId) => {
     cancelStart(sessionId);
-    closeTerminal(sessionId);
-    const entry = children.get(sessionId);
-    if (!entry) return;
-    killProcessGroup(entry.child);
-    children.delete(sessionId);
-    log(`stopped session #${sessionId}`);
+    return enqueue(sessionId, async () => {
+      const entry = children.get(sessionId);
+      const session2 = await client.sessions.get(sessionId);
+      if (session2.worktreePath) await stopRecord(sessionId, session2.worktreePath);
+      if (entry && children.get(sessionId) === entry) children.delete(sessionId);
+    });
   };
   const remove = (sessionId, worktreePath) => {
     cancelStart(sessionId);
     closeTerminal(sessionId);
-    const entry = children.get(sessionId);
-    if (entry) {
-      killProcessGroup(entry.child);
-      children.delete(sessionId);
-    }
-    const wt = entry?.worktreePath ?? worktreePath;
-    if (wt) removeWorktree(repo, wt);
-    log(`deleted session #${sessionId} (removed worktree)`);
+    return enqueue(sessionId, async () => {
+      const entry = children.get(sessionId);
+      const path = entry?.worktreePath ?? worktreePath;
+      if (path) {
+        await stopRecord(sessionId, path);
+        removeWorktree(repo, path);
+      }
+      if (children.get(sessionId) === entry) children.delete(sessionId);
+    });
   };
   const title = async (sessionId, agentSessionId, worktreePath) => {
     const session2 = await client.sessions.get(sessionId);
-    const events = await client.sessions.listEvents(sessionId).catch(() => []);
+    const events = await client.sessions.listEvents(sessionId);
     const exchange = parseFirstExchangeFromEvents(events) ?? (session2.agentKind === "claude-code" ? readFirstExchange(agentSessionId) : null);
     if (!exchange) return log(`title #${sessionId}: no transcript yet, skipping`);
     const outcome = session2.agentKind === "codex" ? await generateTitleWithCodex({
@@ -9766,16 +9926,47 @@ var createSessionSupervisor = (deps) => {
     await client.sessions.setName(sessionId, outcome.title, cfg.apiToken);
     log(`\u270E titled session #${sessionId} \u2192 ${outcome.title}`);
   };
-  const reconcile = async () => {
-    const owned = (await client.sessions.listByProject(cfg.projectId)).filter(
+  const reconcile = async (sessionId) => {
+    const sessions = sessionId === void 0 ? (await client.sessions.listByProject(cfg.projectId)).filter(
       (s) => s.workerId === cfg.workerId
-    );
-    const live = new Set(owned.map((s) => s.id));
-    for (const [sid, entry] of children) {
-      if (!live.has(sid)) {
-        killProcessGroup(entry.child);
-        children.delete(sid);
-        log(`reconcile: stopped orphan session #${sid}`);
+    ) : [await client.sessions.get(sessionId)];
+    for (const candidate of sessions)
+      await enqueue(candidate.id, async () => {
+        const session2 = await client.sessions.get(candidate.id);
+        let execution = await client.sessions.execution(session2.id);
+        if (execution.attempt?.status === "stopping") {
+          if (!session2.worktreePath) throw new Error("unfinished execution without worktree");
+          if (children.has(session2.id) && Date.now() - (execution.attempt.stopRequestedAt ?? 0) < 1e4)
+            return;
+          await stopRecord(session2.id, session2.worktreePath, execution.attempt.runnerToken);
+          children.delete(session2.id);
+          await client.sessions.stopped(
+            session2.id,
+            execution.attempt.id,
+            execution.attempt.runnerToken
+          );
+          execution = await client.sessions.execution(session2.id);
+        }
+        if (execution.paused) {
+          if (session2.worktreePath) await stopRecord(session2.id, session2.worktreePath);
+          return;
+        }
+        if (execution.attempt?.status === "running") {
+          if (!children.has(session2.id) && session2.worktreePath)
+            await stopRecord(session2.id, session2.worktreePath, execution.attempt.runnerToken);
+          return;
+        }
+        if (execution.pendingCount || execution.turn?.status === "recovering")
+          await startOne(session2.id, session2.name, currentStartEpoch(session2.id));
+      });
+    if (sessionId === void 0) {
+      const live = new Set(sessions.map((s) => s.id));
+      for (const [id, entry] of children) {
+        if (!live.has(id))
+          await enqueue(id, async () => {
+            await stopRecord(id, entry.worktreePath);
+            if (children.get(id) === entry) children.delete(id);
+          });
       }
     }
   };
@@ -9786,8 +9977,8 @@ var createSessionSupervisor = (deps) => {
     title,
     reconcile,
     has: (sessionId) => children.has(sessionId),
-    killAll: () => {
-      for (const { child } of children.values()) killProcessGroup(child);
+    killAll: async () => {
+      for (const id of /* @__PURE__ */ new Set([...children.keys(), ...starts.keys()])) await stop(id);
     }
   };
 };
@@ -9810,7 +10001,7 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 import { existsSync as existsSync8, readdirSync as readdirSync2 } from "node:fs";
 import { createRequire as createModuleRequire } from "node:module";
 import { homedir as homedir3 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join14 } from "node:path";
 var MAX_TERMINALS = 10;
 var claudePtyCommand = (agentSessionId, hasJsonl, env = process.env) => ({
   file: env.BATON_CLAUDE_BIN?.trim() || "claude",
@@ -9826,10 +10017,10 @@ var codexPtyCommand = (agentSessionId, env = process.env) => {
   };
 };
 var hasSessionJsonl = (agentSessionId) => {
-  const root = join12(homedir3(), ".claude", "projects");
+  const root = join14(homedir3(), ".claude", "projects");
   if (!existsSync8(root)) return false;
   for (const dir of readdirSync2(root))
-    if (existsSync8(join12(root, dir, `${agentSessionId}.jsonl`))) return true;
+    if (existsSync8(join14(root, dir, `${agentSessionId}.jsonl`))) return true;
   return false;
 };
 var serverTerminalWsUrl = (server, sessionId) => `${server.replace(/^http/, "ws")}/workers/me/terminal/ws?sessionId=${sessionId}`;
@@ -9981,7 +10172,10 @@ var runWorkerDaemon = async (cfg, client, signal) => {
       const cmd = JSON.parse(e.data);
       if (cmd.cmd === "session.start")
         void supervisor.start(cmd.sessionId, cmd.name).catch((err) => log(`start failed: ${String(err)}`));
-      else if (cmd.cmd === "session.stop") supervisor.stop(cmd.sessionId);
+      else if (cmd.cmd === "session.stop")
+        void supervisor.stop(cmd.sessionId).catch((error) => log(`stop failed: ${String(error)}`));
+      else if (cmd.cmd === "session.reconcile")
+        void supervisor.reconcile(cmd.sessionId).catch((error) => log(`reconcile failed: ${String(error)}`));
       else if (cmd.cmd === "session.delete")
         void services.stopSession(cmd.sessionId).then(() => supervisor.remove(cmd.sessionId, cmd.worktreePath)).catch((err) => log(`service cleanup failed: ${String(err)}`));
       else if (cmd.cmd === "session.title")
@@ -9994,7 +10188,8 @@ var runWorkerDaemon = async (cfg, client, signal) => {
         void services.run(cmd.requestId, cmd.sessionId, cmd.name, cmd.argv, cmd.publicUrl, cmd.note).catch((err) => log(`service run failed: ${String(err)}`));
       else if (cmd.cmd === "service.stop")
         void services.stop(cmd.requestId, cmd.name).catch((err) => log(`service stop failed: ${String(err)}`));
-    } catch {
+    } catch (error) {
+      log(`invalid command: ${String(error)}`);
     }
   };
   es.onerror = () => log("command stream error (eventsource will retry)");
@@ -10008,23 +10203,23 @@ var runWorkerDaemon = async (cfg, client, signal) => {
   es.close();
   liveness.stop();
   services.killAll();
-  supervisor.killAll();
+  await supervisor.killAll();
   terminals.killAll();
   if (fatal) process.exit(1);
 };
 
 // src/worker/machine-id.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname5, join as join13 } from "node:path";
-var machineIdPath = (env = process.env) => join13(env.XDG_DATA_HOME ?? join13(env.HOME ?? homedir4(), ".local/share"), "baton", "machine-id");
+import { dirname as dirname5, join as join15 } from "node:path";
+var machineIdPath = (env = process.env) => join15(env.XDG_DATA_HOME ?? join15(env.HOME ?? homedir4(), ".local/share"), "baton", "machine-id");
 var readOrCreateMachineId = (path = machineIdPath()) => {
   if (existsSync10(path)) {
     const s = readFileSync6(path, "utf8").trim();
     if (s) return s;
   }
-  const id = randomUUID2();
+  const id = randomUUID3();
   mkdirSync5(dirname5(path), { recursive: true });
   writeFileSync5(path, `${id}
 `, "utf8");