@threadbase-sh/streamer 1.36.4 → 1.37.0

package/dist/index.cjs

@@ -38,6 +38,7 @@ __export(index_exports, {
   SessionStore: () => SessionStore,
   StreamerServer: () => StreamerServer,
   WSHub: () => WSHub,
+  confidenceForSource: () => confidenceForSource,
   createAgentClient: () => createAgentClient,
   createConversationWriter: () => createConversationWriter,
   createPool: () => createPool,
@@ -329,6 +330,165 @@ var import_crypto = require("crypto");
 var import_fs = require("fs");
 var import_os = require("os");
 var import_path = require("path");
+
+// src/claude-flags.ts
+var PERMISSION_MODES = [
+  "acceptEdits",
+  "auto",
+  "bypassPermissions",
+  "manual",
+  "dontAsk",
+  "plan"
+];
+function isPermissionMode(value) {
+  return typeof value === "string" && PERMISSION_MODES.includes(value);
+}
+var DANGEROUS_PERMISSION_MODES = [
+  "bypassPermissions",
+  "dontAsk"
+];
+function isDangerousPermissionMode(mode) {
+  return DANGEROUS_PERMISSION_MODES.includes(mode);
+}
+var CLAUDE_FLAGS = [
+  {
+    id: "permissionMode",
+    flag: "--permission-mode",
+    valueType: "enum",
+    enumValues: PERMISSION_MODES,
+    risk: "low"
+  },
+  { id: "addDir", flag: "--add-dir", valueType: "list", risk: "elevated" },
+  { id: "allowedTools", flag: "--allowedTools", valueType: "list", risk: "elevated" },
+  { id: "disallowedTools", flag: "--disallowedTools", valueType: "list", risk: "low" },
+  { id: "maxBudgetUsd", flag: "--max-budget-usd", valueType: "string", risk: "low" },
+  { id: "fallbackModel", flag: "--fallback-model", valueType: "string", risk: "low" }
+];
+function findFlag(id) {
+  return CLAUDE_FLAGS.find((f) => f.id === id);
+}
+function validateFlagValues(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const out = {};
+  for (const [id, value] of Object.entries(raw)) {
+    const def = findFlag(id);
+    if (!def) continue;
+    switch (def.valueType) {
+      case "boolean":
+        if (typeof value === "boolean") out[id] = value;
+        break;
+      case "enum":
+        if (typeof value === "string" && def.enumValues?.includes(value)) out[id] = value;
+        break;
+      case "string":
+        if (typeof value === "string" && value.trim().length > 0) out[id] = value.trim();
+        break;
+      case "list": {
+        if (!Array.isArray(value)) break;
+        const items = value.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim());
+        if (items.length > 0) out[id] = items;
+        break;
+      }
+    }
+  }
+  return out;
+}
+function tokenizeExtraArgs(input) {
+  if (!input) return [];
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let started = false;
+  for (const ch of input) {
+    if (quote) {
+      if (ch === quote) quote = null;
+      else current += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      started = true;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (started) {
+        tokens.push(current);
+        current = "";
+        started = false;
+      }
+      continue;
+    }
+    current += ch;
+    started = true;
+  }
+  if (started) tokens.push(current);
+  return tokens;
+}
+function buildFlagArgs(values, extraArgs) {
+  const args = [];
+  const safe = validateFlagValues(values ?? {});
+  for (const def of CLAUDE_FLAGS) {
+    if (def.id === "permissionMode") continue;
+    const value = safe[def.id];
+    if (value === void 0) continue;
+    if (def.valueType === "boolean") {
+      if (value === true) args.push(def.flag);
+      continue;
+    }
+    if (Array.isArray(value)) {
+      args.push(def.flag, ...value);
+      continue;
+    }
+    args.push(def.flag, String(value));
+  }
+  args.push(...tokenizeExtraArgs(extraArgs));
+  return args;
+}
+function buildSettingsJson(permissionMode) {
+  const settings = { spinnerTipsEnabled: false };
+  if (isDangerousPermissionMode(permissionMode)) {
+    settings.skipDangerousModePermissionPrompt = true;
+  }
+  return JSON.stringify(settings);
+}
+
+// src/logger.ts
+var import_pino = __toESM(require("pino"), 1);
+var baseLogger = (0, import_pino.default)({
+  level: process.env.LOG_LEVEL ?? "info",
+  base: { service: "tb-streamer" },
+  timestamp: import_pino.default.stdTimeFunctions.isoTime,
+  redact: {
+    paths: ["req.headers.authorization", "req.headers.cookie", 'req.headers["x-api-key"]'],
+    censor: "[redacted]"
+  }
+});
+function emit(pinoChild, level, msg, fields, dest) {
+  if (dest === "pino" || dest === "both") {
+    if (fields && Object.keys(fields).length > 0) pinoChild[level](fields, msg);
+    else pinoChild[level](msg);
+  }
+  if (dest === "console" || dest === "both") {
+    const consoleMethod = level === "error" ? "error" : level === "warn" ? "warn" : "log";
+    console[consoleMethod](msg);
+  }
+}
+function build(pinoChild) {
+  return {
+    debug: (m, f, d = "both") => emit(pinoChild, "debug", m, f, d),
+    info: (m, f, d = "both") => emit(pinoChild, "info", m, f, d),
+    warn: (m, f, d = "both") => emit(pinoChild, "warn", m, f, d),
+    error: (m, f, d = "both") => emit(pinoChild, "error", m, f, d),
+    log: (lvl, m, f, d = "both") => emit(pinoChild, lvl, m, f, d),
+    pino: pinoChild
+  };
+}
+function getLogger(component) {
+  return build(component ? baseLogger.child({ component }) : baseLogger);
+}
+var logger = build(baseLogger);
+
+// src/auth.ts
 function configDir() {
   return process.env.THREADBASE_CONFIG_DIR ?? (0, import_path.join)((0, import_os.homedir)(), ".threadbase");
 }
@@ -407,11 +567,79 @@ function loadDefaultPermissionMode() {
     const content = (0, import_fs.readFileSync)(configFile(), "utf-8");
     const match = content.match(/default_permission_mode:\s*(\S+)/);
     const value = match?.[1]?.trim();
-    if (value === "acceptEdits" || value === "manual") return value;
+    if (isPermissionMode(value)) return value;
   } catch {
   }
   return void 0;
 }
+function setConfigValue(key, value) {
+  const file = configFile();
+  (0, import_fs.mkdirSync)(configDir(), { recursive: true });
+  let content = "";
+  try {
+    content = (0, import_fs.readFileSync)(file, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const lineRe = new RegExp(`^${key}:\\s*.*$\\n?`, "m");
+  let updated;
+  if (value === void 0) {
+    updated = content.replace(lineRe, "");
+  } else {
+    const line = `${key}: ${value}`;
+    if (lineRe.test(content)) {
+      updated = content.replace(lineRe, `${line}
+`);
+    } else if (content.length === 0 || content.endsWith("\n")) {
+      updated = `${content}${line}
+`;
+    } else {
+      updated = `${content}
+${line}
+`;
+    }
+  }
+  const tmpFile = `${file}.tmp`;
+  (0, import_fs.writeFileSync)(tmpFile, updated, { encoding: "utf-8", mode: 384 });
+  (0, import_fs.chmodSync)(tmpFile, 384);
+  (0, import_fs.renameSync)(tmpFile, file);
+}
+function loadClaudeFlags() {
+  try {
+    const content = (0, import_fs.readFileSync)(configFile(), "utf-8");
+    const match = content.match(/^claude_flags:\s*(.+)$/m);
+    if (!match?.[1]) return {};
+    return validateFlagValues(JSON.parse(match[1].trim()));
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      getLogger("auth").warn(`Ignoring unreadable claude_flags in server.yaml: ${String(err)}`, {
+        event: "config.claude_flags_parse_failed"
+      });
+    }
+    return {};
+  }
+}
+function setClaudeFlags(values) {
+  const safe = validateFlagValues(values);
+  setConfigValue("claude_flags", Object.keys(safe).length === 0 ? void 0 : JSON.stringify(safe));
+}
+function loadClaudeExtraArgs() {
+  try {
+    const content = (0, import_fs.readFileSync)(configFile(), "utf-8");
+    const match = content.match(/^claude_extra_args:\s*(.+)$/m);
+    const value = match?.[1]?.trim();
+    return value && value.length > 0 ? value : void 0;
+  } catch {
+  }
+  return void 0;
+}
+function setClaudeExtraArgs(text) {
+  const trimmed = text?.trim();
+  if (trimmed && /[\r\n]/.test(trimmed)) {
+    throw new Error("claude_extra_args must not contain newlines");
+  }
+  setConfigValue("claude_extra_args", trimmed && trimmed.length > 0 ? trimmed : void 0);
+}
 function validatePublicUrl(raw) {
   let parsed;
   try {
@@ -560,42 +788,6 @@ var import_crypto2 = require("crypto");
 var import_fs5 = require("fs");
 var import_path5 = require("path");
 
-// src/logger.ts
-var import_pino = __toESM(require("pino"), 1);
-var baseLogger = (0, import_pino.default)({
-  level: process.env.LOG_LEVEL ?? "info",
-  base: { service: "tb-streamer" },
-  timestamp: import_pino.default.stdTimeFunctions.isoTime,
-  redact: {
-    paths: ["req.headers.authorization", "req.headers.cookie", 'req.headers["x-api-key"]'],
-    censor: "[redacted]"
-  }
-});
-function emit(pinoChild, level, msg, fields, dest) {
-  if (dest === "pino" || dest === "both") {
-    if (fields && Object.keys(fields).length > 0) pinoChild[level](fields, msg);
-    else pinoChild[level](msg);
-  }
-  if (dest === "console" || dest === "both") {
-    const consoleMethod = level === "error" ? "error" : level === "warn" ? "warn" : "log";
-    console[consoleMethod](msg);
-  }
-}
-function build(pinoChild) {
-  return {
-    debug: (m, f, d = "both") => emit(pinoChild, "debug", m, f, d),
-    info: (m, f, d = "both") => emit(pinoChild, "info", m, f, d),
-    warn: (m, f, d = "both") => emit(pinoChild, "warn", m, f, d),
-    error: (m, f, d = "both") => emit(pinoChild, "error", m, f, d),
-    log: (lvl, m, f, d = "both") => emit(pinoChild, lvl, m, f, d),
-    pino: pinoChild
-  };
-}
-function getLogger(component) {
-  return build(component ? baseLogger.child({ component }) : baseLogger);
-}
-var logger = build(baseLogger);
-
 // src/platform.ts
 var import_child_process = require("child_process");
 var import_fs3 = require("fs");
@@ -947,6 +1139,8 @@ var CodexPtyRunner = class {
       projectName,
       branch: options.branch ?? "",
       status: "running",
+      statusSource: "spawn",
+      statusUpdatedAt: /* @__PURE__ */ new Date(),
       startedAt: /* @__PURE__ */ new Date(),
       completedAt: null,
       promptCount: 0,
@@ -994,6 +1188,8 @@ var CodexPtyRunner = class {
       projectName,
       branch: "",
       status: "running",
+      statusSource: "spawn",
+      statusUpdatedAt: /* @__PURE__ */ new Date(),
       startedAt: /* @__PURE__ */ new Date(),
       completedAt: null,
       promptCount: 0,
@@ -1024,7 +1220,7 @@ var CodexPtyRunner = class {
       this.readyFallbackTimers.delete(sessionId);
       const session = this.sessions.get(sessionId);
       if (session?.status === "running" && this.pendingReady.has(sessionId)) {
-        this.markReady(sessionId, session, "fallback:timeout");
+        this.markReady(sessionId, session, "timeout-fallback", "fallback:timeout");
       }
     }, CODEX_READY_FALLBACK_MS);
     timer.unref?.();
@@ -1039,6 +1235,8 @@ var CodexPtyRunner = class {
     }
     if (session.status === "waiting_input") {
       session.status = "running";
+      session.statusSource = "user-input";
+      session.statusUpdatedAt = /* @__PURE__ */ new Date();
       this.onStatusChange?.(toPublicSession(session));
     }
     const gate = this.openGate.get(sessionId);
@@ -1108,6 +1306,8 @@ var CodexPtyRunner = class {
     }
     if (session.status === "waiting_input") {
       session.status = "running";
+      session.statusSource = "user-input";
+      session.statusUpdatedAt = /* @__PURE__ */ new Date();
       this.onStatusChange?.(toPublicSession(session));
     }
     this.writeSubmit(sessionId, session, input, "direct", session.promptCount + 1);
@@ -1208,6 +1408,8 @@ var CodexPtyRunner = class {
     } catch {
     }
     session.status = "idle";
+    session.statusSource = "shutdown";
+    session.statusUpdatedAt = /* @__PURE__ */ new Date();
     session.completedAt = /* @__PURE__ */ new Date();
     session.screen.dispose();
     this.sessions.delete(sessionId);
@@ -1252,6 +1454,11 @@ var CodexPtyRunner = class {
   getInputHistory(sessionId) {
     return this.sessions.get(sessionId)?.inputHistory ?? [];
   }
+  // OS pid of the spawned agent, or null if the session isn't live here.
+  // Mirrors PTYManager.getPid — see there for why the registry records it.
+  getPid(sessionId) {
+    return this.sessions.get(sessionId)?.process?.pid ?? null;
+  }
   // Record a submitted user message as ground truth and fire onUserMessage.
   // Called from writeSubmit (direct and flush paths) — never from sendKeys.
   recordUserMessage(session, text) {
@@ -1353,9 +1560,9 @@ var CodexPtyRunner = class {
     if (session.status !== "running" || !this.pendingReady.has(sessionId)) return;
     const lastNonBlank2 = [...lines].reverse().find((l) => l.trim() !== "") ?? "";
     if (lastNonBlank2.includes(CODEX_PROMPT_READY_TEXT)) {
-      this.markReady(sessionId, session, `marker:${CODEX_PROMPT_READY_TEXT}`);
+      this.markReady(sessionId, session, "prompt-marker", `marker:${CODEX_PROMPT_READY_TEXT}`);
     } else if (trigger === "quiet") {
-      this.markReady(sessionId, session, "quiet:timeout");
+      this.markReady(sessionId, session, "quiet-fallback", "quiet:timeout");
     }
   }
   // Answer a gate from the persisted remember-store, or surface it as a
@@ -1386,9 +1593,11 @@ var CodexPtyRunner = class {
     });
     this.onPermissionChange?.(sessionId, card);
   }
-  markReady(sessionId, session, reason) {
+  markReady(sessionId, session, source, reason) {
     session.lastActivityAt = /* @__PURE__ */ new Date();
     session.status = "waiting_input";
+    session.statusSource = source;
+    session.statusUpdatedAt = /* @__PURE__ */ new Date();
     this.log.info(`[codex.ready] ${sessionId.slice(0, 8)} ${reason}`, {
       event: "codex.ready",
       sessionId,
@@ -1406,6 +1615,8 @@ var CodexPtyRunner = class {
     if (!session) return;
     session.completedAt = /* @__PURE__ */ new Date();
     session.status = "idle";
+    session.statusSource = "process-exit";
+    session.statusUpdatedAt = /* @__PURE__ */ new Date();
     const elapsedMs = session.completedAt.getTime() - session.startedAt.getTime();
     if (exitCode !== 0 && elapsedMs < 2e3 && session.lastOutput === "") {
       if (!(0, import_fs5.existsSync)(session.projectPath)) {
@@ -1435,6 +1646,8 @@ function toPublicSession(s) {
     lastOutput: s.lastOutput,
     ...s.failureReason != null && { failureReason: s.failureReason },
     ...s.lastActivityAt != null && { lastActivityAt: s.lastActivityAt },
+    ...s.statusSource != null && { statusSource: s.statusSource },
+    ...s.statusUpdatedAt != null && { statusUpdatedAt: s.statusUpdatedAt },
     ...s.filePath != null && { filePath: s.filePath }
   };
 }
@@ -1763,16 +1976,17 @@ var PTYManager = class {
   }
   // Resume an existing Claude conversation. sessionId is the JSONL UUID.
   //
-  // options.permissionMode defaults to `acceptEdits` rather than
-  // `--dangerously-skip-permissions`/`bypassPermissions`. Both suppress
-  // file-edit prompts, but in an interactive (TUI) launch the skip-permissions
-  // flag renders a blocking "Bypass Permissions mode" warning menu on every
-  // boot that no known ~/.claude.json flag suppressed (as of Claude CLI
-  // v2.1.x) — the session never reaches a usable prompt, so the mobile app
-  // shows an empty/stuck screen. `acceptEdits` auto-approves file edits
-  // without that warning gate, while still prompting for shell commands.
-  // `manual` (prompt for everything) is the only other mode callers may pass;
-  // `bypassPermissions`/`plan`/`dontAsk`/`auto` are not supported here.
+  // options.permissionMode defaults to `acceptEdits` — the safe default that
+  // auto-approves file edits while still prompting for shell commands. All six
+  // Claude CLI modes are accepted (see PERMISSION_MODES in claude-flags.ts).
+  //
+  // On the bypass modes: `bypassPermissions`/`dontAsk` DO trigger a blocking
+  // "Bypass Permissions mode" warning menu at boot ("1. No, exit" /
+  // "2. Yes, I accept") which would strand the PTY and leave mobile on an empty
+  // screen. buildSettingsJson() suppresses it by adding
+  // `skipDangerousModePermissionPrompt` to the `--settings` blob for exactly
+  // those modes — probe-verified on Claude Code v2.1.218. We never pass
+  // `--dangerously-skip-permissions`; bypass is requested via --permission-mode.
   // (The other first-run gates — onboarding/theme, workspace trust,
   // custom-API-key — are cleared by the seeded ~/.claude.json in
   // docker/entrypoint.sh.) startFresh() uses the same default for the same reason.
@@ -1790,28 +2004,27 @@ var PTYManager = class {
   async doStart(sessionId, options) {
     const nodePty = await loadPty2();
     const projectName = options.projectName ?? (0, import_path6.basename)(options.projectPath);
-    const proc = nodePty.spawn(
-      resolveClaudeExe(),
-      [
-        "--permission-mode",
-        options.permissionMode ?? "acceptEdits",
-        "--settings",
-        '{"spinnerTipsEnabled":false}',
-        "--model",
-        options.model ?? "sonnet",
-        "--effort",
-        options.effort ?? "low",
-        "--resume",
-        sessionId
-      ],
-      {
-        name: "xterm-256color",
-        cols: 120,
-        rows: 40,
-        cwd: options.projectPath,
-        env: buildSpawnEnv()
-      }
-    );
+    const permissionMode = options.permissionMode ?? "acceptEdits";
+    const args = [
+      "--permission-mode",
+      permissionMode,
+      "--settings",
+      buildSettingsJson(permissionMode),
+      "--model",
+      options.model ?? "sonnet",
+      "--effort",
+      options.effort ?? "low",
+      "--resume",
+      sessionId
+    ];
+    args.push(...buildFlagArgs(options.claudeFlags, options.claudeExtraArgs));
+    const proc = nodePty.spawn(resolveClaudeExe(), args, {
+      name: "xterm-256color",
+      cols: 120,
+      rows: 40,
+      cwd: options.projectPath,
+      env: buildSpawnEnv()
+    });
     const session = {
       id: sessionId,
       provider: CLAUDE_CODE_PROVIDER,
@@ -1819,6 +2032,8 @@ var PTYManager = class {
       projectName,
       branch: options.branch ?? "",
       status: "running",
+      statusSource: "spawn",
+      statusUpdatedAt: /* @__PURE__ */ new Date(),
       startedAt: /* @__PURE__ */ new Date(),
       completedAt: null,
       promptCount: 0,
@@ -1846,11 +2061,12 @@ var PTYManager = class {
     const nodePty = await loadPty2();
     const sessionId = (0, import_crypto3.randomUUID)();
     const projectName = options.projectName ?? (0, import_path6.basename)(options.projectPath);
+    const permissionMode = options.permissionMode ?? "acceptEdits";
     const args = [
       "--permission-mode",
-      options.permissionMode ?? "acceptEdits",
+      permissionMode,
       "--settings",
-      '{"spinnerTipsEnabled":false}',
+      buildSettingsJson(permissionMode),
       "--model",
       options.model ?? "sonnet",
       "--effort",
@@ -1861,6 +2077,7 @@ var PTYManager = class {
     if (options.systemPrompt) {
       args.push("--system-prompt", options.systemPrompt);
     }
+    args.push(...buildFlagArgs(options.claudeFlags, options.claudeExtraArgs));
     const proc = nodePty.spawn(resolveClaudeExe(), args, {
       name: "xterm-256color",
       cols: 120,
@@ -1875,6 +2092,8 @@ var PTYManager = class {
       projectName,
       branch: "",
       status: "running",
+      statusSource: "spawn",
+      statusUpdatedAt: /* @__PURE__ */ new Date(),
       startedAt: /* @__PURE__ */ new Date(),
       completedAt: null,
       promptCount: 0,
@@ -1905,6 +2124,8 @@ var PTYManager = class {
     }
     if (session.status === "waiting_input") {
       session.status = "running";
+      session.statusSource = "user-input";
+      session.statusUpdatedAt = /* @__PURE__ */ new Date();
       this.onStatusChange?.(toPublicSession2(session));
     }
     this.log.info(
@@ -1940,6 +2161,8 @@ var PTYManager = class {
     }
     if (session.status === "waiting_input") {
       session.status = "running";
+      session.statusSource = "user-input";
+      session.statusUpdatedAt = /* @__PURE__ */ new Date();
       this.onStatusChange?.(toPublicSession2(session));
     }
     this.writeSubmit(sessionId, session, input, "direct", session.promptCount + 1);
@@ -2061,6 +2284,8 @@ var PTYManager = class {
     } catch {
     }
     session.status = "idle";
+    session.statusSource = "shutdown";
+    session.statusUpdatedAt = /* @__PURE__ */ new Date();
     session.completedAt = /* @__PURE__ */ new Date();
     session.screen.dispose();
     this.sessions.delete(sessionId);
@@ -2096,6 +2321,13 @@ var PTYManager = class {
   getInputHistory(sessionId) {
     return this.sessions.get(sessionId)?.inputHistory ?? [];
   }
+  // OS pid of the spawned agent, or null if the session isn't live here. The
+  // durable registry records this so a later streamer run can probe whether the
+  // process outlived it. Liveness alone is never identity — a recycled pid is
+  // why the registry stores a cmdline alongside it.
+  getPid(sessionId) {
+    return this.sessions.get(sessionId)?.process?.pid ?? null;
+  }
   // Record a submitted user message as ground truth and fire onUserMessage.
   // Called from writeSubmit (both direct and flush paths) — never from
   // sendKeys, so raw keystrokes aren't logged as messages.
@@ -2172,9 +2404,9 @@ var PTYManager = class {
     session.lastOutput = stripped;
     const matchedMarker = CLAUDE_PROMPT_MARKERS.find((m) => stripped.includes(m));
     if (session.status === "running" && matchedMarker) {
-      this.markReady(sessionId, session, `marker:${matchedMarker}`);
+      this.markReady(sessionId, session, "prompt-marker", `marker:${matchedMarker}`);
     } else if (session.status === "running" && this.pendingReady.has(sessionId) && now - (this.firstChunkAt.get(sessionId) ?? now) >= PROMPT_MARKER_FALLBACK_MS) {
-      this.markReady(sessionId, session, "fallback:timeout");
+      this.markReady(sessionId, session, "timeout-fallback", "fallback:timeout");
     }
     this.onOutput?.(sessionId, data);
     this.detectLivePrompts(sessionId, data, stripped).catch((err) => {
@@ -2274,7 +2506,7 @@ var PTYManager = class {
     const session = this.sessions.get(sessionId);
     if (session?.status !== "running") return;
     if (this.pendingReady.has(sessionId)) {
-      this.markReady(sessionId, session, "quiet:timeout");
+      this.markReady(sessionId, session, "quiet-fallback", "quiet:timeout");
     } else {
       this.recheckReadyFromScreen(sessionId).catch((err) => {
         this.log.warn("[pty.ready] screen recheck failed", {
@@ -2303,14 +2535,16 @@ var PTYManager = class {
     const lines = await this.getOutputLines(sessionId, PTY_ROWS2);
     const matchedMarker = CLAUDE_PROMPT_MARKERS.find((m) => lines.some((l) => l.includes(m)));
     if (matchedMarker && session.status === "running") {
-      this.markReady(sessionId, session, `quiet:screen-marker:${matchedMarker}`);
+      this.markReady(sessionId, session, "screen-marker", `quiet:screen-marker:${matchedMarker}`);
     }
   }
   // Transition a session from "running" to "waiting_input", clear pendingReady,
   // and flush any queued input. Idempotent: callers can invoke at any chunk.
-  markReady(sessionId, session, reason) {
+  markReady(sessionId, session, source, reason) {
     session.lastActivityAt = /* @__PURE__ */ new Date();
     session.status = "waiting_input";
+    session.statusSource = source;
+    session.statusUpdatedAt = /* @__PURE__ */ new Date();
     const elapsedMs = Date.now() - (this.firstChunkAt.get(sessionId) ?? Date.now());
     this.log.info(`[pty.ready] ${sessionId.slice(0, 8)} ${reason} (elapsed=${elapsedMs}ms)`, {
       event: "pty.ready",
@@ -2330,6 +2564,8 @@ var PTYManager = class {
     if (!session) return;
     session.completedAt = /* @__PURE__ */ new Date();
     session.status = "idle";
+    session.statusSource = "process-exit";
+    session.statusUpdatedAt = /* @__PURE__ */ new Date();
     const elapsedMs = session.completedAt.getTime() - session.startedAt.getTime();
     if (exitCode !== 0 && elapsedMs < 2e3 && session.lastOutput === "") {
       if (!(0, import_fs6.existsSync)(session.projectPath)) {
@@ -2364,6 +2600,8 @@ function toPublicSession2(s) {
     lastOutput: s.lastOutput,
     ...s.failureReason != null && { failureReason: s.failureReason },
     ...s.lastActivityAt != null && { lastActivityAt: s.lastActivityAt },
+    ...s.statusSource != null && { statusSource: s.statusSource },
+    ...s.statusUpdatedAt != null && { statusUpdatedAt: s.statusUpdatedAt },
     ...s.filePath != null && { filePath: s.filePath }
   };
 }
@@ -2436,6 +2674,16 @@ var LiveSessionManager = class {
     }
     return null;
   }
+  // Scans rather than using runnerFor(): the registry records a pid on a
+  // best-effort basis, so an unknown session must return null rather than
+  // throw the way the input-routing methods do.
+  getPid(sessionId) {
+    for (const runner of this.runners.values()) {
+      const pid = runner.getPid(sessionId);
+      if (pid != null) return pid;
+    }
+    return null;
+  }
   hasSession(sessionId) {
     for (const runner of this.runners.values()) {
       if (runner.hasSession(sessionId)) return true;
@@ -2612,6 +2860,18 @@ async function getProcessCwdUnix(pid) {
 async function getProcessArgsUnix(pid) {
   return (await run("ps", ["-p", String(pid), "-o", "args="])).trim();
 }
+async function getProcessArgs(pid) {
+  if (!Number.isInteger(pid) || pid < 1) return "";
+  try {
+    if ((0, import_os4.platform)() === "win32") {
+      const info = await getProcessInfoWindows(pid);
+      return info?.args ?? "";
+    }
+    return await getProcessArgsUnix(pid);
+  } catch {
+    return "";
+  }
+}
 async function getProcessStartTimeUnix(pid) {
   const raw = (await run("ps", ["-p", String(pid), "-o", "lstart="])).trim();
   const d = new Date(raw);
@@ -2727,6 +2987,7 @@ async function readGitBranch(dir) {
 var import_node_ws = require("@hono/node-ws");
 var import_client = require("@temporalio/client");
 var import_scanner3 = require("@threadbase-sh/scanner");
+var import_crypto11 = require("crypto");
 var import_events = require("events");
 var import_fs18 = require("fs");
 var import_promises7 = require("fs/promises");
@@ -2991,7 +3252,202 @@ async function handleStartAgentSession(body, deps) {
 }
 
 // src/api/app.ts
-var import_hono13 = require("hono");
+var import_hono16 = require("hono");
+
+// src/db/repositories/devices.repository.ts
+var import_crypto5 = require("crypto");
+
+// src/services/security/capabilities.ts
+var CAPABILITIES = [
+  "history:read",
+  // read conversations, search
+  "session:control",
+  // start, resume, send input, interrupt
+  "fs:browse",
+  // browse the project tree
+  "fs:upload",
+  // upload files into a project
+  "notifications",
+  // register for push
+  "admin"
+  // rotate keys, manage devices
+];
+function isCapability(value) {
+  return typeof value === "string" && CAPABILITIES.includes(value);
+}
+var FULL_CAPABILITIES = [
+  "history:read",
+  "session:control",
+  "fs:browse",
+  "fs:upload",
+  "notifications"
+];
+var READ_ONLY_CAPABILITIES = ["history:read"];
+function capabilitiesForPreset(preset) {
+  return preset === "read-only" ? [...READ_ONLY_CAPABILITIES] : [...FULL_CAPABILITIES];
+}
+function legacyPrincipal() {
+  return { kind: "legacy", capabilities: [...FULL_CAPABILITIES, "admin"] };
+}
+function hasCapability(principal, required) {
+  return principal.capabilities.includes(required);
+}
+var ROUTE_CAPABILITIES = [
+  // Most specific first for readability; matching sorts by length anyway.
+  ["/api/sessions/", "session:control"],
+  ["/api/sessions", "history:read"],
+  // listing sessions is a read
+  ["/api/conversations", "history:read"],
+  ["/api/projects", "history:read"],
+  ["/api/search", "history:read"],
+  ["/api/providers", "history:read"],
+  ["/api/browse", "fs:browse"],
+  ["/api/upload", "fs:upload"],
+  ["/api/push", "notifications"],
+  ["/api/devices", "admin"],
+  ["/api/config", "admin"],
+  ["/api/auth/rotate", "admin"],
+  ["/api/backup", "admin"],
+  // Server identity and capability discovery. A read-only device must be able
+  // to see WHICH server it is talking to and what it supports, or it cannot
+  // render anything at all.
+  ["/api/info", "history:read"],
+  ["/api/profiles", "history:read"],
+  ["/api/diagnostics", "history:read"],
+  ["/api/cache/alert", "history:read"],
+  // Client log shipping: any authenticated client may report its own errors.
+  // Gating this behind a capability would silence diagnostics from exactly the
+  // devices most likely to be misbehaving.
+  ["/api/__client-log", "history:read"],
+  // Logs viewer is localhost-only and already bypasses this middleware; the
+  // mapping exists so a remote request is classified rather than denied as
+  // unclassified.
+  ["/api/logs", "admin"],
+  // Pairing routes other than the public exchange (e.g. minting a token).
+  ["/api/pair", "admin"],
+  // The live WebSocket. Subscribing is a read — terminal output, session
+  // updates, conversation events. Control still flows through the HTTP input
+  // routes, which carry their own capability check, so a read-only device can
+  // watch a session stream without being able to drive it.
+  ["/ws", "history:read"],
+  // Progress webhook (multi-agent). Authenticated by HMAC in the handler and
+  // already skipped by the middleware; classified so a stray request is denied
+  // by rule rather than as "unclassified".
+  ["/internal/sessions", "admin"]
+];
+function requiredCapability(path, method) {
+  if (path.startsWith("/api/sessions") && (method === "GET" || method === "HEAD")) {
+    return "history:read";
+  }
+  let best = null;
+  for (const [prefix, cap] of ROUTE_CAPABILITIES) {
+    if (path.startsWith(prefix) && (best === null || prefix.length > best.len)) {
+      best = { len: prefix.length, cap };
+    }
+  }
+  return best?.cap ?? null;
+}
+
+// src/db/repositories/devices.repository.ts
+function generateDeviceToken() {
+  return (0, import_crypto5.randomBytes)(32).toString("base64url");
+}
+function hashDeviceToken(token) {
+  return (0, import_crypto5.createHash)("sha256").update(token).digest("hex");
+}
+function safeHashEquals(a, b) {
+  if (a.length !== b.length) return false;
+  return (0, import_crypto5.timingSafeEqual)(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+}
+function parseCapabilities(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isCapability);
+  } catch {
+    return [];
+  }
+}
+function toDeviceView(row) {
+  return {
+    deviceId: row.device_id,
+    name: row.name,
+    capabilities: parseCapabilities(row.capabilities),
+    createdAt: row.created_at,
+    lastSeenAt: row.last_seen_at,
+    revokedAt: row.revoked_at
+  };
+}
+var DevicesRepository = class {
+  insertStmt;
+  byTokenHashStmt;
+  byIdStmt;
+  listStmt;
+  revokeStmt;
+  touchStmt;
+  constructor(db) {
+    this.insertStmt = db.prepare(`
+      INSERT INTO devices (
+        device_id, public_key, token_hash, name, capabilities, created_at
+      ) VALUES (
+        @device_id, @public_key, @token_hash, @name, @capabilities, @created_at
+      )
+    `);
+    this.byTokenHashStmt = db.prepare("SELECT * FROM devices WHERE token_hash = ?");
+    this.byIdStmt = db.prepare("SELECT * FROM devices WHERE device_id = ?");
+    this.listStmt = db.prepare("SELECT * FROM devices ORDER BY created_at DESC");
+    this.revokeStmt = db.prepare("UPDATE devices SET revoked_at = ? WHERE device_id = ?");
+    this.touchStmt = db.prepare("UPDATE devices SET last_seen_at = ? WHERE device_id = ?");
+  }
+  /**
+   * Record a newly paired device and mint its token.
+   *
+   * The raw token is returned to the caller and never stored — this is the only
+   * moment it exists outside the client.
+   */
+  register(args) {
+    const deviceId = (0, import_crypto5.randomUUID)();
+    const deviceToken = generateDeviceToken();
+    const capabilities = capabilitiesForPreset(args.preset ?? "full");
+    this.insertStmt.run({
+      device_id: deviceId,
+      public_key: args.publicKey,
+      token_hash: hashDeviceToken(deviceToken),
+      name: args.name ?? null,
+      capabilities: JSON.stringify(capabilities),
+      created_at: args.now ?? Date.now()
+    });
+    return { deviceId, deviceToken, capabilities };
+  }
+  /**
+   * Resolve a presented token to a device, or null.
+   *
+   * Returns null for a revoked device, so revocation takes effect on the very
+   * next request with no cache to go stale.
+   */
+  authenticate(token) {
+    const hash = hashDeviceToken(token);
+    const row = this.byTokenHashStmt.get(hash);
+    if (!row) return null;
+    if (!safeHashEquals(row.token_hash, hash)) return null;
+    if (row.revoked_at != null) return null;
+    return row;
+  }
+  get(deviceId) {
+    return this.byIdStmt.get(deviceId) ?? null;
+  }
+  /** All devices, including revoked ones — an audit surface needs the history. */
+  list() {
+    return this.listStmt.all().map(toDeviceView);
+  }
+  /** Revoke one device. Others are untouched — no key rotation, no collateral. */
+  revoke(deviceId, now = Date.now()) {
+    return this.revokeStmt.run(now, deviceId).changes > 0;
+  }
+  touch(deviceId, now = Date.now()) {
+    this.touchStmt.run(now, deviceId);
+  }
+};
 
 // src/api/middleware/auth.middleware.ts
 function isLocalRequest(remoteAddr) {
@@ -3022,19 +3478,40 @@ var authMiddleware = (deps) => async (c, next) => {
     }
   }
   const authorization = c.req.header("authorization");
-  if (authorization?.startsWith("Bearer ")) {
-    const token = authorization.slice(7);
-    if (validateApiKey(token, deps.apiKey)) {
-      await next();
-      return;
+  const bearer = authorization?.startsWith("Bearer ") ? authorization.slice(7) : void 0;
+  const queryKey = c.req.query("key") ?? void 0;
+  const presented = bearer ?? queryKey;
+  if (!presented) {
+    return c.json({ error: "Unauthorized" }, 401);
+  }
+  let principal = null;
+  const device = deps.devicesRepo()?.authenticate(presented) ?? null;
+  if (device) {
+    principal = {
+      kind: "device",
+      deviceId: device.device_id,
+      capabilities: parseCapabilities(device.capabilities)
+    };
+    try {
+      deps.devicesRepo()?.touch(device.device_id);
+    } catch {
     }
+  } else if (validateApiKey(presented, deps.apiKey)) {
+    principal = legacyPrincipal();
+  }
+  if (!principal) {
+    return c.json({ error: "Unauthorized" }, 401);
   }
-  const key = c.req.query("key");
-  if (key && validateApiKey(key, deps.apiKey)) {
+  const required = requiredCapability(path, method);
+  if (required === null) {
     await next();
     return;
   }
-  return c.json({ error: "Unauthorized" }, 401);
+  if (!hasCapability(principal, required)) {
+    return c.json({ error: "Forbidden", code: "MISSING_CAPABILITY", required }, 403);
+  }
+  c.set("principal", principal);
+  await next();
 };
 
 // src/api/middleware/cors.middleware.ts
@@ -3173,12 +3650,67 @@ var createCacheAlertRoutes = (deps) => {
   return app;
 };
 
-// src/api/routes/conversations.routes.ts
+// src/api/routes/config.routes.ts
 var import_hono4 = require("hono");
+
+// src/schemas/claudeFlags.schema.ts
+var import_zod2 = require("zod");
+var ClaudeFlagsBodySchema = import_zod2.z.object({
+  values: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.union([import_zod2.z.string(), import_zod2.z.boolean(), import_zod2.z.array(import_zod2.z.string())])).default({}),
+  // A newline would corrupt the flat one-line-per-key server.yaml, so reject
+  // it here with a field error instead of silently stripping it.
+  extraArgs: import_zod2.z.string().refine((v) => !/[\r\n]/.test(v), "extraArgs must not contain newlines").optional()
+}).strict();
+
+// src/api/routes/config.routes.ts
+function readRawBody3(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+var createConfigRoutes = (deps) => {
+  const app = new import_hono4.Hono();
+  app.get("/claude-flags", (c) => c.json(deps.claudeFlagsConfig()));
+  app.put("/claude-flags", async (c) => {
+    if (deps.localNoAuth) {
+      return c.json({ error: "claude flag changes are disabled while localNoAuth is active" }, 403);
+    }
+    let body;
+    try {
+      const incoming = c.env?.incoming;
+      const raw = incoming ? await readRawBody3(incoming) : Buffer.from(await c.req.arrayBuffer()).toString("utf-8");
+      body = raw ? JSON.parse(raw) : {};
+    } catch {
+      return c.json({ error: "invalid json" }, 400);
+    }
+    const parsed = ClaudeFlagsBodySchema.safeParse(body);
+    if (!parsed.success) {
+      return c.json({ error: "invalid body", details: parsed.error.flatten() }, 400);
+    }
+    try {
+      const result = deps.setClaudeFlagsConfig(parsed.data.values, parsed.data.extraArgs);
+      return c.json({
+        ...result,
+        ...result.persisted ? {} : {
+          warning: "Flags applied in memory only. The server was started with --claude-flag, so the CLI values will be restored on restart. Drop the flag and let the server manage them via ~/.threadbase/server.yaml for changes to survive restarts."
+        }
+      });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : "could not apply flags" }, 400);
+    }
+  });
+  return app;
+};
+
+// src/api/routes/conversations.routes.ts
+var import_hono5 = require("hono");
 var ALREADY_HANDLED2 = 597;
 var alreadyHandled2 = () => new Response(null, { status: ALREADY_HANDLED2 });
 var createConversationRoutes = (deps) => {
-  const app = new import_hono4.Hono();
+  const app = new import_hono5.Hono();
   app.get("/count", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleConversationsCount(url, c.env.outgoing);
@@ -3204,8 +3736,34 @@ var createConversationRoutes = (deps) => {
   return app;
 };
 
+// src/api/routes/devices.routes.ts
+var import_hono6 = require("hono");
+var createDeviceRoutes = (deps) => {
+  const app = new import_hono6.Hono();
+  app.get("/", (c) => {
+    const repo = deps.devicesRepo();
+    if (!repo) return c.json({ devices: [], available: false });
+    return c.json({ devices: repo.list(), available: true });
+  });
+  app.post("/:id/revoke", (c) => {
+    const repo = deps.devicesRepo();
+    if (!repo) {
+      return c.json({ error: "Device registry is unavailable", code: "STORE_UNAVAILABLE" }, 503);
+    }
+    const id = c.req.param("id");
+    const existing = repo.get(id);
+    if (!existing) return c.json({ error: "Device not found" }, 404);
+    if (existing.revoked_at != null) {
+      return c.json({ ok: true, alreadyRevoked: true });
+    }
+    repo.revoke(id);
+    return c.json({ ok: true, alreadyRevoked: false });
+  });
+  return app;
+};
+
 // src/api/routes/health.routes.ts
-var import_hono5 = require("hono");
+var import_hono7 = require("hono");
 
 // src/version.ts
 var import_node_fs2 = require("fs");
@@ -3242,7 +3800,7 @@ function resolveVersion() {
 
 // src/api/routes/health.routes.ts
 var createHealthRoutes = (deps) => {
-  const app = new import_hono5.Hono();
+  const app = new import_hono7.Hono();
   app.get("/", (c) => {
     const cacheAlert = deps.cacheMonitor()?.healthzField();
     return c.json({ ok: true, version: getVersion(), ...cacheAlert ? { cacheAlert } : {} });
@@ -3253,7 +3811,7 @@ var createHealthRoutes = (deps) => {
 // src/api/routes/logs.routes.ts
 var import_node_fs3 = require("fs");
 var import_node_path5 = require("path");
-var import_hono6 = require("hono");
+var import_hono8 = require("hono");
 
 // src/lifecycle/constants.ts
 var import_node_os = require("os");
@@ -3311,7 +3869,7 @@ function readLogLines(filePath, sinceOffset, limit) {
   }
 }
 function createLogsRoutes() {
-  const app = new import_hono6.Hono();
+  const app = new import_hono8.Hono();
   app.get("/", (c) => {
     try {
       const sourceParam = (c.req.query("source") || "").toLowerCase();
@@ -3382,7 +3940,7 @@ function createLogsRoutes() {
 // src/api/routes/misc.routes.ts
 var import_node_child_process = require("child_process");
 var import_node_crypto2 = require("crypto");
-var import_hono7 = require("hono");
+var import_hono9 = require("hono");
 var import_os5 = require("os");
 
 // src/config/update-config.ts
@@ -3392,15 +3950,15 @@ var import_node_path6 = require("path");
 var import_yaml = require("yaml");
 
 // src/schemas/updateConfig.schema.ts
-var import_zod2 = require("zod");
-var UpdateConfigSchema = import_zod2.z.object({
-  auto_update: import_zod2.z.boolean().default(false),
-  channel: import_zod2.z.enum(["stable", "next"]).default("stable"),
-  allow: import_zod2.z.array(import_zod2.z.enum(["patch", "minor", "major"])).default(["patch", "minor"]),
-  poll_interval_minutes: import_zod2.z.number().int().min(0).default(1440),
-  defer_if_active_sessions: import_zod2.z.boolean().default(true),
-  github_repo: import_zod2.z.string().regex(/^[^/]+\/[^/]+$/, "github_repo must be 'owner/name'"),
-  webhook_secret: import_zod2.z.string().min(1).nullable().default(null)
+var import_zod3 = require("zod");
+var UpdateConfigSchema = import_zod3.z.object({
+  auto_update: import_zod3.z.boolean().default(false),
+  channel: import_zod3.z.enum(["stable", "next"]).default("stable"),
+  allow: import_zod3.z.array(import_zod3.z.enum(["patch", "minor", "major"])).default(["patch", "minor"]),
+  poll_interval_minutes: import_zod3.z.number().int().min(0).default(1440),
+  defer_if_active_sessions: import_zod3.z.boolean().default(true),
+  github_repo: import_zod3.z.string().regex(/^[^/]+\/[^/]+$/, "github_repo must be 'owner/name'"),
+  webhook_secret: import_zod3.z.string().min(1).nullable().default(null)
 }).strict();
 
 // src/config/update-config.ts
@@ -3437,7 +3995,7 @@ function readJsonBody(req) {
     req.on("error", reject);
   });
 }
-function readRawBody3(req) {
+function readRawBody4(req) {
   return new Promise((resolve2, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
@@ -3456,7 +4014,7 @@ function verifyWebhookSignature(body, header, secret) {
 }
 var clientLog = getLogger("client");
 var createMiscRoutes = (deps) => {
-  const app = new import_hono7.Hono();
+  const app = new import_hono9.Hono();
   app.get("/api/info", (c) => {
     const ptyIds = deps.ptyAttachedIds();
     return c.json({
@@ -3464,7 +4022,11 @@ var createMiscRoutes = (deps) => {
       machineName: (0, import_os5.hostname)(),
       platform: process.platform,
       activeSessions: deps.sessionStore.list(ptyIds).filter((s) => s.status === "running").length,
-      publicUrl: deps.publicUrl
+      publicUrl: deps.publicUrl,
+      // Capability flag: this server serves /api/config/claude-flags. Additive —
+      // older clients ignore it, and clients talking to an older server see it
+      // absent and hide the UI rather than 404ing.
+      claudeFlags: true
     });
   });
   app.get("/api/profiles", (c) => c.json([]));
@@ -3481,7 +4043,32 @@ var createMiscRoutes = (deps) => {
       }
     });
   });
-  app.post("/api/push/register", (c) => c.json({ ok: true }));
+  app.post("/api/push/register", async (c) => {
+    const body = await readJsonBody(c.env.incoming).catch(() => null);
+    const token = body?.token;
+    const platform3 = body?.platform;
+    if (typeof token !== "string" || token.length === 0) {
+      return c.json({ error: "Missing token" }, 400);
+    }
+    if (platform3 !== "ios" && platform3 !== "android") {
+      return c.json({ error: "platform must be 'ios' or 'android'" }, 400);
+    }
+    const repo = deps.pushRepo();
+    if (!repo) {
+      return c.json({ error: "Push registration is unavailable", code: "STORE_UNAVAILABLE" }, 503);
+    }
+    repo.register({
+      token,
+      platform: platform3,
+      deviceId: typeof body?.deviceId === "string" ? body.deviceId : null
+    });
+    return c.json({ ok: true });
+  });
+  app.get("/api/push/health", (c) => {
+    const repo = deps.pushRepo();
+    if (!repo) return c.json({ tokens: [], available: false });
+    return c.json({ tokens: repo.listHealth(), available: true });
+  });
   app.post("/api/__update", async (c) => {
     const cfg = loadUpdateConfig();
     if (!cfg?.webhook_secret) {
@@ -3489,7 +4076,7 @@ var createMiscRoutes = (deps) => {
     }
     let body;
     try {
-      body = await readRawBody3(c.env.incoming);
+      body = await readRawBody4(c.env.incoming);
     } catch {
       return c.json({ error: "could not read body" }, 400);
     }
@@ -3532,11 +4119,11 @@ var createMiscRoutes = (deps) => {
 };
 
 // src/api/routes/pair.routes.ts
-var import_hono8 = require("hono");
+var import_hono10 = require("hono");
 var ALREADY_HANDLED3 = 597;
 var alreadyHandled3 = () => new Response(null, { status: ALREADY_HANDLED3 });
 var createPairRoutes = (deps) => {
-  const app = new import_hono8.Hono();
+  const app = new import_hono10.Hono();
   app.post("/start", (c) => {
     deps.handlePairStart(c.env.outgoing);
     return alreadyHandled3();
@@ -3549,11 +4136,11 @@ var createPairRoutes = (deps) => {
 };
 
 // src/api/routes/projects.routes.ts
-var import_hono9 = require("hono");
+var import_hono11 = require("hono");
 var ALREADY_HANDLED4 = 597;
 var alreadyHandled4 = () => new Response(null, { status: ALREADY_HANDLED4 });
 var createProjectRoutes = (deps) => {
-  const app = new import_hono9.Hono();
+  const app = new import_hono11.Hono();
   app.get("/", (c) => {
     const url = new URL(c.req.url);
     deps.handleListProjects(url, c.env.outgoing);
@@ -3567,12 +4154,147 @@ var createProjectRoutes = (deps) => {
   return app;
 };
 
+// src/api/routes/providers.routes.ts
+var import_hono12 = require("hono");
+
+// src/services/providers/providerHealth.ts
+var import_child_process3 = require("child_process");
+
+// src/services/providers/capabilities.ts
+var CLAUDE_CODE_CAPABILITIES = {
+  freshSessionId: "explicit",
+  resume: "native",
+  systemPrompt: "flag",
+  structuredQuestions: true,
+  permissionGates: true,
+  liveControl: true
+};
+var CODEX_CLI_CAPABILITIES = {
+  freshSessionId: "late-bound",
+  resume: "native",
+  systemPrompt: "positional",
+  structuredQuestions: false,
+  permissionGates: true,
+  liveControl: true
+};
+function capabilitiesFor(provider) {
+  switch (provider) {
+    case CLAUDE_CODE_PROVIDER:
+      return CLAUDE_CODE_CAPABILITIES;
+    case CODEX_CLI_PROVIDER:
+      return CODEX_CLI_CAPABILITIES;
+  }
+}
+
+// src/services/providers/providerHealth.ts
+var VERIFIED_AGAINST = {
+  [CLAUDE_CODE_PROVIDER]: { captured: ["2.1.214"], min: "2.1.0" },
+  [CODEX_CLI_PROVIDER]: { captured: ["0.140.0-alpha.19"], min: "0.140.0" }
+};
+var VERSION_TIMEOUT_MS = 3e3;
+function parseVersionOutput(output) {
+  const match = output.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/);
+  return match ? match[0] : null;
+}
+function runVersion(exe) {
+  return new Promise((resolve2) => {
+    (0, import_child_process3.execFile)(exe, ["--version"], { timeout: VERSION_TIMEOUT_MS }, (err, stdout, stderr) => {
+      if (err && !stdout && !stderr) return resolve2(null);
+      resolve2(parseVersionOutput(`${stdout}${stderr}`));
+    });
+  });
+}
+function compareToVerified(version, verified) {
+  if (version === null) {
+    return {
+      code: "version_undetectable",
+      message: "Could not determine the installed version, so compatibility is unverified. Parsing and prompt detection may not match this build."
+    };
+  }
+  if (verified.captured.includes(version)) return null;
+  const below = verified.min != null && compareSemver(version, verified.min) < 0;
+  const above = verified.max != null && compareSemver(version, verified.max) > 0;
+  if (!below && !above && verified.max != null) return null;
+  if (!below && verified.max == null && !isNewerThanAllCaptured(version, verified.captured)) {
+    return null;
+  }
+  return {
+    code: "version_unverified",
+    message: `Installed version ${version} is outside the range these adapters were verified against (captured: ${verified.captured.join(", ")}). It will still run; parsing or prompt detection may differ.`
+  };
+}
+function isNewerThanAllCaptured(version, captured) {
+  return captured.every((c) => compareSemver(version, c) > 0);
+}
+function compareSemver(a, b) {
+  const parse = (v) => {
+    const [core, pre] = v.split("-", 2);
+    const nums = core.split(".").map((n) => Number.parseInt(n, 10) || 0);
+    return { nums, pre: pre ?? null };
+  };
+  const pa = parse(a);
+  const pb = parse(b);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa.nums[i] ?? 0) - (pb.nums[i] ?? 0);
+    if (d !== 0) return d < 0 ? -1 : 1;
+  }
+  if (pa.pre === pb.pre) return 0;
+  if (pa.pre === null) return 1;
+  if (pb.pre === null) return -1;
+  return pa.pre < pb.pre ? -1 : 1;
+}
+async function providerHealth(name, resolveExe, detect = runVersion) {
+  const verifiedAgainst = VERIFIED_AGAINST[name];
+  const capabilities = capabilitiesFor(name);
+  let exe;
+  try {
+    exe = resolveExe();
+  } catch {
+    return {
+      name,
+      available: false,
+      version: null,
+      verifiedAgainst,
+      capabilities,
+      warnings: [
+        {
+          code: "provider_not_found",
+          message: `${name} could not be located. Sessions for this provider cannot start.`
+        }
+      ]
+    };
+  }
+  const version = await detect(exe);
+  const warning = compareToVerified(version, verifiedAgainst);
+  return {
+    name,
+    available: true,
+    version,
+    verifiedAgainst,
+    capabilities,
+    warnings: warning ? [warning] : []
+  };
+}
+
+// src/api/routes/providers.routes.ts
+var createProviderRoutes = () => {
+  const app = new import_hono12.Hono();
+  app.get("/", async (c) => {
+    const providers = await Promise.all([
+      providerHealth(CLAUDE_CODE_PROVIDER, resolveClaudeExe),
+      providerHealth(CODEX_CLI_PROVIDER, resolveCodexExe)
+    ]);
+    return c.json({ providers });
+  });
+  return app;
+};
+
 // src/api/routes/scanner.routes.ts
-var import_hono10 = require("hono");
+var import_hono13 = require("hono");
 var ALREADY_HANDLED5 = 597;
 var alreadyHandled5 = () => new Response(null, { status: ALREADY_HANDLED5 });
 var createScannerRoutes = (deps) => {
-  const app = new import_hono10.Hono();
+  const app = new import_hono13.Hono();
   app.get("/api/search", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleSearch(url, c.env.outgoing);
@@ -3582,11 +4304,11 @@ var createScannerRoutes = (deps) => {
 };
 
 // src/api/routes/sessions.routes.ts
-var import_hono11 = require("hono");
+var import_hono14 = require("hono");
 var ALREADY_HANDLED6 = 597;
 var alreadyHandled6 = () => new Response(null, { status: ALREADY_HANDLED6 });
 var createSessionRoutes = (deps) => {
-  const app = new import_hono11.Hono();
+  const app = new import_hono14.Hono();
   app.get("/count", (c) => {
     deps.handleSessionsCount(c.env.outgoing);
     return alreadyHandled6();
@@ -3653,9 +4375,9 @@ var createSessionRoutes = (deps) => {
 };
 
 // src/api/routes/ws.routes.ts
-var import_hono12 = require("hono");
+var import_hono15 = require("hono");
 var createWsRoutes = (deps, upgradeWebSocket) => {
-  const app = new import_hono12.Hono();
+  const app = new import_hono15.Hono();
   app.get(
     "/ws",
     upgradeWebSocket(() => {
@@ -3681,7 +4403,7 @@ var createWsRoutes = (deps, upgradeWebSocket) => {
 
 // src/api/app.ts
 var createHonoApp = (deps, upgradeWebSocket) => {
-  const app = new import_hono13.Hono();
+  const app = new import_hono16.Hono();
   const httpLog = getLogger("http");
   app.use("*", async (c, next) => {
     const start = Date.now();
@@ -3706,7 +4428,10 @@ var createHonoApp = (deps, upgradeWebSocket) => {
   app.route("/api/sessions", createSessionRoutes(deps));
   app.route("/api/conversations", createConversationRoutes(deps));
   app.route("/api/cache/alert", createCacheAlertRoutes(deps));
+  app.route("/api/config", createConfigRoutes(deps));
   app.route("/api/projects", createProjectRoutes(deps));
+  app.route("/api/providers", createProviderRoutes());
+  app.route("/api/devices", createDeviceRoutes(deps));
   app.route("/api/pair", createPairRoutes(deps));
   app.route("/api", createBrowseRoutes(deps));
   app.route("/", createScannerRoutes(deps));
@@ -3914,11 +4639,11 @@ function joinStatCacheByNativePath(metas, canonicalStats) {
 }
 
 // src/utils/fileIdentity.ts
-var import_crypto5 = require("crypto");
+var import_crypto6 = require("crypto");
 function fileIdentity(stat3, headBytes) {
   if (stat3.ino && stat3.ino > 0) return `inode:${stat3.dev}:${stat3.ino}`;
   const head = headBytes ?? Buffer.alloc(0);
-  return `fp:${(0, import_crypto5.createHash)("sha1").update(head).digest("hex")}`;
+  return `fp:${(0, import_crypto6.createHash)("sha1").update(head).digest("hex")}`;
 }
 function splitCompleteLines(buf, baseOffset) {
   const spans = [];
@@ -5200,8 +5925,122 @@ var ConversationsRepository = class {
   }
 };
 
+// src/db/repositories/managed-sessions.repository.ts
+var ManagedSessionsRepository = class {
+  upsertStmt;
+  updateStatusStmt;
+  getStmt;
+  listNonTerminalStmt;
+  deleteStmt;
+  constructor(db) {
+    this.upsertStmt = db.prepare(`
+      INSERT INTO managed_sessions (
+        session_id, provider, pid, cmdline, project_path, project_name, branch,
+        status, status_source, status_updated_at, started_at, completed_at,
+        last_activity_at, prompt_count, session_name, project_id,
+        bound_conversation_id, resumed_from_conversation_id, failure_reason,
+        streamer_instance_id
+      ) VALUES (
+        @session_id, @provider, @pid, @cmdline, @project_path, @project_name, @branch,
+        @status, @status_source, @status_updated_at, @started_at, @completed_at,
+        @last_activity_at, @prompt_count, @session_name, @project_id,
+        @bound_conversation_id, @resumed_from_conversation_id, @failure_reason,
+        @streamer_instance_id
+      )
+      ON CONFLICT(session_id) DO UPDATE SET
+        pid = excluded.pid,
+        cmdline = excluded.cmdline,
+        project_path = excluded.project_path,
+        project_name = excluded.project_name,
+        branch = excluded.branch,
+        status = excluded.status,
+        status_source = excluded.status_source,
+        status_updated_at = excluded.status_updated_at,
+        completed_at = excluded.completed_at,
+        last_activity_at = excluded.last_activity_at,
+        prompt_count = excluded.prompt_count,
+        session_name = excluded.session_name,
+        project_id = excluded.project_id,
+        bound_conversation_id = excluded.bound_conversation_id,
+        resumed_from_conversation_id = excluded.resumed_from_conversation_id,
+        failure_reason = excluded.failure_reason,
+        streamer_instance_id = excluded.streamer_instance_id
+    `);
+    this.updateStatusStmt = db.prepare(`
+      UPDATE managed_sessions
+         SET status = @status,
+             status_source = @status_source,
+             status_updated_at = @status_updated_at,
+             completed_at = @completed_at,
+             last_activity_at = @last_activity_at,
+             prompt_count = @prompt_count,
+             failure_reason = COALESCE(@failure_reason, failure_reason)
+       WHERE session_id = @session_id
+    `);
+    this.getStmt = db.prepare("SELECT * FROM managed_sessions WHERE session_id = ?");
+    this.listNonTerminalStmt = db.prepare(`
+      SELECT * FROM managed_sessions
+       WHERE completed_at IS NULL
+       ORDER BY started_at ASC
+    `);
+    this.deleteStmt = db.prepare("DELETE FROM managed_sessions WHERE session_id = ?");
+  }
+  /** Record a session at spawn, or refresh every field of an existing row. */
+  recordSpawn({ session, pid, cmdline, streamerInstanceId }) {
+    this.upsertStmt.run({
+      session_id: session.id,
+      provider: session.provider ?? "claude-code",
+      pid,
+      cmdline,
+      project_path: session.projectPath,
+      project_name: session.projectName,
+      branch: session.branch ?? "",
+      status: session.status,
+      status_source: "spawn",
+      status_updated_at: Date.now(),
+      started_at: session.startedAt.getTime(),
+      completed_at: session.completedAt?.getTime() ?? null,
+      last_activity_at: session.lastActivityAt?.getTime() ?? null,
+      prompt_count: session.promptCount,
+      session_name: session.sessionName ?? null,
+      project_id: session.projectId ?? null,
+      bound_conversation_id: session.boundConversationId ?? null,
+      resumed_from_conversation_id: session.resumedFromConversationId ?? null,
+      failure_reason: session.failureReason ?? null,
+      streamer_instance_id: streamerInstanceId
+    });
+  }
+  /**
+   * Persist a status transition. `source` is required rather than defaulted:
+   * a status whose provenance is unknown is the thing this table exists to
+   * prevent, and the reconciler reads it to decide how much to trust the value.
+   */
+  recordStatus(sessionId, status, source, fields = {}) {
+    this.updateStatusStmt.run({
+      session_id: sessionId,
+      status,
+      status_source: source,
+      status_updated_at: Date.now(),
+      completed_at: fields.completedAt?.getTime() ?? null,
+      last_activity_at: fields.lastActivityAt?.getTime() ?? null,
+      prompt_count: fields.promptCount ?? 0,
+      failure_reason: fields.failureReason ?? null
+    });
+  }
+  get(sessionId) {
+    return this.getStmt.get(sessionId) ?? null;
+  }
+  /** Rows with no recorded completion — the reconciler's probe set. */
+  listNonTerminal() {
+    return this.listNonTerminalStmt.all();
+  }
+  delete(sessionId) {
+    this.deleteStmt.run(sessionId);
+  }
+};
+
 // src/db/repositories/projects.repository.ts
-var import_crypto6 = require("crypto");
+var import_crypto7 = require("crypto");
 
 // src/utils/canonicalizeProjectPath.ts
 function canonicalizeProjectPath(projectPath) {
@@ -5294,7 +6133,7 @@ var ProjectsRepository = class {
       });
       return rowToProject(this.getById.get(existing.id));
     }
-    const id = (0, import_crypto6.randomUUID)();
+    const id = (0, import_crypto7.randomUUID)();
     this.insert.run({
       id,
       path,
@@ -5316,6 +6155,125 @@ function deriveNameFromPath(path) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 
+// src/db/repositories/push.repository.ts
+var FAILURE_STREAK_LIMIT = 5;
+function tokenState(row) {
+  if (row.revoked_at != null) return "revoked";
+  if (row.failure_streak >= FAILURE_STREAK_LIMIT) return "dead";
+  if (row.failure_streak > 0) return "failing";
+  if (row.last_success_at == null) return "never-delivered";
+  return "healthy";
+}
+function toHealth(row) {
+  return {
+    platform: row.platform,
+    deviceId: row.device_id,
+    registeredAt: row.registered_at,
+    lastSuccessAt: row.last_success_at,
+    lastFailureAt: row.last_failure_at,
+    lastFailureCode: row.last_failure_code,
+    failureStreak: row.failure_streak,
+    revokedAt: row.revoked_at,
+    state: tokenState(row)
+  };
+}
+var PushRepository = class {
+  upsertStmt;
+  getStmt;
+  listActiveStmt;
+  listAllStmt;
+  successStmt;
+  failureStmt;
+  revokeStmt;
+  claimEventStmt;
+  markDeliveredStmt;
+  constructor(db) {
+    this.upsertStmt = db.prepare(`
+      INSERT INTO push_tokens (token, platform, device_id, registered_at)
+      VALUES (@token, @platform, @device_id, @registered_at)
+      ON CONFLICT(token) DO UPDATE SET
+        platform = excluded.platform,
+        device_id = COALESCE(excluded.device_id, push_tokens.device_id),
+        registered_at = excluded.registered_at,
+        -- A fresh registration clears prior failure state and any revocation:
+        -- the client is telling us this token is live again.
+        failure_streak = 0,
+        last_failure_at = NULL,
+        last_failure_code = NULL,
+        revoked_at = NULL
+    `);
+    this.getStmt = db.prepare("SELECT * FROM push_tokens WHERE token = ?");
+    this.listActiveStmt = db.prepare(`
+      SELECT * FROM push_tokens
+       WHERE revoked_at IS NULL AND failure_streak < ${FAILURE_STREAK_LIMIT}
+       ORDER BY registered_at ASC
+    `);
+    this.listAllStmt = db.prepare("SELECT * FROM push_tokens ORDER BY registered_at ASC");
+    this.successStmt = db.prepare(`
+      UPDATE push_tokens
+         SET last_success_at = @at, failure_streak = 0,
+             last_failure_code = NULL
+       WHERE token = @token
+    `);
+    this.failureStmt = db.prepare(`
+      UPDATE push_tokens
+         SET last_failure_at = @at, last_failure_code = @code,
+             failure_streak = failure_streak + 1
+       WHERE token = @token
+    `);
+    this.revokeStmt = db.prepare("UPDATE push_tokens SET revoked_at = ? WHERE token = ?");
+    this.claimEventStmt = db.prepare(`
+      INSERT OR IGNORE INTO push_events (event_id, session_id, created_at)
+      VALUES (@event_id, @session_id, @created_at)
+    `);
+    this.markDeliveredStmt = db.prepare(
+      "UPDATE push_events SET delivered_at = ? WHERE event_id = ?"
+    );
+  }
+  register(args) {
+    this.upsertStmt.run({
+      token: args.token,
+      platform: args.platform,
+      device_id: args.deviceId ?? null,
+      registered_at: args.now ?? Date.now()
+    });
+  }
+  get(token) {
+    return this.getStmt.get(token) ?? null;
+  }
+  /** Tokens eligible for delivery — not revoked, not past the failure limit. */
+  listDeliverable() {
+    return this.listActiveStmt.all();
+  }
+  /** Every token, including dead and revoked ones, for the health report. */
+  listHealth() {
+    return this.listAllStmt.all().map(toHealth);
+  }
+  recordSuccess(token, now = Date.now()) {
+    this.successStmt.run({ token, at: now });
+  }
+  recordFailure(token, code, now = Date.now()) {
+    this.failureStmt.run({ token, at: now, code });
+  }
+  revoke(token, now = Date.now()) {
+    return this.revokeStmt.run(now, token).changes > 0;
+  }
+  /**
+   * Claim an event id for delivery.
+   *
+   * Returns true exactly once per event id. A retry, a reconnect
+   * reconciliation, or two triggers firing for the same underlying event all
+   * get false and must not notify — the user should never be told twice about
+   * one thing.
+   */
+  claimEvent(eventId, sessionId, now = Date.now()) {
+    return this.claimEventStmt.run({ event_id: eventId, session_id: sessionId, created_at: now }).changes > 0;
+  }
+  markDelivered(eventId, now = Date.now()) {
+    this.markDeliveredStmt.run(now, eventId);
+  }
+};
+
 // src/db/repositories/sessions.repository.ts
 var SessionsRepository = class {
   constructor(store) {
@@ -5384,8 +6342,20 @@ function handleListProjects(url, res) {
   res.end(JSON.stringify({ projects: page, total }));
 }
 
+// src/lifecycle/process-liveness.ts
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    return code === "EPERM";
+  }
+}
+
 // src/pair-store.ts
-var import_crypto7 = require("crypto");
+var import_crypto8 = require("crypto");
 var DEFAULT_TTL_SECONDS = 180;
 var SWEEP_INTERVAL_MS = 6e4;
 var PairTokenStore = class {
@@ -5400,7 +6370,7 @@ var PairTokenStore = class {
     }
   }
   mint() {
-    const token = `pt_${(0, import_crypto7.randomBytes)(16).toString("hex")}`;
+    const token = `pt_${(0, import_crypto8.randomBytes)(16).toString("hex")}`;
     const expiresAt = Date.now() + this.ttlMs;
     this.current = { token, expiresAt, used: false };
     return {
@@ -5468,7 +6438,7 @@ function setCacheMetadata(repo, key, value) {
 }
 
 // src/services/cache-integrity/cacheIntegrityMonitor.ts
-var import_crypto8 = require("crypto");
+var import_crypto9 = require("crypto");
 var import_fs13 = require("fs");
 
 // src/services/cache-integrity/alertStore.ts
@@ -5533,7 +6503,7 @@ function envInt(name, fallback) {
 }
 function fingerprintOf(ids) {
   const sorted = [...ids].sort();
-  return `sha256:${(0, import_crypto8.createHash)("sha256").update(sorted.join("\n")).digest("hex")}`;
+  return `sha256:${(0, import_crypto9.createHash)("sha256").update(sorted.join("\n")).digest("hex")}`;
 }
 var CacheIntegrityMonitor = class {
   constructor(cache, wsHub, log3, cacheDir, rescan, runDuringReset) {
@@ -6347,6 +7317,112 @@ function conversationBusy(input) {
   };
 }
 
+// src/services/sessions/idempotency.ts
+var IDEMPOTENCY_TTL_MS = 10 * 60 * 1e3;
+var IDEMPOTENCY_MAX_KEYS = 200;
+var IdempotencyStore = class {
+  constructor(ttlMs = IDEMPOTENCY_TTL_MS, maxKeys = IDEMPOTENCY_MAX_KEYS) {
+    this.ttlMs = ttlMs;
+    this.maxKeys = maxKeys;
+  }
+  ttlMs;
+  maxKeys;
+  bySession = /* @__PURE__ */ new Map();
+  /**
+   * Previously recorded result for this key, or null if the key is new,
+   * expired, or evicted. A miss always means "treat as a fresh request" —
+   * failing open, because dropping a real prompt is far worse than allowing a
+   * rare duplicate.
+   */
+  get(sessionId, key, now = Date.now()) {
+    const entries = this.bySession.get(sessionId);
+    if (!entries) return null;
+    const hit = entries.find((e) => e.key === key);
+    if (!hit) return null;
+    if (now - hit.at > this.ttlMs) {
+      this.bySession.set(
+        sessionId,
+        entries.filter((e) => e !== hit)
+      );
+      return null;
+    }
+    return hit.result;
+  }
+  /** Record the outcome of an accepted write so a retry can replay it. */
+  set(sessionId, key, result, now = Date.now()) {
+    const entries = this.bySession.get(sessionId) ?? [];
+    const pruned = entries.filter((e) => e.key !== key && now - e.at <= this.ttlMs);
+    pruned.push({ key, at: now, result });
+    this.bySession.set(sessionId, pruned.slice(-this.maxKeys));
+  }
+  /** Drop everything for a session whose PTY is gone. */
+  clear(sessionId) {
+    this.bySession.delete(sessionId);
+  }
+  /** Test/diagnostic helper: how many keys are currently held for a session. */
+  size(sessionId) {
+    return this.bySession.get(sessionId)?.length ?? 0;
+  }
+};
+function readIdempotencyKey(body) {
+  const raw = body.idempotencyKey;
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "string" || raw.length === 0 || raw.length > 200) {
+    throw new Error("idempotencyKey must be a non-empty string of at most 200 characters");
+  }
+  return raw;
+}
+
+// src/services/sessions/reconcileSessions.ts
+async function classifySession(row, probe, currentInstanceId) {
+  const { session_id: sessionId } = row;
+  if (row.completed_at != null) {
+    const clean = probe.endedCleanly?.(row) ?? row.failure_reason == null;
+    return {
+      sessionId,
+      lifecycle: clean ? "completed" : "failed",
+      reason: `terminal (${row.status_source})`
+    };
+  }
+  if (row.pid == null) {
+    return { sessionId, lifecycle: "resumable", reason: "no pid recorded" };
+  }
+  if (!probe.isPidAlive(row.pid)) {
+    const clean = probe.endedCleanly?.(row) ?? false;
+    if (clean) {
+      return { sessionId, lifecycle: "completed", reason: "process gone, history ended cleanly" };
+    }
+    return {
+      sessionId,
+      lifecycle: "resumable",
+      reason: "process gone, resumable from provider history"
+    };
+  }
+  const args = await probe.getProcessArgs(row.pid);
+  const token = row.cmdline;
+  if (!token || !args?.includes(token)) {
+    return {
+      sessionId,
+      lifecycle: "orphaned",
+      reason: args ? "pid alive but command line does not match" : "pid alive but argv unreadable"
+    };
+  }
+  const sameRun = row.streamer_instance_id === currentInstanceId;
+  return {
+    sessionId,
+    lifecycle: sameRun ? "attached" : "detached",
+    reason: sameRun ? "owned by this run" : "survived a previous streamer run"
+  };
+}
+async function reconcileSessions(rows, probe, currentInstanceId) {
+  return Promise.all(rows.map((row) => classifySession(row, probe, currentInstanceId)));
+}
+
+// src/types.ts
+function confidenceForSource(source) {
+  return source === "timeout-fallback" || source === "quiet-fallback" ? "inferred" : "observed";
+}
+
 // src/session-store.ts
 var SessionStore = class {
   managed = /* @__PURE__ */ new Map();
@@ -6486,6 +7562,14 @@ function managedToResponse(s, ptyAttached) {
     conversationId: s.id,
     provider: s.provider ?? CLAUDE_CODE_PROVIDER,
     status: s.status,
+    // Lifecycle for a session this run knows about. `attached` while we hold
+    // its PTY; once the PTY is gone the session is terminal from this run's
+    // perspective — `failed` when it recorded a reason, else `completed`.
+    // Sessions left by *previous* runs never reach here: they aren't in the
+    // in-memory store, and the boot reconciler classifies them instead
+    // (docs/architecture/2026-07-24-durable-session-runtime.md).
+    lifecycle: ptyAttached ? "attached" : s.failureReason != null ? "failed" : "completed",
+    lifecycleSource: ptyAttached ? "spawn" : "exit",
     // We spawned it, so `status` is the authoritative signal — no inferred
     // `activity` is attached for managed sessions.
     ownership: "managed",
@@ -6509,6 +7593,13 @@ function managedToResponse(s, ptyAttached) {
     ...s.lastMessageText != null && { lastMessageText: s.lastMessageText },
     ...s.lastMessageAt != null && { lastMessageAt: s.lastMessageAt.toISOString() },
     ...s.lastActivityAt != null && { lastActivityAt: s.lastActivityAt.toISOString() },
+    // C3: how the status was derived, and how far to trust it. Confidence is
+    // derived from the source rather than stored, so the two cannot disagree.
+    ...s.statusSource != null && {
+      statusSource: s.statusSource,
+      statusConfidence: confidenceForSource(s.statusSource)
+    },
+    ...s.statusUpdatedAt != null && { statusUpdatedAt: s.statusUpdatedAt.toISOString() },
     ...s.filePath != null && { filePath: s.filePath },
     ...s.failureReason != null && { failureReason: s.failureReason },
     ...s.resumedFromConversationId != null && {
@@ -6530,6 +7621,12 @@ function discoveredToResponse(d, conversationId) {
     // Discovery just enumerated this PID, so it was alive moments ago. We never
     // report "gone" here — a vanished process simply stops being listed.
     processLiveness: "alive",
+    // Alive, but spawned outside this streamer, so we hold no PTY for it. That
+    // is precisely `detached` — and it is strictly more informative than the
+    // `status: "idle"` above, which discovery is forced to report because it
+    // cannot see the process's prompt state.
+    lifecycle: "detached",
+    lifecycleSource: "probe",
     projectPath: d.projectPath,
     projectName: d.projectName,
     branch: d.branch,
@@ -6544,7 +7641,7 @@ function discoveredToResponse(d, conversationId) {
 }
 
 // src/uploads.ts
-var import_crypto9 = require("crypto");
+var import_crypto10 = require("crypto");
 var import_promises6 = require("fs/promises");
 var import_heic_convert = __toESM(require("heic-convert"), 1);
 var import_path17 = require("path");
@@ -6578,7 +7675,7 @@ async function saveUploadFile(input) {
     mimeType = "image/jpeg";
     originalName = originalName.replace(/\.(heic|heif)$/i, ".jpg");
   }
-  const id = `up_${(0, import_crypto9.randomBytes)(8).toString("hex")}`;
+  const id = `up_${(0, import_crypto10.randomBytes)(8).toString("hex")}`;
   const safeName = sanitizeFilename(originalName) || `file${MIME_TO_EXT[mimeType] ?? ""}`;
   const dir = (0, import_path17.join)(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
   await (0, import_promises6.mkdir)(dir, { recursive: true });
@@ -6612,21 +7709,46 @@ function extractCodexText(content) {
     return "";
   }).filter(Boolean).join("").trim();
 }
-function normalizeCodexLineToClaudeShape(line) {
+var KNOWN_CODEX_TYPES = /* @__PURE__ */ new Set(["response_item", "event_msg", "session_meta", "turn_context"]);
+function classifyCodexLine(line) {
   let entry;
   try {
     entry = JSON.parse(line);
   } catch {
-    return null;
+    return { kind: "unknown", raw: line, reason: "line is not valid JSON" };
+  }
+  if (typeof entry.type !== "string" || !KNOWN_CODEX_TYPES.has(entry.type)) {
+    return {
+      kind: "unknown",
+      raw: line,
+      reason: `unrecognized rollout envelope type: ${String(entry.type)}`
+    };
+  }
+  if (entry.type !== "response_item") {
+    return { kind: "ignored", reason: `${entry.type} carries no chat content` };
   }
-  if (entry.type !== "response_item") return null;
   const payload = entry.payload;
-  if (payload?.type !== "message") return null;
+  if (payload?.type !== "message") {
+    return { kind: "ignored", reason: `response_item payload is ${String(payload?.type)}` };
+  }
   const role = payload.role;
-  if (role !== "user" && role !== "assistant") return null;
+  if (role !== "user" && role !== "assistant") {
+    return { kind: "ignored", reason: `role ${String(role)} is not rendered` };
+  }
   const text = extractCodexText(payload.content);
-  if (!text) return null;
-  if (role === "user" && isCodexInjectedContext(text)) return null;
+  if (!text) {
+    return { kind: "ignored", reason: "message has no extractable text" };
+  }
+  if (role === "user" && isCodexInjectedContext(text)) {
+    return { kind: "ignored", reason: "synthetic injected context" };
+  }
+  return { kind: "message", line: buildClaudeShapedLine(entry, payload, role, text) };
+}
+function normalizeCodexLineToClaudeShape(line) {
+  const result = classifyCodexLine(line);
+  return result.kind === "message" ? result.line : null;
+}
+function buildClaudeShapedLine(entry, payload, role, text) {
   const timestamp2 = typeof entry.timestamp === "string" ? entry.timestamp : (/* @__PURE__ */ new Date()).toISOString();
   const uuid = typeof payload.id === "string" && payload.id.length > 0 ? payload.id : `codex-${role}-${timestamp2}-${hashPrefix(text)}`;
   return JSON.stringify({
@@ -6831,6 +7953,8 @@ var BROWSE_SYSTEM_PROMPT = (browseRoot) => `You are working within the project b
 var DEFAULT_SYSTEM_PROMPT = "When presenting options or choices to the user, limit the options to at most 3.";
 var DEFAULT_PTY_GRACE_PERIOD_MS = 27e4;
 var GRACE_MAX_DEFERS = 4;
+var IDLE_REAP_AFTER_MS = 6 * 60 * 60 * 1e3;
+var IDLE_REAP_SWEEP_MS = 5 * 60 * 1e3;
 var RESUME_DISCOVERY_TIMEOUT_MS = 750;
 var DISCOVERY_TTL_MS = 15e3;
 var ADOPT_KILL_TIMEOUT_MS = 5e3;
@@ -6952,6 +8076,16 @@ var StreamerServer = class {
   defaultPermissionMode;
   defaultModel;
   defaultEffort;
+  // Allowlisted Claude CLI flags + free-text escape hatch, applied to every
+  // spawn. Resolved once at startup (flag → server.yaml), then mutated in place
+  // by PUT /api/config/claude-flags so a change applies to the next session
+  // without a restart.
+  claudeFlags;
+  claudeExtraArgs;
+  // True when the values came from server.yaml (and so a write persists).
+  // False when they were pinned by a CLI flag, mirroring the api-key rotate
+  // contract: the write still takes effect in memory but won't survive restart.
+  claudeFlagsPersistable;
   // Map of sessionId → grace timer; fires to kill PTY after WS disconnect
   ptyGraceTimers = /* @__PURE__ */ new Map();
   // Consecutive grace-timer defers for a still-`running` session (see
@@ -6959,6 +8093,18 @@ var StreamerServer = class {
   ptyGraceDeferCounts = /* @__PURE__ */ new Map();
   // Map of sessionId → set of subscribed WS clients
   sessionSubscribers = /* @__PURE__ */ new Map();
+  // sessionId → wall-clock ms of the last PTY chunk. Written from onOutput for
+  // every provider; read only by the idle reaper. Entries are dropped when the
+  // session leaves the runner (reap/exit/hold).
+  lastAgentChunkAt = /* @__PURE__ */ new Map();
+  // Recently accepted input idempotency keys (C4). A retried POST replays its
+  // original outcome instead of submitting the prompt to the agent twice.
+  idempotency = new IdempotencyStore();
+  // sessionId → lifecycle verdict from boot reconciliation. Only holds sessions
+  // this run did NOT spawn; live ones derive their lifecycle from ptyAttached.
+  sessionLifecycles = /* @__PURE__ */ new Map();
+  // Periodic sweep that releases PTYs no agent is using. Null until listen().
+  idleReaperTimer = null;
   // Map of clientId → WS socket (populated by the "register" WS handshake)
   clientIdToWs = /* @__PURE__ */ new Map();
   // Reverse map for cleanup on close
@@ -6968,7 +8114,20 @@ var StreamerServer = class {
   projectsRepo = null;
   conversationsRepo = null;
   sessionsRepo = null;
+  // Durable session registry (C1 Phase 2). Null when the cache DB failed to
+  // open — persistence degrades to today's in-memory-only behaviour rather than
+  // taking the server down with it, so every write goes through `?.`.
+  managedSessionsRepo = null;
+  // Identifies this streamer run. A registry row carrying a different id is a
+  // session that outlived the process that started it.
+  streamerInstanceId = (0, import_crypto11.randomUUID)();
   cacheMetadataRepo = null;
+  // Push registration + delivery state (C7). Null when the cache DB failed to
+  // open — registration then degrades to a no-op rather than 500ing.
+  pushRepo = null;
+  // Paired-device registry (C5). Null when the cache DB failed to open — auth
+  // then falls back to the shared API key alone, which is the pre-C5 behaviour.
+  devicesRepo = null;
   discoveryCache = null;
   cacheDir;
   tailSize;
@@ -7007,6 +8166,9 @@ var StreamerServer = class {
     this.defaultPermissionMode = config.defaultPermissionMode ?? loadDefaultPermissionMode() ?? "acceptEdits";
     this.defaultModel = config.defaultModel ?? "sonnet";
     this.defaultEffort = config.defaultEffort ?? "low";
+    this.claudeFlagsPersistable = config.claudeFlags === void 0;
+    this.claudeFlags = config.claudeFlags ?? loadClaudeFlags();
+    this.claudeExtraArgs = config.claudeExtraArgs ?? loadClaudeExtraArgs();
     this.cacheDir = config.cacheDir ?? loadCacheDir() ?? (0, import_path18.join)((0, import_os9.homedir)(), ".threadbase", "cache");
     this.tailSize = config.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config.directoryScanDebounceMs ?? 1e3;
@@ -7131,6 +8293,7 @@ var StreamerServer = class {
     this.ptyManager = new LiveSessionManager({
       logger: getLogger("pty"),
       onOutput: (sessionId, data) => {
+        this.lastAgentChunkAt.set(sessionId, Date.now());
         this.wsHub.broadcast({ type: "terminal_output", sessionId, data });
       },
       onUserMessage: (sessionId, text, ts) => {
@@ -7159,6 +8322,17 @@ var StreamerServer = class {
           completedAt: session.completedAt,
           ...session.lastActivityAt != null && { lastActivityAt: session.lastActivityAt }
         });
+        this.managedSessionsRepo?.recordStatus(
+          session.id,
+          session.status,
+          session.completedAt != null ? "exit" : "transition",
+          {
+            completedAt: session.completedAt,
+            lastActivityAt: session.lastActivityAt ?? null,
+            promptCount: session.promptCount,
+            failureReason: session.failureReason ?? null
+          }
+        );
         if (session.status === "waiting_input" || session.status === "idle") {
           const filePath = this.sessionFileMap.get(session.id);
           if (filePath) {
@@ -7230,6 +8404,8 @@ var StreamerServer = class {
       localNoAuth: this.localNoAuth,
       logMenubarRequests: this.logMenubarRequests,
       rotateApiKey: () => this.rotateApiKey(),
+      claudeFlagsConfig: () => this.getClaudeFlagsConfig(),
+      setClaudeFlagsConfig: (values, extraArgs) => this.setClaudeFlagsConfig(values, extraArgs),
       publicUrl: this.publicUrl,
       browseRoot: this.browseRoot,
       browserCors: this.browserCors,
@@ -7238,6 +8414,8 @@ var StreamerServer = class {
       wsHub: this.wsHub,
       cache: () => this.cache,
       cacheMonitor: () => this.cacheMonitor,
+      pushRepo: () => this.pushRepo,
+      devicesRepo: () => this.devicesRepo,
       projectsRepo: () => this.projectsRepo,
       conversationsRepo: () => this.conversationsRepo,
       sessionsRepo: () => this.sessionsRepo,
@@ -7271,7 +8449,9 @@ var StreamerServer = class {
       handleMkdir: (req, res) => this.handleMkdir(req, res),
       handleWsOpen: (ws) => {
         this.wsHub.addClient(ws);
-        const sessions = this.sessionStore.list(this.ptyAttachedIds());
+        const sessions = this.withReconciledLifecycle(
+          this.sessionStore.list(this.ptyAttachedIds())
+        );
         ws.send(JSON.stringify({ type: "session_list", sessions }));
         if (!this.currentWarmupState()) {
           ws.send(JSON.stringify({ type: "cache_ready" }));
@@ -7347,11 +8527,8 @@ var StreamerServer = class {
           this.clientIdToWs.delete(clientId);
           this.wsToClientId.delete(ws);
         }
-        for (const [sessionId, subscribers] of this.sessionSubscribers) {
+        for (const subscribers of this.sessionSubscribers.values()) {
           subscribers.delete(ws);
-          if (subscribers.size === 0 && this.ptyGracePeriodMs > 0) {
-            this.startGraceTimer(sessionId, this.ptyGracePeriodMs);
-          }
         }
       },
       agentClient,
@@ -7414,7 +8591,7 @@ var StreamerServer = class {
     const ws = typeof clientId === "string" ? this.clientIdToWs.get(clientId) : void 0;
     const payload = {
       type: "session_list",
-      sessions: this.sessionStore.list(this.ptyAttachedIds())
+      sessions: this.withReconciledLifecycle(this.sessionStore.list(this.ptyAttachedIds()))
     };
     if (ws) {
       this.wsHub.unicast(ws, payload);
@@ -7422,6 +8599,29 @@ var StreamerServer = class {
       this.wsHub.broadcast(payload);
     }
   }
+  /**
+   * Overlay boot-reconciliation verdicts onto session responses.
+   *
+   * A session left by a previous run is not in the in-memory store, so
+   * SessionStore cannot classify it — it only ever sees what this run spawned.
+   * Discovery may still surface the process, in which case the reconciler knows
+   * strictly more about it than discovery does: it can tell `detached` (alive
+   * and confirmed ours) from `orphaned` (alive but identity unconfirmed), which
+   * a pid enumeration alone cannot.
+   *
+   * Only applied when the session is NOT live here: a session this run owns has
+   * an authoritative lifecycle already, and a stale verdict must never override
+   * it.
+   */
+  withReconciledLifecycle(sessions) {
+    if (this.sessionLifecycles.size === 0) return sessions;
+    return sessions.map((s) => {
+      if (s.ptyAttached) return s;
+      const verdict = this.sessionLifecycles.get(s.id);
+      if (!verdict) return s;
+      return { ...s, lifecycle: verdict, lifecycleSource: "reconcile" };
+    });
+  }
   addSessionSubscriber(sessionId, ws) {
     let subs = this.sessionSubscribers.get(sessionId);
     if (!subs) {
@@ -7436,6 +8636,181 @@ var StreamerServer = class {
     }
     this.ptyGraceDeferCounts.delete(sessionId);
   }
+  /**
+   * Classify sessions left behind by previous streamer runs (C1 Phase 3a).
+   *
+   * Agents already outlive the streamer today on the crash and dev-takeover
+   * paths, which exit without reaching ptyManager.dispose() — they are just
+   * invisible when they do, because nothing recorded that they existed. This
+   * turns those rows into an explicit verdict per session.
+   *
+   * Read-only with respect to processes: it probes and classifies, and never
+   * signals anything. `orphaned` is a report, not a cleanup trigger.
+   */
+  async reconcilePreviousSessions() {
+    if (!this.managedSessionsRepo) return [];
+    let verdicts = [];
+    try {
+      const rows = this.managedSessionsRepo.listNonTerminal();
+      if (rows.length === 0) return [];
+      verdicts = await reconcileSessions(
+        rows,
+        { isPidAlive, getProcessArgs },
+        this.streamerInstanceId
+      );
+      for (const v of verdicts) {
+        this.sessionLifecycles.set(v.sessionId, v.lifecycle);
+        if (v.lifecycle === "completed" || v.lifecycle === "failed") {
+          this.managedSessionsRepo.recordStatus(v.sessionId, "idle", "reconcile", {
+            completedAt: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+      this.log.info(`[reconcile] classified ${verdicts.length} session(s) from previous runs`, {
+        event: "sessions.reconciled",
+        counts: verdicts.reduce((acc, v) => {
+          acc[v.lifecycle] = (acc[v.lifecycle] ?? 0) + 1;
+          return acc;
+        }, {})
+      });
+    } catch (err) {
+      this.log.warn("[reconcile] failed to reconcile previous sessions", {
+        event: "sessions.reconcile_failed",
+        err
+      });
+    }
+    return verdicts;
+  }
+  /**
+   * Pick a token guaranteed to appear in the spawned process's argv, for the
+   * reconciler's pid-reuse guard.
+   *
+   * Claude always passes the session id (`--resume <id>` or `--session-id
+   * <id>`), so it is both present and unique. Codex only does on *resume*
+   * (`codex resume <id>`); a fresh Codex spawn is `codex --cd <path>
+   * --no-alt-screen` with no id at all, because the rollout id does not exist
+   * until the CLI writes it. boundConversationId is what distinguishes the two:
+   * it is set once that rollout has been discovered.
+   */
+  spawnArgvToken(session) {
+    if (session.provider !== CODEX_CLI_PROVIDER) return session.id;
+    return session.boundConversationId ?? session.projectPath;
+  }
+  /**
+   * Mirror a freshly-spawned session into the durable registry (C1 Phase 2).
+   *
+   * Called at each addManaged() site rather than inside SessionStore, because
+   * the store is a pure in-memory structure with no DB dependency and adding
+   * one would drag persistence into every unit test that touches it.
+   *
+   * Best-effort by design: a failed registry write must never break session
+   * start. Losing a row costs post-restart *visibility* for that session, which
+   * is strictly better than refusing to run the agent at all.
+   */
+  recordSessionSpawn(session) {
+    if (!this.managedSessionsRepo) return;
+    try {
+      const pid = this.ptyManager.getPid(session.id);
+      this.managedSessionsRepo.recordSpawn({
+        session,
+        pid,
+        // Identity guard against pid reuse: the reconciler requires this token
+        // to appear in the live process's argv before it will claim the pid is
+        // still ours (docs/architecture/2026-07-24-durable-session-runtime.md).
+        //
+        // Reading the real argv here would cost an async `ps` per session start
+        // on a path the user is waiting on, so we record a token we already
+        // know is in it. Claude always carries the session id (`--resume <id>`
+        // on resume, `--session-id <id>` on fresh). A *fresh* Codex spawn does
+        // not — its argv is only `--cd <path> --no-alt-screen`, because the
+        // rollout id doesn't exist yet — so fall back to the project path,
+        // which is present in every spawn path for both providers.
+        //
+        // The fallback is weaker: two sessions in one project share a token, so
+        // it proves "a process of ours in this project" rather than "this exact
+        // session". It still rejects an unrelated recycled pid, which is the
+        // failure being guarded against.
+        //
+        // Note the Codex id is always *set* (a local placeholder) — it is just
+        // not in the process's argv — so the choice keys off the provider, not
+        // off the id being null.
+        cmdline: pid != null ? this.spawnArgvToken(session) : null,
+        streamerInstanceId: this.streamerInstanceId
+      });
+    } catch (err) {
+      this.log.warn("[registry] failed to record session spawn", {
+        event: "registry.spawn_write_failed",
+        sessionId: session.id,
+        err
+      });
+    }
+  }
+  /**
+   * Stamp every live session as ended-by-shutdown before dispose() kills it.
+   *
+   * PTYManager.dispose() signals each child directly and fires no
+   * onStatusChange, so the registry would otherwise keep rows sitting at
+   * `running` forever and the next boot could not tell a deliberate restart
+   * from a crash. Recording `shutdown` as the status source makes that
+   * distinction explicit rather than inferred.
+   *
+   * Not a `completed_at` write for the agent's own work — the agent did not
+   * finish, we stopped it — but the session is genuinely terminal, so it must
+   * leave the reconciler's probe set.
+   */
+  recordShutdownState() {
+    if (!this.managedSessionsRepo) return;
+    const now = /* @__PURE__ */ new Date();
+    for (const session of this.ptyManager.listSessions()) {
+      try {
+        this.managedSessionsRepo.recordStatus(session.id, "idle", "shutdown", {
+          completedAt: now,
+          lastActivityAt: session.lastActivityAt ?? null,
+          promptCount: session.promptCount
+        });
+      } catch (err) {
+        this.log.warn("[registry] failed to record shutdown state", {
+          event: "registry.shutdown_write_failed",
+          sessionId: session.id,
+          err
+        });
+      }
+    }
+  }
+  /**
+   * Release PTYs whose agent has been silent past IDLE_REAP_AFTER_MS.
+   *
+   * This is the bound that lets handleWsClose stop arming kill timers. The
+   * distinction that matters: the old timer measured how long nobody was
+   * *watching*, which is uncorrelated with whether work is in flight. This
+   * measures how long the *agent* has produced nothing, and only ever considers
+   * sessions that are already settled — a `running` PTY is skipped regardless of
+   * age, so a long silent turn is never interrupted.
+   *
+   * Exposed (not private) so tests can drive one sweep deterministically instead
+   * of waiting on the interval.
+   */
+  reapIdleSessions(now = Date.now()) {
+    const reaped = [];
+    for (const session of this.ptyManager.listSessions()) {
+      if (session.status === "running") continue;
+      const lastActive = this.lastAgentChunkAt.get(session.id) ?? session.lastActivityAt?.getTime() ?? session.startedAt.getTime();
+      if (now - lastActive < IDLE_REAP_AFTER_MS) continue;
+      this.log.info(
+        `[reap] releasing idle PTY for ${session.id} (idle ${Math.round((now - lastActive) / 6e4)}m)`,
+        { sessionId: session.id, event: "pty.idle_reap", idleMs: now - lastActive },
+        "pino"
+      );
+      this.ptyManager.putOnHold(session.id);
+      this.lastAgentChunkAt.delete(session.id);
+      this.idempotency.clear(session.id);
+      this.sessionSubscribers.delete(session.id);
+      reaped.push(session.id);
+      const held = this.sessionStore.get(session.id, this.ptyAttachedIds());
+      if (held) this.wsHub.broadcast({ type: "session_update", session: held });
+    }
+    return reaped;
+  }
   startGraceTimer(sessionId, delayMs) {
     const existing = this.ptyGraceTimers.get(sessionId);
     if (existing) clearTimeout(existing);
@@ -7530,6 +8905,8 @@ var StreamerServer = class {
       this.log.info("Database migrations applied", { event: "db.migrations_applied" });
     }
     await this.bindWithRetry(port);
+    this.idleReaperTimer = setInterval(() => this.reapIdleSessions(), IDLE_REAP_SWEEP_MS);
+    this.idleReaperTimer.unref?.();
     const warmUp = new Promise((resolveWarm) => {
       {
         this.log.info(`Streamer server listening on port ${port}`, {
@@ -7563,7 +8940,11 @@ var StreamerServer = class {
           this.projectsRepo = new ProjectsRepository(db);
           this.conversationsRepo = new ConversationsRepository(this.cache);
           this.sessionsRepo = new SessionsRepository(this.sessionStore);
+          this.managedSessionsRepo = new ManagedSessionsRepository(db);
+          void this.reconcilePreviousSessions();
           this.cacheMetadataRepo = new CacheMetadataRepository(db);
+          this.pushRepo = new PushRepository(db);
+          this.devicesRepo = new DevicesRepository(db);
           this.cacheMonitor = new CacheIntegrityMonitor(
             this.cache,
             this.wsHub,
@@ -7781,6 +9162,12 @@ var StreamerServer = class {
   async close() {
     for (const timer of this.ptyGraceTimers.values()) clearTimeout(timer);
     this.ptyGraceTimers.clear();
+    if (this.idleReaperTimer) {
+      clearInterval(this.idleReaperTimer);
+      this.idleReaperTimer = null;
+    }
+    this.lastAgentChunkAt.clear();
+    this.recordShutdownState();
     this.markScannerStaleDebounced.cancel();
     await Promise.all([...this.inFlightCacheWrites]);
     await Promise.all([...this.allScanners].map((s) => s.close()));
@@ -7870,12 +9257,28 @@ var StreamerServer = class {
       ip,
       ts
     });
+    let device = null;
+    try {
+      const name = typeof body?.deviceName === "string" ? body.deviceName.slice(0, 100) : null;
+      const preset = body?.readOnly === true ? "read-only" : "full";
+      device = this.devicesRepo?.register({ publicKey: clientPublicKey, name, preset }) ?? null;
+    } catch (err) {
+      this.log.warn("[pair] device registration failed; pairing continues", {
+        event: "pair.device_register_failed",
+        err
+      });
+    }
     json(res, 200, {
       ciphertext: sealed.ciphertext,
       nonce: sealed.nonce,
       ephemeralPublicKey: sealed.ephemeralPublicKey,
       publicUrl: this.publicUrl,
-      machineName: hostname2()
+      machineName: hostname2(),
+      ...device && {
+        deviceId: device.deviceId,
+        deviceToken: device.deviceToken,
+        capabilities: device.capabilities
+      }
     });
   }
   rotateApiKey() {
@@ -7892,6 +9295,48 @@ var StreamerServer = class {
     });
     return { newKey, persisted };
   }
+  getClaudeFlagsConfig() {
+    return {
+      registry: CLAUDE_FLAGS,
+      values: this.claudeFlags,
+      extraArgs: this.claudeExtraArgs ?? null,
+      persisted: this.claudeFlagsPersistable
+    };
+  }
+  /**
+   * Replace the per-server flag set. Applies to the NEXT spawn — a live PTY
+   * keeps the argv it was started with.
+   *
+   * Mirrors rotateApiKey(): when the values were pinned by a CLI flag we still
+   * apply them in memory but skip the server.yaml write, because the flag would
+   * win again on restart and silently revert them.
+   *
+   * Logged with old→new at info level on purpose: this can disable the
+   * permission prompts entirely, so it needs a forensic trail.
+   */
+  setClaudeFlagsConfig(values, extraArgs) {
+    const safe = validateFlagValues(values);
+    const previous = { values: this.claudeFlags, extraArgs: this.claudeExtraArgs };
+    if (this.claudeFlagsPersistable) {
+      setClaudeExtraArgs(extraArgs);
+      setClaudeFlags(safe);
+    }
+    this.claudeFlags = safe;
+    this.claudeExtraArgs = extraArgs?.trim() ? extraArgs.trim() : void 0;
+    this.log.info("Claude CLI flags updated", {
+      event: "config.claude_flags_updated",
+      persisted: this.claudeFlagsPersistable,
+      previousValues: previous.values,
+      previousExtraArgs: previous.extraArgs ?? null,
+      values: this.claudeFlags,
+      extraArgs: this.claudeExtraArgs ?? null
+    });
+    return {
+      values: this.claudeFlags,
+      extraArgs: this.claudeExtraArgs ?? null,
+      persisted: this.claudeFlagsPersistable
+    };
+  }
   checkRateLimit(map, key, limit, windowMs) {
     const now = Date.now();
     const arr = (map.get(key) ?? []).filter((t) => now - t < windowMs);
@@ -8909,7 +10354,13 @@ var StreamerServer = class {
     }
     const hasPaginationParams = url.searchParams.has("limit") || url.searchParams.has("cursor") || url.searchParams.has("sortBy") || url.searchParams.has("order") || url.searchParams.has("status");
     if (!hasPaginationParams) {
-      json(res, 200, this.withExternalActivity(this.sessionStore.list(this.ptyAttachedIds())));
+      json(
+        res,
+        200,
+        this.withExternalActivity(
+          this.withReconciledLifecycle(this.sessionStore.list(this.ptyAttachedIds()))
+        )
+      );
       return;
     }
     const parsed = parseSessionListQuery(url);
@@ -8919,7 +10370,7 @@ var StreamerServer = class {
     }
     try {
       const page = this.sessionStore.paginate(this.ptyAttachedIds(), parsed.query);
-      page.sessions = this.withExternalActivity(page.sessions);
+      page.sessions = this.withExternalActivity(this.withReconciledLifecycle(page.sessions));
       json(res, 200, page);
     } catch (err) {
       if (err instanceof Error && err.message === "INVALID_CURSOR") {
@@ -8936,6 +10387,9 @@ var StreamerServer = class {
       if (!(0, import_fs18.existsSync)(session.projectPath)) {
         session.failureReason = `Project directory not found: ${session.projectPath}`;
       }
+      const reconciled = this.withReconciledLifecycle([session])[0];
+      session.lifecycle = reconciled.lifecycle;
+      session.lifecycleSource = reconciled.lifecycleSource;
       if (this.ptyManager.hasSession(sessionId)) {
         try {
           const lines = await this.ptyManager.getOutputLines(sessionId, 10);
@@ -9033,10 +10487,13 @@ var StreamerServer = class {
       projectName: body.projectName,
       branch: body.branch,
       permissionMode: this.defaultPermissionMode,
+      claudeFlags: this.claudeFlags,
+      claudeExtraArgs: this.claudeExtraArgs,
       model: this.defaultModel,
       effort: this.defaultEffort
     });
     this.sessionStore.addManaged(session);
+    this.recordSessionSpawn(session);
     void this.watchConversationFile(sessionId);
     const resp = this.sessionStore.get(session.id, this.ptyAttachedIds());
     this.broadcastOrUnicastSessionList(req);
@@ -9109,6 +10566,24 @@ var StreamerServer = class {
     }
     const body = await readBody(req);
     const { input, keys } = body;
+    let idempotencyKey;
+    try {
+      idempotencyKey = readIdempotencyKey(body);
+    } catch (err) {
+      json(res, 400, { error: err instanceof Error ? err.message : "Invalid idempotencyKey" });
+      return;
+    }
+    if (idempotencyKey) {
+      const replayed = this.idempotency.get(sessionId, idempotencyKey);
+      if (replayed) {
+        this.log.info(`[input.replay] ${sessionId.slice(0, 8)} duplicate idempotencyKey`, {
+          event: "input.idempotent_replay",
+          sessionId
+        });
+        json(res, replayed.status, replayed.body);
+        return;
+      }
+    }
     if (typeof keys === "string") {
       try {
         this.ptyManager.sendKeys(sessionId, keys);
@@ -9116,7 +10591,9 @@ var StreamerServer = class {
         if (updated) {
           this.wsHub.broadcast({ type: "session_update", session: updated });
         }
-        json(res, 200, { ok: true });
+        const result = { status: 200, body: { ok: true } };
+        if (idempotencyKey) this.idempotency.set(sessionId, idempotencyKey, result);
+        json(res, result.status, result.body);
       } catch (err) {
         const message = err instanceof Error ? err.message : "Failed to send keys";
         json(res, 400, { error: message });
@@ -9154,7 +10631,9 @@ var StreamerServer = class {
           });
         });
       }
-      json(res, 200, { ok: true });
+      const result = { status: 200, body: { ok: true } };
+      if (idempotencyKey) this.idempotency.set(sessionId, idempotencyKey, result);
+      json(res, result.status, result.body);
     } catch (err) {
       const message = err instanceof Error ? err.message : "Failed to send input";
       json(res, 400, { error: message });
@@ -9459,10 +10938,13 @@ var StreamerServer = class {
       projectName,
       branch,
       permissionMode: this.defaultPermissionMode,
+      claudeFlags: this.claudeFlags,
+      claudeExtraArgs: this.claudeExtraArgs,
       model: this.defaultModel,
       effort: this.defaultEffort
     });
     this.sessionStore.addManaged(session);
+    this.recordSessionSpawn(session);
     void this.watchConversationFile(session.id);
     this.wsHub.broadcast({
       type: "session_list",
@@ -9532,10 +11014,13 @@ var StreamerServer = class {
         projectName: body.projectName,
         systemPrompt: systemPromptParts.join("\n"),
         permissionMode: this.defaultPermissionMode,
+        claudeFlags: this.claudeFlags,
+        claudeExtraArgs: this.claudeExtraArgs,
         model: this.defaultModel,
         effort: this.defaultEffort
       });
       this.sessionStore.addManaged(session);
+      this.recordSessionSpawn(session);
       const readyOrFailed = new Promise((resolve2) => {
         const handler = (status) => {
           if (status === "waiting_input" || status === "idle") {
@@ -10057,6 +11542,7 @@ function readBody(req) {
   SessionStore,
   StreamerServer,
   WSHub,
+  confidenceForSource,
   createAgentClient,
   createConversationWriter,
   createPool,