frizz-server 0.15.4 → 0.15.5

package/dist/dev-child.js

@@ -14782,6 +14782,11 @@ ${ANSWER_CONTINUATION_INDENT}`);
        *  same card and the swap is invisible. Absent whenever there is nothing in flight, which is almost
        *  always — it exists for the seconds between the human sending and the worker being handed it. */
       answersInFlight: external_exports.string().optional(),
+      /** The human's message — a follow-up or a registered answer — is on its way to the worker and the turn
+       *  has not started yet (board.deriveDeliveryInFlight). The queue has already let the thread go; this
+       *  tells the rail to draw it as working in every tab, not only the one that sent it (web
+       *  lib/steering.ts). Absent otherwise. */
+      deliveryInFlight: external_exports.boolean().optional(),
       // ISO8601 of the newest REAL user interaction (answer/steer/dispatch) — the chronological listing
       // sort key. Optional; the listing falls back to spawnedAt when absent (a dispatch IS an interaction).
       lastUserAt: external_exports.string().optional(),
@@ -23755,6 +23760,7 @@ var init_tail_cache = __esm({
 // packages/server/src/tailer.ts
 import { statSync as statSync8, openSync as openSync10, readSync as readSync4, closeSync as closeSync9, readdirSync as readdirSync5, realpathSync as realpathSync5, mkdirSync as mkdirSync10, writeFileSync as writeFileSync8, readFileSync as readFileSync12, existsSync as existsSync5 } from "node:fs";
 import { execFile as execFile2 } from "node:child_process";
+import { createHash as createHash7 } from "node:crypto";
 import { promisify as promisify2 } from "node:util";
 import { basename as basename4, join as join18, win32 } from "node:path";
 import { homedir as homedir7 } from "node:os";
@@ -23991,7 +23997,7 @@ function trackDispatches(state, rec) {
       state.subAgents.set(id, { kind: "agent", toolUseId: id, label: desc ?? "sub-agent", startedAt, subagentType, outputFile });
     } else if (b.name === "Bash" && input.run_in_background === true || b.name === "Monitor") {
       const command = typeof input.command === "string" ? input.command : previous?.command;
-      state.subAgents.set(id, { kind: "shell", toolUseId: id, label: desc ?? shellSummary(input.command), startedAt, command, outputFile, taskId: previous?.taskId });
+      state.subAgents.set(id, { kind: "shell", toolUseId: id, label: desc ?? shellSummary(input.command), startedAt, command, outputFile, taskId: previous?.taskId, ...b.name === "Monitor" ? { monitor: true } : {} });
     } else if (b.name === "Bash") {
       const pending = state.pendingShells ??= /* @__PURE__ */ new Map();
       pending.set(id, { label: desc ?? shellSummary(input.command), command: typeof input.command === "string" ? input.command : void 0, startedAt });
@@ -24062,6 +24068,22 @@ function findLiveByTaskId(state, taskId) {
   for (const e14 of state.subAgents.values()) if (e14.taskId === taskId) return e14;
   return void 0;
 }
+function knowsDirectOp(state, taskId) {
+  if (findLiveByTaskId(state, taskId)) return true;
+  for (const r of state.retiredSubAgents.values()) if (r.taskId === taskId) return true;
+  for (const r of state.retiredShells.values()) if (r.taskId === taskId) return true;
+  return false;
+}
+function rememberFoldedTerminal(state, taskId, fingerprint) {
+  const seen = state.foldedTerminals ??= /* @__PURE__ */ new Map();
+  seen.delete(taskId);
+  seen.set(taskId, fingerprint);
+  while (seen.size > FOLDED_TERMINALS_MAX) {
+    const oldest = seen.keys().next().value;
+    if (oldest === void 0) break;
+    seen.delete(oldest);
+  }
+}
 function launchOutputFile(state, text2) {
   const m = text2.match(/output_file:\s*(\S+)/) ?? text2.match(/Output is being written to:\s*(\S+)/);
   if (m) return m[1].replace(/\.$/, "");
@@ -24227,14 +24249,21 @@ function trackCompletions(state, rec) {
     const monitorTimedOut = block.includes("<event>[Monitor timed out");
     const terminal = status === "completed" || status === "failed" || status === "killed" ? status : status === "stopped" || monitorTimedOut ? "killed" : void 0;
     if (!terminal) continue;
+    const fingerprint = createHash7("sha1").update(block).digest("hex").slice(0, 16);
+    const repeatOf = /* @__PURE__ */ new Set();
+    for (const id of blockTaskIds(block)) {
+      if (state.foldedTerminals?.get(id) === fingerprint) repeatOf.add(id);
+      else if (knowsDirectOp(state, id)) rememberFoldedTerminal(state, id, fingerprint);
+    }
     const doomed = /* @__PURE__ */ new Set();
     for (const m of block.matchAll(/<tool-use-id>([^<]*)<\/tool-use-id>/g)) {
       const entry = state.subAgents.get(m[1]);
-      if (entry) doomed.add(entry);
+      if (entry && !(entry.taskId && repeatOf.has(entry.taskId))) doomed.add(entry);
     }
     const stampedAt = typeof rec.timestamp === "string" ? Date.parse(rec.timestamp) : Number.NaN;
     for (const m of block.matchAll(/<task-id>([^<]*)<\/task-id>/g)) {
       if (m[1].startsWith("__orphan_summary__")) continue;
+      if (repeatOf.has(m[1])) continue;
       const entry = findLiveByTaskId(state, m[1]);
       if (entry) doomed.add(entry);
       else if (Number.isFinite(stampedAt)) recordDescendantTerminal(state, m[1], stampedAt);
@@ -24814,7 +24843,7 @@ function createTailer(deps) {
       if (e14.kind !== "shell") continue;
       const lastActivityAt = entryLastActivity(state, e14);
       const shellState = shellIsGone(e14) ? "stale" : "running";
-      out.push({ label: e14.label, startedAt: e14.startedAt, state: shellState, id: e14.toolUseId, ...e14.taskId ? { stoppable: true, taskId: e14.taskId } : {}, ...lastActivityAt ? { lastActivityAt } : {} });
+      out.push({ label: e14.label, startedAt: e14.startedAt, state: shellState, id: e14.toolUseId, ...e14.taskId ? { stoppable: true, taskId: e14.taskId } : {}, ...lastActivityAt ? { lastActivityAt } : {}, ...e14.monitor ? { outputUnavailable: true } : {} });
     }
     return out;
   }
@@ -25998,7 +26027,7 @@ function landsAfterRead(eventAt, lastReadAt) {
   if (!Number.isFinite(e14) || !Number.isFinite(r)) return true;
   return e14 > r;
 }
-var IDLE_BACKSTOP_MS, RUNTIME_CHASE_MAX, POLL_MS2, MAX_PRIME_ROWS_PER_TICK, PRIME_BUDGET_MS, TRANSCRIPT_READ_WINDOW, EMPTY_BUFFER, MAX_POLL_MS, SUBAGENT_STALE_MS, SHELL_PROBE_TTL_MS, SHELL_PROBE_GRACE_MS, execFileAsync, FOREIGN_FRESH_MS, FOREIGN_MAX, FOREIGN_SCAN_EVERY, CACHE_FLUSH_MS, PRIME_PROGRESS_EVERY, DISCOVER_RETRY_MS, DISCOVER_RETRY_MAX_MS, RETAINED_SUBAGENTS_MAX, RETAINED_SHELLS_MAX, DESCENDANT_TERMINALS_MAX, PENDING_RESUMES_MAX, PENDING_SHELLS_MAX, RESUME_REPLAY_SLACK_MS, FIRST_USER_TEXT_MAX, QUESTION_BLOCK_RE, SIGNAL_FENCE_RE, FENCE_BODY_MAX, LOCAL_COMMAND_RECEIPT, LAUNCH_ACK_RE, AUTO_BACKGROUND_ACK_RE, DESCENDANT_SIDECAR_MAX, DESCENDANT_NOTIFY_GRACE_MS, MAX_OWNED_TOOL_USE_IDS, BROKER_LIVENESS_TTL_MS, UNRESTORED_TAIL_FIELDS;
+var IDLE_BACKSTOP_MS, RUNTIME_CHASE_MAX, POLL_MS2, MAX_PRIME_ROWS_PER_TICK, PRIME_BUDGET_MS, TRANSCRIPT_READ_WINDOW, EMPTY_BUFFER, MAX_POLL_MS, SUBAGENT_STALE_MS, SHELL_PROBE_TTL_MS, SHELL_PROBE_GRACE_MS, execFileAsync, FOREIGN_FRESH_MS, FOREIGN_MAX, FOREIGN_SCAN_EVERY, CACHE_FLUSH_MS, PRIME_PROGRESS_EVERY, DISCOVER_RETRY_MS, DISCOVER_RETRY_MAX_MS, RETAINED_SUBAGENTS_MAX, RETAINED_SHELLS_MAX, DESCENDANT_TERMINALS_MAX, PENDING_RESUMES_MAX, PENDING_SHELLS_MAX, RESUME_REPLAY_SLACK_MS, FIRST_USER_TEXT_MAX, QUESTION_BLOCK_RE, SIGNAL_FENCE_RE, FENCE_BODY_MAX, LOCAL_COMMAND_RECEIPT, LAUNCH_ACK_RE, AUTO_BACKGROUND_ACK_RE, FOLDED_TERMINALS_MAX, DESCENDANT_SIDECAR_MAX, DESCENDANT_NOTIFY_GRACE_MS, MAX_OWNED_TOOL_USE_IDS, BROKER_LIVENESS_TTL_MS, UNRESTORED_TAIL_FIELDS;
 var init_tailer = __esm({
   "packages/server/src/tailer.ts"() {
     "use strict";
@@ -26052,6 +26081,7 @@ var init_tailer = __esm({
     LOCAL_COMMAND_RECEIPT = /^<local-command-(stdout|stderr)>[\s\S]*<\/local-command-\1>$/;
     LAUNCH_ACK_RE = /^\s*(Async agent launched successfully|Spawned successfully|Command running in background|Monitor started|Command did not complete within its)/;
     AUTO_BACKGROUND_ACK_RE = /^\s*Command did not complete within its .{0,40}?and was moved to the background/;
+    FOLDED_TERMINALS_MAX = 64;
     DESCENDANT_SIDECAR_MAX = 512;
     DESCENDANT_NOTIFY_GRACE_MS = 5e3;
     MAX_OWNED_TOOL_USE_IDS = 25e3;
@@ -29148,7 +29178,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net2 = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash: createHash17 } = __require("crypto");
+    var { randomBytes, createHash: createHash18 } = __require("crypto");
     var { Duplex, Readable: Readable2 } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -29816,7 +29846,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash17("sha1").update(key + GUID).digest("base64");
+        const digest = createHash18("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -30185,7 +30215,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash: createHash17 } = __require("crypto");
+    var { createHash: createHash18 } = __require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -30492,7 +30522,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash17("sha1").update(key + GUID).digest("base64");
+        const digest = createHash18("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -30723,7 +30753,7 @@ var init_codex_mcp = __esm({
 import { spawn as spawn2 } from "node:child_process";
 import { connect } from "node:net";
 import { Agent as HttpAgent } from "node:http";
-import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID9 } from "node:crypto";
 import { existsSync as existsSync6, mkdirSync as mkdirSync11, readFileSync as readFileSync15, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "node:fs";
 import { join as join20 } from "node:path";
 import { PassThrough, Writable } from "node:stream";
@@ -30735,7 +30765,7 @@ function nativeRecordPath(stateDir, projectId) {
   return join20(nativeDir(stateDir), `${projectId}.json`);
 }
 function nativeListenSocketPath(stateDir, projectId) {
-  const key = createHash7("sha256").update(stateDir).update("\0").update(projectId).digest("hex").slice(0, 16);
+  const key = createHash8("sha256").update(stateDir).update("\0").update(projectId).digest("hex").slice(0, 16);
   return frizzIpcPath(`frizz-codex-native-${key}`);
 }
 function pidAlive2(pid) {
@@ -31003,7 +31033,7 @@ var init_codex_app_server_native = __esm({
 // packages/server/src/backend/codex-app-server-host.ts
 import { spawn as spawn3 } from "node:child_process";
 import { createConnection } from "node:net";
-import { createHash as createHash8, randomUUID as randomUUID10 } from "node:crypto";
+import { createHash as createHash9, randomUUID as randomUUID10 } from "node:crypto";
 import { existsSync as existsSync7, mkdirSync as mkdirSync12, readFileSync as readFileSync16, unlinkSync as unlinkSync3 } from "node:fs";
 import { join as join21 } from "node:path";
 import { PassThrough as PassThrough2, Writable as Writable2 } from "node:stream";
@@ -31015,7 +31045,7 @@ function recordPath(stateDir, projectId) {
   return join21(daemonDir(stateDir), `${projectId}.json`);
 }
 function codexAppServerSocketPath(stateDir, projectId) {
-  const key = createHash8("sha256").update(stateDir).update("\0").update(projectId).digest("hex").slice(0, 16);
+  const key = createHash9("sha256").update(stateDir).update("\0").update(projectId).digest("hex").slice(0, 16);
   return frizzIpcPath(`frizz-codex-${key}`);
 }
 function pidAlive3(pid) {
@@ -31312,7 +31342,7 @@ var init_codex_app_server_host = __esm({
 // packages/server/src/backend/claude-quota.ts
 import { join as join22 } from "node:path";
 import { homedir as homedir9, platform } from "node:os";
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
@@ -31419,7 +31449,7 @@ function retryAtFrom(res, now) {
   return now + Math.min(backoff, RATE_LIMIT_MAX_BACKOFF_MS);
 }
 function cachePaths(cacheDir, configDir) {
-  const profile = createHash9("sha256").update(configDir).digest("hex").slice(0, 12);
+  const profile = createHash10("sha256").update(configDir).digest("hex").slice(0, 12);
   return {
     data: join22(cacheDir, `claude-${profile}.json`),
     lock: join22(cacheDir, `claude-${profile}.lock`)
@@ -31599,15 +31629,15 @@ async function tryAcquireLock2(path3) {
   }
   return void 0;
 }
-function rateLimited(shared, now) {
-  return shared?.retryAt !== void 0 && now < shared.retryAt;
+function rateLimited(shared2, now) {
+  return shared2?.retryAt !== void 0 && now < shared2.retryAt;
 }
-function serveRateLimited(shared, now) {
-  if (shared.quota.status !== "ok" || now - shared.at >= STALE_MAX_AGE_MS) return UNAVAILABLE;
+function serveRateLimited(shared2, now) {
+  if (shared2.quota.status !== "ok" || now - shared2.at >= STALE_MAX_AGE_MS) return UNAVAILABLE;
   const minutes = (ms, round) => Math.max(1, round(ms / 6e4));
   return {
-    ...shared.quota,
-    detail: `Next refresh in ${minutes(shared.retryAt - now, Math.ceil)}m \xB7 last updated ${minutes(now - shared.at, Math.round)}m ago`
+    ...shared2.quota,
+    detail: `Next refresh in ${minutes(shared2.retryAt - now, Math.ceil)}m \xB7 last updated ${minutes(now - shared2.at, Math.round)}m ago`
   };
 }
 function refreshSharedInBackground(paths, claudeBin, deps, now) {
@@ -32028,7 +32058,7 @@ var init_codex_execution_health = __esm({
 });
 
 // packages/server/src/backend/codex-app-server.ts
-import { createHash as createHash10, randomUUID as randomUUID11 } from "node:crypto";
+import { createHash as createHash11, randomUUID as randomUUID11 } from "node:crypto";
 import { existsSync as existsSync8 } from "node:fs";
 import { StringDecoder as StringDecoder3 } from "node:string_decoder";
 function selectCodexHostKind(flagValue, platform3, hasSpawn) {
@@ -32376,7 +32406,7 @@ function canonicalJson2(value) {
   return JSON.stringify(normalize2(value));
 }
 function logicalRequestId(method, parts) {
-  const digest = createHash10("sha256").update(JSON.stringify([method, ...parts])).digest("hex");
+  const digest = createHash11("sha256").update(JSON.stringify([method, ...parts])).digest("hex");
   return `codex-${digest}`;
 }
 function requestFingerprint(value) {
@@ -32386,7 +32416,7 @@ function requestFingerprint(value) {
     delete record.startedAtMs;
     delete record.autoResolutionMs;
   }
-  return createHash10("sha256").update(canonicalJson2(normalized)).digest("hex");
+  return createHash11("sha256").update(canonicalJson2(normalized)).digest("hex");
 }
 function decision(id, semantic, label) {
   return { id, semantic, label };
@@ -32674,7 +32704,7 @@ function createCodexAppServerBridge(options) {
 function codexAppServerBridgeEnabled() {
   return true;
 }
-var CODEX_APP_SERVER_PROVIDER, CODEX_NATIVE_LISTEN_FLAG, CODEX_APP_SERVER_SUPPORTED_VERSION, CODEX_APP_SERVER_PROTOCOL_REVISION, aheadVersionWarned, PROTOCOL_FINGERPRINT, CLIENT_INFO, CLIENT_CAPABILITIES, CODEX_SANDBOX_MODES, CODEX_APPROVAL_POLICY, CODEX_DEFAULT_SANDBOX, SANDBOX_CONFIRM_TIMEOUT_MS, SANDBOX_NOOP_GRACE_MS, MAX_JSONL_BYTES, MAX_INBOUND_JSONL_BYTES, MAX_INBOUND_RECORDS, MAX_INBOUND_QUEUED_BYTES, MAX_OUTBOUND_REQUESTS, MAX_STDERR_BYTES, DEFAULT_REQUEST_TIMEOUT_MS, AUTH_REPLACEMENT_WAIT_MS, MAX_AUTH_REPLACEMENT_ATTEMPTS, BRIDGE_DB_SCHEMA_VERSION, RpcIdSchema, Opaque, SafeTimestampMs, NullableString, CommandAction, NetworkApprovalContext, FileSystemSpecialPath, FileSystemPath, FileSystemSandboxEntry, NetworkPermissions, FileSystemPermissions, RequestedPermissions, NetworkPolicyAmendment, CommandApprovalParams, FileApprovalParams, PatchChangeKind, FileUpdateChange, FileChangeItem, CommandExecutionItem, ItemStartedNotification, ItemCompletedNotification, FileChangePatchUpdatedNotification, PermissionsApprovalParams, UserInputQuestion, UserInputParams, McpBase, McpElicitationParams, ResolvedNotification, RpcProtocolError, JsonlRpcConnection, BindingRowSchema, BridgeMetaRowSchema, DISPLAY_REDACTION, UNSAFE_DISPLAY_TEXT, SECRET_NAME, commandDecisionMap, InitializeResponse, ThreadResponse, TurnResponse, TurnSteerResponse, SkillsListResponse, ThreadResumeSandbox, ThreadResumeStatus, ThreadSettingsUpdated, TurnStarted, TurnCompleted, MAX_CORRELATED_FILE_ITEMS, CODEX_APP_SERVER_TABLES, CodexAppServerBridge;
+var CODEX_APP_SERVER_PROVIDER, CODEX_NATIVE_LISTEN_FLAG, CODEX_APP_SERVER_SUPPORTED_VERSION, CODEX_APP_SERVER_PROTOCOL_REVISION, aheadVersionWarned, PROTOCOL_FINGERPRINT, CLIENT_INFO, CLIENT_CAPABILITIES, CODEX_SANDBOX_MODES, CODEX_APPROVAL_POLICY, CODEX_DEFAULT_SANDBOX, SANDBOX_CONFIRM_TIMEOUT_MS, SANDBOX_NOOP_GRACE_MS, MAX_JSONL_BYTES, MAX_INBOUND_JSONL_BYTES, MAX_INBOUND_RECORDS, MAX_INBOUND_QUEUED_BYTES, MAX_OUTBOUND_REQUESTS, MAX_STDERR_BYTES, DEFAULT_REQUEST_TIMEOUT_MS, AUTH_REPLACEMENT_WAIT_MS, MAX_AUTH_REPLACEMENT_ATTEMPTS, BRIDGE_DB_SCHEMA_VERSION, RpcIdSchema, Opaque, SafeTimestampMs, NullableString, CommandAction, NetworkApprovalContext, FileSystemSpecialPath, FileSystemPath, FileSystemSandboxEntry, NetworkPermissions, FileSystemPermissions, RequestedPermissions, NetworkPolicyAmendment, CommandApprovalParams, FileApprovalParams, PatchChangeKind, FileUpdateChange, FileChangeItem, CommandExecutionItem, BackgroundTerminalsListResponse, ItemStartedNotification, ItemCompletedNotification, FileChangePatchUpdatedNotification, PermissionsApprovalParams, UserInputQuestion, UserInputParams, McpBase, McpElicitationParams, ResolvedNotification, RpcProtocolError, JsonlRpcConnection, BindingRowSchema, BridgeMetaRowSchema, DISPLAY_REDACTION, UNSAFE_DISPLAY_TEXT, SECRET_NAME, commandDecisionMap, InitializeResponse, ThreadResponse, TurnResponse, TurnSteerResponse, SkillsListResponse, ThreadResumeSandbox, ThreadResumeStatus, ThreadSettingsUpdated, TurnStarted, TurnCompleted, MAX_CORRELATED_FILE_ITEMS, CODEX_APP_SERVER_TABLES, CodexAppServerBridge;
 var init_codex_app_server = __esm({
   "packages/server/src/backend/codex-app-server.ts"() {
     "use strict";
@@ -32845,6 +32875,13 @@ var init_codex_app_server = __esm({
       status: external_exports.string().max(64).optional(),
       exitCode: external_exports.number().nullish()
     });
+    BackgroundTerminalsListResponse = external_exports.object({
+      data: external_exports.array(external_exports.object({
+        processId: external_exports.union([external_exports.string().max(128), external_exports.number()]),
+        command: external_exports.string().max(8192).optional()
+      })).max(256),
+      nextCursor: external_exports.string().max(1024).nullish()
+    });
     ItemStartedNotification = external_exports.object({
       item: external_exports.unknown(),
       threadId: Opaque,
@@ -33296,8 +33333,9 @@ var init_codex_app_server = __esm({
       // ops-strip row it projects has no handle to address a kill with. This map is what gives a codex
       // shell row an id, and the id it gives is exactly what `backgroundTerminals/terminate` accepts.
       //
-      // A LEVEL, not an edge log: `item/started` adds, any terminal `item/*` removes, and the whole
-      // per-thread entry is dropped when the session is released or the process goes away. Nothing here is
+      // A LEVEL, not an edge log: `item/started` adds, any terminal `item/*` removes, a rejoin of the same
+      // process re-seeds it from `backgroundTerminals/list` (seedLiveExecs), and the whole per-thread entry
+      // is dropped when the session is released or the process goes away. Nothing here is
       // durable, and it must not be — a processId belongs to one app-server process, so a stale one
       // surviving a restart would offer an × that addresses a PTY that no longer exists.
       liveExecs = /* @__PURE__ */ new Map();
@@ -34186,8 +34224,11 @@ var init_codex_app_server = __esm({
               deathAt: matched?.at || void 0
             });
           }
-          await this.reconcileOwnedSessions(connection, negotiated.sameProcess);
+          const sameGeneration = attachment.reattached && negotiated.previousGeneration === attachment.generation;
+          const execThreads = sameGeneration ? [...(await this.listLiveExecs(connection, this.boundCodexThreadIds())).keys()] : [];
+          await this.reconcileOwnedSessions(connection, negotiated.sameProcess, execThreads);
           if (this.connection !== connection) throw new Error("Codex app-server disconnected during session reconciliation");
+          if (execThreads.length > 0) this.seedLiveExecs(connection, await this.listLiveExecs(connection, execThreads));
           return connection;
         } catch (error) {
           connection.close();
@@ -34229,16 +34270,27 @@ var init_codex_app_server = __esm({
        * mid-turn detached rows too; idle detached rows stay lazily rebound on next use, which keeps this
        * bounded on a board with a long history.
        *
+       * The one exception is `execThreads`: idle threads that still own a running background exec. Over
+       * the native listener subscriptions are per-connection, so an idle thread left detached never
+       * hears its exec END — the `item/completed` goes nowhere and the re-seeded row outlives the command
+       * (measured live, backend/_live_codex_bgterm_reseed.mts). Rebinding them here, exactly as the next
+       * follow-up would, is what re-subscribes this connection to them.
+       *
        * `sameProcess` says we rejoined the very app-server that owned these turns (it outlived our
        * restart inside the daemon). Then the turns are STILL RUNNING and the only correct action is to
        * re-mark the binding active and keep `current_turn_id`: issuing `thread/resume` against a live
        * turn would disturb it, and clearing the id would orphan the `turn/completed` still to come.
        */
-      async reconcileOwnedSessions(connection, sameProcess) {
+      async reconcileOwnedSessions(connection, sameProcess, execThreads = []) {
         const rows = this.scope.prepare(`
       SELECT * FROM codex_app_server_session
       WHERE project_id = @project_id AND (state = 'active' OR (state = 'detached' AND current_turn_id IS NOT NULL))
     `).all().map(checkedBindingRow);
+        for (const threadId of execThreads) {
+          if (rows.some((row2) => row2.codex_thread_id === threadId)) continue;
+          const row = this.bindingForCodexThread(threadId);
+          if (row) rows.push(row);
+        }
         const detach = (row) => {
           this.scope.prepare("UPDATE codex_app_server_session SET state = 'detached', updated_at = ? WHERE project_id = @project_id AND frizz_session_id = ?").run(this.now().toISOString(), row.frizz_session_id);
         };
@@ -34688,8 +34740,9 @@ var init_codex_app_server = __esm({
       // The live background-exec level rides the same lifecycle as the correlated file items — a released
       // session and a lost process both invalidate it — but for a different reason. A `processId` names a
       // PTY inside ONE app-server process, so a surviving entry after that process goes away would put an ×
-      // on the board that addresses a handle nothing can honour. The next connection's item stream
-      // repopulates it, exactly as the SDK's `background_tasks_changed` level does on the Claude side.
+      // on the board that addresses a handle nothing can honour. The next connection's item stream only
+      // repopulates it with execs that START after it attached; one already running when we rejoin the same
+      // process is re-learned by seedLiveExecs, because its `item/started` is never sent again.
       forgetCorrelatedFileItems(threadId, turnId) {
         if (threadId === void 0) {
           this.correlatedFileItems.clear();
@@ -34995,6 +35048,71 @@ var init_codex_app_server = __esm({
           startedAtMs: existing?.startedAtMs ?? startedAtMs ?? this.now().getTime()
         });
       }
+      // Re-learn the live background execs after rejoining an app-server we had already been talking to.
+      //
+      // The level above is folded off `item/started`, and that notification went to the client connection
+      // we just lost: the daemon queues only while NO client is attached, and the native listener queues
+      // nothing, so neither ever replays it. The exec, meanwhile, is still running in that process's PTY —
+      // so without this its row vanished from the board after every Frizz restart or dropped socket and
+      // never came back until the exec ended, taking its × with it. `thread/backgroundTerminals/list` is
+      // the app-server's own answer to "what is still running".
+      //
+      // connect() asks TWICE. The first pass goes to every bound thread, because a yielded exec outlives
+      // its turn and the thread most likely to own one is an IDLE one whose binding sat detached; it only
+      // decides which threads reconcile must rebind. The second pass, after that rebind re-subscribed this
+      // connection, is the one that seeds — so an exec that ended in between is not seeded as a row no
+      // `item/completed` will ever clear. A thread the process never loaded answers "thread not found"
+      // (measured on 0.158.0, and the list does not load it), and any failure — that, an older codex
+      // without the method — leaves the thread out, which is exactly the level it had before this existed.
+      // Nothing here throws: a board row is not worth a failed connect.
+      async listLiveExecs(connection, threadIds) {
+        const found = /* @__PURE__ */ new Map();
+        const seenAtMs = this.now().getTime();
+        await Promise.all(threadIds.map(async (threadId) => {
+          const execs = [];
+          let cursor;
+          for (let page = 0; page < 8; page++) {
+            let parsed;
+            try {
+              parsed = BackgroundTerminalsListResponse.parse(await connection.request(
+                "thread/backgroundTerminals/list",
+                cursor === void 0 ? { threadId } : { threadId, cursor }
+              ));
+            } catch {
+              return;
+            }
+            for (const terminal of parsed.data) {
+              execs.push({ processId: String(terminal.processId), command: terminal.command, startedAtMs: seenAtMs });
+            }
+            if (!parsed.nextCursor) break;
+            cursor = parsed.nextCursor;
+          }
+          if (execs.length > 0) found.set(threadId, execs);
+        }));
+        return found;
+      }
+      seedLiveExecs(connection, found) {
+        if (this.connection !== connection) return;
+        for (const [threadId, execs] of found) {
+          let byProcess = this.liveExecs.get(threadId);
+          if (!byProcess) {
+            byProcess = /* @__PURE__ */ new Map();
+            this.liveExecs.set(threadId, byProcess);
+          }
+          for (const exec of execs) {
+            if (!byProcess.has(exec.processId)) byProcess.set(exec.processId, exec);
+          }
+        }
+      }
+      boundCodexThreadIds() {
+        try {
+          return this.scope.prepare(
+            "SELECT codex_thread_id FROM codex_app_server_session WHERE project_id = @project_id"
+          ).all().map((row) => row.codex_thread_id);
+        } catch {
+          return [];
+        }
+      }
       async handleNotification(connection, method, rawParams) {
         if (method === "error") {
           const parsed = external_exports.object({ threadId: Opaque, turnId: Opaque, error: external_exports.unknown(), willRetry: external_exports.boolean() }).passthrough().safeParse(rawParams);
@@ -38166,7 +38284,7 @@ var init_claude_agent_broker_bridge = __esm({
 // packages/server/src/dispatch.ts
 import { closeSync as closeSync12, constants as constants2, existsSync as existsSync11, fstatSync as fstatSync2, lstatSync as lstatSync3, openSync as openSync13, readFileSync as readFileSync20, realpathSync as realpathSync8, statSync as statSync14, writeFileSync as writeFileSync10, mkdirSync as mkdirSync13, rmSync as rmSync9 } from "node:fs";
 import { basename as basename6, join as join30, dirname as dirname12 } from "node:path";
-import { createHash as createHash11, randomUUID as randomUUID13 } from "node:crypto";
+import { createHash as createHash12, randomUUID as randomUUID13 } from "node:crypto";
 function fallbackTitle(prompt) {
   const firstLine2 = prompt.trim().split("\n", 1)[0].trim();
   let allWords = firstLine2.split(/\s+/).filter(Boolean);
@@ -38235,7 +38353,7 @@ function resolveLegacyThreadFile(projectDir, value) {
       size: after.size,
       mtimeMs: after.mtimeMs,
       ctimeMs: after.ctimeMs,
-      digest: createHash11("sha256").update(contents).digest("hex")
+      digest: createHash12("sha256").update(contents).digest("hex")
     };
   } catch {
     return null;
@@ -39029,6 +39147,10 @@ function hasLiveBackgroundWork(tele) {
 function hasUnretiredOwnAgents(tele) {
   return Boolean(tele?.subAgents?.some((agent) => isDirectSubAgent(agent) && (agent.state === "running" || agent.state === "stale")));
 }
+function orphanedAgents(agents, ownerGone) {
+  if (!ownerGone) return agents;
+  return agents.map((agent) => agent.state === "running" ? { ...agent, state: "stale" } : agent);
+}
 function stampStoppable(agents, row) {
   if (!isBrokerClaudeRow(row)) return agents;
   return agents.map((agent) => agent.state === "running" ? { ...agent, stoppable: true } : agent);
@@ -39233,6 +39355,14 @@ function hasFreshDelivery(row, processGone) {
   if (processGone) return false;
   return parseDeliveryLedger(row.delivery_ledger).some((d) => d.state === "pending" || d.state === "enqueued" || d.state === "delivered");
 }
+function deriveDeliveryInFlight(row, runtime, needsYou, deliveryProcessGone, answerInFlight, nowMs = Date.now()) {
+  if (needsYou || runtime !== "turn-idle" && runtime !== "exited") return false;
+  if (answerInFlight) return true;
+  if (deliveryProcessGone) return false;
+  return parseDeliveryLedger(row.delivery_ledger).some(
+    (d) => (d.state === "pending" || d.state === "enqueued" || d.state === "delivered") && nowMs - Date.parse(d.at) < DELIVERY_IN_FLIGHT_SPIN_MS
+  );
+}
 function deriveNeedsYou(row, tele, runtime, hasActionableInteraction = false, nowMs = Date.now(), limitPause = void 0, excuseLiveOwnWork = true, deliveryProcessGone = false, github = {}, registeredPrWatches = /* @__PURE__ */ new Set(), armedTimerIds = /* @__PURE__ */ new Set(), armedWatches = [], openQuestions = 0, answerInFlight = false) {
   if (futureSnooze(row, nowMs)) return false;
   if (hasActionableInteraction) return true;
@@ -39432,7 +39562,9 @@ function sessionThreadView(projectDir, storage, row, rawTele, registeredLegacyTe
   const state = effectiveSessionState(row, registeredLegacyTerminal);
   const archived = state === "archived";
   const limitPause = resolveLimitPause(row, tele, nowMs);
-  const needsYou = archived ? false : deriveNeedsYou(row, tele, runtime, interactionPresence.needsUser, nowMs, limitPause, true, deliveryProcessGone, github, registeredPrWatches, armedTimerIds, armedWatches, questions.length, answerAwaitingDelivery(questionRows, rawTele?.lastUserAt, nowMs));
+  const answerInFlight = answerAwaitingDelivery(questionRows, rawTele?.lastUserAt, nowMs);
+  const needsYou = archived ? false : deriveNeedsYou(row, tele, runtime, interactionPresence.needsUser, nowMs, limitPause, true, deliveryProcessGone, github, registeredPrWatches, armedTimerIds, armedWatches, questions.length, answerInFlight);
+  const deliveryInFlight = !archived && deriveDeliveryInFlight(row, runtime, needsYou, deliveryProcessGone, answerInFlight, nowMs);
   const awaitingBackground = archived ? false : deriveAwaitingBackground(row, tele, runtime, interactionPresence.needsUser, nowMs, limitPause, deliveryProcessGone, github, registeredPrWatches, armedTimerIds, armedWatches, questions.length);
   const crashed = runtime === "exited" && (tele?.turn === "in-flight" || hasLiveBackgroundWork(tele) || headlessLostWork);
   const snoozedUntil = futureSnooze(row, nowMs);
@@ -39465,7 +39597,7 @@ function sessionThreadView(projectDir, storage, row, rawTele, registeredLegacyTe
     spawnedAt: row.spawned_at,
     lastActivityAt: tele?.lastActivityAt,
     lastAssistantAt: tele?.lastAssistantAt,
-    subAgents: stampStoppable(tele?.subAgents ?? [], row),
+    subAgents: stampStoppable(orphanedAgents(tele?.subAgents ?? [], deliveryProcessGone), row),
     bgShells: stampStoppableShells(tele?.bgShells ?? [], row),
     links: (registries.links.get(row.slug) ?? []).map(threadLinkView),
     // ONE SOURCE: the FENCE. Both kinds are derived from what the worker wrote — `prs:` entries
@@ -39477,6 +39609,7 @@ function sessionThreadView(projectDir, storage, row, rawTele, registeredLegacyTe
     pendingQuestion: tele?.pendingQuestion ?? false,
     questions,
     answersInFlight: inFlightAnswers,
+    deliveryInFlight: deliveryInFlight || void 0,
     lastUserAt: tele?.lastUserAt,
     // Runtime provider-auth rejection (claude-auth plan): only the typed category travels — the raw
     // error/provider text never leaves the server. Drives the trusted sign-in recovery card in ChatView.
@@ -39915,7 +40048,7 @@ function createBoard(project, storage, bus, tailer, bootId, deps = {}) {
     }
   };
 }
-var DEBOUNCE_MS, RECONCILE_MS, STALL_GRACE_MS, LINE_CAP, FRIZZ_WATCH_IGNORED_DIRS, DECLARED_PARK_MAX_MS, ANSWER_IN_FLIGHT_EXCUSAL_MS;
+var DEBOUNCE_MS, RECONCILE_MS, STALL_GRACE_MS, LINE_CAP, FRIZZ_WATCH_IGNORED_DIRS, DECLARED_PARK_MAX_MS, ANSWER_IN_FLIGHT_EXCUSAL_MS, DELIVERY_IN_FLIGHT_SPIN_MS;
 var init_board = __esm({
   "packages/server/src/board.ts"() {
     "use strict";
@@ -39940,6 +40073,7 @@ var init_board = __esm({
     FRIZZ_WATCH_IGNORED_DIRS = ["threads", ".session-state"];
     DECLARED_PARK_MAX_MS = 24 * 60 * 60 * 1e3;
     ANSWER_IN_FLIGHT_EXCUSAL_MS = 6e4;
+    DELIVERY_IN_FLIGHT_SPIN_MS = 6e4;
   }
 });
 
@@ -40726,7 +40860,7 @@ var init_pr_watch_noise = __esm({
 // packages/server/src/scheduler.ts
 import { execFile as execFile8 } from "node:child_process";
 import { promisify as promisify7 } from "node:util";
-import { createHash as createHash12, randomUUID as randomUUID14 } from "node:crypto";
+import { createHash as createHash13, randomUUID as randomUUID14 } from "node:crypto";
 function failureSignature(rollup) {
   const ids = [];
   for (const c of Array.isArray(rollup) ? rollup : []) {
@@ -40736,7 +40870,7 @@ function failureSignature(rollup) {
     ids.push(`${label}@${c.detailsUrl ?? c.targetUrl ?? c.completedAt ?? ""}`);
   }
   if (ids.length === 0) return "";
-  return createHash12("sha1").update(ids.sort().join("\n")).digest("hex").slice(0, 12);
+  return createHash13("sha1").update(ids.sort().join("\n")).digest("hex").slice(0, 12);
 }
 function ghPrViewArgs(ref) {
   return ["pr", "view", String(ref.number), "--repo", `${ref.owner}/${ref.repo}`, "--json", "state,mergedAt,statusCheckRollup,headRefOid,mergeable,reviewDecision"];
@@ -40824,7 +40958,7 @@ function githubWatchStatus(pr2, polledAt) {
   };
 }
 function wakeDeliveryId(slug, sessionId, fenceId) {
-  return createHash12("sha256").update(slug).update("\0").update(sessionId).update("\0").update(fenceId).digest("hex");
+  return createHash13("sha256").update(slug).update("\0").update(sessionId).update("\0").update(fenceId).digest("hex");
 }
 function limitFenceId(fault) {
   return `${LIMIT_FENCE_PREFIX}${fault.at}`;
@@ -40839,7 +40973,7 @@ function isReportFenceId(fenceId) {
   return fenceId.startsWith(`${REPORT_FENCE_PREFIX}:`);
 }
 function snoozeFenceId(until, prompt) {
-  const digest = createHash12("sha256").update(prompt).digest("hex").slice(0, 16);
+  const digest = createHash13("sha256").update(prompt).digest("hex").slice(0, 16);
   return `${SNOOZE_FENCE_PREFIX}:${until}:${digest}`;
 }
 function isSnoozeFenceId(fenceId) {
@@ -40983,7 +41117,7 @@ function isOwnWatchExpiredFenceId(fenceId) {
   return fenceId.startsWith(`${OWN_WATCH_EXPIRED_FENCE_PREFIX}:`);
 }
 function questionAnswerFenceId(ids) {
-  return `${QUESTION_ANSWER_FENCE_PREFIX}:${createHash12("sha256").update([...ids].sort().join(",")).digest("hex").slice(0, 16)}`;
+  return `${QUESTION_ANSWER_FENCE_PREFIX}:${createHash13("sha256").update([...ids].sort().join(",")).digest("hex").slice(0, 16)}`;
 }
 function isQuestionAnswerFenceId(fenceId) {
   return fenceId.startsWith(`${QUESTION_ANSWER_FENCE_PREFIX}:`);
@@ -43470,7 +43604,7 @@ var init_acp_rpc = __esm({
 // packages/server/src/backend/acp-host.ts
 import { spawn as spawn7 } from "node:child_process";
 import { createConnection as createConnection2 } from "node:net";
-import { createHash as createHash13, randomUUID as randomUUID15 } from "node:crypto";
+import { createHash as createHash14, randomUUID as randomUUID15 } from "node:crypto";
 import { existsSync as existsSync14, mkdirSync as mkdirSync15, readFileSync as readFileSync22, readdirSync as readdirSync8, unlinkSync as unlinkSync4 } from "node:fs";
 import { join as join34 } from "node:path";
 import { PassThrough as PassThrough3, Writable as Writable3 } from "node:stream";
@@ -43482,7 +43616,7 @@ function acpDaemonRecordPath(stateDir, sessionId) {
   return join34(daemonDir2(stateDir), `${sessionId}.json`);
 }
 function acpDaemonSocketPath(stateDir, sessionId) {
-  const key = createHash13("sha256").update(stateDir).update("\0").update(sessionId).digest("hex").slice(0, 16);
+  const key = createHash14("sha256").update(stateDir).update("\0").update(sessionId).digest("hex").slice(0, 16);
   return frizzIpcPath(`frizz-acp-${key}`);
 }
 function pidAlive4(pid) {
@@ -69792,9 +69926,10 @@ var init_stale_socket_sweep = __esm({
 });
 
 // packages/server/src/orphan-reaper.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
+import { execFile as execFile10 } from "node:child_process";
 import { readFileSync as readFileSync24 } from "node:fs";
 import { dirname as dirname16 } from "node:path";
+import { promisify as promisify8 } from "node:util";
 function firstTokenBasename(command) {
   const first = command.trimStart().split(/\s+/, 1)[0] ?? "";
   const slash = first.lastIndexOf("/");
@@ -69893,8 +70028,8 @@ function parseEtimeMs(etime) {
   else return 0;
   return (((days * 24 + h2) * 60 + m) * 60 + s) * 1e3;
 }
-function enumerateProcs(exec = defaultExec, opts = {}) {
-  const base = exec("ps", ["-Aww", "-o", "pid=,ppid=,etime=,command="]);
+async function enumerateProcs(exec = defaultExec, opts = {}) {
+  const base = await exec("ps", ["-Aww", "-o", "pid=,ppid=,etime=,command="]);
   const rows = [];
   const byPid = /* @__PURE__ */ new Map();
   const pids = [];
@@ -69927,7 +70062,7 @@ function enumerateProcs(exec = defaultExec, opts = {}) {
   }
   let text2;
   try {
-    text2 = exec("ps", ["-Eww", "-o", "pid=,command=", "-p", pids.join(",")]);
+    text2 = await exec("ps", ["-Eww", "-o", "pid=,command=", "-p", pids.join(",")]);
   } catch {
     return rows;
   }
@@ -69962,12 +70097,12 @@ function parseCpuTimeMs(value) {
   const ms = ((Number(d ?? 0) * 24 + Number(h2 ?? 0)) * 3600 + Number(min) * 60 + Number(s)) * 1e3;
   return Number.isFinite(ms) ? ms : 0;
 }
-function detectRunawayAux(rows, liveSlugs, exec = defaultExec, options = {}) {
+async function detectRunawayAux(rows, liveSlugs, exec = defaultExec, options = {}) {
   const minCores = options.minCores ?? 0.5;
   const minAgeMs = options.minAgeMs ?? 30 * 6e4;
   let text2;
   try {
-    text2 = exec("ps", ["-Ao", "pid=,cputime="]);
+    text2 = await exec("ps", ["-Ao", "pid=,cputime="]);
   } catch {
     return [];
   }
@@ -69994,13 +70129,13 @@ function summarizeRunaways(runaways) {
     return `orphan-reaper: thread "${slug}" is holding ~${cores.toFixed(1)} core(s) across ${list.length} background process(es), oldest ${hours}h \u2014 frizz dispatched these but does not reap a LIVE thread's work`;
   });
 }
-function sweepOrphansOnce(deps = {}) {
+async function sweepOrphansOnce(deps = {}) {
   const exec = deps.exec ?? defaultExec;
   const selfPid = deps.selfPid ?? process.pid;
   const minAgeMs = deps.minAgeMs ?? ORPHAN_MIN_AGE_MS;
   let rows;
   try {
-    rows = enumerateProcs(exec, { platform: deps.platform, readEnv: deps.readEnv });
+    rows = await enumerateProcs(exec, { platform: deps.platform, readEnv: deps.readEnv });
   } catch (error) {
     const code = error?.code;
     return { reaped: 0, deadSlugs: [], liveSlugs: [], ...code === "ENOENT" ? { unavailable: "`ps` is not on PATH" } : {} };
@@ -70008,7 +70143,7 @@ function sweepOrphansOnce(deps = {}) {
   const protectedPids = selfAndAncestors(rows, selfPid);
   const { reap, liveSlugs } = decideOrphans(rows, { minAgeMs, protectedPids });
   if (deps.log && deps.runawayReport !== false) {
-    for (const line of summarizeRunaways(detectRunawayAux(rows, new Set(liveSlugs), exec, deps.runaway))) deps.log(line);
+    for (const line of summarizeRunaways(await detectRunawayAux(rows, new Set(liveSlugs), exec, deps.runaway))) deps.log(line);
   }
   if (!reap.length) return { reaped: 0, deadSlugs: [], liveSlugs };
   const bySlug = new Map(rows.map((r) => [r.pid, r.slug]));
@@ -70033,34 +70168,60 @@ function startOrphanReaper(deps = {}) {
     };
   }
   const intervalMs = deps.intervalMs ?? ORPHAN_REAP_INTERVAL_MS;
-  const unavailable = (result) => {
-    if (!result.unavailable) return false;
-    deps.log?.(`orphan-reaper: unavailable on this machine \u2014 ${result.unavailable}; background processes a stopped thread leaves behind are not collected here`);
-    return true;
+  let stopped = false;
+  let timer = null;
+  let sweeping = false;
+  const stopSweeps = () => {
+    if (timer) clearInterval(timer);
+    timer = null;
   };
-  try {
-    if (unavailable(sweepOrphansOnce(deps))) return () => {
-    };
-  } catch {
-  }
-  const timer = setInterval(() => {
+  const sweep = async () => {
+    if (sweeping || stopped) return;
+    sweeping = true;
     try {
-      if (unavailable(sweepOrphansOnce(deps))) clearInterval(timer);
+      const result = await sweepOrphansOnce(deps);
+      if (result.unavailable && !stopped) {
+        stopped = true;
+        stopSweeps();
+        deps.log?.(`orphan-reaper: unavailable on this machine \u2014 ${result.unavailable}; background processes a stopped thread leaves behind are not collected here`);
+      }
     } catch {
+    } finally {
+      sweeping = false;
     }
-  }, intervalMs);
-  timer.unref?.();
+  };
+  void sweep().then(() => {
+    if (stopped) return;
+    timer = setInterval(() => void sweep(), intervalMs);
+    timer.unref?.();
+  });
   const socketDelay = setTimeout(sweepStaleBrokerSockets, STALE_SOCKET_SWEEP_DELAY_MS);
   socketDelay.unref?.();
   const socketTimer = setInterval(sweepStaleBrokerSockets, STALE_SOCKET_SWEEP_INTERVAL_MS);
   socketTimer.unref?.();
   return () => {
-    clearInterval(timer);
+    stopped = true;
+    stopSweeps();
     clearTimeout(socketDelay);
     clearInterval(socketTimer);
   };
 }
-var ORPHAN_REAP_INTERVAL_MS, ORPHAN_MIN_AGE_MS, SLUG_RE, defaultExec, defaultReadEnv, defaultKill2, STALE_SOCKET_SWEEP_INTERVAL_MS, STALE_SOCKET_SWEEP_DELAY_MS, CLAUDE_BROKER_SOCKET_PREFIX, UNAVAILABLE_ON_WINDOWS;
+function acquireSharedOrphanReaper(deps = {}) {
+  if (!shared) shared = { refs: 0, stop: startOrphanReaper(deps) };
+  const handle = shared;
+  handle.refs++;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    handle.refs--;
+    if (handle.refs === 0 && shared === handle) {
+      shared = null;
+      handle.stop();
+    }
+  };
+}
+var ORPHAN_REAP_INTERVAL_MS, ORPHAN_MIN_AGE_MS, SLUG_RE, execFileAsync6, defaultExec, defaultReadEnv, defaultKill2, STALE_SOCKET_SWEEP_INTERVAL_MS, STALE_SOCKET_SWEEP_DELAY_MS, CLAUDE_BROKER_SOCKET_PREFIX, UNAVAILABLE_ON_WINDOWS, shared;
 var init_orphan_reaper = __esm({
   "packages/server/src/orphan-reaper.ts"() {
     "use strict";
@@ -70069,7 +70230,8 @@ var init_orphan_reaper = __esm({
     ORPHAN_REAP_INTERVAL_MS = 6e4;
     ORPHAN_MIN_AGE_MS = 12e4;
     SLUG_RE = /FRIZZ_THREAD=([A-Za-z0-9._-]+)/;
-    defaultExec = (file, args) => execFileSync4(file, args, { encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: 1e4 });
+    execFileAsync6 = promisify8(execFile10);
+    defaultExec = async (file, args) => (await execFileAsync6(file, args, { encoding: "utf8", maxBuffer: 16 * 1024 * 1024, timeout: 1e4 })).stdout;
     defaultReadEnv = (pid) => {
       try {
         return readFileSync24(`/proc/${pid}/environ`, "utf8");
@@ -70087,6 +70249,7 @@ var init_orphan_reaper = __esm({
     STALE_SOCKET_SWEEP_DELAY_MS = 3e4;
     CLAUDE_BROKER_SOCKET_PREFIX = "frizz-claude-";
     UNAVAILABLE_ON_WINDOWS = "orphan-reaper: unavailable on Windows \u2014 a worker's FRIZZ_THREAD is read from its process environment, which Windows does not expose; background processes a stopped thread leaves behind are not collected here, and a live thread's runaway work is not reported";
+    shared = null;
   }
 });
 
@@ -70305,7 +70468,7 @@ function createContextUnchecked(opts, resources) {
     contextUnsubscribers.push(() => clearInterval(quotaRefreshTimer));
   }
   if (!process.env.FRIZZ_ORPHAN_REAPER_OFF) {
-    contextUnsubscribers.push(startOrphanReaper({ log: (m) => log.info("reaper", m) }));
+    contextUnsubscribers.push(acquireSharedOrphanReaper({ log: (m) => log.info("reaper", m) }));
   }
   opts.startup?.afterPhase?.("orphan reaper");
   reconcileSessions(storage);
@@ -73519,10 +73682,10 @@ var init_edited_files = __esm({
 });
 
 // packages/server/src/repo-files.ts
-import { execFileSync as execFileSync5 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import path2 from "node:path";
 function git(args, cwd) {
-  return execFileSync5("git", args, {
+  return execFileSync4("git", args, {
     cwd,
     encoding: "utf8",
     env: { ...process.env, LC_ALL: "C" },
@@ -73563,7 +73726,7 @@ function probeIgnored(projectDir, inside) {
     return /* @__PURE__ */ new Set();
   }
   try {
-    const out = execFileSync5("git", ["check-ignore", "-z", "--stdin"], {
+    const out = execFileSync4("git", ["check-ignore", "-z", "--stdin"], {
       cwd: projectDir,
       encoding: "utf8",
       env: { ...process.env, LC_ALL: "C" },
@@ -73755,7 +73918,7 @@ var init_bash_background = __esm({
 
 // packages/server/src/transcript.ts
 import { closeSync as closeSync14, existsSync as existsSync17, fstatSync as fstatSync3, mkdirSync as mkdirSync18, openSync as openSync15, readdirSync as readdirSync11, readFileSync as readFileSync27, readSync as readSync8, renameSync as renameSync10, statSync as statSync17, unlinkSync as unlinkSync7, writeFileSync as writeFileSync12 } from "node:fs";
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 import { StringDecoder as StringDecoder6 } from "node:string_decoder";
 import { join as join39 } from "node:path";
 import { homedir as homedir16 } from "node:os";
@@ -74394,7 +74557,7 @@ function persistDataUrlImage(dataUrl, idKey) {
 function persistBase64Image(mediaType, data, idKey) {
   const ext = IMAGE_MEDIA_EXT[typeof mediaType === "string" ? mediaType.toLowerCase() : ""];
   if (!ext || !data) return void 0;
-  const name = createHash14("sha256").update(idKey).digest("hex").slice(0, 32);
+  const name = createHash15("sha256").update(idKey).digest("hex").slice(0, 32);
   const path3 = join39(SCREENSHOT_CACHE_DIR, `${name}.${ext}`);
   try {
     if (existsSync17(path3)) return path3;
@@ -74416,7 +74579,7 @@ function persistSentFile(srcPath, idKey) {
   if (!ATTACHMENT_IMAGE_EXTENSIONS.includes(ext)) return void 0;
   const outExt = ext === "jpeg" ? "jpg" : ext;
   try {
-    const name = createHash14("sha256").update(idKey).digest("hex").slice(0, 32);
+    const name = createHash15("sha256").update(idKey).digest("hex").slice(0, 32);
     const dest = join39(SCREENSHOT_CACHE_DIR, `${name}.${outExt}`);
     if (existsSync17(dest)) return dest;
     const size = statSync17(srcPath).size;
@@ -75230,7 +75393,7 @@ function latestTranscriptWindow(messages) {
     );
     if (tools.length === 0) continue;
     pinned.push({
-      sourceId: `pinned-bg:${createHash14("sha256").update(message.sourceId).digest("base64url").slice(0, 24)}`,
+      sourceId: `pinned-bg:${createHash15("sha256").update(message.sourceId).digest("base64url").slice(0, 24)}`,
       pinnedFromSourceId: message.sourceId,
       role: "assistant",
       text: "",
@@ -76026,7 +76189,7 @@ function fixedSnapshot(source) {
     };
     let allBytes;
     const fileKey = `${before.dev}:${before.ino}:${Math.trunc(before.birthtimeMs)}`;
-    const transcriptKey = createHash14("sha256").update(`${source.slug}\0${source.sessionId}\0${source.nativeId}\0${source.backend}\0${source.runtimeGeneration}\0${fileKey}`).digest("base64url").slice(0, 32);
+    const transcriptKey = createHash15("sha256").update(`${source.slug}\0${source.sessionId}\0${source.nativeId}\0${source.backend}\0${source.runtimeGeneration}\0${fileKey}`).digest("base64url").slice(0, 32);
     let rawText;
     return {
       ...source,
@@ -76059,7 +76222,7 @@ function projectSnapshot(snapshot) {
   return retireStaleQueuedBubbles([...entry.fold.allMessages()]);
 }
 function digestPrefix(bytes, length = bytes.length) {
-  return createHash14("sha256").update(bytes.subarray(0, length)).digest("base64url");
+  return createHash15("sha256").update(bytes.subarray(0, length)).digest("base64url");
 }
 function fullDigest(snapshot) {
   const key = `${snapshot.fileKey}\0${snapshot.size}`;
@@ -76069,7 +76232,7 @@ function fullDigest(snapshot) {
     fullDigestCache.set(key, hit);
     return hit;
   }
-  const hash = createHash14("sha256");
+  const hash = createHash15("sha256");
   for (let at2 = 0; at2 < snapshot.size; ) {
     const buf = snapshot.readRange(at2, Math.min(TRANSCRIPT_DECODE_WINDOW, snapshot.size - at2));
     if (buf.length === 0) break;
@@ -76152,7 +76315,7 @@ function emptyTranscriptPage(source) {
     beforeCursor: null,
     hasEarlier: false,
     reachedTurnBoundary: true,
-    transcriptKey: createHash14("sha256").update(keySeed).digest("base64url").slice(0, 32),
+    transcriptKey: createHash15("sha256").update(keySeed).digest("base64url").slice(0, 32),
     editedFiles: []
   };
 }
@@ -76293,7 +76456,7 @@ function projectTranscriptPageAgentLifecycles(page, lookup, peerLookup) {
 }
 function readTranscriptFile(absPath) {
   try {
-    const pathKey = createHash14("sha256").update(absPath).digest("base64url").slice(0, 16);
+    const pathKey = createHash15("sha256").update(absPath).digest("base64url").slice(0, 16);
     return parseTranscript(readFileSync27(absPath, "utf8"), `claude-file:${pathKey}`);
   } catch {
     return [];
@@ -76694,8 +76857,8 @@ var init_github_hovercard = __esm({
 });
 
 // packages/server/src/backend/account-actions.ts
-import { execFile as execFile10 } from "node:child_process";
-import { promisify as promisify8 } from "node:util";
+import { execFile as execFile11 } from "node:child_process";
+import { promisify as promisify9 } from "node:util";
 function liveThreadsForBackend(threads, backend) {
   let count = 0;
   for (const thread of threads) {
@@ -76715,7 +76878,7 @@ async function runProviderLogout(opts) {
   const args = opts.backend === "codex" ? ["logout"] : ["auth", "logout"];
   let failure;
   try {
-    await execFileAsync6(bin, args, { encoding: "utf8", timeout: opts.timeoutMs ?? 15e3 });
+    await execFileAsync7(bin, args, { encoding: "utf8", timeout: opts.timeoutMs ?? 15e3 });
   } catch (err) {
     const e14 = err;
     const stderr = typeof e14.stderr === "string" ? e14.stderr.trim() : "";
@@ -76725,12 +76888,12 @@ async function runProviderLogout(opts) {
   if (failure && auth !== "signed-out") return { status: "failed", detail: failure, auth };
   return { status: "done", auth };
 }
-var execFileAsync6, LIVE_RUNTIMES;
+var execFileAsync7, LIVE_RUNTIMES;
 var init_account_actions = __esm({
   "packages/server/src/backend/account-actions.ts"() {
     "use strict";
     init_auth_status();
-    execFileAsync6 = promisify8(execFile10);
+    execFileAsync7 = promisify9(execFile11);
     LIVE_RUNTIMES = /* @__PURE__ */ new Set(["spawning", "running", "perm-prompt"]);
   }
 });
@@ -77005,8 +77168,8 @@ var init_image_header = __esm({
 });
 
 // packages/server/src/directory-picker.ts
-import { execFile as execFile11 } from "node:child_process";
-import { promisify as promisify9 } from "node:util";
+import { execFile as execFile12 } from "node:child_process";
+import { promisify as promisify10 } from "node:util";
 async function pickImageFile(startIn, prompt = "Choose an image for this project", platform3 = process.platform) {
   if (platform3 === "darwin") {
     const location = startIn ? ` default location POSIX file ${JSON.stringify(startIn)}` : "";
@@ -77116,7 +77279,7 @@ var run2, PICKER_TIMEOUT_MS, timedOut, unanswered, OSASCRIPT, WINDOWS_PICKER_EDI
 var init_directory_picker = __esm({
   "packages/server/src/directory-picker.ts"() {
     "use strict";
-    run2 = promisify9(execFile11);
+    run2 = promisify10(execFile12);
     PICKER_TIMEOUT_MS = 5 * 6e4;
     timedOut = (error) => error.killed === true;
     unanswered = (what) => ({
@@ -78680,6 +78843,7 @@ ${gapNote}` : input.message;
           fireAtMs: Date.parse(input.fireAt),
           createdAtMs: Date.now()
         });
+        ctx.board.refresh();
         return { id, fireAt: input.fireAt, timers: armedTimerViews(input.slug) };
       }
     }),
@@ -78688,6 +78852,7 @@ ${gapNote}` : input.message;
       output: CancelOwnThreadTimerResult,
       handler: async ({ input }) => {
         const cancelled = ctx.storage.cancelThreadTimer(input.slug, input.id, Date.now());
+        if (cancelled) ctx.board.refresh();
         return { cancelled, timers: armedTimerViews(input.slug) };
       }
     }),
@@ -78811,7 +78976,8 @@ ${gapNote}` : input.message;
           throw new Error(`\`${input.target}\` is not ${kind === "issue" ? "an issue" : "a pull request"} I can watch \u2014 give owner/repo#123 or ${kind === "issue" ? "an issue" : "a PR"} URL`);
         }
         const armed = ctx.storage.listPrWatches(input.slug, { armedOnly: true });
-        const existing = armed.find((w) => w.kind === kind && w.owner === ref.owner && w.repo === ref.repo && w.number === ref.number);
+        const sameName = (a, b) => a.toLowerCase() === b.toLowerCase();
+        const existing = armed.find((w) => w.kind === kind && sameName(w.owner, ref.owner) && sameName(w.repo, ref.repo) && w.number === ref.number);
         const target = `${ref.owner}/${ref.repo}#${ref.number}`;
         if (existing) {
           const expiresAt = new Date(existing.expires_at ?? Date.now()).toISOString();
@@ -80645,7 +80811,7 @@ var init_app = __esm({
 });
 
 // packages/server/src/app-socket.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 function isWsPath(url) {
   return (url ?? "").split("?")[0] === WS_PATH;
 }
@@ -80849,7 +81015,7 @@ function createAppSocketServer(deps) {
     sendEncoded(ws, frame, false);
   }
   function frameSignature(frame) {
-    return createHash15("sha256").update(frame.text).digest("base64url");
+    return createHash16("sha256").update(frame.text).digest("base64url");
   }
   const globalReadTimes = [];
   const originReadTimes = /* @__PURE__ */ new Map();
@@ -81697,7 +81863,7 @@ var init_runtime_lease = __esm({
 });
 
 // packages/server/src/runtimes.ts
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash17 } from "node:crypto";
 import {
   chmodSync,
   closeSync as closeSync17,
@@ -81811,7 +81977,7 @@ async function provisionRuntime(backend, options) {
     const response = await fetchImpl(tarball);
     if (!response.ok || !response.body) throw new Error(`tarball download answered ${response.status}`);
     const total = Number(response.headers.get("content-length") ?? 0);
-    const hash = createHash16("sha512");
+    const hash = createHash17("sha512");
     let seen = 0;
     let lastReport = 0;
     const hasher = new Transform({