@threadbase-sh/streamer 1.36.4 → 1.38.0

package/dist/index.js

@@ -278,6 +278,217 @@ import { randomBytes, timingSafeEqual } from "crypto";
 import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "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
+import pino from "pino";
+var baseLogger = pino({
+  level: process.env.LOG_LEVEL ?? "info",
+  base: { service: "tb-streamer" },
+  timestamp: pino.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/feature-flags.ts
+var FEATURE_FLAGS = [
+  {
+    id: "codexSystemPrompt",
+    description: "Send the built system prompt to fresh Codex sessions. Off by default: Codex has no --system-prompt flag, so the prompt goes in the positional [PROMPT] argument, which Codex treats as the user's opening turn rather than a system-level instruction.",
+    default: false,
+    env: "THREADBASE_FEATURE_CODEX_SYSTEM_PROMPT"
+  }
+];
+function findFeatureFlag(id) {
+  return FEATURE_FLAGS.find((f) => f.id === id);
+}
+function parseBooleanEnv(raw) {
+  if (raw === void 0) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "") return false;
+  return !(v === "0" || v === "false" || v === "no" || v === "off");
+}
+function validateFeatureFlagValues(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  const out = {};
+  const dropped = [];
+  for (const [id, value] of Object.entries(raw)) {
+    if (!findFeatureFlag(id) || typeof value !== "boolean") {
+      dropped.push(id);
+      continue;
+    }
+    out[id] = value;
+  }
+  if (dropped.length > 0) {
+    getLogger("feature-flags").warn(
+      `Ignoring unknown or non-boolean feature flags: ${dropped.join(", ")}`,
+      {
+        event: "config.feature_flags_dropped",
+        dropped
+      }
+    );
+  }
+  return out;
+}
+function resolveFeatureFlags(opts) {
+  const env = opts?.env ?? process.env;
+  const out = {};
+  for (const def of FEATURE_FLAGS) {
+    out[def.id] = parseBooleanEnv(env[def.env]) ?? opts?.cli?.[def.id] ?? opts?.yaml?.[def.id] ?? def.default;
+  }
+  return out;
+}
+function nonDefaultFeatureFlags(values) {
+  return FEATURE_FLAGS.filter((f) => values[f.id] !== f.default).map((f) => f.id);
+}
+
+// src/auth.ts
 function configDir() {
   return process.env.THREADBASE_CONFIG_DIR ?? join2(homedir(), ".threadbase");
 }
@@ -356,11 +567,94 @@ function loadDefaultPermissionMode() {
     const content = 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();
+  mkdirSync(configDir(), { recursive: true });
+  let content = "";
+  try {
+    content = 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`;
+  writeFileSync(tmpFile, updated, { encoding: "utf-8", mode: 384 });
+  chmodSync(tmpFile, 384);
+  renameSync(tmpFile, file);
+}
+function loadClaudeFlags() {
+  try {
+    const content = 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 = 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 loadFeatureFlags() {
+  try {
+    const content = readFileSync(configFile(), "utf-8");
+    const match = content.match(/^feature_flags:\s*(.+)$/m);
+    if (!match?.[1]) return {};
+    return validateFeatureFlagValues(JSON.parse(match[1].trim()));
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      getLogger("auth").warn(`Ignoring unreadable feature_flags in server.yaml: ${String(err)}`, {
+        event: "config.feature_flags_parse_failed"
+      });
+    }
+    return {};
+  }
+}
 function validatePublicUrl(raw) {
   let parsed;
   try {
@@ -508,42 +802,6 @@ import { randomUUID } from "crypto";
 import { existsSync as existsSync2 } from "fs";
 import { basename } from "path";
 
-// src/logger.ts
-import pino from "pino";
-var baseLogger = pino({
-  level: process.env.LOG_LEVEL ?? "info",
-  base: { service: "tb-streamer" },
-  timestamp: pino.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
 import { execFileSync } from "child_process";
 import { existsSync } from "fs";
@@ -895,6 +1153,8 @@ var CodexPtyRunner = class {
       projectName,
       branch: options.branch ?? "",
       status: "running",
+      statusSource: "spawn",
+      statusUpdatedAt: /* @__PURE__ */ new Date(),
       startedAt: /* @__PURE__ */ new Date(),
       completedAt: null,
       promptCount: 0,
@@ -942,6 +1202,8 @@ var CodexPtyRunner = class {
       projectName,
       branch: "",
       status: "running",
+      statusSource: "spawn",
+      statusUpdatedAt: /* @__PURE__ */ new Date(),
       startedAt: /* @__PURE__ */ new Date(),
       completedAt: null,
       promptCount: 0,
@@ -972,7 +1234,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?.();
@@ -987,6 +1249,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);
@@ -1056,6 +1320,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);
@@ -1156,6 +1422,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);
@@ -1200,6 +1468,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) {
@@ -1301,9 +1574,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
@@ -1334,9 +1607,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,
@@ -1354,6 +1629,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 (!existsSync2(session.projectPath)) {
@@ -1383,6 +1660,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 }
   };
 }
@@ -1711,16 +1990,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.
@@ -1738,28 +2018,27 @@ var PTYManager = class {
   async doStart(sessionId, options) {
     const nodePty = await loadPty2();
     const projectName = options.projectName ?? basename2(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,
@@ -1767,6 +2046,8 @@ var PTYManager = class {
       projectName,
       branch: options.branch ?? "",
       status: "running",
+      statusSource: "spawn",
+      statusUpdatedAt: /* @__PURE__ */ new Date(),
       startedAt: /* @__PURE__ */ new Date(),
       completedAt: null,
       promptCount: 0,
@@ -1794,11 +2075,12 @@ var PTYManager = class {
     const nodePty = await loadPty2();
     const sessionId = randomUUID2();
     const projectName = options.projectName ?? basename2(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",
@@ -1809,6 +2091,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,
@@ -1823,6 +2106,8 @@ var PTYManager = class {
       projectName,
       branch: "",
       status: "running",
+      statusSource: "spawn",
+      statusUpdatedAt: /* @__PURE__ */ new Date(),
       startedAt: /* @__PURE__ */ new Date(),
       completedAt: null,
       promptCount: 0,
@@ -1853,6 +2138,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(
@@ -1888,6 +2175,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);
@@ -2009,6 +2298,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);
@@ -2044,6 +2335,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.
@@ -2120,9 +2418,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) => {
@@ -2222,7 +2520,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", {
@@ -2251,14 +2549,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",
@@ -2278,6 +2578,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 (!existsSync3(session.projectPath)) {
@@ -2312,6 +2614,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 }
   };
 }
@@ -2384,6 +2688,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;
@@ -2560,6 +2874,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 (platform2() === "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);
@@ -2682,6 +3008,7 @@ import {
   ConversationScanner,
   search
 } from "@threadbase-sh/scanner";
+import { randomUUID as randomUUID5 } from "crypto";
 import { EventEmitter } from "events";
 import {
   createReadStream,
@@ -2693,7 +3020,7 @@ import {
 } from "fs";
 import { realpath as realpath2 } from "fs/promises";
 import { createServer } from "http";
-import { homedir as homedir9 } from "os";
+import { homedir as homedir9, hostname as hostname2 } from "os";
 import { basename as basename5, dirname as dirname9, join as join18 } from "path";
 import { createInterface } from "readline";
 
@@ -2953,7 +3280,202 @@ async function handleStartAgentSession(body, deps) {
 }
 
 // src/api/app.ts
-import { Hono as Hono13 } from "hono";
+import { Hono as Hono16 } from "hono";
+
+// src/db/repositories/devices.repository.ts
+import { createHash, randomBytes as randomBytes2, randomUUID as randomUUID3, timingSafeEqual as timingSafeEqual2 } from "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 randomBytes2(32).toString("base64url");
+}
+function hashDeviceToken(token) {
+  return createHash("sha256").update(token).digest("hex");
+}
+function safeHashEquals(a, b) {
+  if (a.length !== b.length) return false;
+  return timingSafeEqual2(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 = randomUUID3();
+    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) {
@@ -2984,19 +3506,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();
   }
-  const key = c.req.query("key");
-  if (key && validateApiKey(key, deps.apiKey)) {
+  if (!principal) {
+    return c.json({ error: "Unauthorized" }, 401);
+  }
+  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
@@ -3135,12 +3678,68 @@ var createCacheAlertRoutes = (deps) => {
   return app;
 };
 
-// src/api/routes/conversations.routes.ts
+// src/api/routes/config.routes.ts
 import { Hono as Hono4 } from "hono";
+
+// src/schemas/claudeFlags.schema.ts
+import { z as z2 } from "zod";
+var ClaudeFlagsBodySchema = z2.object({
+  values: z2.record(z2.string(), z2.union([z2.string(), z2.boolean(), z2.array(z2.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: z2.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 Hono4();
+  app.get("/claude-flags", (c) => c.json(deps.claudeFlagsConfig()));
+  app.get("/feature-flags", (c) => c.json(deps.featureFlagsConfig()));
+  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
+import { Hono as Hono5 } from "hono";
 var ALREADY_HANDLED2 = 597;
 var alreadyHandled2 = () => new Response(null, { status: ALREADY_HANDLED2 });
 var createConversationRoutes = (deps) => {
-  const app = new Hono4();
+  const app = new Hono5();
   app.get("/count", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleConversationsCount(url, c.env.outgoing);
@@ -3166,8 +3765,34 @@ var createConversationRoutes = (deps) => {
   return app;
 };
 
+// src/api/routes/devices.routes.ts
+import { Hono as Hono6 } from "hono";
+var createDeviceRoutes = (deps) => {
+  const app = new Hono6();
+  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
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono7 } from "hono";
 
 // src/version.ts
 import { readFileSync as readFileSync4, realpathSync } from "fs";
@@ -3204,7 +3829,7 @@ function resolveVersion() {
 
 // src/api/routes/health.routes.ts
 var createHealthRoutes = (deps) => {
-  const app = new Hono5();
+  const app = new Hono7();
   app.get("/", (c) => {
     const cacheAlert = deps.cacheMonitor()?.healthzField();
     return c.json({ ok: true, version: getVersion(), ...cacheAlert ? { cacheAlert } : {} });
@@ -3215,7 +3840,7 @@ var createHealthRoutes = (deps) => {
 // src/api/routes/logs.routes.ts
 import { closeSync, existsSync as existsSync5, fstatSync, openSync, readSync, statSync } from "fs";
 import { join as join9 } from "path";
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono8 } from "hono";
 
 // src/lifecycle/constants.ts
 import { homedir as homedir4 } from "os";
@@ -3273,7 +3898,7 @@ function readLogLines(filePath, sinceOffset, limit) {
   }
 }
 function createLogsRoutes() {
-  const app = new Hono6();
+  const app = new Hono8();
   app.get("/", (c) => {
     try {
       const sourceParam = (c.req.query("source") || "").toLowerCase();
@@ -3343,8 +3968,8 @@ function createLogsRoutes() {
 
 // src/api/routes/misc.routes.ts
 import { spawn } from "child_process";
-import { createHmac, timingSafeEqual as timingSafeEqual2 } from "crypto";
-import { Hono as Hono7 } from "hono";
+import { createHmac, timingSafeEqual as timingSafeEqual3 } from "crypto";
+import { Hono as Hono9 } from "hono";
 import { hostname } from "os";
 
 // src/config/update-config.ts
@@ -3354,15 +3979,15 @@ import { join as join10 } from "path";
 import { parse as parseYaml } from "yaml";
 
 // src/schemas/updateConfig.schema.ts
-import { z as z2 } from "zod";
-var UpdateConfigSchema = z2.object({
-  auto_update: z2.boolean().default(false),
-  channel: z2.enum(["stable", "next"]).default("stable"),
-  allow: z2.array(z2.enum(["patch", "minor", "major"])).default(["patch", "minor"]),
-  poll_interval_minutes: z2.number().int().min(0).default(1440),
-  defer_if_active_sessions: z2.boolean().default(true),
-  github_repo: z2.string().regex(/^[^/]+\/[^/]+$/, "github_repo must be 'owner/name'"),
-  webhook_secret: z2.string().min(1).nullable().default(null)
+import { z as z3 } from "zod";
+var UpdateConfigSchema = z3.object({
+  auto_update: z3.boolean().default(false),
+  channel: z3.enum(["stable", "next"]).default("stable"),
+  allow: z3.array(z3.enum(["patch", "minor", "major"])).default(["patch", "minor"]),
+  poll_interval_minutes: z3.number().int().min(0).default(1440),
+  defer_if_active_sessions: z3.boolean().default(true),
+  github_repo: z3.string().regex(/^[^/]+\/[^/]+$/, "github_repo must be 'owner/name'"),
+  webhook_secret: z3.string().min(1).nullable().default(null)
 }).strict();
 
 // src/config/update-config.ts
@@ -3383,7 +4008,264 @@ function loadUpdateConfig(opts = {}) {
   return UpdateConfigSchema.parse(parsed);
 }
 
+// src/db/repositories/push.repository.ts
+var FAILURE_STREAK_LIMIT = 5;
+var PUSH_TOKEN_KINDS = ["expo", "liveactivity_start", "liveactivity_update"];
+var DEFAULT_PUSH_TOKEN_KIND = "expo";
+function isPushTokenKind(value) {
+  return typeof value === "string" && PUSH_TOKEN_KINDS.includes(value);
+}
+function tokenState(row, now = Date.now()) {
+  if (row.revoked_at != null) return "revoked";
+  if (row.expires_at != null && row.expires_at <= now) return "expired";
+  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, now = Date.now()) {
+  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, now),
+    kind: row.kind,
+    activityId: row.activity_id,
+    sessionId: row.session_id,
+    expiresAt: row.expires_at
+  };
+}
+var PushRepository = class {
+  upsertStmt;
+  getStmt;
+  listActiveStmt;
+  listAllStmt;
+  successStmt;
+  failureStmt;
+  revokeStmt;
+  claimEventStmt;
+  markDeliveredStmt;
+  listByKindSessionStmt;
+  listByKindStmt;
+  listRenewableStmt;
+  claimRenewalStmt;
+  expireStmt;
+  expireSessionActivitiesStmt;
+  constructor(db) {
+    this.upsertStmt = db.prepare(`
+      INSERT INTO push_tokens (
+        token, platform, device_id, registered_at,
+        kind, activity_id, session_id, expires_at, stale_date, started_at
+      )
+      VALUES (
+        @token, @platform, @device_id, @registered_at,
+        @kind, @activity_id, @session_id, @expires_at, @stale_date, @started_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,
+        kind = excluded.kind,
+        activity_id = COALESCE(excluded.activity_id, push_tokens.activity_id),
+        session_id = COALESCE(excluded.session_id, push_tokens.session_id),
+        expires_at = excluded.expires_at,
+        stale_date = excluded.stale_date,
+        -- Preserve the ORIGINAL start across a re-registration. iOS renders its
+        -- own ticking timer from started_at, so overwriting it with a fresh
+        -- value visibly resets the user's elapsed time to zero.
+        started_at = COALESCE(push_tokens.started_at, excluded.started_at),
+        -- A fresh registration clears prior failure state and any revocation:
+        -- the client is telling us this token is live again. renewed_at clears
+        -- too \u2014 this is a new activity generation, so it is renewable again.
+        failure_streak = 0,
+        last_failure_at = NULL,
+        last_failure_code = NULL,
+        revoked_at = NULL,
+        renewed_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}
+         AND kind = 'expo'
+       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.listByKindSessionStmt = db.prepare(`
+      SELECT * FROM push_tokens
+       WHERE kind = @kind AND session_id = @session_id
+         AND revoked_at IS NULL AND failure_streak < ${FAILURE_STREAK_LIMIT}
+         AND (expires_at IS NULL OR expires_at > @now)
+       ORDER BY registered_at ASC
+    `);
+    this.listByKindStmt = db.prepare(`
+      SELECT * FROM push_tokens
+       WHERE kind = @kind
+         AND revoked_at IS NULL AND failure_streak < ${FAILURE_STREAK_LIMIT}
+         AND (expires_at IS NULL OR expires_at > @now)
+       ORDER BY registered_at ASC
+    `);
+    this.listRenewableStmt = db.prepare(`
+      SELECT * FROM push_tokens
+       WHERE kind = 'liveactivity_update'
+         AND stale_date IS NOT NULL AND renewed_at IS NULL
+         AND revoked_at IS NULL AND failure_streak < ${FAILURE_STREAK_LIMIT}
+       ORDER BY stale_date ASC
+    `);
+    this.claimRenewalStmt = db.prepare(`
+      UPDATE push_tokens SET renewed_at = @at
+       WHERE token = @token AND renewed_at IS NULL
+    `);
+    this.expireStmt = db.prepare("UPDATE push_tokens SET expires_at = ? WHERE token = ?");
+    this.expireSessionActivitiesStmt = db.prepare(`
+      UPDATE push_tokens SET expires_at = @at
+       WHERE session_id = @session_id AND kind = 'liveactivity_update'
+         AND (expires_at IS NULL OR expires_at > @at)
+    `);
+    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 or refresh a token.
+   *
+   * `kind` defaults to Expo so a released client posting `{ token, platform }`
+   * keeps working — tb-mobile cannot be force-updated, and every client
+   * predating Live Activities is registering an Expo relay token.
+   *
+   * Several rows per device is normal and intended: a device runs one activity
+   * per live session, each with its own update token. The token itself is the
+   * primary key, so distinct activities never collide.
+   */
+  register(args) {
+    this.upsertStmt.run({
+      token: args.token,
+      platform: args.platform,
+      device_id: args.deviceId ?? null,
+      registered_at: args.now ?? Date.now(),
+      kind: args.kind ?? DEFAULT_PUSH_TOKEN_KIND,
+      activity_id: args.activityId ?? null,
+      session_id: args.sessionId ?? null,
+      expires_at: args.expiresAt ?? null,
+      stale_date: args.staleDate ?? null,
+      started_at: args.startedAt ?? null
+    });
+  }
+  get(token) {
+    return this.getStmt.get(token) ?? null;
+  }
+  /**
+   * Expo tokens eligible for delivery — not revoked, not past the failure limit.
+   *
+   * Deliberately Expo-only. ActivityKit tokens go over direct APNs with a
+   * different topic and are rejected by Expo's relay, so the ordinary
+   * notification fan-out must not see them.
+   */
+  listDeliverable() {
+    return this.listActiveStmt.all();
+  }
+  /** Live-activity tokens for one session, eligible for delivery. */
+  listForSession(kind, sessionId, now = Date.now()) {
+    return this.listByKindSessionStmt.all({
+      kind,
+      session_id: sessionId,
+      now
+    });
+  }
+  /**
+   * Every deliverable token of one kind.
+   *
+   * Used for push-to-start, which is app-wide rather than session-scoped: the
+   * activity does not exist yet, so there is no per-activity token to look up.
+   */
+  listByKind(kind, now = Date.now()) {
+    return this.listByKindStmt.all({ kind, now });
+  }
+  /** Unrenewed activities with a renewal deadline, soonest first. */
+  listRenewable() {
+    return this.listRenewableStmt.all();
+  }
+  /**
+   * Claim a row for renewal.
+   *
+   * Returns true exactly once per row. A restart re-arms timers from the
+   * persisted deadline, so the same renewal can be attempted twice; the loser
+   * gets false and must not send. Doing this as a conditional UPDATE rather
+   * than read-then-write avoids the race where both attempts observe
+   * "not yet renewed".
+   */
+  claimRenewal(token, now = Date.now()) {
+    return this.claimRenewalStmt.run({ token, at: now }).changes > 0;
+  }
+  /** Mark one token expired, so it stops being a delivery target. */
+  expire(token, now = Date.now()) {
+    this.expireStmt.run(now, token);
+  }
+  /**
+   * Expire every live activity for a session.
+   *
+   * Called when the session ends. Without this, a per-activity token outlives
+   * its session and a later renewal sweep would resurrect an activity for a
+   * session that is already gone.
+   */
+  expireSessionActivities(sessionId, now = Date.now()) {
+    this.expireSessionActivitiesStmt.run({ session_id: sessionId, at: now });
+  }
+  /** Every token, including dead and revoked ones, for the health report. */
+  listHealth(now = Date.now()) {
+    return this.listAllStmt.all().map((r) => toHealth(r, now));
+  }
+  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/api/routes/misc.routes.ts
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 function readJsonBody(req) {
   return new Promise((resolve2, reject) => {
     const chunks = [];
@@ -3399,7 +4281,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));
@@ -3414,11 +4296,11 @@ function verifyWebhookSignature(body, header, secret) {
   const a = Buffer.from(provided, "utf-8");
   const b = Buffer.from(expected, "utf-8");
   if (a.length !== b.length) return false;
-  return timingSafeEqual2(a, b);
+  return timingSafeEqual3(a, b);
 }
 var clientLog = getLogger("client");
 var createMiscRoutes = (deps) => {
-  const app = new Hono7();
+  const app = new Hono9();
   app.get("/api/info", (c) => {
     const ptyIds = deps.ptyAttachedIds();
     return c.json({
@@ -3426,7 +4308,15 @@ var createMiscRoutes = (deps) => {
       machineName: 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,
+      // Same contract: this server serves GET /api/config/feature-flags. Lives
+      // here rather than behind /api/config (admin-only) so a read-only client
+      // still learns the server supports flags even if it can't read values.
+      featureFlags: true
     });
   });
   app.get("/api/profiles", (c) => c.json([]));
@@ -3443,7 +4333,54 @@ 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 kind = body?.kind === void 0 ? DEFAULT_PUSH_TOKEN_KIND : body.kind;
+    if (!isPushTokenKind(kind)) {
+      return c.json(
+        { error: `kind must be one of ${PUSH_TOKEN_KINDS.join(", ")}`, code: "INVALID_KIND" },
+        400
+      );
+    }
+    if (kind === "liveactivity_update" && typeof body?.activityId !== "string") {
+      return c.json(
+        {
+          error: "activityId is required for kind 'liveactivity_update'",
+          code: "MISSING_ACTIVITY"
+        },
+        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,
+      kind,
+      activityId: typeof body?.activityId === "string" ? body.activityId : null,
+      sessionId: typeof body?.sessionId === "string" ? body.sessionId : null,
+      expiresAt: numberOrNull(body?.expiresAt),
+      staleDate: numberOrNull(body?.staleDate),
+      startedAt: numberOrNull(body?.startedAt)
+    });
+    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) {
@@ -3451,7 +4388,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);
     }
@@ -3494,11 +4431,11 @@ var createMiscRoutes = (deps) => {
 };
 
 // src/api/routes/pair.routes.ts
-import { Hono as Hono8 } from "hono";
+import { Hono as Hono10 } from "hono";
 var ALREADY_HANDLED3 = 597;
 var alreadyHandled3 = () => new Response(null, { status: ALREADY_HANDLED3 });
 var createPairRoutes = (deps) => {
-  const app = new Hono8();
+  const app = new Hono10();
   app.post("/start", (c) => {
     deps.handlePairStart(c.env.outgoing);
     return alreadyHandled3();
@@ -3511,11 +4448,11 @@ var createPairRoutes = (deps) => {
 };
 
 // src/api/routes/projects.routes.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono11 } from "hono";
 var ALREADY_HANDLED4 = 597;
 var alreadyHandled4 = () => new Response(null, { status: ALREADY_HANDLED4 });
 var createProjectRoutes = (deps) => {
-  const app = new Hono9();
+  const app = new Hono11();
   app.get("/", (c) => {
     const url = new URL(c.req.url);
     deps.handleListProjects(url, c.env.outgoing);
@@ -3529,12 +4466,147 @@ var createProjectRoutes = (deps) => {
   return app;
 };
 
+// src/api/routes/providers.routes.ts
+import { Hono as Hono12 } from "hono";
+
+// src/services/providers/providerHealth.ts
+import { execFile as execFile2 } from "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) => {
+    execFile2(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 Hono12();
+  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
-import { Hono as Hono10 } from "hono";
+import { Hono as Hono13 } from "hono";
 var ALREADY_HANDLED5 = 597;
 var alreadyHandled5 = () => new Response(null, { status: ALREADY_HANDLED5 });
 var createScannerRoutes = (deps) => {
-  const app = new Hono10();
+  const app = new Hono13();
   app.get("/api/search", async (c) => {
     const url = new URL(c.req.url);
     await deps.handleSearch(url, c.env.outgoing);
@@ -3544,11 +4616,11 @@ var createScannerRoutes = (deps) => {
 };
 
 // src/api/routes/sessions.routes.ts
-import { Hono as Hono11 } from "hono";
+import { Hono as Hono14 } from "hono";
 var ALREADY_HANDLED6 = 597;
 var alreadyHandled6 = () => new Response(null, { status: ALREADY_HANDLED6 });
 var createSessionRoutes = (deps) => {
-  const app = new Hono11();
+  const app = new Hono14();
   app.get("/count", (c) => {
     deps.handleSessionsCount(c.env.outgoing);
     return alreadyHandled6();
@@ -3615,9 +4687,9 @@ var createSessionRoutes = (deps) => {
 };
 
 // src/api/routes/ws.routes.ts
-import { Hono as Hono12 } from "hono";
+import { Hono as Hono15 } from "hono";
 var createWsRoutes = (deps, upgradeWebSocket) => {
-  const app = new Hono12();
+  const app = new Hono15();
   app.get(
     "/ws",
     upgradeWebSocket(() => {
@@ -3643,7 +4715,7 @@ var createWsRoutes = (deps, upgradeWebSocket) => {
 
 // src/api/app.ts
 var createHonoApp = (deps, upgradeWebSocket) => {
-  const app = new Hono13();
+  const app = new Hono16();
   const httpLog = getLogger("http");
   app.use("*", async (c, next) => {
     const start = Date.now();
@@ -3668,7 +4740,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));
@@ -3878,11 +4953,11 @@ function joinStatCacheByNativePath(metas, canonicalStats) {
 }
 
 // src/utils/fileIdentity.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "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:${createHash("sha1").update(head).digest("hex")}`;
+  return `fp:${createHash2("sha1").update(head).digest("hex")}`;
 }
 function splitCompleteLines(buf, baseOffset) {
   const spans = [];
@@ -5164,8 +6239,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
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/utils/canonicalizeProjectPath.ts
 function canonicalizeProjectPath(projectPath) {
@@ -5258,7 +6447,7 @@ var ProjectsRepository = class {
       });
       return rowToProject(this.getById.get(existing.id));
     }
-    const id = randomUUID3();
+    const id = randomUUID4();
     this.insert.run({
       id,
       path,
@@ -5348,8 +6537,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
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 var DEFAULT_TTL_SECONDS = 180;
 var SWEEP_INTERVAL_MS = 6e4;
 var PairTokenStore = class {
@@ -5364,7 +6565,7 @@ var PairTokenStore = class {
     }
   }
   mint() {
-    const token = `pt_${randomBytes2(16).toString("hex")}`;
+    const token = `pt_${randomBytes3(16).toString("hex")}`;
     const expiresAt = Date.now() + this.ttlMs;
     this.current = { token, expiresAt, used: false };
     return {
@@ -5432,7 +6633,7 @@ function setCacheMetadata(repo, key, value) {
 }
 
 // src/services/cache-integrity/cacheIntegrityMonitor.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import { existsSync as existsSync8 } from "fs";
 
 // src/services/cache-integrity/alertStore.ts
@@ -5497,13 +6698,13 @@ function envInt(name, fallback) {
 }
 function fingerprintOf(ids) {
   const sorted = [...ids].sort();
-  return `sha256:${createHash2("sha256").update(sorted.join("\n")).digest("hex")}`;
+  return `sha256:${createHash3("sha256").update(sorted.join("\n")).digest("hex")}`;
 }
 var CacheIntegrityMonitor = class {
-  constructor(cache, wsHub, log3, cacheDir, rescan, runDuringReset) {
+  constructor(cache, wsHub, log7, cacheDir, rescan, runDuringReset) {
     this.cache = cache;
     this.wsHub = wsHub;
-    this.log = log3;
+    this.log = log7;
     this.cacheDir = cacheDir;
     this.rescan = rescan;
     this.runDuringReset = runDuringReset;
@@ -6059,62 +7260,633 @@ function refreshConversationCache(deps) {
   };
 }
 
-// src/services/conversations/shouldRefreshProjectsFromHdd.ts
-import { readdirSync as readdirSync5, statSync as statSync7 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join16 } from "path";
-var DEFAULT_PROJECTS_DIR = join16(homedir8(), ".claude", "projects");
-function maxProjectsTreeMtimeMs(projectsDir) {
-  let maxMs;
-  try {
-    maxMs = statSync7(projectsDir).mtimeMs;
-  } catch {
-    return null;
+// src/services/conversations/shouldRefreshProjectsFromHdd.ts
+import { readdirSync as readdirSync5, statSync as statSync7 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join16 } from "path";
+var DEFAULT_PROJECTS_DIR = join16(homedir8(), ".claude", "projects");
+function maxProjectsTreeMtimeMs(projectsDir) {
+  let maxMs;
+  try {
+    maxMs = statSync7(projectsDir).mtimeMs;
+  } catch {
+    return null;
+  }
+  try {
+    for (const ent of readdirSync5(projectsDir, { withFileTypes: true })) {
+      if (!ent.isDirectory()) continue;
+      try {
+        const childMs = statSync7(join16(projectsDir, ent.name)).mtimeMs;
+        if (childMs > maxMs) maxMs = childMs;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return maxMs;
+}
+function shouldRefreshProjectsFromHdd(conversationsRepo, cacheMetadataRepo, opts = {}) {
+  if (conversationsRepo.hasOrphanRows()) return true;
+  const dirs = /* @__PURE__ */ new Set();
+  if (opts.projectsDirs) {
+    for (const d of opts.projectsDirs) dirs.add(d);
+  }
+  dirs.add(opts.projectsDir ?? DEFAULT_PROJECTS_DIR);
+  let newestMs = null;
+  for (const dir of dirs) {
+    const ms = maxProjectsTreeMtimeMs(dir);
+    if (ms === null) continue;
+    if (newestMs === null || ms > newestMs) newestMs = ms;
+  }
+  if (newestMs === null) return false;
+  const lastIndexedIso = getCacheMetadata(cacheMetadataRepo, "conversations_last_indexed_at");
+  if (!lastIndexedIso) return true;
+  const lastIndexedMs = Date.parse(lastIndexedIso);
+  if (Number.isNaN(lastIndexedMs)) return true;
+  return newestMs > lastIndexedMs;
+}
+
+// src/services/projectChats/deriveProjectChatTitle.ts
+function deriveProjectChatTitle(input) {
+  const trimmed = input.title?.trim();
+  if (trimmed) return trimmed;
+  const name = input.projectName?.trim();
+  if (name) return name;
+  const pathSuffix = input.projectPath ? input.projectPath.split(/[/\\]/).filter(Boolean).slice(-2).join("/") : "";
+  if (pathSuffix) return pathSuffix;
+  return `Untitled \xB7 ${input.id.slice(0, 8)}`;
+}
+
+// src/services/push/apnsClient.ts
+import { createSign } from "crypto";
+import { connect, constants } from "http2";
+var log3 = getLogger("apns");
+var APNS_HOST_SANDBOX = "api.sandbox.push.apple.com";
+var APNS_MAX_PAYLOAD_BYTES = 4096;
+var JWT_TTL_SECONDS = 3e3;
+var DEAD_TOKEN_REASONS = /* @__PURE__ */ new Set([
+  "BadDeviceToken",
+  "DeviceTokenNotForTopic",
+  "Unregistered",
+  "ExpiredToken"
+]);
+function base64url(input) {
+  return Buffer.from(input).toString("base64url");
+}
+function readApnsCredentialsFromEnv(env = process.env) {
+  const key = env.APNS_KEY;
+  if (!key || key.trim().length === 0) return null;
+  const keyId = env.APNS_KEY_ID?.trim();
+  const teamId = env.APNS_TEAM_ID?.trim();
+  const bundleId = env.APNS_BUNDLE_ID?.trim();
+  if (!keyId || !teamId || !bundleId) return null;
+  const host = env.APNS_HOST ?? APNS_HOST_SANDBOX;
+  return { key, keyId, teamId, bundleId, host };
+}
+function describeMissingApnsCredentials(env = process.env) {
+  if (!env.APNS_KEY || env.APNS_KEY.trim().length === 0) {
+    return "APNS_KEY is not set, so Live Activity push is disabled. Set it to the p8 key contents (not a path) to enable it.";
+  }
+  const missing = [
+    ["APNS_KEY_ID", env.APNS_KEY_ID],
+    ["APNS_TEAM_ID", env.APNS_TEAM_ID],
+    ["APNS_BUNDLE_ID", env.APNS_BUNDLE_ID]
+  ].filter(([, value]) => !value || value.trim().length === 0).map(([name]) => name);
+  if (missing.length === 0) return null;
+  return `APNS_KEY is set but ${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} not, so Live Activity push is disabled. Under launchd, APNS_KEY_ID is derived from the AuthKey_<keyId>.p8 filename; the team and bundle ids must be set explicitly.`;
+}
+var ApnsClient = class {
+  constructor(creds) {
+    this.creds = creds;
+  }
+  creds;
+  session = null;
+  cachedJwt = null;
+  /**
+   * The `apns-topic` for Live Activity pushes.
+   *
+   * The `.push-type.liveactivity` suffix is mandatory and is why the signing key
+   * must be Team Scoped (All Topics) — a key scoped to the bundle id alone
+   * cannot sign this topic.
+   */
+  get topic() {
+    return `${this.creds.bundleId}.push-type.liveactivity`;
+  }
+  /**
+   * Mint or reuse the provider JWT.
+   *
+   * ES256 over the p8 key. Cached until shortly before expiry: Apple rejects a
+   * token older than an hour, but minting one per request is wasteful and can
+   * trip APNs' provider-token-update throttle.
+   */
+  getJwt(now = Date.now()) {
+    const nowSeconds = Math.floor(now / 1e3);
+    if (this.cachedJwt && this.cachedJwt.expiresAt > nowSeconds + 60) {
+      return this.cachedJwt.token;
+    }
+    const header = base64url(JSON.stringify({ alg: "ES256", kid: this.creds.keyId, typ: "JWT" }));
+    const payload = base64url(JSON.stringify({ iss: this.creds.teamId, iat: nowSeconds }));
+    const signingInput = `${header}.${payload}`;
+    const signature = createSign("SHA256").update(signingInput).sign({ key: this.creds.key, dsaEncoding: "ieee-p1363" });
+    const token = `${signingInput}.${base64url(signature)}`;
+    this.cachedJwt = { token, expiresAt: nowSeconds + JWT_TTL_SECONDS };
+    return token;
+  }
+  /**
+   * Reuse one HTTP/2 session across sends.
+   *
+   * APNs expects a long-lived connection; a fresh TLS handshake per push is slow
+   * and Apple treats connection churn as abuse.
+   */
+  getSession() {
+    if (this.session && !this.session.closed && !this.session.destroyed) {
+      return this.session;
+    }
+    const session = connect(`https://${this.creds.host}`);
+    session.on("error", (err) => {
+      log3.warn("apns.session_error", { event: "apns.session_error", err: String(err) });
+    });
+    this.session = session;
+    return session;
+  }
+  /**
+   * Send one push.
+   *
+   * Resolves with a result rather than rejecting on an APNs rejection: a
+   * rejected push is an expected outcome the caller must act on (retire the
+   * token), not an exception. Only a genuinely unexpected local failure throws,
+   * and the caller logs it.
+   */
+  async send(args) {
+    const body = Buffer.from(JSON.stringify(args.payload), "utf-8");
+    if (body.byteLength > APNS_MAX_PAYLOAD_BYTES) {
+      throw new Error(
+        `APNs payload is ${body.byteLength} bytes, over the ${APNS_MAX_PAYLOAD_BYTES} byte limit`
+      );
+    }
+    const session = this.getSession();
+    const headers = {
+      [constants.HTTP2_HEADER_METHOD]: "POST",
+      [constants.HTTP2_HEADER_PATH]: `/3/device/${args.deviceToken}`,
+      [constants.HTTP2_HEADER_AUTHORIZATION]: `bearer ${this.getJwt()}`,
+      "apns-push-type": "liveactivity",
+      "apns-topic": this.topic,
+      "apns-priority": String(args.priority ?? 10),
+      ...args.expirationSeconds != null && {
+        "apns-expiration": String(args.expirationSeconds)
+      },
+      [constants.HTTP2_HEADER_CONTENT_TYPE]: "application/json",
+      [constants.HTTP2_HEADER_CONTENT_LENGTH]: String(body.byteLength)
+    };
+    return new Promise((resolve2, reject) => {
+      const req = session.request(headers);
+      req.setTimeout(args.timeoutMs ?? 1e4, () => {
+        req.close(constants.NGHTTP2_CANCEL);
+        resolve2({ ok: false, status: 0, reason: "Timeout", tokenDead: false });
+      });
+      let status = 0;
+      req.on("response", (resHeaders) => {
+        status = Number(resHeaders[constants.HTTP2_HEADER_STATUS] ?? 0);
+      });
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("error", reject);
+      req.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf-8");
+        let reason;
+        if (raw.length > 0) {
+          try {
+            reason = JSON.parse(raw).reason;
+          } catch {
+            reason = raw.slice(0, 200);
+          }
+        }
+        resolve2({
+          ok: status === 200,
+          status,
+          reason,
+          tokenDead: reason != null && DEAD_TOKEN_REASONS.has(reason)
+        });
+      });
+      req.end(body);
+    });
+  }
+  /** Close the shared connection. Called on server shutdown. */
+  close() {
+    this.session?.close();
+    this.session = null;
+  }
+};
+
+// src/services/push/liveActivityContentState.ts
+var LAST_OUTPUT_MAX_LENGTH = 90;
+function toLiveActivityStatus(status) {
+  return status === "running" || status === "waiting_input" ? status : null;
+}
+function truncateLastOutput(raw) {
+  const oneLine = raw.replace(/\s+/g, " ").trim();
+  return oneLine.length <= LAST_OUTPUT_MAX_LENGTH ? oneLine : oneLine.slice(0, LAST_OUTPUT_MAX_LENGTH);
+}
+
+// src/services/push/liveActivityNotifier.ts
+var log4 = getLogger("live-activity");
+function contentStateForSession(args) {
+  const status = toLiveActivityStatus(args.session.status);
+  if (!status) return null;
+  return {
+    sessionId: args.session.id,
+    serverId: args.serverId,
+    projectName: args.session.projectName,
+    status,
+    startedAt: args.startedAtOverride ?? args.session.startedAt.getTime(),
+    lastOutput: truncateLastOutput(args.session.lastOutput ?? ""),
+    ...args.serverLabel != null && { serverLabel: args.serverLabel }
+  };
+}
+var LiveActivityNotifier = class {
+  constructor(sender, serverId, serverLabel) {
+    this.sender = sender;
+    this.serverId = serverId;
+    this.serverLabel = serverLabel;
+  }
+  sender;
+  serverId;
+  serverLabel;
+  /**
+   * Last status pushed per session.
+   *
+   * Live Activity pushes are rate-limited by iOS and the surface only renders
+   * `running` vs `waiting_input`, so re-pushing an unchanged status is pure
+   * budget spend for no visible change. This is what makes the notifier
+   * edge-triggered rather than level-triggered.
+   */
+  lastPushed = /* @__PURE__ */ new Map();
+  /**
+   * React to a session status change.
+   *
+   * Fire-and-forget by design: a push must never delay or fail a session
+   * transition, so this returns a promise the caller may ignore and every error
+   * is logged rather than propagated.
+   */
+  async onStatusChange(session) {
+    const status = toLiveActivityStatus(session.status);
+    try {
+      if (!status) {
+        await this.endFor(session);
+        return;
+      }
+      if (this.lastPushed.get(session.id) === status) return;
+      const contentState = contentStateForSession({
+        session,
+        serverId: this.serverId,
+        serverLabel: this.serverLabel
+      });
+      if (!contentState) return;
+      const outcome = await this.sender.send({
+        sessionId: session.id,
+        event: "update",
+        contentState
+      });
+      this.lastPushed.set(session.id, status);
+      if (outcome.attempted > 0) {
+        log4.info("live_activity.updated", {
+          event: "live_activity.updated",
+          sessionId: session.id,
+          status,
+          ...outcome
+        });
+      }
+    } catch (err) {
+      log4.error("live_activity.notify_failed", {
+        event: "live_activity.notify_failed",
+        sessionId: session.id,
+        status: session.status,
+        err: String(err)
+      });
+    }
+  }
+  async endFor(session) {
+    const lastStatus = this.lastPushed.get(session.id);
+    this.lastPushed.delete(session.id);
+    const contentState = contentStateForSession({
+      session: {
+        ...session,
+        status: lastStatus === "waiting_input" ? "waiting_input" : "running"
+      },
+      serverId: this.serverId,
+      serverLabel: this.serverLabel
+    });
+    if (!contentState) return;
+    const outcome = await this.sender.end({ sessionId: session.id, contentState });
+    if (outcome.attempted > 0) {
+      log4.info("live_activity.ended", {
+        event: "live_activity.ended",
+        sessionId: session.id,
+        ...outcome
+      });
+    }
+  }
+  /** Drop cached state for a session, so a resume re-pushes its first status. */
+  forget(sessionId) {
+    this.lastPushed.delete(sessionId);
+  }
+};
+
+// src/services/push/liveActivitySender.ts
+var log5 = getLogger("live-activity");
+var ACTIVITY_MAX_LIFETIME_MS = 8 * 60 * 60 * 1e3;
+function buildActivityKitPayload(args) {
+  return {
+    aps: {
+      timestamp: Math.floor(args.now / 1e3),
+      event: args.event,
+      "content-state": args.contentState,
+      ...args.staleDate != null && { "stale-date": Math.floor(args.staleDate / 1e3) },
+      ...args.dismissalDate != null && {
+        "dismissal-date": Math.floor(args.dismissalDate / 1e3)
+      }
+    }
+  };
+}
+var LiveActivitySender = class {
+  constructor(apns, repo) {
+    this.apns = apns;
+    this.repo = repo;
+  }
+  apns;
+  repo;
+  /**
+   * Push to every live activity of a session.
+   *
+   * Sends are independent: one rejected token must not stop the others, because
+   * a single dead device would otherwise silence every other device watching the
+   * same session.
+   */
+  async send(args) {
+    const now = args.now ?? Date.now();
+    return this.sendToTokens({
+      tokens: this.repo.listForSession("liveactivity_update", args.sessionId, now),
+      sessionId: args.sessionId,
+      event: args.event,
+      contentState: args.contentState,
+      now,
+      priority: args.priority
+    });
+  }
+  /**
+   * Push to an explicit token list.
+   *
+   * Renewal needs this: a replacement activity does not exist yet, so it is
+   * started via the app-wide push-to-start token rather than any per-session
+   * lookup. Shares one fan-out body with `send()` so failure handling cannot
+   * drift between the two paths.
+   */
+  async sendToTokens(args) {
+    const now = args.now ?? Date.now();
+    const tokens = args.tokens;
+    const outcome = {
+      attempted: tokens.length,
+      succeeded: 0,
+      retired: 0
+    };
+    if (tokens.length === 0) return outcome;
+    const results = await Promise.all(
+      tokens.map(
+        (row) => this.sendToToken(row, args.event, args.contentState, now, args.priority, args.staleDate)
+      )
+    );
+    for (const { row, result, error } of results) {
+      if (error) {
+        log5.error("live_activity.send_failed", {
+          event: "live_activity.send_failed",
+          sessionId: args.sessionId,
+          activityId: row.activity_id,
+          apnsEvent: args.event,
+          err: String(error)
+        });
+        this.repo.recordFailure(row.token, "SendError", now);
+        continue;
+      }
+      if (!result) continue;
+      if (result.ok) {
+        this.repo.recordSuccess(row.token, now);
+        outcome.succeeded += 1;
+        continue;
+      }
+      this.repo.recordFailure(row.token, result.reason ?? `HTTP_${result.status}`, now);
+      if (result.tokenDead) {
+        this.repo.expire(row.token, now);
+        outcome.retired += 1;
+      }
+      log5.warn("live_activity.send_rejected", {
+        event: "live_activity.send_rejected",
+        sessionId: args.sessionId,
+        activityId: row.activity_id,
+        apnsEvent: args.event,
+        status: result.status,
+        reason: result.reason,
+        tokenDead: result.tokenDead
+      });
+    }
+    return outcome;
+  }
+  /**
+   * End every live activity for a session and stop tracking them.
+   *
+   * Expiring locally is what stops the renewal sweep from later resurrecting an
+   * activity for a session that has already finished.
+   */
+  async end(args) {
+    const now = args.now ?? Date.now();
+    const outcome = await this.send({
+      sessionId: args.sessionId,
+      event: "end",
+      contentState: args.contentState,
+      now
+    });
+    this.repo.expireSessionActivities(args.sessionId, now);
+    return outcome;
+  }
+  async sendToToken(row, event, contentState, now, priority, staleDateOverride) {
+    const staleDate = event === "update" ? staleDateOverride ?? row.stale_date ?? contentState.startedAt + ACTIVITY_MAX_LIFETIME_MS : null;
+    try {
+      const result = await this.apns.send({
+        deviceToken: row.token,
+        payload: buildActivityKitPayload({ event, contentState, now, staleDate }),
+        priority
+      });
+      return { row, result };
+    } catch (error) {
+      return { row, error };
+    }
+  }
+};
+
+// src/services/push/liveActivityRenewal.ts
+var log6 = getLogger("live-activity");
+var RENEWAL_LEAD_MS = 30 * 60 * 1e3;
+var MAX_TIMER_MS = 60 * 60 * 1e3;
+function renewalDueAt(row) {
+  return row.stale_date == null ? null : row.stale_date - RENEWAL_LEAD_MS;
+}
+var LiveActivityRenewalScheduler = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? (() => Date.now());
+  }
+  deps;
+  timer = null;
+  stopped = false;
+  now;
+  /**
+   * Arm the scheduler from persisted state.
+   *
+   * Called on boot, which is what makes a renewal survive a restart: the
+   * deadlines were never in memory to begin with.
+   */
+  start() {
+    this.stopped = false;
+    void this.tick();
   }
-  try {
-    for (const ent of readdirSync5(projectsDir, { withFileTypes: true })) {
-      if (!ent.isDirectory()) continue;
-      try {
-        const childMs = statSync7(join16(projectsDir, ent.name)).mtimeMs;
-        if (childMs > maxMs) maxMs = childMs;
-      } catch {
+  stop() {
+    this.stopped = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * Renew everything due, then sleep until the next deadline.
+   *
+   * Re-reads from the DB every tick rather than caching a schedule in memory, so
+   * an activity registered after boot is picked up without re-arming anything.
+   */
+  async tick() {
+    if (this.stopped) return;
+    const now = this.now();
+    try {
+      for (const row of this.deps.repo.listRenewable()) {
+        const dueAt = renewalDueAt(row);
+        if (dueAt == null || dueAt > now) continue;
+        await this.renew(row, now);
       }
+    } catch (err) {
+      log6.error("live_activity.renewal_sweep_failed", {
+        event: "live_activity.renewal_sweep_failed",
+        err: String(err)
+      });
     }
-  } catch {
+    this.scheduleNext();
   }
-  return maxMs;
-}
-function shouldRefreshProjectsFromHdd(conversationsRepo, cacheMetadataRepo, opts = {}) {
-  if (conversationsRepo.hasOrphanRows()) return true;
-  const dirs = /* @__PURE__ */ new Set();
-  if (opts.projectsDirs) {
-    for (const d of opts.projectsDirs) dirs.add(d);
+  scheduleNext() {
+    if (this.stopped) return;
+    const now = this.now();
+    const pending = this.deps.repo.listRenewable().map(renewalDueAt).filter((d) => d != null);
+    const nextDue = pending.length > 0 ? Math.min(...pending) : now + MAX_TIMER_MS;
+    const delay = Math.min(Math.max(nextDue - now, 0), MAX_TIMER_MS);
+    this.timer = setTimeout(() => void this.tick(), delay);
+    this.timer.unref?.();
   }
-  dirs.add(opts.projectsDir ?? DEFAULT_PROJECTS_DIR);
-  let newestMs = null;
-  for (const dir of dirs) {
-    const ms = maxProjectsTreeMtimeMs(dir);
-    if (ms === null) continue;
-    if (newestMs === null || ms > newestMs) newestMs = ms;
+  /**
+   * Renew one activity.
+   *
+   * Claims first: `claimRenewal()` succeeds exactly once per row, so a timer
+   * re-armed after a restart mid-window cannot send a second time.
+   */
+  async renew(row, now) {
+    if (!row.session_id) return;
+    const session = this.deps.sessionStore.getManaged(row.session_id);
+    const status = session ? toLiveActivityStatus(session.status) : null;
+    if (!session || !status) {
+      this.deps.repo.claimRenewal(row.token, now);
+      this.deps.repo.expire(row.token, now);
+      log6.info("live_activity.renewal_skipped", {
+        event: "live_activity.renewal_skipped",
+        sessionId: row.session_id,
+        activityId: row.activity_id,
+        reason: session ? `status_${session.status}` : "session_gone"
+      });
+      return;
+    }
+    if (!this.deps.repo.claimRenewal(row.token, now)) {
+      return;
+    }
+    const startedAt = row.started_at ?? session.startedAt.getTime();
+    const contentState = {
+      sessionId: session.id,
+      serverId: this.deps.serverId,
+      projectName: session.projectName,
+      status,
+      startedAt,
+      lastOutput: session.lastOutput ?? "",
+      ...this.deps.serverLabel != null && { serverLabel: this.deps.serverLabel }
+    };
+    try {
+      await this.deps.sender.send({
+        sessionId: session.id,
+        event: "end",
+        contentState: { ...contentState, lastOutput: truncateLastOutput(contentState.lastOutput) },
+        now
+      });
+      this.deps.repo.expire(row.token, now);
+      const started = await this.startReplacement({
+        sessionId: session.id,
+        startedAt,
+        now
+      });
+      log6.info("live_activity.renewed", {
+        event: "live_activity.renewed",
+        sessionId: session.id,
+        activityId: row.activity_id,
+        // Logged because a regression here is invisible on the server and only
+        // shows up as a reset timer on someone's Lock Screen.
+        startedAt,
+        replacementRequested: started
+      });
+    } catch (err) {
+      log6.error("live_activity.renewal_failed", {
+        event: "live_activity.renewal_failed",
+        sessionId: session.id,
+        activityId: row.activity_id,
+        err: String(err)
+      });
+    }
   }
-  if (newestMs === null) return false;
-  const lastIndexedIso = getCacheMetadata(cacheMetadataRepo, "conversations_last_indexed_at");
-  if (!lastIndexedIso) return true;
-  const lastIndexedMs = Date.parse(lastIndexedIso);
-  if (Number.isNaN(lastIndexedMs)) return true;
-  return newestMs > lastIndexedMs;
-}
-
-// src/services/projectChats/deriveProjectChatTitle.ts
-function deriveProjectChatTitle(input) {
-  const trimmed = input.title?.trim();
-  if (trimmed) return trimmed;
-  const name = input.projectName?.trim();
-  if (name) return name;
-  const pathSuffix = input.projectPath ? input.projectPath.split(/[/\\]/).filter(Boolean).slice(-2).join("/") : "";
-  if (pathSuffix) return pathSuffix;
-  return `Untitled \xB7 ${input.id.slice(0, 8)}`;
-}
+  /**
+   * Ask the device to start a replacement activity.
+   *
+   * Uses the app-wide push-to-start token, because the replacement does not
+   * exist yet and therefore has no per-activity token. Returns false when the
+   * device never registered one, which is not an error: the app simply cannot be
+   * asked to start an activity remotely, and the next foreground WS update
+   * recreates it.
+   */
+  async startReplacement(args) {
+    const starters = this.deps.repo.listByKind("liveactivity_start", args.now);
+    if (starters.length === 0) return false;
+    const session = this.deps.sessionStore.getManaged(args.sessionId);
+    const status = session ? toLiveActivityStatus(session.status) : null;
+    if (!session || !status) return false;
+    await this.deps.sender.sendToTokens({
+      tokens: starters,
+      event: "update",
+      sessionId: args.sessionId,
+      contentState: {
+        sessionId: session.id,
+        serverId: this.deps.serverId,
+        projectName: session.projectName,
+        status,
+        // Carried through unchanged — the whole point of the renewal.
+        startedAt: args.startedAt,
+        lastOutput: truncateLastOutput(session.lastOutput ?? ""),
+        ...this.deps.serverLabel != null && { serverLabel: this.deps.serverLabel }
+      },
+      now: args.now,
+      staleDate: args.startedAt + ACTIVITY_MAX_LIFETIME_MS
+    });
+    return true;
+  }
+};
 
 // src/services/questions/parseStatusLine.ts
 var MODEL_RE = /(Opus|Sonnet|Haiku|Fable)\s+[\d.]+(?:\s*\([^)]*\))?/;
@@ -6311,6 +8083,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();
@@ -6450,6 +8328,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",
@@ -6473,6 +8359,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 && {
@@ -6494,6 +8387,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,
@@ -6508,7 +8407,7 @@ function discoveredToResponse(d, conversationId) {
 }
 
 // src/uploads.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes4 } from "crypto";
 import { mkdir as mkdir3, writeFile } from "fs/promises";
 import heicConvert from "heic-convert";
 import { join as join17 } from "path";
@@ -6542,7 +8441,7 @@ async function saveUploadFile(input) {
     mimeType = "image/jpeg";
     originalName = originalName.replace(/\.(heic|heif)$/i, ".jpg");
   }
-  const id = `up_${randomBytes3(8).toString("hex")}`;
+  const id = `up_${randomBytes4(8).toString("hex")}`;
   const safeName = sanitizeFilename(originalName) || `file${MIME_TO_EXT[mimeType] ?? ""}`;
   const dir = join17(input.projectPath, UPLOAD_DIR_NAME, input.sessionId);
   await mkdir3(dir, { recursive: true });
@@ -6576,21 +8475,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({
@@ -6646,13 +8570,13 @@ function hashPrefix(text) {
 }
 
 // src/utils/conversationEtag.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function computeConversationEtag({
   filePath,
   messageCount,
   timestamp: timestamp2
 }) {
-  const digest = createHash3("sha1").update(`${filePath}:${messageCount}:${timestamp2}`).digest("hex").slice(0, 16);
+  const digest = createHash4("sha1").update(`${filePath}:${messageCount}:${timestamp2}`).digest("hex").slice(0, 16);
   return `"${digest}"`;
 }
 
@@ -6795,6 +8719,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;
@@ -6913,9 +8839,25 @@ var StreamerServer = class {
   sessionInputAttempts = /* @__PURE__ */ new Map();
   ptyGracePeriodMs;
   defaultSystemPrompt;
+  // Resolved once at boot; see src/feature-flags.ts. Total map — every registry
+  // id is present, so indexing it never yields undefined.
+  featureFlags;
+  // Derived from featureFlags.codexSystemPrompt. Kept as its own field so the
+  // read site in startFresh() is unchanged.
+  codexSystemPromptEnabled;
   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
@@ -6923,6 +8865,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
@@ -6932,7 +8886,26 @@ 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 = randomUUID5();
   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;
+  // Live Activity push (Feature 12). Null when APNS_KEY is unset — the ordinary
+  // case on a dev machine and in CI, where the feature is simply off. Missing an
+  // optional push credential must never stop the server from booting.
+  apnsClient = null;
+  liveActivityNotifier = null;
+  liveActivityRenewal = null;
   discoveryCache = null;
   cacheDir;
   tailSize;
@@ -6968,9 +8941,17 @@ var StreamerServer = class {
     this.codexRoots = config.codexRoots ?? [join18(homedir9(), ".codex", "sessions")];
     this.ptyGracePeriodMs = config.ptyGracePeriodMs ?? DEFAULT_PTY_GRACE_PERIOD_MS;
     this.defaultSystemPrompt = config.defaultSystemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.featureFlags = resolveFeatureFlags({ cli: config.featureFlags, yaml: loadFeatureFlags() });
+    if (config.codexSystemPromptEnabled !== void 0) {
+      this.featureFlags.codexSystemPrompt = config.codexSystemPromptEnabled;
+    }
+    this.codexSystemPromptEnabled = this.featureFlags.codexSystemPrompt;
     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() ?? join18(homedir9(), ".threadbase", "cache");
     this.tailSize = config.tailSize ?? loadTailSize() ?? 10;
     this.directoryDebounceMs = parseDirScanDebounceEnv(process.env.THREADBASE_DIR_SCAN_DEBOUNCE_MS) ?? config.directoryScanDebounceMs ?? 1e3;
@@ -6980,6 +8961,13 @@ var StreamerServer = class {
     }, this.directoryDebounceMs);
     this.includeAgents = parseIncludeAgentsEnv(process.env.THREADBASE_INCLUDE_AGENTS);
     this.agentEntrypoints = parseAgentEntrypointsEnv(process.env.THREADBASE_AGENT_ENTRYPOINTS);
+    const enabledFlags = nonDefaultFeatureFlags(this.featureFlags);
+    if (enabledFlags.length > 0) {
+      this.log.info(`Feature flags active: ${enabledFlags.join(", ")}`, {
+        event: "config.feature_flags_active",
+        flags: enabledFlags
+      });
+    }
     const rawRoot = process.env.THREADBASE_BROWSE_ROOT ?? loadBrowseRoot() ?? config.browseRoot;
     if (rawRoot) {
       realpath2(rawRoot).then((resolved) => {
@@ -7095,6 +9083,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) => {
@@ -7123,6 +9112,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) {
@@ -7161,6 +9161,7 @@ var StreamerServer = class {
         if (resp) {
           this.wsHub.broadcast({ type: "session_update", session: resp });
         }
+        void this.liveActivityNotifier?.onStatusChange(session);
         this.sessionStatusBus.emit(`status:${session.id}`, session.status);
       }
     });
@@ -7194,6 +9195,9 @@ var StreamerServer = class {
       localNoAuth: this.localNoAuth,
       logMenubarRequests: this.logMenubarRequests,
       rotateApiKey: () => this.rotateApiKey(),
+      claudeFlagsConfig: () => this.getClaudeFlagsConfig(),
+      featureFlagsConfig: () => this.getFeatureFlagsConfig(),
+      setClaudeFlagsConfig: (values, extraArgs) => this.setClaudeFlagsConfig(values, extraArgs),
       publicUrl: this.publicUrl,
       browseRoot: this.browseRoot,
       browserCors: this.browserCors,
@@ -7202,6 +9206,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,
@@ -7235,7 +9241,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" }));
@@ -7311,11 +9319,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,
@@ -7378,7 +9383,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);
@@ -7386,6 +9391,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) {
@@ -7400,6 +9428,216 @@ var StreamerServer = class {
     }
     this.ptyGraceDeferCounts.delete(sessionId);
   }
+  /**
+   * Bring up Live Activity push, if credentials are present (Feature 12).
+   *
+   * APNS_KEY absent is the ordinary case on a dev machine and in CI, so this
+   * logs once at info and leaves the feature off rather than failing: the server
+   * must not refuse to boot over a missing optional push credential.
+   *
+   * The key is read from the environment as PEM contents and never from a path
+   * on disk; neither it nor any device token is ever logged.
+   */
+  initLiveActivityPush(pushRepo) {
+    const creds = readApnsCredentialsFromEnv();
+    if (!creds) {
+      const why = describeMissingApnsCredentials();
+      if (why) this.log.info(why, { event: "live_activity.disabled" });
+      return;
+    }
+    this.apnsClient = new ApnsClient(creds);
+    const sender = new LiveActivitySender(this.apnsClient, pushRepo);
+    const serverId = process.env.THREADBASE_INSTANCE_ID ?? hostname2();
+    this.liveActivityNotifier = new LiveActivityNotifier(sender, serverId, hostname2());
+    this.liveActivityRenewal = new LiveActivityRenewalScheduler({
+      repo: pushRepo,
+      sender,
+      sessionStore: this.sessionStore,
+      serverId,
+      serverLabel: hostname2()
+    });
+    this.liveActivityRenewal.start();
+    this.log.info("Live Activity push enabled", {
+      event: "live_activity.enabled",
+      host: creds.host,
+      topic: `${creds.bundleId}.push-type.liveactivity`
+    });
+  }
+  /**
+   * 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);
@@ -7494,6 +9732,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}`, {
@@ -7527,7 +9767,12 @@ 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.initLiveActivityPush(this.pushRepo);
           this.cacheMonitor = new CacheIntegrityMonitor(
             this.cache,
             this.wsHub,
@@ -7745,6 +9990,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()));
@@ -7756,6 +10007,8 @@ var StreamerServer = class {
     this.externalTails.clear();
     this.wsHub.dispose();
     this.pairTokens.dispose();
+    this.liveActivityRenewal?.stop();
+    this.apnsClient?.close();
     if (this.dbPool) {
       await this.dbPool.end();
     }
@@ -7827,19 +10080,34 @@ var StreamerServer = class {
       json(res, 400, { error: message });
       return;
     }
-    const { hostname: hostname2 } = __require("os");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     this.log.info(`[pair] token exchanged from ${ip} at ${ts}`, {
       event: "pair.token_exchanged",
       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() {
@@ -7856,6 +10124,58 @@ var StreamerServer = class {
     });
     return { newKey, persisted };
   }
+  /**
+   * The registry ships with the values so a client renders the list from one
+   * round-trip, same as getClaudeFlagsConfig().
+   *
+   * Deliberately no `persisted` field: unlike claude-flags there is no PUT, and
+   * the absence of that field is the signal that this endpoint is read-only.
+   */
+  getFeatureFlagsConfig() {
+    return { registry: FEATURE_FLAGS, values: this.featureFlags };
+  }
+  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);
@@ -8873,7 +11193,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);
@@ -8883,7 +11209,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") {
@@ -8900,6 +11226,9 @@ var StreamerServer = class {
       if (!existsSync10(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);
@@ -8997,10 +11326,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);
@@ -9073,6 +11405,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);
@@ -9080,7 +11430,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 });
@@ -9118,7 +11470,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 });
@@ -9423,10 +11777,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",
@@ -9489,17 +11846,21 @@ var StreamerServer = class {
       BROWSE_SYSTEM_PROMPT(this.browseRoot),
       typeof clientPrompt === "string" ? clientPrompt : null
     ].filter(Boolean);
+    const includeSystemPrompt = provider !== CODEX_CLI_PROVIDER || this.codexSystemPromptEnabled;
     try {
       const session = await this.ptyManager.startFresh({
         provider,
         projectPath: resolvedPath,
         projectName: body.projectName,
-        systemPrompt: systemPromptParts.join("\n"),
+        ...includeSystemPrompt && { 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") {
@@ -10020,6 +12381,7 @@ export {
   SessionStore,
   StreamerServer,
   WSHub,
+  confidenceForSource,
   createAgentClient,
   createConversationWriter,
   createPool,