frayui 0.1.2 → 0.1.3

package/dist/dev-child.js

@@ -1722,6 +1722,186 @@ var init_shutdown = __esm({
   }
 });
 
+// packages/server/src/logging.ts
+import {
+  appendFileSync,
+  mkdirSync as mkdirSync5,
+  openSync as openSync4,
+  readdirSync,
+  rmSync as rmSync4,
+  statSync as statSync4,
+  symlinkSync,
+  writeFileSync as writeFileSync4,
+  writeSync
+} from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join5 } from "node:path";
+function defaultLogRoot(stateDir, home = homedir3()) {
+  return stateDir ? join5(stateDir, "logs") : join5(home, ".fray", "logs");
+}
+function runStamp(at) {
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${at.getFullYear()}-${pad(at.getMonth() + 1)}-${pad(at.getDate())}T${pad(at.getHours())}-${pad(at.getMinutes())}-${pad(at.getSeconds())}`;
+}
+function runLogPath(stateDir, at = /* @__PURE__ */ new Date(), pid = process.pid, home = homedir3(), env = process.env) {
+  const name = `fray-${runStamp(at)}-${pid}.log`;
+  const override = env[LOG_PATH_ENV]?.trim();
+  if (override) return override.endsWith(".log") ? override : join5(override, name);
+  return join5(defaultLogRoot(stateDir, home), name);
+}
+function latestLogPath(dir) {
+  return join5(dir, "latest.log");
+}
+function linkLatest(dir, target) {
+  const link = latestLogPath(dir);
+  try {
+    rmSync4(link, { force: true });
+    symlinkSync(target, link);
+  } catch {
+    try {
+      writeFileSync4(link, `${target}
+`, { mode: 384 });
+    } catch {
+    }
+  }
+}
+function pruneRunLogs(dir, keep = RETAINED_RUNS, days = RETAINED_DAYS, now = Date.now()) {
+  let entries;
+  try {
+    entries = readdirSync(dir).filter((name) => name.endsWith(".log") && name !== "latest.log");
+  } catch {
+    return;
+  }
+  const dated = entries.map((name) => {
+    try {
+      return { name, at: statSync4(join5(dir, name)).mtimeMs };
+    } catch {
+      return { name, at: 0 };
+    }
+  }).sort((a, b) => b.at - a.at);
+  const cutoff = now - days * 24 * 60 * 60 * 1e3;
+  const stale = dated.filter((entry, index) => index >= keep || entry.at < cutoff);
+  for (const entry of stale) {
+    try {
+      rmSync4(join5(dir, entry.name), { force: true });
+    } catch {
+    }
+  }
+}
+function formatDiskLine(record) {
+  const at = new Date(record.at);
+  const pad = (value, width = 2) => String(value).padStart(width, "0");
+  const clock = `${pad(at.getHours())}:${pad(at.getMinutes())}:${pad(at.getSeconds())}.${pad(at.getMilliseconds(), 3)}`;
+  return `${clock}  ${record.level.toUpperCase().padEnd(5)}  ${record.scope.padEnd(12)}  ${record.message}
+`;
+}
+function openLogFile(path) {
+  try {
+    mkdirSync5(join5(path, ".."), { recursive: true, mode: 448 });
+    return openSync4(path, "a", 384);
+  } catch {
+    return null;
+  }
+}
+function createLogger(options = {}) {
+  const path = options.file === null ? null : options.file ?? runLogPath(options.stateDir);
+  const level = options.level ?? "debug";
+  const now = options.now ?? Date.now;
+  const threshold = LEVEL_ORDER[level];
+  const maxBytes = options.maxBytes ?? MAX_LOG_BYTES;
+  let fd = path === null ? null : openLogFile(path);
+  if (fd !== null && path !== null && options.owner !== false) {
+    const dir = join5(path, "..");
+    pruneRunLogs(dir);
+    linkLatest(dir, path);
+  }
+  let written = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const emit2 = (recordLevel, scope, message) => {
+    if (LEVEL_ORDER[recordLevel] < threshold) return;
+    const record = { at: now(), level: recordLevel, scope, message };
+    if (fd !== null) {
+      try {
+        const line = formatDiskLine(record);
+        if (written + line.length > maxBytes) {
+          writeSync(fd, `--- log truncated at ${maxBytes} bytes ---
+`);
+          fd = null;
+        } else {
+          writeSync(fd, line);
+          written += line.length;
+        }
+      } catch {
+        fd = null;
+      }
+    }
+    for (const listener of listeners) {
+      try {
+        listener(record);
+      } catch {
+      }
+    }
+  };
+  return {
+    debug: (scope, message) => emit2("debug", scope, message),
+    info: (scope, message) => emit2("info", scope, message),
+    warn: (scope, message) => emit2("warn", scope, message),
+    error: (scope, message) => emit2("error", scope, message),
+    get file() {
+      return fd === null ? null : path;
+    },
+    onRecord(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    close() {
+      listeners.clear();
+      fd = null;
+    }
+  };
+}
+function formatFeedLine(record) {
+  return formatDiskLine(record).trimEnd();
+}
+function attachTerminalMirror(logger, enabled = process.env.FRAY_DEBUG === "1") {
+  if (!enabled) return () => {
+  };
+  return logger.onRecord((record) => process.stderr.write(`${formatFeedLine(record)}
+`));
+}
+function ambientLogger() {
+  if (ambient) return ambient;
+  const inherited = process.env[LOG_FILE_ENV] ?? process.env[LOG_PATH_ENV];
+  const level = process.env[LOG_LEVEL_ENV];
+  const logger = createLogger({
+    ...inherited ? { file: inherited, owner: false } : { file: null },
+    ...level && level in LEVEL_ORDER ? { level } : {}
+  });
+  attachTerminalMirror(logger);
+  ambient = logger;
+  return ambient;
+}
+var LEVEL_ORDER, LOG_FILE_ENV, LOG_LEVEL_ENV, LOG_PATH_ENV, RETAINED_RUNS, RETAINED_DAYS, MAX_LOG_BYTES, ambient, log;
+var init_logging = __esm({
+  "packages/server/src/logging.ts"() {
+    "use strict";
+    LEVEL_ORDER = { debug: 10, info: 20, warn: 30, error: 40 };
+    LOG_FILE_ENV = "FRAY_LOG_FILE";
+    LOG_LEVEL_ENV = "FRAY_LOG_LEVEL";
+    LOG_PATH_ENV = "FRAY_LOG_PATH";
+    RETAINED_RUNS = 20;
+    RETAINED_DAYS = 14;
+    MAX_LOG_BYTES = 32 * 1024 * 1024;
+    ambient = null;
+    log = {
+      debug: (scope, message) => ambientLogger().debug(scope, message),
+      info: (scope, message) => ambientLogger().info(scope, message),
+      warn: (scope, message) => ambientLogger().warn(scope, message),
+      error: (scope, message) => ambientLogger().error(scope, message)
+    };
+  }
+});
+
 // node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType;
 var init_util = __esm({
@@ -6151,6 +6331,14 @@ var init_interactions = __esm({
         ...CommonPayload,
         kind: external_exports.literal("permission-approval"),
         permission: InteractionOpaqueId,
+        // The exact text of what is being authorized — a command, a path, a request body. Multi-line and
+        // rendered monospace, because a Bash command is the one thing the operator actually reads and a
+        // single-line label cannot hold a heredoc. Adapters redact and clamp it before it gets here.
+        preview: InteractionPreview.optional(),
+        // A shell prompt to render in FRONT of `preview`, which is how a terminal shows a command and where
+        // the working directory belongs when there is one. Set it only when the preview genuinely IS a shell
+        // command line: a file path or an MCP argument behind a `❯` would be a lie about what runs.
+        promptLabel: plainText(256, 512).optional(),
         resourceLabel: plainText(1024, 2048).optional(),
         workingDirectoryLabel: plainText(1024, 2048).optional(),
         scopeLabel: InteractionDescription.optional(),
@@ -6582,7 +6770,37 @@ function formatGithubWakeSteer({ ref, items, omitted }) {
 
 ${lines}${more}${reviewTail}`;
 }
-var ATTACHMENT_IMAGE_EXTENSIONS, ATTACHMENT_DOC_EXTENSIONS, ATTACHMENT_EXTENSIONS, ATTACHMENT_MAX_BASE64_CHARS, ATTACHMENT_MAX_BYTES, ATTACHMENT_EXT_SET, ATTACHMENT_ACCEPT, FrayStatus, BlockMechanism, RuntimeState, Backend, CodexModel, ThreadProfileOption, ThreadAgent, SubAgentView, BgShellView, CompletionHoldOp, CompletionHold, AskOption, AskQuestion, PendingAsk, NativeInputRequired, AwaitingHint, AWAITING_TIMER_RE, SnoozeUntil, SNOOZE_PROMPT_MAX, SnoozePrompt, ThreadFence, PlanView, LimitWindow, LimitPause, ThreadView, BoardErrorItem, BoardSnapshot, QuotaWindow, ProviderQuota, QuotaSnapshot, ProviderAuth, AuthSnapshot, AccountLogoutInput, AccountLogoutResult, AccountLoginStartInput, AccountLoginStartResult, AccountLoginStatusInput, AccountLoginStatusResult, PermissionMode, LocalFileOpener, Settings, DispatchProviderPreferences, DispatchPreferences, DispatchProfileSnapshot, SetDispatchPreferenceInput, DispatchInput, ADOPT_THREAD_MESSAGE_MAX_CHARS, AdoptThreadInput, AdoptThreadResult, FollowUpInput, UnqueueFollowUpInput, UnqueueFollowUpResult, SetThreadSnoozeInput, ConfirmAwaitingInput, RenameThreadInput, AiRenameThreadInput, AiRenameThreadResult, SetThreadPermissionInput, SetThreadPermissionResult, ThreadProfileOptionsInput, ThreadProfileOptionsResult, SetThreadProfileInput, SetThreadProfileResult, DISPATCH_TASK_BANNER, DISPATCH_TASK_BANNER_MARKER, GITHUB_DISPATCH_UI_BOUNDARY, WAKE_DELIVERY_TOKEN_TAIL, AGENT_MESSAGE_WRAPPER, WAKE_SCOPE, WAKE_REVIEW_LEAD, WAKE_REF, WAKE_SINGLE, WAKE_MULTI_HEAD, GithubStatus, GithubItem, GithubListInput, GithubBatchInput, GithubBatchResult, BoardMeta, ServerEvent, TranscriptEdit, TranscriptTodo, TranscriptToolCall, THOUGHT_EVENT_PREFIX, TranscriptPart, TranscriptMessage, TranscriptPageCursor, TranscriptPage, TranscriptEarlierInput, SocketTranscriptSlug, SocketClientMsg, DEFAULT_PORT, tmuxSessionName;
+function parseGithubWakeSteer(text) {
+  const item = (label, actor, bot, at, url) => ({
+    label,
+    actor,
+    bot,
+    ...at ? { at } : {},
+    ...url ? { url } : {}
+  });
+  const lines = text.trim().split("\n").map((line) => line.trim()).filter(Boolean);
+  const single = WAKE_SINGLE.exec(lines[0] ?? "");
+  if (single) {
+    return { ref: single[3], omitted: 0, items: [item(single[2], single[4], single[1] === "\u{1F916}", single[5], single[6])] };
+  }
+  const head = WAKE_MULTI_HEAD.exec(lines[0] ?? "");
+  if (!head) return null;
+  const items = [];
+  let omitted = 0;
+  for (const line of lines.slice(1)) {
+    const more = WAKE_MORE.exec(line);
+    if (more) {
+      omitted = Number(more[1]);
+      continue;
+    }
+    const m = WAKE_ITEM.exec(line);
+    if (!m) continue;
+    items.push(item(m[2], m[3], m[1] === "\u{1F916}", m[4], m[5]));
+  }
+  if (!items.length || items.length + omitted !== Number(head[2])) return null;
+  return { ref: head[3], omitted, items };
+}
+var ATTACHMENT_IMAGE_EXTENSIONS, ATTACHMENT_DOC_EXTENSIONS, ATTACHMENT_EXTENSIONS, ATTACHMENT_MAX_BASE64_CHARS, ATTACHMENT_MAX_BYTES, ATTACHMENT_EXT_SET, ATTACHMENT_ACCEPT, FrayStatus, BlockMechanism, RuntimeState, Backend, CodexModel, ThreadProfileOption, ThreadAgent, SubAgentView, BgShellView, CompletionHoldOp, CompletionHold, AskOption, AskQuestion, PendingAsk, NativeInputRequired, AwaitingHint, AWAITING_TIMER_RE, SnoozeUntil, SNOOZE_PROMPT_MAX, SnoozePrompt, ThreadFence, PlanView, LimitWindow, LimitPause, ThreadView, BoardErrorItem, BoardSnapshot, QuotaWindow, ProviderQuota, QuotaSnapshot, ProviderAuth, AuthSnapshot, AccountLogoutInput, AccountLogoutResult, AccountLoginStartInput, AccountLoginStartResult, AccountLoginStatusInput, AccountLoginStatusResult, PermissionMode, LocalFileOpener, Settings, DispatchProviderPreferences, DispatchPreferences, DispatchProfileSnapshot, SetDispatchPreferenceInput, DispatchInput, ADOPT_THREAD_MESSAGE_MAX_CHARS, AdoptThreadInput, AdoptThreadResult, FollowUpInput, UnqueueFollowUpInput, UnqueueFollowUpResult, SetThreadSnoozeInput, ConfirmAwaitingInput, RenameThreadInput, AiRenameThreadInput, AiRenameThreadResult, SetThreadPermissionInput, SetThreadPermissionResult, ThreadProfileOptionsInput, ThreadProfileOptionsResult, SetThreadProfileInput, SetThreadProfileResult, DISPATCH_TASK_BANNER, DISPATCH_TASK_BANNER_MARKER, GITHUB_DISPATCH_UI_BOUNDARY, WAKE_DELIVERY_TOKEN_TAIL, AGENT_MESSAGE_WRAPPER, GithubWakeItem, GithubWakeSteer, WAKE_SCOPE, WAKE_REVIEW_LEAD, WAKE_REF, WAKE_SINGLE, WAKE_MULTI_HEAD, WAKE_ITEM, WAKE_MORE, GithubStatus, GithubItem, GithubListInput, GithubBatchInput, GithubBatchResult, BoardMeta, ServerEvent, TranscriptEdit, TranscriptTodo, TranscriptToolCall, THOUGHT_EVENT_PREFIX, TranscriptPart, TranscriptMessage, TranscriptPageCursor, TranscriptPage, TranscriptEarlierInput, SocketTranscriptSlug, SocketClientMsg, DEFAULT_PORT, tmuxSessionName;
 var init_src = __esm({
   "packages/shared/src/index.ts"() {
     "use strict";
@@ -7216,7 +7434,13 @@ var init_src = __esm({
       sessionId: external_exports.string().min(1),
       message: external_exports.string().min(1),
       // Generated once before the optimistic clear so a transport replay can be idempotent.
-      deliveryId: external_exports.string().min(1).max(200).optional()
+      deliveryId: external_exports.string().min(1).max(200).optional(),
+      // Retire the worker's live process before delivering, so this message lands in a `claude` that has
+      // just started. The operator's "Restart worker" verb — the ONLY caller that sets it — exists because
+      // a worker inherits its plugin/hooks AND its system prompt at process start and can never pick up a
+      // newer fray build in place (hooks are read once, at startup). Everything else that needs a fresh
+      // process derives it server-side; see needsFreshProcessForLimit.
+      freshProcess: external_exports.boolean().optional()
     });
     UnqueueFollowUpInput = external_exports.object({
       slug: ThreadSlug,
@@ -7287,6 +7511,25 @@ ${DISPATCH_TASK_BANNER}
     GITHUB_DISPATCH_UI_BOUNDARY = "<!-- fray-ui:github-dispatch-ui-boundary:v1 -->";
     WAKE_DELIVERY_TOKEN_TAIL = /\n*<!-- fray-wake:[A-Za-z0-9_-]+ -->\s*$/;
     AGENT_MESSAGE_WRAPPER = /^<agent-message from="([^"]*)">\n?([\s\S]*?)\n?<\/agent-message>\s*$/;
+    GithubWakeItem = external_exports.object({
+      label: external_exports.string(),
+      // the activity's noun ("comment", "approval", "change request", …)
+      actor: external_exports.string(),
+      // GitHub login, no leading @
+      bot: external_exports.boolean(),
+      // drives the 🤖/👤 icon; an app files most of what wakes this watcher
+      at: external_exports.string().optional(),
+      // ISO8601
+      url: external_exports.string().optional()
+      // the item's own permalink
+    });
+    GithubWakeSteer = external_exports.object({
+      ref: external_exports.string(),
+      // owner/repo#N
+      items: external_exports.array(GithubWakeItem),
+      omitted: external_exports.number()
+      // fresh items counted but not named (the enumeration cap)
+    });
     WAKE_SCOPE = "ignore older activity you have already handled";
     WAKE_REVIEW_LEAD = "A review's body is often empty because its substance is inline comments. Read them, one call each:";
     WAKE_REF = String.raw`[A-Za-z0-9][\w.-]*\/[A-Za-z0-9][\w.-]*#\d+`;
@@ -7296,6 +7539,8 @@ ${DISPATCH_TASK_BANNER}
     WAKE_MULTI_HEAD = new RegExp(
       String.raw`^(👤|🤖) (\d+) new GitHub items on (${WAKE_REF})\. Read exactly these — ` + WAKE_SCOPE + String.raw` — and continue:$`
     );
+    WAKE_ITEM = /^- (👤|🤖) (.+?) from @(\S+?)(?: at (\S+?))?(?:: (\S+))?$/;
+    WAKE_MORE = /^- …and (\d+) more not listed — check .+ for the rest$/;
     GithubStatus = external_exports.object({
       installed: external_exports.boolean(),
       inRepo: external_exports.boolean(),
@@ -7585,11 +7830,20 @@ ${DISPATCH_TASK_BANNER}
       // non-reasoning messages and on any reasoning block whose timing couldn't be derived.
       durationMs: external_exports.number().nonnegative().optional(),
       // A turn-BOUNDARY marker: this `kind:"event"` line was emitted at the position an EXTERNAL wake — a
-      // background task/shell completion `<task-notification>` — re-invoked the agent and started a fresh
-      // turn. The client renders it as a centered divider rule carrying the cause label, so two consecutive
-      // assistant turns (each with its own trailing signal) no longer paint as one seamless bubble. Additive
-      // + optional: an old client ignores it and shows the plain quiet event line (graceful degrade).
-      boundary: external_exports.boolean().optional(),
+      // This event opened a fresh turn, so it renders as a centered divider rule carrying the cause label —
+      // without it, two consecutive assistant turns (each with its own trailing signal) paint as one
+      // seamless bubble. Additive + optional: an old client ignores it and shows the plain quiet event line
+      // (graceful degrade).
+      //
+      // It names WHICH KIND of boundary, because two unrelated events earn the divider and the client has to
+      // tell them apart to put the right glyph on each:
+      //   wake       — a background task/shell completion `<task-notification>` re-invoked the agent
+      //   compaction — the provider rewrote the conversation and dropped everything above this point
+      // It was a bare boolean until the dividers grew icons (a shell glyph on a compaction line is simply
+      // wrong), and the kind has to come from the SERVER: the alternative is the client sniffing the label
+      // text, which is the guess this codebase refuses everywhere else. A string stays truthy, so any
+      // surviving `if (boundary)` reads exactly as it did.
+      boundary: external_exports.enum(["wake", "compaction"]).optional(),
       // Block-ordered content for an assistant turn (see TranscriptPart). Defaults to [] so a pre-restart
       // server (which ships only text/tools) parses; the client renders `parts` when non-empty and falls
       // back to the legacy tools-then-text layout when it's empty. `text`/`tools` stay populated for that
@@ -7618,6 +7872,17 @@ ${DISPATCH_TASK_BANNER}
       // old client ignores it and shows the plain bubble (the previous behavior), and an old server simply
       // never sets it.
       wake: external_exports.boolean().optional(),
+      // The STRUCTURED wake, parsed by the server from the same text the same build formatted. The chat
+      // renders the divider from this rather than re-deriving it from prose in the browser.
+      //
+      // It exists because re-deriving it in the browser is version-skewed by construction. `web/api/boot.ts`
+      // adopts a new server boot id IN PLACE (so an unsent draft survives a restart), so a promoted artifact
+      // swaps the server under tabs that keep their old bundle — and on 2026-07-31 a steer that gained two
+      // agent-facing lines met parsers that predated them, which cost every open tab its card and dumped the
+      // raw `gh api …` text into the transcript instead. Server-side, formatter and parser can never
+      // disagree. Additive + optional: absent from a legacy transcript or an older server, and the client
+      // falls back to `parseGithubWakeSteer` on the text.
+      wakeSteer: GithubWakeSteer.optional(),
       // A SUB-AGENT (or peer session) wrote this user turn, not the human — the same defect class `wake`
       // above corrects. Claude Code's agent-to-agent channel (a background child calling
       // `SendMessage({to:"main"})`) delivers UPWARD into the parent's queue like any follow-up, so the
@@ -10010,15 +10275,15 @@ var init_settings = __esm({
 });
 
 // packages/server/src/discover.ts
-import { readdirSync, statSync as statSync4, openSync as openSync4, readSync, closeSync as closeSync4 } from "node:fs";
-import { join as join5 } from "node:path";
+import { readdirSync as readdirSync2, statSync as statSync5, openSync as openSync5, readSync, closeSync as closeSync4 } from "node:fs";
+import { join as join6 } from "node:path";
 function sentinelFor(sessionId) {
   return `threads/${sessionId}/scratch.md`;
 }
 function readHead(path) {
   let fd;
   try {
-    fd = openSync4(path, "r");
+    fd = openSync5(path, "r");
     const buf = Buffer.allocUnsafe(HEAD_BYTES);
     const n = readSync(fd, buf, 0, HEAD_BYTES, 0);
     return buf.toString("utf8", 0, n);
@@ -10039,7 +10304,7 @@ function discoverTranscriptId(logDir, sessionId, opts = {}) {
   const sentinel = sentinelFor(sessionId);
   let names;
   try {
-    names = readdirSync(logDir);
+    names = readdirSync2(logDir);
   } catch {
     return void 0;
   }
@@ -10048,10 +10313,10 @@ function discoverTranscriptId(logDir, sessionId, opts = {}) {
     if (name.startsWith(".") || !name.endsWith(".jsonl")) continue;
     const id = name.slice(0, -".jsonl".length);
     if (!id || id === sessionId || exclude?.has(id)) continue;
-    const path = join5(logDir, name);
+    const path = join6(logDir, name);
     let mtime;
     try {
-      mtime = statSync4(path).mtimeMs;
+      mtime = statSync5(path).mtimeMs;
     } catch {
       continue;
     }
@@ -10423,7 +10688,7 @@ function spawnWithRunner(slug, cmd, cwd, env, options, runner) {
     invalidateLiveness();
     return identity;
   } catch {
-    console.error(`[fray-ui] tmux worker spawn failed (stage=${stage}, created=${identity ? "yes" : "no"})`);
+    log.error("tmux", `worker spawn failed (stage=${stage}, created=${identity ? "yes" : "no"})`);
     throw new TmuxSpawnError(stage, identity);
   }
 }
@@ -10993,6 +11258,7 @@ var init_tmux = __esm({
     "use strict";
     init_src();
     init_tmux_socket();
+    init_logging();
     init_tmux_socket();
     execFileAsync = promisify(execFile);
     socket = "fray";
@@ -11316,6 +11582,28 @@ A \` \`\`\`question \` block IS the handback \u2014 do not also emit a \`done\`/
 as your next user message, possibly as terse as "1: A, 2: B".`;
     STOP_CRITERION = `## The stop criterion
 
+**COMING TO REST IS A STOP, and it needs the same justification as a question.** Everything below is
+about when to ASK \u2014 but the far more common failure is quieter: you finish one part of a multi-part
+instruction, write it up, and rest with the rest of the mandate untouched. Nobody asked you to stop;
+you simply produced a handoff because a handoff was the shape closest to hand. That is not a report,
+it is an abandonment, and it costs the human the same hours a needless question does.
+
+So: **if the human's instruction still has parts left, do not write up \u2014 do the next part in this same
+turn.** Keep issuing tool calls. A verified milestone is not a stopping point, a green test run is not
+a stopping point, and neither is a long turn \u2014 the conversation is summarized automatically, so turn
+length is never a reason to pause. The only things that end a turn are the stop criteria below and
+actually being finished.
+
+Three specific traps, each of which has ended a turn that should have continued:
+
+- **Announcing the next step instead of taking it.** "Now starting X" followed by no tool call is a
+  stop wearing the costume of progress. If you can write the sentence, you can make the call instead.
+- **Writing the next action into the scratchpad and feeling done.** Recording work is not doing work.
+  The pad is crash insurance, never a handoff \u2014 see the scratchpad section. If the pad's next action
+  is something the human already told you to do, the only correct move is to do it NOW.
+- **Pre-emptively worrying about context budget.** You do not get to stop early because the turn feels
+  long. If context genuinely runs out, the harness summarizes and you continue.
+
 **Your default is to DECIDE.** A reversible call costs minutes to redo; a round-trip to the human costs
 hours \u2014 they may not read your question for hours, and the whole effort sits idle until they do. If it
 is derivable from the code, the conventions, or ordinary engineering judgment, it is yours: make it,
@@ -11369,6 +11657,12 @@ rate-limited to once every two minutes so it cannot create a tight stop loop. Re
 \`stop_hook\` to deregister it before genuinely finishing. This is a rest-time nudge, not a timer and
 cannot wake a turn that already stopped.
 
+- **IT IS OPTIONAL, IT IS NOT A DELIVERABLE, AND WRITING IN IT IS NOT DOING THE WORK.** The pad exists
+  in case you want it \u2014 crash insurance for a long effort, and the file watchers and stop hooks read
+  it. A single direct task usually needs NOTHING here: just do the task. Never let a pad entry stand in
+  for an action. Recording "next: X" when the human asked for X is not progress on X, and a turn that
+  ends right after a pad update is nearly always a turn that stopped for no reason. When it is worth
+  writing, write it AS YOU GO, mid-work, and then keep working.
 - **It is your compaction-survival mechanism, so use it deliberately.** A long effort WILL be
   compacted, and compaction drops the REASONING first \u2014 the plan, the alternatives you ruled out, why
   the human chose what they chose. A summary preserves what you did, not why. So write that here AS
@@ -11408,6 +11702,13 @@ rate-limited to once every two minutes so it cannot create a tight stop loop. Re
 \`stop_hook\` to deregister it before genuinely finishing. This is a rest-time nudge, not a timer and
 cannot wake a turn that already stopped.
 
+**IT IS OPTIONAL, IT IS NOT A DELIVERABLE, AND WRITING IN IT IS NOT DOING THE WORK.** The pad exists in
+case you want it \u2014 crash insurance for a long effort, and the file watchers and stop hooks read it. A
+single direct task usually needs NOTHING here: just do the task. Never let a pad entry stand in for an
+action. Recording "next: X" when the human asked for X is not progress on X, and a turn that ends right
+after a pad update is nearly always a turn that stopped for no reason. When it is worth writing, write
+it AS YOU GO, mid-work, and then keep working.
+
 **It is your compaction-survival mechanism, so use it deliberately.** A long effort WILL be compacted,
 and compaction drops the REASONING first \u2014 the plan, the alternatives you ruled out, why the human
 chose what they chose. A summary preserves what you did, not why. So write that here AS YOU GO rather
@@ -11735,10 +12036,10 @@ var init_detached_daemons = __esm({
 });
 
 // packages/server/src/backend/claude-broker-diagnostics.ts
-import { appendFileSync, mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync4, statSync as statSync5 } from "node:fs";
-import { join as join6 } from "node:path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6, readFileSync as readFileSync5, renameSync as renameSync4, statSync as statSync6 } from "node:fs";
+import { join as join7 } from "node:path";
 function claudeBrokerDiagnosticLogPath(stateDir, sessionId) {
-  return join6(stateDir, "claude-broker", `${sessionId}.diagnostics.log`);
+  return join7(stateDir, "claude-broker", `${sessionId}.diagnostics.log`);
 }
 function readClaudeBrokerExit(stateDir, sessionId) {
   let newest = null;
@@ -11782,14 +12083,14 @@ var init_claude_broker_diagnostics = __esm({
 // packages/server/src/backend/claude-broker-host.ts
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash4, randomUUID as randomUUID8 } from "node:crypto";
-import { accessSync, constants as fsConstants, mkdirSync as mkdirSync6, readFileSync as readFileSync6, readdirSync as readdirSync2, unlinkSync } from "node:fs";
-import { delimiter, dirname as dirname4, isAbsolute as isAbsolute4, join as join7 } from "node:path";
+import { accessSync, constants as fsConstants, mkdirSync as mkdirSync7, readFileSync as readFileSync6, readdirSync as readdirSync3, unlinkSync } from "node:fs";
+import { delimiter, dirname as dirname4, isAbsolute as isAbsolute4, join as join8 } from "node:path";
 function resolveClaudeExecutableAbsolute(bin, env = process.env) {
   const candidate = bin && bin.length > 0 ? bin : "claude";
   if (isAbsolute4(candidate)) return candidate;
   for (const dir of (env.PATH ?? "").split(delimiter)) {
     if (!dir) continue;
-    const full = join7(dir, candidate);
+    const full = join8(dir, candidate);
     try {
       accessSync(full, fsConstants.X_OK);
       return full;
@@ -11801,11 +12102,11 @@ function resolveClaudeExecutableAbsolute(bin, env = process.env) {
 function claudeBrokerSocketPath(stateDir, sessionId) {
   const key = createHash4("sha256").update(stateDir).update("\0").update(sessionId).digest("hex").slice(0, 16);
   if (process.platform === "win32") return `\\\\.\\pipe\\fray-claude-${key}`;
-  return join7(process.env.TMPDIR ?? "/tmp", `fray-claude-${key}.sock`);
+  return join8(process.env.TMPDIR ?? "/tmp", `fray-claude-${key}.sock`);
 }
 function claudeBrokerRecordPath(stateDir, sessionId) {
   const key = createHash4("sha256").update(sessionId).digest("hex").slice(0, 16);
-  return join7(stateDir, "claude-broker", `${key}.json`);
+  return join8(stateDir, "claude-broker", `${key}.json`);
 }
 function pidAlive(pid) {
   try {
@@ -11834,17 +12135,17 @@ function liveBrokerRecord(recordPath2) {
   return null;
 }
 function liveBrokerRecords(stateDir) {
-  const dir = join7(stateDir, "claude-broker");
+  const dir = join8(stateDir, "claude-broker");
   let names;
   try {
-    names = readdirSync2(dir);
+    names = readdirSync3(dir);
   } catch {
     return [];
   }
   const out = [];
   for (const name of names) {
     if (!name.endsWith(".json")) continue;
-    const record = liveBrokerRecord(join7(dir, name));
+    const record = liveBrokerRecord(join8(dir, name));
     if (record) out.push(record);
   }
   return out;
@@ -11852,7 +12153,7 @@ function liveBrokerRecords(stateDir) {
 function forkBroker(options) {
   const socketPath = claudeBrokerSocketPath(options.stateDir, options.sessionId);
   const recordPath2 = claudeBrokerRecordPath(options.stateDir, options.sessionId);
-  mkdirSync6(dirname4(recordPath2), { recursive: true });
+  mkdirSync7(dirname4(recordPath2), { recursive: true });
   const config = {
     socketPath,
     cwd: options.cwd,
@@ -12071,6 +12372,17 @@ var init_claude_broker_client = __esm({
 });
 
 // packages/server/src/backend/claude-agent-sdk-protocol.ts
+function hasUndeliverableInputText(value) {
+  for (const character of value) {
+    const code = character.codePointAt(0);
+    if (code >= 55296 && code <= 57343) return true;
+    if (code === 8232 || code === 8233) return true;
+    if (code <= 31 || code >= 127 && code <= 159) {
+      if (!DELIVERABLE_CONTROL_CODES.has(code)) return true;
+    }
+  }
+  return false;
+}
 function utf8Bytes(value) {
   return encoder2.encode(value).byteLength;
 }
@@ -12151,8 +12463,8 @@ function validateInputMessage(value) {
   if (utf8Bytes(value.text) > CLAUDE_AGENT_SDK_MAX_INPUT_BYTES) {
     throw new ClaudeAgentSdkProtocolError(`input.text exceeds ${CLAUDE_AGENT_SDK_MAX_INPUT_BYTES} bytes`);
   }
-  const text = safeText(value.text, "input.text", CLAUDE_AGENT_SDK_MAX_INPUT_BYTES);
-  if (text !== value.text) throw new ClaudeAgentSdkProtocolError("input.text contains unsafe text");
+  const text = value.text;
+  if (hasUndeliverableInputText(text)) throw new ClaudeAgentSdkProtocolError("input.text contains unsafe text");
   const parentToolUseId = boundedOptionalId(value.parentToolUseId, "input.parentToolUseId");
   return parentToolUseId === void 0 ? { id, text } : { id, text, parentToolUseId };
 }
@@ -12182,7 +12494,7 @@ function validatePermissionDecision(value) {
   }
   throw new ClaudeAgentSdkProtocolError("permission decision behavior is unsupported");
 }
-var CLAUDE_AGENT_SDK_MAX_INPUT_BYTES, CLAUDE_AGENT_SDK_MAX_JSON_BYTES, CLAUDE_AGENT_SDK_MAX_EVENT_TEXT_BYTES, CLAUDE_AGENT_SDK_MAX_DIAGNOSTIC_BYTES, encoder2, UNSAFE_TEXT2, ID_PATTERN, RESERVED_KEYS, CLAUDE_BROKER_CAPABILITY_SUBAGENT_STEER, CLAUDE_BROKER_CAPABILITY_CANCEL_INPUT, CLAUDE_BROKER_CAPABILITY_STOP_TASK, ClaudeAgentSdkProtocolError;
+var CLAUDE_AGENT_SDK_MAX_INPUT_BYTES, CLAUDE_AGENT_SDK_MAX_JSON_BYTES, CLAUDE_AGENT_SDK_MAX_EVENT_TEXT_BYTES, CLAUDE_AGENT_SDK_MAX_DIAGNOSTIC_BYTES, encoder2, UNSAFE_TEXT2, ID_PATTERN, RESERVED_KEYS, DELIVERABLE_CONTROL_CODES, CLAUDE_BROKER_CAPABILITY_SUBAGENT_STEER, CLAUDE_BROKER_CAPABILITY_CANCEL_INPUT, CLAUDE_BROKER_CAPABILITY_STOP_TASK, ClaudeAgentSdkProtocolError;
 var init_claude_agent_sdk_protocol = __esm({
   "packages/server/src/backend/claude-agent-sdk-protocol.ts"() {
     "use strict";
@@ -12194,6 +12506,7 @@ var init_claude_agent_sdk_protocol = __esm({
     UNSAFE_TEXT2 = /[\p{Cf}\p{Cs}\p{Zl}\p{Zp}\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu;
     ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:@/-]*$/;
     RESERVED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+    DELIVERABLE_CONTROL_CODES = /* @__PURE__ */ new Set([9, 10, 13]);
     CLAUDE_BROKER_CAPABILITY_SUBAGENT_STEER = "subagent-steer-v1";
     CLAUDE_BROKER_CAPABILITY_CANCEL_INPUT = "cancel-input-v1";
     CLAUDE_BROKER_CAPABILITY_STOP_TASK = "stop-task-v1";
@@ -12353,28 +12666,35 @@ var init_credential_redaction = __esm({
 });
 
 // packages/server/src/backend/claude-permission-interactions.ts
+import { homedir as homedir4 } from "node:os";
 function clip(text, max) {
   return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
 }
+function tildePath(path) {
+  const home = homedir4();
+  if (!path.startsWith(home)) return path;
+  const rest = path.slice(home.length);
+  return rest === "" ? "~" : rest.startsWith("/") ? `~${rest}` : path;
+}
+function inputPreview(input, shown) {
+  if (!input) return "";
+  const subject = SUBJECT_KEYS.find((key) => typeof input[key] === "string" && input[key] !== "");
+  const lines = Object.entries(input).filter((entry) => entry[0] !== subject && entry[1] !== "" && entry[1] !== null && entry[1] !== shown).map((entry) => `${entry[0]}: ${typeof entry[1] === "string" ? entry[1] : JSON.stringify(entry[1])}`);
+  if (subject) lines.unshift(String(input[subject]));
+  const text = redactCredentialSyntax(lines.join("\n\n")).split("\n");
+  return clip(text.length > PREVIEW_MAX_LINES ? `${text.slice(0, PREVIEW_MAX_LINES).join("\n")}
+\u2026` : text.join("\n"), PREVIEW_MAX_CHARS);
+}
 function buildClaudePermissionInteraction(request, owner) {
   const tool = request.toolName || "tool";
-  let inputSummary = "";
-  try {
-    inputSummary = clip(redactCredentialSyntax(JSON.stringify(request.input ?? {})), 3800);
-  } catch {
-    inputSummary = "(uninspectable input)";
-  }
-  const title = clip(`Approve ${tool}?`, 150);
+  const command = typeof request.input?.command === "string" ? request.input.command : "";
+  const title = clip(command ? "Run a command?" : `Approve ${tool}?`, 150);
+  const description = request.description ? clip(redactCredentialSyntax(request.description), 1e3) : "";
   const message = clip(
-    `A ${tool} tool call needs your approval before it runs.` + (request.description ? `
-
-${clip(redactCredentialSyntax(request.description), 1e3)}` : "") + (inputSummary ? `
-
-Input: ${inputSummary}` : "") + (request.blockedPath ? `
-
-Path: ${clip(request.blockedPath, 500)}` : ""),
-    7900
+    [description, request.blockedPath ? `Blocked path: ${clip(request.blockedPath, 500)}` : ""].filter(Boolean).join("\n\n"),
+    2e3
   );
+  const preview = inputPreview(request.input, request.description);
   const parsed = InteractionRequest.safeParse({
     protocolVersion: INTERACTION_PROTOCOL_VERSION,
     contentFormat: "plain-text",
@@ -12394,12 +12714,14 @@ Path: ${clip(request.blockedPath, 500)}` : ""),
     providerRequestId: clip(request.requestId, 500),
     allowedDecisions: ALLOWED_DECISIONS,
     payload: {
-      title,
-      message,
       kind: "permission-approval",
-      permission: clip(request.requestId, 500),
-      resourceLabel: clip(tool, 2e3),
-      workingDirectoryLabel: clip(owner.cwd, 2e3)
+      title,
+      // `permission` is the card's readable identity, the way Codex's is "network+filesystem". It was
+      // the requestId, which put a bare UUID on screen and told the operator nothing.
+      permission: singleLine(tool, 250, "tool"),
+      ...message ? { message } : {},
+      ...preview ? { preview } : {},
+      ...command ? { promptLabel: singleLine(tildePath(owner.cwd), 250, "~", false) } : { workingDirectoryLabel: clip(owner.cwd, 2e3) }
     },
     expiresAt: null
   });
@@ -12553,7 +12875,7 @@ function claudeQuestionDecisionFor(spec, decisionId, values) {
     message: "Fray could not return the operator's answer in a form this tool accepts. Ask the question in your final message instead."
   };
 }
-var CLAUDE_PERMISSION_DECISIONS, ALLOWED_DECISIONS, CLAUDE_ASK_USER_QUESTION_TOOL, CLAUDE_QUESTION_DECISIONS, QUESTION_DECISIONS, MAX_QUESTIONS, MAX_OPTIONS, MAX_QUESTION_KEY_BYTES, encoder3, UNSAFE_TEXT_SOURCE, SCRUB_UNSAFE_TEXT, HAS_UNSAFE_TEXT, CLAUDE_NOTES_ONLY, CLAUDE_QUESTION_DECLINED;
+var CLAUDE_PERMISSION_DECISIONS, ALLOWED_DECISIONS, SUBJECT_KEYS, PREVIEW_MAX_CHARS, PREVIEW_MAX_LINES, CLAUDE_ASK_USER_QUESTION_TOOL, CLAUDE_QUESTION_DECISIONS, QUESTION_DECISIONS, MAX_QUESTIONS, MAX_OPTIONS, MAX_QUESTION_KEY_BYTES, encoder3, UNSAFE_TEXT_SOURCE, SCRUB_UNSAFE_TEXT, HAS_UNSAFE_TEXT, CLAUDE_NOTES_ONLY, CLAUDE_QUESTION_DECLINED;
 var init_claude_permission_interactions = __esm({
   "packages/server/src/backend/claude-permission-interactions.ts"() {
     "use strict";
@@ -12568,6 +12890,9 @@ var init_claude_permission_interactions = __esm({
       { id: CLAUDE_PERMISSION_DECISIONS.allow, semantic: "approve", label: "Grant for turn", description: "Allow this tool call to run once." },
       { id: CLAUDE_PERMISSION_DECISIONS.deny, semantic: "deny", label: "Deny", description: "Block this tool call." }
     ];
+    SUBJECT_KEYS = ["command", "file_path", "notebook_path", "path", "url", "pattern", "query", "prompt"];
+    PREVIEW_MAX_CHARS = 6e3;
+    PREVIEW_MAX_LINES = 200;
     CLAUDE_ASK_USER_QUESTION_TOOL = "AskUserQuestion";
     CLAUDE_QUESTION_DECISIONS = { answer: "answer", decline: "decline" };
     QUESTION_DECISIONS = [
@@ -12594,6 +12919,20 @@ function claudeBrokerBridgeEnabled(env = process.env) {
 function inputIdFor(deliveryId) {
   return deliveryId && UUID_SHAPE.test(deliveryId) ? deliveryId : randomUUID9();
 }
+function validatedInput(message) {
+  try {
+    return validateInputMessage(message);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    if (/exceeds/.test(detail)) {
+      throw new Error(`This message is too long to send (the limit is ${CLAUDE_AGENT_SDK_MAX_INPUT_BYTES / 1024}KB). Shorten it and resend.`);
+    }
+    if (/unsafe text/.test(detail)) {
+      throw new Error("This message holds a control or incomplete character fray can't send. Edit and resend.");
+    }
+    throw new Error(`fray could not send this message: ${detail}`);
+  }
+}
 function createClaudeAgentBrokerBridge(deps) {
   const sessions = /* @__PURE__ */ new Map();
   const executablePath = resolveClaudeExecutableAbsolute(deps.executablePath, deps.env);
@@ -12713,11 +13052,13 @@ function createClaudeAgentBrokerBridge(deps) {
         killBroker(deps.stateDir, prior.sessionId);
         sessions.delete(input.threadSlug);
       }
+      const message = validatedInput({ id: randomUUID9(), text: input.prompt });
       const session = await attach3(input.threadSlug, input.sessionId, input.cwd, input.permissionMode ?? "default", { appendSystemPrompt: input.appendSystemPrompt, model: input.model, effort: input.effort });
-      session.client.sendInput({ id: randomUUID9(), text: input.prompt });
+      session.client.sendInput(message);
       return { binding: { threadSlug: input.threadSlug, sessionId: input.sessionId, cwd: input.cwd, generation: session.generation, state: "active" } };
     },
     async followUp(input) {
+      const message = validatedInput({ id: inputIdFor(input.deliveryId), text: input.text });
       let held = current(input.threadSlug, input.sessionId);
       if (held && !holdsLiveDaemon(held)) {
         held.client.close();
@@ -12737,7 +13078,7 @@ function createClaudeAgentBrokerBridge(deps) {
         input.permissionMode ?? "default",
         { resume: true, appendSystemPrompt: input.appendSystemPrompt, model: input.model, effort: input.effort }
       );
-      session.client.sendInput({ id: inputIdFor(input.deliveryId), text: input.text });
+      session.client.sendInput(message);
     },
     async cancelFollowUp(input) {
       const held = current(input.threadSlug, input.sessionId);
@@ -12859,15 +13200,15 @@ var init_claude_agent_broker_bridge = __esm({
 });
 
 // packages/server/src/backend/claude-quota.ts
-import { join as join8 } from "node:path";
-import { homedir as homedir3, platform } from "node:os";
+import { join as join9 } from "node:path";
+import { homedir as homedir5, platform } from "node:os";
 import { createHash as createHash5 } from "node:crypto";
 import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 function claudeConfigDir() {
   const override = process.env.CLAUDE_CONFIG_DIR;
-  return override && override.trim() ? override : join8(homedir3(), ".claude");
+  return override && override.trim() ? override : join9(homedir5(), ".claude");
 }
 function tokenFromCredentialsJson(raw2) {
   let doc;
@@ -12896,7 +13237,7 @@ async function readKeychainToken() {
 }
 async function readAccessToken(configDir) {
   try {
-    const fromFile = tokenFromCredentialsJson(await readFile(join8(configDir, ".credentials.json"), "utf8"));
+    const fromFile = tokenFromCredentialsJson(await readFile(join9(configDir, ".credentials.json"), "utf8"));
     if (fromFile) return fromFile;
   } catch {
   }
@@ -12965,8 +13306,8 @@ function parseClaudeUsage(body, planType) {
 function cachePaths(cacheDir, configDir) {
   const profile = createHash5("sha256").update(configDir).digest("hex").slice(0, 12);
   return {
-    data: join8(cacheDir, `claude-${profile}.json`),
-    lock: join8(cacheDir, `claude-${profile}.lock`)
+    data: join9(cacheDir, `claude-${profile}.json`),
+    lock: join9(cacheDir, `claude-${profile}.lock`)
   };
 }
 async function readShared(path) {
@@ -13158,7 +13499,7 @@ function refreshSharedInBackground(paths, claudeBin, deps, now) {
 async function refreshClaudeQuotaInBackground(claudeBin = "claude", deps = {}) {
   const now = (deps.now ?? Date.now)();
   const configDir = claudeConfigDir();
-  const cacheDir = deps.cacheDir ?? join8(homedir3(), ".fray", "quota-cache");
+  const cacheDir = deps.cacheDir ?? join9(homedir5(), ".fray", "quota-cache");
   try {
     await mkdir(cacheDir, { recursive: true, mode: 448 });
   } catch {
@@ -13169,7 +13510,7 @@ async function refreshClaudeQuotaInBackground(claudeBin = "claude", deps = {}) {
 async function readClaudeQuota(claudeBin = "claude", deps = {}, options = {}) {
   const now = (deps.now ?? Date.now)();
   const configDir = claudeConfigDir();
-  const cacheDir = deps.cacheDir ?? join8(homedir3(), ".fray", "quota-cache");
+  const cacheDir = deps.cacheDir ?? join9(homedir5(), ".fray", "quota-cache");
   const paths = cachePaths(cacheDir, configDir);
   try {
     await mkdir(cacheDir, { recursive: true, mode: 448 });
@@ -13257,19 +13598,19 @@ var init_claude_quota = __esm({
 });
 
 // packages/server/src/backend/auth-status.ts
-import { join as join9 } from "node:path";
-import { homedir as homedir4, platform as platform2 } from "node:os";
+import { join as join10 } from "node:path";
+import { homedir as homedir6, platform as platform2 } from "node:os";
 import { readFileSync as readFileSync7 } from "node:fs";
 import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
 function claudeConfigDir2() {
   const override = process.env.CLAUDE_CONFIG_DIR;
-  return override && override.trim() ? override : join9(homedir4(), ".claude");
+  return override && override.trim() ? override : join10(homedir6(), ".claude");
 }
 function claudeFileState(configDir) {
   let raw2;
   try {
-    raw2 = readFileSync7(join9(configDir, ".credentials.json"), "utf8");
+    raw2 = readFileSync7(join10(configDir, ".credentials.json"), "utf8");
   } catch (err) {
     return err.code === "ENOENT" ? "absent" : "error";
   }
@@ -13302,7 +13643,7 @@ function readCodexAuthState(codexHome = defaultCodexHome()) {
   if (process.env.OPENAI_API_KEY || process.env.CODEX_API_KEY || process.env.CODEX_ACCESS_TOKEN) return "authed";
   let raw2;
   try {
-    raw2 = readFileSync7(join9(codexHome, "auth.json"), "utf8");
+    raw2 = readFileSync7(join10(codexHome, "auth.json"), "utf8");
   } catch (err) {
     return err.code === "ENOENT" ? "signed-out" : "unknown";
   }
@@ -13392,7 +13733,7 @@ var init_auth_status = __esm({
 // packages/server/src/fray.ts
 import { execFile as execFile4 } from "node:child_process";
 import { lstatSync, realpathSync as realpathSync4 } from "node:fs";
-import { basename as basename3, dirname as dirname5, join as join10, resolve as resolve5 } from "node:path";
+import { basename as basename3, dirname as dirname5, join as join11, resolve as resolve5 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 function frayScriptsDir() {
   if (process.env.FRAY_SCRIPTS_DIR) return process.env.FRAY_SCRIPTS_DIR;
@@ -13401,7 +13742,7 @@ function frayScriptsDir() {
 function directFrayRoot(projectDir) {
   try {
     const projectRoot = realpathSync4(projectDir);
-    const path = join10(projectRoot, ".fray");
+    const path = join11(projectRoot, ".fray");
     const stat2 = lstatSync(path);
     if (!stat2.isDirectory() || stat2.isSymbolicLink()) return null;
     const real = realpathSync4(path);
@@ -13415,7 +13756,7 @@ function frayDirExists(projectDir) {
 }
 async function readBoard(projectDir, scriptsDir = frayScriptsDir()) {
   if (!directFrayRoot(projectDir)) throw new Error("unsafe or missing .fray directory");
-  const { stdout } = await execFileP("node", [join10(scriptsDir, "index.mjs"), "--json"], {
+  const { stdout } = await execFileP("node", [join11(scriptsDir, "index.mjs"), "--json"], {
     cwd: projectDir,
     env: { ...process.env, CLAUDE_PROJECT_DIR: projectDir },
     maxBuffer: 32 * 1024 * 1024
@@ -13440,7 +13781,7 @@ async function readBoard(projectDir, scriptsDir = frayScriptsDir()) {
   };
 }
 async function runThreadUpdate(projectDir, slug, args, scriptsDir = frayScriptsDir()) {
-  await execFileP("node", [join10(scriptsDir, "thread-update.mjs"), slug, ...args], {
+  await execFileP("node", [join11(scriptsDir, "thread-update.mjs"), slug, ...args], {
     cwd: projectDir,
     env: { ...process.env, CLAUDE_PROJECT_DIR: projectDir }
   });
@@ -13455,12 +13796,12 @@ var init_fray = __esm({
 });
 
 // packages/server/src/session-files.ts
-import { lstatSync as lstatSync2, rmSync as rmSync4 } from "node:fs";
+import { lstatSync as lstatSync2, rmSync as rmSync5 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 function systemPromptPath(sessionId) {
   if (!SESSION_ID_RE.test(sessionId)) throw new Error("invalid session id");
-  return join11(SYSTEM_PROMPT_DIR, `${sessionId}.md`);
+  return join12(SYSTEM_PROMPT_DIR, `${sessionId}.md`);
 }
 function isDirectDirectory(path) {
   try {
@@ -13480,9 +13821,9 @@ function pathAbsent(path) {
 }
 function unlinkDirectChild(parent, filename) {
   if (!isDirectDirectory(parent)) return pathAbsent(parent);
-  const child = join11(parent, filename);
+  const child = join12(parent, filename);
   try {
-    rmSync4(child, { force: true });
+    rmSync5(child, { force: true });
   } catch {
     return false;
   }
@@ -13490,14 +13831,14 @@ function unlinkDirectChild(parent, filename) {
 }
 function cleanupAdoptionSessionFiles(projectDir, sessionId) {
   if (!SESSION_ID_RE.test(sessionId)) return false;
-  const frayDir = join11(projectDir, ".fray");
+  const frayDir = join12(projectDir, ".fray");
   let clean = true;
   if (isDirectDirectory(frayDir)) {
-    const threads = join11(frayDir, "threads");
+    const threads = join12(frayDir, "threads");
     if (isDirectDirectory(threads)) {
-      const child = join11(threads, sessionId);
+      const child = join12(threads, sessionId);
       try {
-        rmSync4(child, { recursive: true, force: true });
+        rmSync5(child, { recursive: true, force: true });
       } catch {
         clean = false;
       }
@@ -13510,7 +13851,7 @@ var SYSTEM_PROMPT_DIR, SESSION_ID_RE;
 var init_session_files = __esm({
   "packages/server/src/session-files.ts"() {
     "use strict";
-    SYSTEM_PROMPT_DIR = join11(tmpdir2(), "fray-sysprompts");
+    SYSTEM_PROMPT_DIR = join12(tmpdir2(), "fray-sysprompts");
     SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/;
   }
 });
@@ -13747,8 +14088,8 @@ var init_adoption_recovery = __esm({
 });
 
 // packages/server/src/dispatch.ts
-import { closeSync as closeSync5, constants, existsSync as existsSync3, fstatSync, lstatSync as lstatSync3, openSync as openSync5, readFileSync as readFileSync8, realpathSync as realpathSync5, statSync as statSync6, writeFileSync as writeFileSync4, renameSync as renameSync5, mkdirSync as mkdirSync7, rmSync as rmSync5 } from "node:fs";
-import { basename as basename4, join as join12, dirname as dirname6 } from "node:path";
+import { closeSync as closeSync5, constants, existsSync as existsSync3, fstatSync, lstatSync as lstatSync3, openSync as openSync6, readFileSync as readFileSync8, realpathSync as realpathSync5, statSync as statSync7, writeFileSync as writeFileSync5, renameSync as renameSync5, mkdirSync as mkdirSync8, rmSync as rmSync6 } from "node:fs";
+import { basename as basename4, join as join13, dirname as dirname6 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { createHash as createHash6, randomUUID as randomUUID11 } from "node:crypto";
 function fallbackTitle(prompt) {
@@ -13768,7 +14109,7 @@ function fallbackTitle(prompt) {
 }
 function resolveSlug(frayDir, base, taken) {
   base = ThreadSlug.parse(base);
-  const isTaken = (slug) => existsSync3(join12(frayDir, `${slug}.md`)) || (taken?.(slug) ?? false);
+  const isTaken = (slug) => existsSync3(join13(frayDir, `${slug}.md`)) || (taken?.(slug) ?? false);
   if (!isTaken(base)) return base;
   for (let n = 2; ; n++) {
     const suffix = `-${n}`;
@@ -13785,12 +14126,12 @@ function resolveLegacyThreadFile(projectDir, value) {
   if (!parsed.success) return null;
   try {
     const projectRoot = realpathSync5(projectDir);
-    const frayPath = join12(projectRoot, ".fray");
+    const frayPath = join13(projectRoot, ".fray");
     const frayStat = lstatSync3(frayPath);
     if (!frayStat.isDirectory() || frayStat.isSymbolicLink()) return null;
     const realFray = realpathSync5(frayPath);
     if (dirname6(realFray) !== projectRoot || basename4(realFray) !== ".fray") return null;
-    const path = join12(realFray, `${parsed.data}.md`);
+    const path = join13(realFray, `${parsed.data}.md`);
     const before = lstatSync3(path);
     if (!before.isFile() || before.isSymbolicLink()) return null;
     const realPath = realpathSync5(path);
@@ -13798,7 +14139,7 @@ function resolveLegacyThreadFile(projectDir, value) {
     let contents;
     let openedBefore;
     let openedAfter;
-    const fd = openSync5(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    const fd = openSync6(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
       openedBefore = fstatSync(fd);
       contents = readFileSync8(fd);
@@ -13834,9 +14175,9 @@ function boardAuthorizesAdoption(board, slug) {
   return !board.errorItems.some((item) => item.file === `${slug}.md`);
 }
 function ensureSafeDirectDirectory(parent, name) {
-  const path = join12(parent, name);
+  const path = join13(parent, name);
   try {
-    mkdirSync7(path);
+    mkdirSync8(path);
   } catch (error) {
     const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
     if (code !== "EEXIST") throw error;
@@ -13907,14 +14248,14 @@ function writeScratchpad(projectDir, sessionId, title, kind = "claude") {
   const threadsDir = ensureSafeDirectDirectory(frayDir, "threads");
   const dir = ensureSafeDirectDirectory(threadsDir, sessionId);
   const rel = scratchpadRelPath(sessionId);
-  const path = join12(dir, "scratch.md");
-  const tmp = join12(dir, ".scratch.tmp");
+  const path = join13(dir, "scratch.md");
+  const tmp = join13(dir, ".scratch.tmp");
   try {
-    writeFileSync4(tmp, scratchpadContent(title, kind), { flag: "wx", mode: 384 });
+    writeFileSync5(tmp, scratchpadContent(title, kind), { flag: "wx", mode: 384 });
     if (existsSync3(path)) throw new Error("scratchpad already exists");
     renameSync5(tmp, path);
   } catch (error) {
-    rmSync5(tmp, { force: true });
+    rmSync6(tmp, { force: true });
     throw error;
   }
   return rel;
@@ -13932,8 +14273,9 @@ function codexScratchpadHookConfig(hookScript, sessionId) {
       }
     ]
   });
-  const bashBackgroundHook = join12(dirname6(hookScript), "bash-background.mjs");
-  const scratchpadStopHook = join12(dirname6(hookScript), "scratchpad-stop.mjs");
+  const bashBackgroundHook = join13(dirname6(hookScript), "bash-background.mjs");
+  const scratchpadStopHook = join13(dirname6(hookScript), "scratchpad-stop.mjs");
+  const fenceStopHook = join13(dirname6(hookScript), "fence-stop.mjs");
   return {
     bypass_hook_trust: true,
     hooks: {
@@ -13948,12 +14290,19 @@ function codexScratchpadHookConfig(hookScript, sessionId) {
         }]
       }],
       // An optional scratchpad-frontmatter reminder can keep a worker from forgetting owned work when
-      // it tries to rest. The hook itself persists the two-minute anti-loop cooldown.
+      // it tries to rest, and the fence check catches a rest that hands a decision back in prose
+      // instead of a ```question card. Each hook persists its own anti-loop guard.
       Stop: [{
-        hooks: [{
-          type: "command",
-          command: `node ${JSON.stringify(scratchpadStopHook)} --session=${JSON.stringify(sessionId)}`
-        }]
+        hooks: [
+          {
+            type: "command",
+            command: `node ${JSON.stringify(scratchpadStopHook)} --session=${JSON.stringify(sessionId)}`
+          },
+          {
+            type: "command",
+            command: `node ${JSON.stringify(fenceStopHook)} --session=${JSON.stringify(sessionId)}`
+          }
+        ]
       }],
       // Native Codex children inherit the root scratchpad mandate even with `fork_turns:"none"`.
       // Constrain it structurally at child start: shared writes, but only merge-style scoped edits.
@@ -13966,10 +14315,10 @@ function codexScratchpadHookConfig(hookScript, sessionId) {
 }
 function scratchpadHookScript() {
   const plugin = workerPluginDir();
-  return plugin ? join12(plugin, "hooks", "scratchpad.mjs") : void 0;
+  return plugin ? join13(plugin, "hooks", "scratchpad.mjs") : void 0;
 }
 function composePrompt(sessionId, prompt, kind = "claude") {
-  const scratch = kind === "codex" ? `Your scratchpad is \`.fray/threads/${sessionId}/scratch.md\` \u2014 the CANONICAL record of this thread, your compaction-survival mechanism, and a shared progress document for native sub-agents. Keep your task list, the approach and what you rejected, the human's decisions, and anything that must outlive your context IN it, written as you go; re-read it after any compaction or resume before asserting anything. Each native sub-agent should merge its own scoped progress into it rather than leaving the root as its sole writer, but must re-read before each edit, preserve all existing content, and never delete, truncate, reinitialize, move, or replace the whole file.` : `Your scratchpad is \`.fray/threads/${sessionId}/scratch.md\` \u2014 the CANONICAL record of this thread, your compaction-survival mechanism, and the shared blackboard for your sub-agents. Keep your task list, the approach and what you rejected, the human's decisions, and anything that must outlive your context IN it, written as you go; re-read it after any compaction or resume, and pass its path to every sub-agent you dispatch. Each sub-agent should merge its own scoped progress into it rather than leaving the root as its sole writer, but must re-read before each edit, preserve all existing content, and never delete, truncate, reinitialize, move, or replace the whole file.`;
+  const scratch = kind === "codex" ? `Your scratchpad is \`.fray/threads/${sessionId}/scratch.md\` \u2014 an OPTIONAL scratch file kept for you, not a deliverable. A single direct task usually needs nothing in it, and writing in it never substitutes for doing the work. On a long effort it is useful crash insurance and a shared progress document for native sub-agents: keep the approach, what you rejected, and the human's decisions in it as you go, mid-work, then keep working; re-read it after any compaction or resume before asserting anything. Each native sub-agent should merge its own scoped progress into it rather than leaving the root as its sole writer, but must re-read before each edit, preserve all existing content, and never delete, truncate, reinitialize, move, or replace the whole file.` : `Your scratchpad is \`.fray/threads/${sessionId}/scratch.md\` \u2014 an OPTIONAL scratch file kept for you, not a deliverable. A single direct task usually needs nothing in it, and writing in it never substitutes for doing the work. On a long effort it is useful crash insurance and the shared blackboard for your sub-agents: keep the approach, what you rejected, and the human's decisions in it as you go, mid-work, then keep working; re-read it after any compaction or resume, and pass its path to every sub-agent you dispatch. Each sub-agent should merge its own scoped progress into it rather than leaving the root as its sole writer, but must re-read before each edit, preserve all existing content, and never delete, truncate, reinitialize, move, or replace the whole file.`;
   const handoff = "\n\nEverything above the banner below is fray system orientation. Everything below it is the human operator's own prompt, verbatim \u2014 that, and nothing else, is your task.";
   return `${scratch}${handoff}
 
@@ -13977,16 +14326,16 @@ function composePrompt(sessionId, prompt, kind = "claude") {
 ${DISPATCH_TASK_BANNER_MARKER}${prompt}`;
 }
 function scratchpadOrientation(sessionId, planPath, kind = "claude") {
-  const scratch = kind === "codex" ? `SCRATCHPAD: .fray/threads/${sessionId}/scratch.md \u2014 the CANONICAL record of this thread, your compaction-survival mechanism, and a shared progress document for native sub-agents (write your task list, the approach and what you rejected, and anything that must outlive your context there, as you go; re-read it after any compaction or resume). Each native sub-agent should merge its own scoped progress into it rather than leaving the root as its sole writer, but must re-read before each edit, preserve all existing content, and never delete, truncate, reinitialize, move, or replace the whole file.` : `SCRATCHPAD: .fray/threads/${sessionId}/scratch.md \u2014 the CANONICAL record of this thread, your compaction-survival mechanism, and the shared blackboard for your sub-agents (write your task list, the approach and what you rejected, and anything that must outlive your context there, as you go; re-read it after any compaction or resume; pass this path in every sub-agent prompt). Each sub-agent should merge its own scoped progress into it rather than leaving the root as its sole writer, but must re-read before each edit, preserve all existing content, and never delete, truncate, reinitialize, move, or replace the whole file.`;
+  const scratch = kind === "codex" ? `SCRATCHPAD (optional): .fray/threads/${sessionId}/scratch.md \u2014 a scratch file kept FOR YOU, not a deliverable. A single direct task usually needs nothing in it; writing in it is never a substitute for doing the work. Useful on a long effort as crash insurance, and a shared progress document for native sub-agents (write your task list, the approach and what you rejected, and anything that must outlive your context there, as you go; re-read it after any compaction or resume). Each native sub-agent should merge its own scoped progress into it rather than leaving the root as its sole writer, but must re-read before each edit, preserve all existing content, and never delete, truncate, reinitialize, move, or replace the whole file.` : `SCRATCHPAD (optional): .fray/threads/${sessionId}/scratch.md \u2014 a scratch file kept FOR YOU, not a deliverable. A single direct task usually needs nothing in it; writing in it is never a substitute for doing the work. Useful on a long effort as crash insurance, and the shared blackboard for your sub-agents (write your task list, the approach and what you rejected, and anything that must outlive your context there, as you go; re-read it after any compaction or resume; pass this path in every sub-agent prompt). Each sub-agent should merge its own scoped progress into it rather than leaving the root as its sole writer, but must re-read before each edit, preserve all existing content, and never delete, truncate, reinitialize, move, or replace the whole file.`;
   const lines = [scratch];
   if (planPath) lines.push(`PLAN: ${planPath} \u2014 the durable plan artifact this thread works from; read it FIRST.`);
   return lines.join("\n");
 }
 function frayConfigBlock(projectDir) {
-  const path = join12(projectDir, "FRAY.md");
+  const path = join13(projectDir, "FRAY.md");
   let body;
   try {
-    const st = statSync6(path);
+    const st = statSync7(path);
     if (!st.isFile() || st.size > FRAY_MD_MAX_BYTES) return "";
     body = readFileSync8(path, "utf8").trim();
   } catch {
@@ -14002,7 +14351,7 @@ ${clipped}`;
 }
 function validPlanPath(projectDir, planPath) {
   if (!planPath || !PLAN_PATH_RE.test(planPath)) return null;
-  return existsSync3(join12(projectDir, planPath)) ? planPath : null;
+  return existsSync3(join13(projectDir, planPath)) ? planPath : null;
 }
 function workerPermissionMode(m) {
   return m === "plan" ? "auto" : m;
@@ -14014,15 +14363,15 @@ function effectivePermissionMode(kind, mode) {
 }
 function systemPromptFlags(sessionId, system) {
   if (!system) return [];
-  mkdirSync7(SYSTEM_PROMPT_DIR, { recursive: true });
+  mkdirSync8(SYSTEM_PROMPT_DIR, { recursive: true });
   const path = systemPromptPath(sessionId);
-  writeFileSync4(path, system);
+  writeFileSync5(path, system);
   return ["--append-system-prompt-file", path];
 }
 function resolveFrayMcp(stateDir, moduleUrl = import.meta.url, env = process.env) {
   const pluginDir = resolveWorkerPluginDir(moduleUrl, env);
   if (!pluginDir) return void 0;
-  const scriptPath = join12(pluginDir, "bin", FRAY_MCP.script);
+  const scriptPath = join13(pluginDir, "bin", FRAY_MCP.script);
   if (!existsSync3(scriptPath)) return void 0;
   return { scriptPath, stateDir };
 }
@@ -14060,12 +14409,12 @@ function buildClaudeCommand(opts) {
 }
 function resolveWorkerPluginDir(moduleUrl = import.meta.url, env = process.env) {
   const override = env.FRAY_WORKER_PLUGIN_DIR;
-  if (override && existsSync3(join12(override, ".claude-plugin", "plugin.json")))
+  if (override && existsSync3(join13(override, ".claude-plugin", "plugin.json")))
     return override;
   let current = dirname6(fileURLToPath2(moduleUrl));
   for (; ; ) {
-    const candidate = join12(current, "cc-worker");
-    if (existsSync3(join12(candidate, ".claude-plugin", "plugin.json"))) return candidate;
+    const candidate = join13(current, "cc-worker");
+    if (existsSync3(join13(candidate, ".claude-plugin", "plugin.json"))) return candidate;
     const parent = dirname6(current);
     if (parent === current) return void 0;
     current = parent;
@@ -14109,7 +14458,7 @@ function createDispatcher(deps) {
   const killPane2 = deps.killPane ?? killPane;
   const killSession2 = deps.killSession ?? killSession;
   const readBoardSource = deps.readBoard ?? readBoard;
-  const frayDir = join12(deps.project.dir, ".fray");
+  const frayDir = join13(deps.project.dir, ".fray");
   const adoptionRuntime = deps.adoptionRuntime ?? {
     lookupAdoptionPane,
     findAdoptionPane,
@@ -14149,14 +14498,14 @@ function createDispatcher(deps) {
   }
   function writePrewrites(built) {
     for (const file of built.prewrite) {
-      if (file.mode === void 0) writeFileSync4(file.path, file.contents);
-      else writeFileSync4(file.path, file.contents, { mode: file.mode });
+      if (file.mode === void 0) writeFileSync5(file.path, file.contents);
+      else writeFileSync5(file.path, file.contents, { mode: file.mode });
     }
   }
   function cleanupPrewrites(built) {
     for (const path of new Set(built.prewrite.map((file) => file.path))) {
       try {
-        rmSync5(path, { force: true });
+        rmSync6(path, { force: true });
       } catch {
       }
     }
@@ -14164,7 +14513,7 @@ function createDispatcher(deps) {
   function cleanupDispatchFiles(scratchRel, built, sessionId) {
     cleanupPrewrites(built);
     try {
-      rmSync5(join12(deps.project.dir, scratchRel), { force: true });
+      rmSync6(join13(deps.project.dir, scratchRel), { force: true });
     } catch {
     }
     cleanupAdoptionSessionFiles(deps.project.dir, sessionId);
@@ -14952,10 +15301,10 @@ var init_permission_controller = __esm({
 });
 
 // packages/server/src/backend/codex-models.ts
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import { readFileSync as readFileSync9 } from "node:fs";
 function cachePath(codexHome) {
-  return join13(codexHome, "models_cache.json");
+  return join14(codexHome, "models_cache.json");
 }
 function toCodexModel(raw2) {
   if (!raw2 || typeof raw2 !== "object") return void 0;
@@ -15717,7 +16066,7 @@ var init_delivery_ledger = __esm({
 });
 
 // packages/server/src/codex-subagents.ts
-import { closeSync as closeSync6, openSync as openSync6, readSync as readSync2, statSync as statSync7 } from "node:fs";
+import { closeSync as closeSync6, openSync as openSync7, readSync as readSync2, statSync as statSync8 } from "node:fs";
 function createCodexSubAgentTracker(deps) {
   const findRollouts = deps.findRollouts ?? ((ids) => findRolloutsByIds(ids, deps.codexHome));
   const readAppended = deps.readAppended ?? defaultReadAppended;
@@ -15900,7 +16249,7 @@ function agentLabel(path) {
 function defaultReadAppended(path, offset) {
   let size;
   try {
-    size = statSync7(path).size;
+    size = statSync8(path).size;
   } catch {
     return void 0;
   }
@@ -15908,7 +16257,7 @@ function defaultReadAppended(path, offset) {
   const from = restarted ? 0 : offset;
   if (size <= from) return { text: "", offset: from, restarted };
   try {
-    const fd = openSync6(path, "r");
+    const fd = openSync7(path, "r");
     try {
       const buf = Buffer.allocUnsafe(size - from);
       const read = readSync2(fd, buf, 0, buf.length, from);
@@ -16011,15 +16360,15 @@ var init_completion_relay = __esm({
 
 // packages/server/src/tail-cache.ts
 import { createHash as createHash7 } from "node:crypto";
-import { closeSync as closeSync7, openSync as openSync7, readFileSync as readFileSync10, readSync as readSync3, statSync as statSync8 } from "node:fs";
-import { join as join14 } from "node:path";
+import { closeSync as closeSync7, openSync as openSync8, readFileSync as readFileSync10, readSync as readSync3, statSync as statSync9 } from "node:fs";
+import { join as join15 } from "node:path";
 function foldSchemaDigest(dir = import.meta.dirname) {
   if (foldSchemaMemo) return foldSchemaMemo;
   const hash = createHash7("sha256").update("fray-tail-state-v1\0");
   let read = 0;
   for (const name of FOLD_SOURCES) {
     try {
-      hash.update(name).update("\0").update(readFileSync10(join14(dir, name)));
+      hash.update(name).update("\0").update(readFileSync10(join15(dir, name)));
       read++;
     } catch {
       hash.update(name).update("\0missing\0");
@@ -16049,9 +16398,9 @@ function measureFence(path, offset) {
   if (!Number.isSafeInteger(offset) || offset <= 0) return null;
   let fd;
   try {
-    const stat2 = statSync8(path);
+    const stat2 = statSync9(path);
     if (stat2.size < offset) return null;
-    fd = openSync7(path, "r");
+    fd = openSync8(path, "r");
     const window = Math.min(SAMPLE_BYTES, offset);
     const head = Buffer.allocUnsafe(window);
     const headRead = readSync3(fd, head, 0, window, 0);
@@ -16215,9 +16564,9 @@ var init_tail_cache = __esm({
 });
 
 // packages/server/src/tailer.ts
-import { statSync as statSync9, openSync as openSync8, readSync as readSync4, closeSync as closeSync8, readdirSync as readdirSync3, mkdirSync as mkdirSync8, writeFileSync as writeFileSync5, readFileSync as readFileSync11 } from "node:fs";
-import { join as join15 } from "node:path";
-import { homedir as homedir5, tmpdir as tmpdir3 } from "node:os";
+import { statSync as statSync10, openSync as openSync9, readSync as readSync4, closeSync as closeSync8, readdirSync as readdirSync4, mkdirSync as mkdirSync9, writeFileSync as writeFileSync6, readFileSync as readFileSync11 } from "node:fs";
+import { join as join16 } from "node:path";
+import { homedir as homedir7, tmpdir as tmpdir3 } from "node:os";
 function activityMinute(at) {
   if (!at) return "";
   const ms = Date.parse(at);
@@ -16471,7 +16820,7 @@ function launchTaskId(text) {
 function readDescendantSidecars(sessionDir, mtimeMs) {
   let names;
   try {
-    names = readdirSync3(join15(sessionDir, "subagents"));
+    names = readdirSync4(join16(sessionDir, "subagents"));
   } catch {
     return [];
   }
@@ -16482,7 +16831,7 @@ function readDescendantSidecars(sessionDir, mtimeMs) {
     if (!agentId) continue;
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync11(join15(sessionDir, "subagents", name), "utf8"));
+      parsed = JSON.parse(readFileSync11(join16(sessionDir, "subagents", name), "utf8"));
     } catch {
       continue;
     }
@@ -16496,7 +16845,7 @@ function readDescendantSidecars(sessionDir, mtimeMs) {
       agentType: text(meta.agentType),
       parentAgentId: text(meta.parentAgentId),
       spawnDepth: typeof meta.spawnDepth === "number" && Number.isFinite(meta.spawnDepth) ? meta.spawnDepth : void 0,
-      spawnedAtMs: mtimeMs(join15(sessionDir, "subagents", name))
+      spawnedAtMs: mtimeMs(join16(sessionDir, "subagents", name))
     });
   }
   return out;
@@ -16932,13 +17281,13 @@ function isPermMarker(v) {
 }
 function defaultMtimeMs(path) {
   try {
-    return statSync9(path).mtimeMs;
+    return statSync10(path).mtimeMs;
   } catch {
     return void 0;
   }
 }
 function defaultLogDir(project) {
-  return join15(homedir5(), ".claude", "projects", project.cwdSlug);
+  return join16(homedir7(), ".claude", "projects", project.cwdSlug);
 }
 function defaultReadPermMarker(project) {
   if (!project.stateDir) return () => void 0;
@@ -17087,7 +17436,7 @@ function createTailer(deps) {
     return captured.kind === "captured" ? captured.text : "";
   }
   const defaultBackend = {
-    transcriptPath: (sessionId) => join15(logDir, `${sessionId}.jsonl`),
+    transcriptPath: (sessionId) => join16(logDir, `${sessionId}.jsonl`),
     foldLine: (state, line) => {
       const rec = parseLine(line);
       if (rec) applyRecord(state, rec);
@@ -17189,7 +17538,7 @@ ${ask}`;
     return state.path.replace(/\.jsonl$/, "");
   }
   function descendantSidecars(state) {
-    const at = mtimeMs(join15(sessionDirOf(state), "subagents"));
+    const at = mtimeMs(join16(sessionDirOf(state), "subagents"));
     const cached = descendantIndex.get(state.slug);
     if (cached && cached.at === at) return cached.all;
     const all = readDescendantSidecars(sessionDirOf(state), mtimeMs);
@@ -17203,7 +17552,7 @@ ${ask}`;
     return descendantIndex.get(state.slug)?.byToolUse.get(id);
   }
   function descendantTranscript(state, meta) {
-    return join15(sessionDirOf(state), "subagents", `agent-${meta.agentId}.jsonl`);
+    return join16(sessionDirOf(state), "subagents", `agent-${meta.agentId}.jsonl`);
   }
   function descendantState(state, meta) {
     const task = deps.runtimeTasks?.(state.sessionId).find((entry) => entry.taskId === meta.agentId);
@@ -17428,7 +17777,7 @@ ${ask}`;
   function scanForeign(nowMs) {
     let names;
     try {
-      names = readdirSync3(logDir);
+      names = readdirSync4(logDir);
     } catch {
       return [];
     }
@@ -17443,10 +17792,10 @@ ${ask}`;
       if (name.startsWith(".") || !name.endsWith(".jsonl")) continue;
       const id = name.slice(0, -".jsonl".length);
       if (!id || registered.has(id)) continue;
-      const path = join15(logDir, name);
+      const path = join16(logDir, name);
       let mtime;
       try {
-        mtime = statSync9(path).mtimeMs;
+        mtime = statSync10(path).mtimeMs;
       } catch {
         continue;
       }
@@ -17636,7 +17985,7 @@ ${ask}`;
   function consume(state, backend, onLine) {
     let size;
     try {
-      size = statSync9(state.path).size;
+      size = statSync10(state.path).size;
     } catch {
       return;
     }
@@ -17647,7 +17996,7 @@ ${ask}`;
     if (size <= state.offset) return;
     let chunk = "";
     try {
-      const fd = openSync8(state.path, "r");
+      const fd = openSync9(state.path, "r");
       try {
         const buf = Buffer.allocUnsafe(size - state.offset);
         const read = readSync4(fd, buf, 0, buf.length, state.offset);
@@ -17687,13 +18036,14 @@ ${ask}`;
     const authFailure = row.backend !== "codex" && isClaudeAuthErrorText(pane);
     if (authFailure) state.authFault = "authentication_rejected";
     const detail = authFailure ? "(claude authentication failure \u2014 pane content redacted; sign in and retry)" : pane.trim() || "(pane empty / unavailable)";
-    console.error(
-      `[fray-ui] thread ${row.slug} (session ${row.session_id}): no transcript ${DISCOVERY_GRACE_MS / 1e3}s after dispatch \u2014 likely a boot failure. Pane:
+    log.error(
+      "tailer",
+      `thread ${row.slug} (session ${row.session_id}): no transcript ${DISCOVERY_GRACE_MS / 1e3}s after dispatch \u2014 likely a boot failure. Pane:
 ${detail.slice(0, 4e3)}`
     );
     try {
-      mkdirSync8(STALL_LOG_DIR, { recursive: true });
-      writeFileSync5(join15(STALL_LOG_DIR, `${row.slug}.stall.log`), `session_id: ${row.session_id}
+      mkdirSync9(STALL_LOG_DIR, { recursive: true });
+      writeFileSync6(join16(STALL_LOG_DIR, `${row.slug}.stall.log`), `session_id: ${row.session_id}
 captured_at: ${new Date(now()).toISOString()}
 
 ${detail}
@@ -17705,7 +18055,7 @@ ${detail}
     if (state.offset > 0) return true;
     let size = 0;
     try {
-      size = statSync9(state.path).size;
+      size = statSync10(state.path).size;
     } catch {
       size = 0;
     }
@@ -17732,7 +18082,7 @@ ${detail}
         committed = false;
       }
       if (!committed) return false;
-      state.path = join15(logDir, `${found}.jsonl`);
+      state.path = join16(logDir, `${found}.jsonl`);
       state.offset = 0;
       state.partial = "";
       state.primed = false;
@@ -17760,7 +18110,7 @@ ${detail}
       let state = states.get(row.slug);
       const runtimeGeneration = row.runtime_generation ?? 0;
       if (!state || state.sessionId !== row.session_id || state.nativeSessionId !== nativeId || state.runtimeGeneration !== runtimeGeneration) {
-        const path = backend.transcriptPath(nativeId) ?? join15(logDir, `${nativeId}.jsonl`);
+        const path = backend.transcriptPath(nativeId) ?? join16(logDir, `${nativeId}.jsonl`);
         state = newTailState(row.slug, row.session_id, path, false, nativeId, runtimeGeneration);
         hydrateFromCache(state, row, nativeId);
         states.set(row.slug, state);
@@ -17999,8 +18349,9 @@ ${detail}
       if (elapsed > POLL_MS3) {
         overBudgetTicks++;
         if (overBudgetTicks === 1 || overBudgetTicks % 30 === 0) {
-          console.error(
-            `[fray-ui] tailer tick took ${Math.round(elapsed)}ms (poll ${POLL_MS3}ms, ${states.size} sessions) \u2014 the event loop is blocked for that long, so RPCs and board pushes are delayed (occurrence ${overBudgetTicks})`
+          log.warn(
+            "tailer",
+            `tick took ${Math.round(elapsed)}ms (poll ${POLL_MS3}ms, ${states.size} sessions) \u2014 the event loop is blocked for that long, so RPCs and board pushes are delayed (occurrence ${overBudgetTicks})`
           );
         }
       }
@@ -18010,7 +18361,7 @@ ${detail}
   function reportTickFailure(error) {
     tickFailures++;
     if (tickFailures === 1 || tickFailures % 50 === 0) {
-      console.error(`[fray-ui] tailer tick threw (occurrence ${tickFailures}; the loop keeps running): ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
+      log.error("tailer", `tick threw (occurrence ${tickFailures}; the loop keeps running): ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
     }
   }
   function scheduleTick() {
@@ -18130,6 +18481,7 @@ var init_tailer = __esm({
     init_codex_subagents();
     init_completion_relay();
     init_tail_cache();
+    init_logging();
     IDLE_BACKSTOP_MS = 5e3;
     RUNTIME_CHASE_MAX = 20;
     POLL_MS3 = 1e3;
@@ -18143,7 +18495,7 @@ var init_tailer = __esm({
     CACHE_FLUSH_MS = 3e4;
     PRIME_PROGRESS_EVERY = 20;
     DISCOVER_RETRY_MS = 15e3;
-    STALL_LOG_DIR = join15(tmpdir3(), "fray-worker-logs");
+    STALL_LOG_DIR = join16(tmpdir3(), "fray-worker-logs");
     PERM_YES_OPTION = /(^|\n)\s*(❯\s*)?1\.\s+Yes\b/;
     PERM_QUESTION = /\b(?:Do you want|Would you like)\b/;
     PERM_FOOTER = /\bEsc to (cancel|reject)\b/;
@@ -18203,14 +18555,14 @@ var init_tailer = __esm({
 });
 
 // packages/server/src/backend/codex.ts
-import { join as join16 } from "node:path";
-import { homedir as homedir6 } from "node:os";
-import { readdirSync as readdirSync4, statSync as statSync10 } from "node:fs";
+import { join as join17 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { readdirSync as readdirSync5, statSync as statSync11 } from "node:fs";
 function defaultCodexHome() {
-  return process.env.CODEX_HOME && process.env.CODEX_HOME.trim() ? process.env.CODEX_HOME : join16(homedir6(), ".codex");
+  return process.env.CODEX_HOME && process.env.CODEX_HOME.trim() ? process.env.CODEX_HOME : join17(homedir8(), ".codex");
 }
 function sessionsDir(codexHome) {
-  return join16(codexHome, "sessions");
+  return join17(codexHome, "sessions");
 }
 function codexSandbox(mode) {
   switch (mode) {
@@ -18627,23 +18979,23 @@ function collectRollouts(dir, out, budget) {
   const files = entries.filter((e) => e.isFile() && e.name.startsWith("rollout-") && e.name.endsWith(".jsonl")).sort(descByName);
   for (const d of dirs) {
     if (budget.n <= 0) return;
-    collectRollouts(join16(dir, d.name), out, budget);
+    collectRollouts(join17(dir, d.name), out, budget);
   }
   for (const f of files) {
     if (budget.n <= 0) return;
     let mtimeMs;
     try {
-      mtimeMs = statSync10(join16(dir, f.name)).mtimeMs;
+      mtimeMs = statSync11(join17(dir, f.name)).mtimeMs;
     } catch {
       continue;
     }
-    out.push({ path: join16(dir, f.name), mtimeMs });
+    out.push({ path: join17(dir, f.name), mtimeMs });
     budget.n--;
   }
 }
 function safeReaddir(dir) {
   try {
-    return readdirSync4(dir, { withFileTypes: true });
+    return readdirSync5(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -22491,23 +22843,64 @@ var init_wrapper = __esm({
   }
 });
 
+// packages/server/src/backend/codex-mcp.ts
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function inlineTable(entries) {
+  return `{${entries.map(([k, v]) => `${k}=${v}`).join(",")}}`;
+}
+function serverTable(command, args, env) {
+  const entries = [
+    ["command", tomlString(command)],
+    ["args", `[${args.map(tomlString).join(",")}]`]
+  ];
+  if (env && Object.keys(env).length > 0) {
+    entries.push(["env", inlineTable(Object.entries(env).map(([k, v]) => [k, tomlString(v)]))]);
+  }
+  return inlineTable(entries);
+}
+function codexMcpConfigArgs(frayMcp, nodeBin = process.execPath) {
+  const args = [
+    "-c",
+    `mcp_servers.${CHROME_DEVTOOLS_MCP.name}=${serverTable(CHROME_DEVTOOLS_MCP.command, CHROME_DEVTOOLS_MCP.args)}`
+  ];
+  if (frayMcp) {
+    args.push(
+      "-c",
+      `mcp_servers.${FRAY_MCP.name}=${serverTable(nodeBin, [frayMcp.scriptPath], { FRAY_STATE_DIR: frayMcp.stateDir })}`
+    );
+  }
+  args.push("-c", `default_tools_approval_mode=${tomlString("approve")}`);
+  return args;
+}
+function codexAppServerArgv(transport, frayMcp) {
+  return ["app-server", ...codexMcpConfigArgs(frayMcp), ...transport];
+}
+var init_codex_mcp = __esm({
+  "packages/server/src/backend/codex-mcp.ts"() {
+    "use strict";
+    init_types2();
+  }
+});
+
 // packages/server/src/backend/codex-app-server-native.ts
 import { spawn as spawn3 } from "node:child_process";
 import { connect } from "node:net";
 import { createHash as createHash8, randomUUID as randomUUID12 } from "node:crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync9, readFileSync as readFileSync12, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync10, readFileSync as readFileSync12, unlinkSync as unlinkSync2, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join18 } from "node:path";
 import { PassThrough, Writable } from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 function nativeDir(stateDir) {
-  return join17(stateDir, "codex-app-server-native");
+  return join18(stateDir, "codex-app-server-native");
 }
 function nativeRecordPath(stateDir, projectId) {
-  return join17(nativeDir(stateDir), `${projectId}.json`);
+  return join18(nativeDir(stateDir), `${projectId}.json`);
 }
 function nativeListenSocketPath(stateDir, projectId) {
   const key = createHash8("sha256").update(stateDir).update("\0").update(projectId).digest("hex").slice(0, 16);
-  return join17(process.env.TMPDIR ?? "/tmp", `fray-codex-native-${key}.sock`);
+  return join18(process.env.TMPDIR ?? "/tmp", `fray-codex-native-${key}.sock`);
 }
 function pidAlive2(pid) {
   try {
@@ -22666,7 +23059,7 @@ function attach(record, timeoutMs) {
 }
 async function startListener(options) {
   const { stateDir, projectId } = options;
-  mkdirSync9(nativeDir(stateDir), { recursive: true });
+  mkdirSync10(nativeDir(stateDir), { recursive: true });
   const socketPath = nativeListenSocketPath(stateDir, projectId);
   if (existsSync4(socketPath) && !await socketAccepting(socketPath)) {
     try {
@@ -22675,7 +23068,7 @@ async function startListener(options) {
     }
   }
   const generation = randomUUID12();
-  const child = spawn3(options.codexBin, ["app-server", "--listen", `unix://${socketPath}`], {
+  const child = spawn3(options.codexBin, codexAppServerArgv(["--listen", `unix://${socketPath}`], options.frayMcp), {
     cwd: options.cwd,
     env: options.env,
     detached: true,
@@ -22689,7 +23082,7 @@ async function startListener(options) {
     socketPath,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  writeFileSync6(nativeRecordPath(stateDir, projectId), JSON.stringify(record));
+  writeFileSync7(nativeRecordPath(stateDir, projectId), JSON.stringify(record));
   const deadline = Date.now() + (options.timeoutMs ?? 3e4);
   for (; ; ) {
     if (existsSync4(socketPath) && await socketAccepting(socketPath)) return record;
@@ -22703,6 +23096,8 @@ var init_codex_app_server_native = __esm({
   "packages/server/src/backend/codex-app-server-native.ts"() {
     "use strict";
     init_wrapper();
+    init_codex_mcp();
+    init_logging();
     PRESUMED_LOSSY_REJOIN = 1;
     nativeListenCodexAppServerHost = async (options) => {
       const timeoutMs = options.timeoutMs ?? 3e4;
@@ -22743,8 +23138,8 @@ var init_codex_app_server_native = __esm({
             droppedWhileDetached: PRESUMED_LOSSY_REJOIN
           };
         }
-        console.error(`[fray-ui] codex app-server native listener unavailable (${error.message}); falling back to an in-process app-server \u2014 turns will NOT survive a fray restart`);
-        const child = spawn3(options.codexBin, ["app-server", "--stdio"], { cwd: options.cwd, env: options.env, stdio: ["pipe", "pipe", "pipe"] });
+        log.error("codex", `codex app-server native listener unavailable (${error.message}); falling back to an in-process app-server \u2014 turns will NOT survive a fray restart`);
+        const child = spawn3(options.codexBin, codexAppServerArgv(["--stdio"], options.frayMcp), { cwd: options.cwd, env: options.env, stdio: ["pipe", "pipe", "pipe"] });
         return { process: child, generation: randomUUID12(), reattached: false, daemonPid: process.pid, droppedWhileDetached: 0 };
       }
     };
@@ -22755,20 +23150,20 @@ var init_codex_app_server_native = __esm({
 import { spawn as spawn4 } from "node:child_process";
 import { createConnection } from "node:net";
 import { createHash as createHash9, randomUUID as randomUUID13 } from "node:crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync10, readFileSync as readFileSync13, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync11, readFileSync as readFileSync13, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join19 } from "node:path";
 import { PassThrough as PassThrough2, Writable as Writable2 } from "node:stream";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 function daemonDir(stateDir) {
-  return join18(stateDir, "codex-app-server");
+  return join19(stateDir, "codex-app-server");
 }
 function recordPath(stateDir, projectId) {
-  return join18(daemonDir(stateDir), `${projectId}.json`);
+  return join19(daemonDir(stateDir), `${projectId}.json`);
 }
 function codexAppServerSocketPath(stateDir, projectId) {
   const key = createHash9("sha256").update(stateDir).update("\0").update(projectId).digest("hex").slice(0, 16);
   if (process.platform === "win32") return `\\\\.\\pipe\\fray-codex-${key}`;
-  return join18(process.env.TMPDIR ?? "/tmp", `fray-codex-${key}.sock`);
+  return join19(process.env.TMPDIR ?? "/tmp", `fray-codex-${key}.sock`);
 }
 function pidAlive3(pid) {
   try {
@@ -22852,7 +23247,7 @@ async function stopCodexAppServerDaemon(stateDir, projectId, timeoutMs = 1e4) {
 }
 function forkDaemon(options) {
   const { stateDir, projectId } = options;
-  mkdirSync10(daemonDir(stateDir), { recursive: true });
+  mkdirSync11(daemonDir(stateDir), { recursive: true });
   const record = recordPath(stateDir, projectId);
   try {
     unlinkSync3(record);
@@ -22872,6 +23267,10 @@ function forkDaemon(options) {
     generation,
     clientInfo: options.clientInfo,
     capabilities: options.capabilities,
+    // The argv is built HERE, not in the daemon: the daemon is a bare forked entry that should not have
+    // to resolve fray's MCP descriptors, and building it once keeps this transport identical to the
+    // native listener's.
+    appServerArgs: codexAppServerArgv(["--stdio"], options.frayMcp),
     ...options.reachabilityCheckMs === void 0 ? {} : { reachabilityCheckMs: options.reachabilityCheckMs }
   });
   const child = spawn4(process.execPath, [options.daemonEntry ?? daemonEntry()], {
@@ -22982,7 +23381,7 @@ function attach2(record, timeoutMs) {
   });
 }
 function inProcessCodexAppServer(options) {
-  const child = spawn4(options.codexBin, ["app-server", "--stdio"], {
+  const child = spawn4(options.codexBin, codexAppServerArgv(["--stdio"], options.frayMcp), {
     cwd: options.cwd,
     env: options.env,
     stdio: ["pipe", "pipe", "pipe"]
@@ -22991,7 +23390,7 @@ function inProcessCodexAppServer(options) {
 }
 function directChildHost(spawnChild, generationId = randomUUID13) {
   return async (options) => ({
-    process: spawnChild(options.codexBin, ["app-server", "--stdio"], { cwd: options.cwd, env: options.env }),
+    process: spawnChild(options.codexBin, codexAppServerArgv(["--stdio"], options.frayMcp), { cwd: options.cwd, env: options.env }),
     generation: generationId(),
     reattached: false,
     daemonPid: process.pid,
@@ -23004,6 +23403,8 @@ var init_codex_app_server_host = __esm({
     "use strict";
     init_detached_daemons();
     init_codex_app_server_native();
+    init_codex_mcp();
+    init_logging();
     daemonEntry = () => resolveDetachedDaemonEntry(import.meta.url, "codex-app-server-daemon");
     daemonCodexAppServerHost = async (options) => {
       const existing = liveDaemonRecord(options.stateDir, options.projectId);
@@ -23033,7 +23434,7 @@ var init_codex_app_server_host = __esm({
         const attached = await attach2(record, timeoutMs);
         return { ...attached, generation: record.generation, reattached: false, daemonPid: record.daemonPid };
       } catch (error) {
-        console.error(`[fray-ui] codex app-server daemon unavailable (${error.message}); falling back to an in-process app-server \u2014 turns will NOT survive a fray restart`);
+        log.error("codex", `codex app-server daemon unavailable (${error.message}); falling back to an in-process app-server \u2014 turns will NOT survive a fray restart`);
         return inProcessCodexAppServer(options);
       }
     };
@@ -23597,6 +23998,7 @@ var init_codex_app_server = __esm({
     init_credential_redaction();
     init_codex_app_server_host();
     init_codex_app_server_native();
+    init_logging();
     CODEX_APP_SERVER_PROVIDER = "codex-app-server";
     CODEX_NATIVE_LISTEN_FLAG = "FRAY_CODEX_NATIVE_LISTEN";
     CODEX_APP_SERVER_SUPPORTED_VERSION = "0.146.0";
@@ -24922,7 +25324,8 @@ var init_codex_app_server = __esm({
           // environment; no value is copied into argv, SQLite, diagnostics, or logs.
           env: codexAppServerEnvironment(),
           clientInfo: CLIENT_INFO,
-          capabilities: CLIENT_CAPABILITIES
+          capabilities: CLIENT_CAPABILITIES,
+          frayMcp: this.options.frayMcp
         });
         const child = attachment.process;
         let connection;
@@ -24961,7 +25364,7 @@ var init_codex_app_server = __esm({
             });
             if (version !== aheadVersionWarned) {
               aheadVersionWarned = version;
-              console.warn(`[fray-ui] ${verdict.message}`);
+              log.warn("codex", verdict.message);
             }
           }
           handshaking = false;
@@ -25832,17 +26235,17 @@ var init_codex_app_server = __esm({
 });
 
 // packages/server/src/backend/codex-quota.ts
-import { join as join19 } from "node:path";
-import { readdirSync as readdirSync5, statSync as statSync11, openSync as openSync9, readSync as readSync5, fstatSync as fstatSync2, closeSync as closeSync9 } from "node:fs";
+import { join as join20 } from "node:path";
+import { readdirSync as readdirSync6, statSync as statSync12, openSync as openSync10, readSync as readSync5, fstatSync as fstatSync2, closeSync as closeSync9 } from "node:fs";
 import { spawn as spawn5 } from "node:child_process";
 function sessionsDir2(codexHome) {
-  return join19(codexHome, "sessions");
+  return join20(codexHome, "sessions");
 }
 function newestRollouts(dir, out, budget) {
   if (budget.n <= 0) return;
   let entries;
   try {
-    entries = readdirSync5(dir, { withFileTypes: true });
+    entries = readdirSync6(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -25850,18 +26253,18 @@ function newestRollouts(dir, out, budget) {
   const files = entries.filter((e) => e.isFile() && e.name.startsWith("rollout-") && e.name.endsWith(".jsonl")).map((e) => e.name).sort(descByName2);
   for (const d of dirs) {
     if (budget.n <= 0) return;
-    newestRollouts(join19(dir, d), out, budget);
+    newestRollouts(join20(dir, d), out, budget);
   }
   for (const f of files) {
     if (budget.n <= 0) return;
-    out.push(join19(dir, f));
+    out.push(join20(dir, f));
     budget.n--;
   }
 }
 function readTail(path) {
   let fd;
   try {
-    fd = openSync9(path, "r");
+    fd = openSync10(path, "r");
     const size = fstatSync2(fd).size;
     const start = Math.max(0, size - TAIL_BYTES);
     const len = size - start;
@@ -25926,7 +26329,7 @@ function readCodexQuotaFromRollouts(codexHome = defaultCodexHome()) {
     newestRollouts(sessionsDir2(codexHome), rollouts, { n: 8 });
     const byMtime = rollouts.map((path) => {
       try {
-        return { path, mtimeMs: statSync11(path).mtimeMs };
+        return { path, mtimeMs: statSync12(path).mtimeMs };
       } catch {
         return void 0;
       }
@@ -26102,7 +26505,7 @@ async function readQuota(opts = {}) {
   if (fx && process.env.NODE_ENV !== "production") {
     const snap = await fixture(fx);
     if (snap) {
-      console.warn(`[fray-ui] quota: serving FIXTURE "${fx}" (FRAY_QUOTA_FIXTURE set; dev-only seam)`);
+      log.warn("quota", `serving FIXTURE "${fx}" (FRAY_QUOTA_FIXTURE set; dev-only seam)`);
       return snap;
     }
   }
@@ -26117,6 +26520,7 @@ var init_quota = __esm({
     "use strict";
     init_codex_quota();
     init_claude_quota();
+    init_logging();
   }
 });
 
@@ -26126,20 +26530,20 @@ import {
   constants as constants2,
   fstatSync as fstatSync3,
   lstatSync as lstatSync4,
-  openSync as openSync10,
+  openSync as openSync11,
   readFileSync as readFileSync14,
-  readdirSync as readdirSync6,
+  readdirSync as readdirSync7,
   realpathSync as realpathSync6,
   unlinkSync as unlinkSync4
 } from "node:fs";
 import { createHash as createHash11 } from "node:crypto";
-import { basename as basename5, dirname as dirname7, join as join20 } from "node:path";
+import { basename as basename5, dirname as dirname7, join as join21 } from "node:path";
 function sameStat(a, b) {
   return a.dev === b.dev && a.ino === b.ino && a.mode === b.mode && a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
 }
 function directDirectory(parentRealPath, name) {
   try {
-    const path = join20(parentRealPath, name);
+    const path = join21(parentRealPath, name);
     const stat2 = lstatSync4(path);
     if (!stat2.isDirectory() || stat2.isSymbolicLink()) return null;
     const realPath = realpathSync6(path);
@@ -26177,7 +26581,7 @@ function resolvePlanFile(projectDir, value, hooks = {}) {
     const directoryBefore = planDirectory(projectDir);
     if (!directoryBefore) return null;
     hooks.afterDirectoryCheck?.();
-    const path = join20(directoryBefore.plans.realPath, filename);
+    const path = join21(directoryBefore.plans.realPath, filename);
     const before = lstatSync4(path);
     if (!before.isFile() || before.isSymbolicLink()) return null;
     const realPath = realpathSync6(path);
@@ -26186,7 +26590,7 @@ function resolvePlanFile(projectDir, value, hooks = {}) {
     let contents;
     let openedBefore;
     let openedAfter;
-    const fd = openSync10(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+    const fd = openSync11(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
     try {
       openedBefore = fstatSync3(fd);
       contents = readFileSync14(fd);
@@ -26231,7 +26635,7 @@ function listPlanFiles(projectDir, hooks = {}) {
   if (!directoryBefore) return [];
   try {
     hooks.afterDirectoryCheck?.();
-    const names = readdirSync6(directoryBefore.plans.realPath).sort();
+    const names = readdirSync7(directoryBefore.plans.realPath).sort();
     const files = names.flatMap((filename) => {
       const relativePath = `.fray/plans/${filename}`;
       if (!filenameFromPlanPath(relativePath)) return [];
@@ -26256,7 +26660,7 @@ import {
   existsSync as existsSync6,
   watch as fsWatch
 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 import watcher from "@parcel/watcher";
 function appServerTurnStalled(liveness, lastActivityAt, nowMs) {
   if (!liveness) return false;
@@ -26357,7 +26761,7 @@ function deriveAwaitingBackground(row, tele, runtime, hasActionableInteraction =
 }
 function scratchpadPathIfExists(projectDir, sessionId) {
   const rel = scratchpadRelPath(sessionId);
-  return existsSync6(join21(projectDir, rel)) ? rel : void 0;
+  return existsSync6(join22(projectDir, rel)) ? rel : void 0;
 }
 function resolveSessionProfile(row, tele) {
   const persistedModel = row.model?.trim() || void 0;
@@ -26716,7 +27120,7 @@ function createBoard(project, storage, bus, tailer, bootId, deps = {}) {
     if (parcelSub || stopped) return Promise.resolve();
     if (watchSetup) return watchSetup;
     const setup = (async () => {
-      const next = await subscribe(join21(project.dir, ".fray"), () => scheduleRebuild());
+      const next = await subscribe(join22(project.dir, ".fray"), () => scheduleRebuild());
       if (stopped) {
         await next.unsubscribe();
         return;
@@ -27514,7 +27918,7 @@ function createScheduler(deps) {
   const autoResumeOnLimit = deps.autoResumeOnLimit ?? (() => true);
   const fetchPr = deps.fetchPr ?? defaultFetchPr;
   const fetchGithubReview = deps.fetchGithubReview ?? createGithubReviewFetcher({ now });
-  const log = deps.log ?? ((m) => console.log(`[fray-ui] ${m}`));
+  const log2 = deps.log ?? ((m) => log.info("scheduler", m));
   const tickMs = deps.tickMs ?? 1e4;
   const pollMs = deps.pollMs ?? 6e4;
   const deliveryLeaseMs = Math.max(1, deps.deliveryLeaseMs ?? 3e4);
@@ -27744,14 +28148,14 @@ function createScheduler(deps) {
       return;
     }
     const suppressed = prior?.suppressed ? ` (${prior.suppressed} identical repeats suppressed)` : "";
-    log(`waker: GitHub review check failed for ${key} (${slug}) [${result.failure.kind}] \u2014 ${result.failure.message}${suppressed}`);
+    log2(`waker: GitHub review check failed for ${key} (${slug}) [${result.failure.kind}] \u2014 ${result.failure.message}${suppressed}`);
     reviewFailures.set(key, { signature, loggedAt: at, suppressed: 0 });
   }
   function recordReviewSuccess(key, slug) {
     const prior = reviewFailures.get(key);
     if (!prior) return;
     const suppressed = prior.suppressed ? `; ${prior.suppressed} identical repeats were suppressed` : "";
-    log(`waker: GitHub review check recovered for ${key} (${slug})${suppressed}`);
+    log2(`waker: GitHub review check recovered for ${key} (${slug})${suppressed}`);
     reviewFailures.delete(key);
   }
   async function evalThread(slug, sessionId, fence, nowMs, fenceAt) {
@@ -27799,9 +28203,9 @@ function createScheduler(deps) {
           try {
             const s = await fetchPr(ref);
             if (s) st.prCache.set(k, s);
-            else log(`waker: gh check skipped for ${k} (${slug}) \u2014 gh unavailable / not authed / rate-limited`);
+            else log2(`waker: gh check skipped for ${k} (${slug}) \u2014 gh unavailable / not authed / rate-limited`);
           } catch (err) {
-            log(`waker: gh check errored for ${k} (${slug}): ${err instanceof Error ? err.message : String(err)}`);
+            log2(`waker: gh check errored for ${k} (${slug}): ${err instanceof Error ? err.message : String(err)}`);
           }
         }),
         ...[...reviewRefs].map(async ([k, ref]) => {
@@ -27846,7 +28250,7 @@ function createScheduler(deps) {
       }, nowMs).delivery;
       st.fired = true;
       if (isPrWatchHint(h.kind)) deps.storage.setSnoozedUntil(slug, null);
-      log(`waker: queued ${slug} \u2014 ${verdict.reason}`);
+      log2(`waker: queued ${slug} \u2014 ${verdict.reason}`);
       checkpoint("after-enqueue", item);
       return;
     }
@@ -27897,7 +28301,7 @@ function createScheduler(deps) {
       try {
         quota = await deps.readQuota();
       } catch (err) {
-        log(`waker: quota read failed while checking limit resumes: ${err instanceof Error ? err.message : String(err)}`);
+        log2(`waker: quota read failed while checking limit resumes: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
     for (const c of candidates) {
@@ -27914,7 +28318,7 @@ function createScheduler(deps) {
         message: limitResumeSteer(c.fault.window),
         reason: `${c.fault.window} usage limit reset (interrupted ${c.fault.at})`
       }, nowMs).delivery;
-      log(`waker: queued ${c.slug} \u2014 ${item.reason}`);
+      log2(`waker: queued ${c.slug} \u2014 ${item.reason}`);
       checkpoint("after-enqueue", item);
     }
   }
@@ -27937,7 +28341,7 @@ function createScheduler(deps) {
           message: relayMessage(report),
           reason: `sub-agent report never reached the model (${report.summary ?? report.taskId})`
         }, nowMs).delivery;
-        log(`waker: queued ${row.slug} \u2014 ${item.reason}`);
+        log2(`waker: queued ${row.slug} \u2014 ${item.reason}`);
         checkpoint("after-enqueue", item);
       }
     }
@@ -27958,7 +28362,7 @@ function createScheduler(deps) {
         message: armed.prompt,
         reason: `snooze elapsed (${armed.until})`
       }, nowMs).delivery;
-      log(`waker: queued ${row.slug} \u2014 ${item.reason}`);
+      log2(`waker: queued ${row.slug} \u2014 ${item.reason}`);
       checkpoint("after-enqueue", item);
     }
   }
@@ -27993,7 +28397,7 @@ function createScheduler(deps) {
       );
       if (recovered?.state === "exhausted") {
         settleSnooze(item);
-        log(`waker: delivery EXHAUSTED for ${item.slug} after ${recovered.attempts} attempts \u2014 ${recovered.lastError ?? "unknown error"}`);
+        log2(`waker: delivery EXHAUSTED for ${item.slug} after ${recovered.attempts} attempts \u2014 ${recovered.lastError ?? "unknown error"}`);
       }
     }
   }
@@ -28033,7 +28437,7 @@ function createScheduler(deps) {
         if (error?.terminalDelivery === true) {
           outbox.supersede(item.id, failedAt, message);
           settleSnooze(item);
-          log(`waker: delivery ABANDONED for ${item.slug} (terminal, no retry): ${message}`);
+          log2(`waker: delivery ABANDONED for ${item.slug} (terminal, no retry): ${message}`);
           continue;
         }
         outbox.deferFailure(
@@ -28043,14 +28447,14 @@ function createScheduler(deps) {
           failedAt + Math.max(deliveryLeaseMs, retryDelay(item.attempts)),
           message
         );
-        log(`waker: delivery FAILED for ${item.slug} (attempt ${item.attempts} of ${maxDeliveryAttempts}): ${message}`);
+        log2(`waker: delivery FAILED for ${item.slug} (attempt ${item.attempts} of ${maxDeliveryAttempts}): ${message}`);
         continue;
       }
       const retried = item.attempts > 1 ? ` (on attempt ${item.attempts})` : "";
-      log(`waker: delivered ${item.slug} \u2014 ${item.reason}${retried}`);
+      log2(`waker: delivered ${item.slug} \u2014 ${item.reason}${retried}`);
       checkpoint("after-delivery", item);
       if (!outbox.acknowledge(item.id, deliveryOwner, now())) {
-        log(`waker: delivery acknowledgement lost ownership for ${item.slug}; preserving the authoritative terminal state`);
+        log2(`waker: delivery acknowledgement lost ownership for ${item.slug}; preserving the authoritative terminal state`);
         continue;
       }
       settleSnooze(item);
@@ -28076,7 +28480,7 @@ function createScheduler(deps) {
         await evalThread(row.slug, row.session_id, fence, nowMs, fenceAt);
       } catch (err) {
         if (err instanceof InjectedSchedulerCrash) throw err;
-        log(`waker: tick error for ${row.slug}: ${err instanceof Error ? err.message : String(err)}`);
+        log2(`waker: tick error for ${row.slug}: ${err instanceof Error ? err.message : String(err)}`);
       }
     }));
     const crashed = candidateResults.find((result) => result.status === "rejected");
@@ -28093,19 +28497,19 @@ function createScheduler(deps) {
       await evalLimits(now());
     } catch (err) {
       if (err instanceof InjectedSchedulerCrash) throw err;
-      log(`waker: limit-resume pass failed: ${err instanceof Error ? err.message : String(err)}`);
+      log2(`waker: limit-resume pass failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     try {
       evalSnoozes(now());
     } catch (err) {
       if (err instanceof InjectedSchedulerCrash) throw err;
-      log(`waker: snooze-bump pass failed: ${err instanceof Error ? err.message : String(err)}`);
+      log2(`waker: snooze-bump pass failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     try {
       repairDroppedReports(now());
     } catch (err) {
       if (err instanceof InjectedSchedulerCrash) throw err;
-      log(`waker: report-repair pass failed: ${err instanceof Error ? err.message : String(err)}`);
+      log2(`waker: report-repair pass failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     reconcileOutbox(now());
     await deliverDue();
@@ -28129,9 +28533,9 @@ function createScheduler(deps) {
     start() {
       if (timer) return;
       if (stopped) throw new ProducerStoppedError("wake scheduler");
-      void tick().catch((error) => log(`waker: tick failed: ${error instanceof Error ? error.message : String(error)}`));
+      void tick().catch((error) => log2(`waker: tick failed: ${error instanceof Error ? error.message : String(error)}`));
       timer = setInterval(() => {
-        void tick().catch((error) => log(`waker: tick failed: ${error instanceof Error ? error.message : String(error)}`));
+        void tick().catch((error) => log2(`waker: tick failed: ${error instanceof Error ? error.message : String(error)}`));
       }, tickMs);
       timer.unref?.();
     },
@@ -28156,6 +28560,7 @@ var init_scheduler = __esm({
     init_completion_relay();
     init_github_review();
     init_github_review();
+    init_logging();
     execFileAsync5 = promisify6(execFile6);
     PR_REF_RE = /(?:https?:\/\/github\.com\/)?([A-Za-z0-9][\w.-]*)\/([A-Za-z0-9][\w.-]*?)(?:\/pull\/|\/pulls\/|#)(\d+)/;
     LIMIT_FENCE_PREFIX = "limit
";
@@ -28175,7 +28580,7 @@ var init_scheduler = __esm({
 });
 
 // packages/server/src/resume.ts
-import { writeFileSync as writeFileSync7 } from "node:fs";
+import { writeFileSync as writeFileSync8 } from "node:fs";
 import { randomUUID as randomUUID16 } from "node:crypto";
 import { setTimeout as delay2 } from "node:timers/promises";
 function permissionModeForRow(row, settings) {
@@ -28216,7 +28621,7 @@ function spawnPinnedSession(deps, tx, row, permissionMode, message, options, lau
     env: claudeWorkerEnvironment(),
     prewrite: []
   };
-  for (const f of built.prewrite) writeFileSync7(f.path, f.contents);
+  for (const f of built.prewrite) writeFileSync8(f.path, f.contents);
   return tx.spawn(row.slug, built.argv, deps.project.dir, {
     ...built.env,
     FRAY_UI_THREAD: row.slug,
@@ -29235,7 +29640,7 @@ var init_resume = __esm({
 });
 
 // packages/server/src/backend/claude.ts
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 function toolResultText2(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -29324,7 +29729,7 @@ function createClaudeBackend(opts) {
       return { argv, env: claudeWorkerEnvironment(), prewrite: [] };
     },
     transcriptPath(sessionId) {
-      return join22(opts.logDir, `${sessionId}.jsonl`);
+      return join23(opts.logDir, `${sessionId}.jsonl`);
     },
     parseLine(line) {
       return parseClaudeLine(line);
@@ -30295,27 +30700,27 @@ var init_profile_controller = __esm({
 });
 
 // packages/server/src/backend/codex-app-server-diagnostics.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync11, renameSync as renameSync6, statSync as statSync12 } from "node:fs";
-import { join as join23 } from "node:path";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync12, renameSync as renameSync6, statSync as statSync13 } from "node:fs";
+import { join as join24 } from "node:path";
 function codexDiagnosticLogPath(stateDir, projectId) {
-  return join23(stateDir, "codex-app-server", `${projectId}.diagnostics.log`);
+  return join24(stateDir, "codex-app-server", `${projectId}.diagnostics.log`);
 }
 function createCodexDiagnosticSink(stateDir, projectId, now = () => /* @__PURE__ */ new Date()) {
-  const dir = join23(stateDir, "codex-app-server");
+  const dir = join24(stateDir, "codex-app-server");
   const path = codexDiagnosticLogPath(stateDir, projectId);
   let ensured = false;
   return (event) => {
     if (event.event === "stderr") return;
     try {
       if (!ensured) {
-        mkdirSync11(dir, { recursive: true });
+        mkdirSync12(dir, { recursive: true });
         ensured = true;
       }
       try {
-        if (statSync12(path).size > MAX_BYTES2) renameSync6(path, `${path}.1`);
+        if (statSync13(path).size > MAX_BYTES2) renameSync6(path, `${path}.1`);
       } catch {
       }
-      appendFileSync2(path, `${JSON.stringify({ at: now().toISOString(), ...event })}
+      appendFileSync3(path, `${JSON.stringify({ at: now().toISOString(), ...event })}
 `);
     } catch {
     }
@@ -30331,15 +30736,15 @@ var init_codex_app_server_diagnostics = __esm({
 
 // packages/server/src/backend/stale-socket-sweep.ts
 import { execFile as execFile8 } from "node:child_process";
-import { readdirSync as readdirSync7, unlinkSync as unlinkSync5 } from "node:fs";
+import { readdirSync as readdirSync8, unlinkSync as unlinkSync5 } from "node:fs";
 import { connect as connectSocket } from "node:net";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 function sweepStaleSockets(options, deps = {}) {
   if (process.platform === "win32") return;
   const keep = new Set(options.keep ?? []);
   let candidates;
   try {
-    candidates = (deps.readdir ?? readdirSync7)(options.dir).filter((name) => name.startsWith(options.prefix) && name.endsWith(".sock")).map((name) => join24(options.dir, name)).filter((path) => !keep.has(path));
+    candidates = (deps.readdir ?? readdirSync8)(options.dir).filter((name) => name.startsWith(options.prefix) && name.endsWith(".sock")).map((name) => join25(options.dir, name)).filter((path) => !keep.has(path));
   } catch {
     return;
   }
@@ -30652,7 +31057,7 @@ var init_orphan_reaper = __esm({
 });
 
 // packages/server/src/context.ts
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 import { randomUUID as randomUUID17 } from "node:crypto";
 function reconcileSessions(storage) {
   for (const row of storage.allSessions()) {
@@ -30805,7 +31210,7 @@ function createContextUnchecked(opts, resources) {
     projectId: project.id,
     projectDir: project.dir
   }, project.tmuxSocketManaged !== false);
-  const dbPath = join25(project.stateDir, "ui.db");
+  const dbPath = join26(project.stateDir, "ui.db");
   const storage = createStorage(dbPath);
   resources.storage = storage;
   const bus = new Bus();
@@ -30868,7 +31273,7 @@ function createContextUnchecked(opts, resources) {
     contextUnsubscribers.push(() => clearInterval(quotaRefreshTimer));
   }
   if (!process.env.FRAY_ORPHAN_REAPER_OFF) {
-    contextUnsubscribers.push(startOrphanReaper({ log: (m) => console.log(`[fray-ui] ${m}`) }));
+    contextUnsubscribers.push(startOrphanReaper({ log: (m) => log.info("reaper", m) }));
   }
   opts.startup?.afterPhase?.("orphan reaper");
   reconcileSessions(storage);
@@ -30883,6 +31288,9 @@ function createContextUnchecked(opts, resources) {
     // The detached app-server daemon's socket + record live under the project state dir, so a
     // later fray generation can find the app-server this one left running.
     stateDir: project.stateDir,
+    // Codex's MCP servers mount PROCESS-wide on the app-server, not per thread, so the descriptor
+    // is resolved once here — the codex twin of the per-dispatch resolveFrayMcp on the claude side.
+    frayMcp: resolveFrayMcp(project.stateDir),
     dbPath,
     interactions: storage.interactions,
     codexBin: opts.codexBin,
@@ -30952,7 +31360,7 @@ function createContextUnchecked(opts, resources) {
     // per death rather than a card nobody asked for.
     onDiagnostic: (slug, _sessionId, diagnostic) => {
       if (diagnostic.kind !== "lifecycle" || diagnostic.phase !== "crashed") return;
-      console.log(`[fray-ui] claude broker ${slug}: ${diagnostic.message ?? "died without a recorded cause"}`);
+      log.warn("broker", `claude broker ${slug}: ${diagnostic.message ?? "died without a recorded cause"}`);
     }
   }) : void 0;
   resources.claudeBroker = claudeBroker;
@@ -31174,6 +31582,7 @@ var init_context = __esm({
     init_adoption_recovery();
     init_orphan_reaper();
     init_shutdown();
+    init_logging();
     CONTEXT_STARTUP_CLEANUP_TIMEOUT_MS = 4e3;
     QUOTA_REFRESH_INTERVAL_MS = 2 * 6e4;
     ContextStartupError = class extends Error {
@@ -33827,7 +34236,7 @@ var init_server = __esm({
 });
 
 // packages/server/src/repair.ts
-import { existsSync as existsSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync9 } from "node:fs";
 import { basename as basename6, dirname as dirname9, resolve as resolve7 } from "node:path";
 function quoteValue(v) {
   if (/^[\w./#:+-]+$/.test(v)) return v;
@@ -33858,7 +34267,7 @@ function repairThreadFile(frayDir, file) {
     "---",
     ""
   ].join("\n");
-  writeFileSync8(abs, frontmatter + content);
+  writeFileSync9(abs, frontmatter + content);
   return { slug };
 }
 var RepairError, REPAIR_STATUS_TEXT;
@@ -34009,11 +34418,11 @@ var init_bash_background = __esm({
 });
 
 // packages/server/src/transcript.ts
-import { closeSync as closeSync11, existsSync as existsSync8, fstatSync as fstatSync4, mkdirSync as mkdirSync12, openSync as openSync11, readdirSync as readdirSync8, readFileSync as readFileSync17, readSync as readSync6, renameSync as renameSync7, statSync as statSync13, unlinkSync as unlinkSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { closeSync as closeSync11, existsSync as existsSync8, fstatSync as fstatSync4, mkdirSync as mkdirSync13, openSync as openSync12, readdirSync as readdirSync9, readFileSync as readFileSync17, readSync as readSync6, renameSync as renameSync7, statSync as statSync14, unlinkSync as unlinkSync6, writeFileSync as writeFileSync10 } from "node:fs";
 import { createHash as createHash13 } from "node:crypto";
 import { StringDecoder as StringDecoder4 } from "node:string_decoder";
-import { join as join26 } from "node:path";
-import { homedir as homedir7, tmpdir as tmpdir4 } from "node:os";
+import { join as join27 } from "node:path";
+import { homedir as homedir9, tmpdir as tmpdir4 } from "node:os";
 function isInjectedNoise(text) {
   const t = text.trimStart();
   return NOISE_PREFIXES.some((p) => t.startsWith(p));
@@ -34028,7 +34437,7 @@ function compactionLabel(preTokens, postTokens) {
   return shrank ? `Context compacted \u2014 ${formatTokens(preTokens)} \u2192 ${formatTokens(postTokens)} tokens` : "Context compacted";
 }
 function compactionMessage(sourceId, at, preTokens, postTokens) {
-  return { sourceId, role: "assistant", kind: "event", boundary: true, text: compactionLabel(preTokens, postTokens), tools: [], parts: [], at };
+  return { sourceId, role: "assistant", kind: "event", boundary: "compaction", text: compactionLabel(preTokens, postTokens), tools: [], parts: [], at };
 }
 function normalizeNewlines(s) {
   return stripDeliveryMarkers(s).replace(/\r\n?/g, "\n");
@@ -34071,7 +34480,9 @@ function userProjection(text, first) {
   const peer = parseAgentMessage(text);
   if (peer) return { displayText: peer.body, peerFrom: peer.from };
   const displayText2 = userDisplayText(text, first);
-  return { ...displayText2 ? { displayText: displayText2 } : {}, ...isWakeDelivery(text) ? { wake: true } : {} };
+  if (!isWakeDelivery(text)) return { ...displayText2 ? { displayText: displayText2 } : {} };
+  const steer = parseGithubWakeSteer(displayText2 ?? text);
+  return { ...displayText2 ? { displayText: displayText2 } : {}, wake: true, ...steer ? { wakeSteer: steer } : {} };
 }
 function pushTextPart(m, text) {
   const last = m.parts[m.parts.length - 1];
@@ -34134,6 +34545,7 @@ function createTranscriptFold(identityPrefix = "claude") {
   const backgroundShells = /* @__PURE__ */ new Map();
   const backgroundTaskIds = /* @__PURE__ */ new Map();
   const childDispatchIds = /* @__PURE__ */ new Map();
+  const dispatchLabels = /* @__PURE__ */ new Map();
   let prevTs;
   let thinkingMsgId = null;
   const queuedPending = [];
@@ -34247,14 +34659,13 @@ function createTranscriptFold(identityPrefix = "claude") {
         if (entry) {
           resolveQueued(prompt);
           if (dispatchId && entry.message.peerFrom) entry.message.peerDispatchId = dispatchId;
-          const dispatched = dispatchId ? agentDispatches.get(dispatchId) : void 0;
-          const described = dispatched?.call.detail?.trim();
+          const described = dispatchId ? dispatchLabels.get(dispatchId) : void 0;
           if (described && entry.message.peerFrom) entry.message.peerFrom = described;
           if (thisTs) prevTs = thisTs;
           lastAssistantId = null;
         } else {
           const parsed = prompt.trim() ? parseAgentMessage(prompt) : void 0;
-          const describedHere = (dispatchId ? agentDispatches.get(dispatchId) : void 0)?.call.detail?.trim();
+          const describedHere = dispatchId ? dispatchLabels.get(dispatchId) : void 0;
           const from = describedHere || str(peerOrigin.from) || str(peerOrigin.name) || parsed?.from || "";
           const body = parsed?.body ?? (typeof peerOrigin.body === "string" ? peerOrigin.body : "");
           if (from && body.trim()) {
@@ -34351,9 +34762,10 @@ ${block.text}` : block.text;
             pushToolPart(m, call);
             m.tools.push(call);
             if (call.agentId) agentDispatches.set(call.agentId, { at: rec.timestamp, call });
+            if (call.agentId && call.detail?.trim()) dispatchLabels.set(call.agentId, call.detail.trim());
             if (call.sendTo && call.sendTo !== "main") {
               const dispatchId = childDispatchIds.get(call.sendTo);
-              const described = dispatchId ? agentDispatches.get(dispatchId)?.call.detail?.trim() : void 0;
+              const described = dispatchId ? dispatchLabels.get(dispatchId) : void 0;
               if (dispatchId) call.sendDispatchId = dispatchId;
               if (described) call.sendTargetLabel = described;
             }
@@ -34503,18 +34915,18 @@ function looksLikeImage(buf, ext) {
 }
 function pruneScreenshotCache() {
   try {
-    const entries = readdirSync8(SCREENSHOT_CACHE_DIR).filter((n) => !n.startsWith("."));
+    const entries = readdirSync9(SCREENSHOT_CACHE_DIR).filter((n) => !n.startsWith("."));
     if (entries.length <= SCREENSHOT_CACHE_MAX) return;
     const byMtime = entries.map((n) => {
       try {
-        return { n, m: statSync13(join26(SCREENSHOT_CACHE_DIR, n)).mtimeMs };
+        return { n, m: statSync14(join27(SCREENSHOT_CACHE_DIR, n)).mtimeMs };
       } catch {
         return { n, m: 0 };
       }
     }).sort((a, b) => b.m - a.m);
     for (const { n } of byMtime.slice(SCREENSHOT_CACHE_MAX)) {
       try {
-        unlinkSync6(join26(SCREENSHOT_CACHE_DIR, n));
+        unlinkSync6(join27(SCREENSHOT_CACHE_DIR, n));
       } catch {
       }
     }
@@ -34544,15 +34956,15 @@ function persistBase64Image(mediaType, data, idKey) {
   const ext = IMAGE_MEDIA_EXT[typeof mediaType === "string" ? mediaType.toLowerCase() : ""];
   if (!ext || !data) return void 0;
   const name = createHash13("sha256").update(idKey).digest("hex").slice(0, 32);
-  const path = join26(SCREENSHOT_CACHE_DIR, `${name}.${ext}`);
+  const path = join27(SCREENSHOT_CACHE_DIR, `${name}.${ext}`);
   try {
     if (existsSync8(path)) return path;
     if (data.length > SCREENSHOT_MAX_BASE64) return void 0;
     const buf = Buffer.from(data, "base64");
     if (buf.length === 0 || !looksLikeImage(buf, ext)) return void 0;
-    mkdirSync12(SCREENSHOT_CACHE_DIR, { recursive: true });
-    const tmp = join26(SCREENSHOT_CACHE_DIR, `.${name}.${process.pid}.${screenshotTmpSeq++}.tmp`);
-    writeFileSync9(tmp, buf);
+    mkdirSync13(SCREENSHOT_CACHE_DIR, { recursive: true });
+    const tmp = join27(SCREENSHOT_CACHE_DIR, `.${name}.${process.pid}.${screenshotTmpSeq++}.tmp`);
+    writeFileSync10(tmp, buf);
     renameSync7(tmp, path);
     pruneScreenshotCache();
     return path;
@@ -34566,15 +34978,15 @@ function persistSentFile(srcPath, idKey) {
   const outExt = ext === "jpeg" ? "jpg" : ext;
   try {
     const name = createHash13("sha256").update(idKey).digest("hex").slice(0, 32);
-    const dest = join26(SCREENSHOT_CACHE_DIR, `${name}.${outExt}`);
+    const dest = join27(SCREENSHOT_CACHE_DIR, `${name}.${outExt}`);
     if (existsSync8(dest)) return dest;
-    const size = statSync13(srcPath).size;
+    const size = statSync14(srcPath).size;
     if (size === 0 || size > SENT_IMAGE_MAX_BYTES) return void 0;
     const buf = readFileSync17(srcPath);
     if (!looksLikeImage(buf, outExt)) return void 0;
-    mkdirSync12(SCREENSHOT_CACHE_DIR, { recursive: true });
-    const tmp = join26(SCREENSHOT_CACHE_DIR, `.${name}.${process.pid}.${screenshotTmpSeq++}.tmp`);
-    writeFileSync9(tmp, buf);
+    mkdirSync13(SCREENSHOT_CACHE_DIR, { recursive: true });
+    const tmp = join27(SCREENSHOT_CACHE_DIR, `.${name}.${process.pid}.${screenshotTmpSeq++}.tmp`);
+    writeFileSync10(tmp, buf);
     renameSync7(tmp, dest);
     pruneScreenshotCache();
     return dest;
@@ -34874,7 +35286,7 @@ function completionEvents(rec, dispatches, backgroundShells, backgroundTaskIds)
         const elapsedMs2 = elapsedBetween(shell.at, rec.timestamp);
         shell.call.status = status === "completed" ? "completed" : status === "killed" ? "cancelled" : "failed";
         if (elapsedMs2 !== void 0) shell.call.durationMs = elapsedMs2;
-        out.push({ role: "assistant", kind: "event", boundary: true, text: backgroundWakeLabel(shell.call, status, block), tools: [], parts: [], at });
+        out.push({ role: "assistant", kind: "event", boundary: "wake", text: backgroundWakeLabel(shell.call, status, block), tools: [], parts: [], at });
         continue;
       }
       dispatches.delete(id);
@@ -34922,11 +35334,11 @@ function retainedFoldEntry(path, identityPrefix, fileId, size) {
   return { entry, hit };
 }
 function readTranscript(project, sessionId) {
-  const path = join26(homedir7(), ".claude", "projects", project.cwdSlug, `${sessionId}.jsonl`);
+  const path = join27(homedir9(), ".claude", "projects", project.cwdSlug, `${sessionId}.jsonl`);
   const identityPrefix = `claude:${sessionId}`;
   let fd;
   try {
-    fd = openSync11(path, "r");
+    fd = openSync12(path, "r");
     const st = fstatSync4(fd);
     const size = st.size;
     const fileId = `${st.dev}:${st.ino}:${Math.trunc(st.birthtimeMs)}`;
@@ -34970,7 +35382,7 @@ function verifyIncrementalParse(path, identityPrefix, incremental) {
   }
 }
 function logDirOf(project) {
-  return join26(homedir7(), ".claude", "projects", project.cwdSlug);
+  return join27(homedir9(), ".claude", "projects", project.cwdSlug);
 }
 function projectCodexTranscript(raw2, identityPrefix = "codex") {
   const out = [];
@@ -35876,7 +36288,7 @@ function sourceForThread(project, storage, slug, backendFor) {
   if (row) {
     const backend = row.backend === "codex" ? "codex" : "claude";
     const nativeId = backend === "codex" ? row.agent_session_id ?? row.session_id : row.transcript_id ?? row.session_id;
-    const path = backend === "codex" ? (backendFor?.("codex") ?? defaultCodexBackend()).transcriptPath(nativeId) : join26(logDirOf(project), `${nativeId}.jsonl`);
+    const path = backend === "codex" ? (backendFor?.("codex") ?? defaultCodexBackend()).transcriptPath(nativeId) : join27(logDirOf(project), `${nativeId}.jsonl`);
     if (!path) return void 0;
     return {
       slug,
@@ -35894,7 +36306,7 @@ function sourceForThread(project, storage, slug, backendFor) {
     nativeId: slug,
     backend: "claude",
     runtimeGeneration: 0,
-    path: join26(logDirOf(project), `${slug}.jsonl`)
+    path: join27(logDirOf(project), `${slug}.jsonl`)
   };
 }
 function discoveredClaudeSource(project, storage, slug, expectedNativeId) {
@@ -35915,13 +36327,13 @@ function discoveredClaudeSource(project, storage, slug, expectedNativeId) {
     nativeId,
     backend: "claude",
     runtimeGeneration: row.runtime_generation ?? 0,
-    path: join26(logDirOf(project), `${nativeId}.jsonl`)
+    path: join27(logDirOf(project), `${nativeId}.jsonl`)
   };
 }
 function fixedSnapshot(source) {
   let fd;
   try {
-    fd = openSync11(source.path, "r");
+    fd = openSync12(source.path, "r");
     const before = fstatSync4(fd);
     if (!Number.isSafeInteger(before.size) || before.size < 0) throw new Error("transcript is too large to page safely");
     const bytes = Buffer.allocUnsafe(before.size);
@@ -36220,7 +36632,7 @@ var init_transcript = __esm({
       "image/gif": "gif",
       "image/webp": "webp"
     };
-    SCREENSHOT_CACHE_DIR = join26(tmpdir4(), "fray-tool-images");
+    SCREENSHOT_CACHE_DIR = join27(tmpdir4(), "fray-tool-images");
     SCREENSHOT_CACHE_MAX = 200;
     SCREENSHOT_MAX_BASE64 = 32e6;
     screenshotTmpSeq = 0;
@@ -36270,9 +36682,9 @@ var init_open_external = __esm({
 
 // packages/server/src/local-file.ts
 import { spawn as spawn7 } from "node:child_process";
-import { realpathSync as realpathSync7, statSync as statSync14 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
-import { isAbsolute as isAbsolute5, join as join27, resolve as resolve8, sep as sep2 } from "node:path";
+import { realpathSync as realpathSync7, statSync as statSync15 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+import { isAbsolute as isAbsolute5, join as join28, resolve as resolve8, sep as sep2 } from "node:path";
 function isUnder(real, root) {
   let rootReal;
   try {
@@ -36292,17 +36704,17 @@ function resolveLocalFile(rawPath, roots) {
   }
   if (!roots.some((root) => isUnder(real, root))) throw new Error("Local file is outside Fray's trusted roots");
   try {
-    if (!statSync14(real).isFile()) throw new Error("Local path is not a regular file");
+    if (!statSync15(real).isFile()) throw new Error("Local path is not a regular file");
   } catch (error) {
     if (error instanceof Error && error.message === "Local path is not a regular file") throw error;
     throw new Error("Local file was not found");
   }
   return real;
 }
-function resolveOpenableFile(raw2, projectDir, roots, home = homedir8()) {
+function resolveOpenableFile(raw2, projectDir, roots, home = homedir10()) {
   const trimmed = raw2.trim().replace(/:\d+(?::\d+)?$/, "");
   if (!trimmed) return null;
-  const abs = trimmed === "~" ? home : trimmed.startsWith("~/") ? join27(home, trimmed.slice(2)) : isAbsolute5(trimmed) ? trimmed : resolve8(projectDir, trimmed);
+  const abs = trimmed === "~" ? home : trimmed.startsWith("~/") ? join28(home, trimmed.slice(2)) : isAbsolute5(trimmed) ? trimmed : resolve8(projectDir, trimmed);
   try {
     return resolveLocalFile(abs, roots);
   } catch {
@@ -36646,11 +37058,11 @@ var init_external_terminal = __esm({
 });
 
 // packages/server/src/background-shell-output.ts
-import { closeSync as closeSync12, fstatSync as fstatSync5, openSync as openSync12, readSync as readSync7 } from "node:fs";
+import { closeSync as closeSync12, fstatSync as fstatSync5, openSync as openSync13, readSync as readSync7 } from "node:fs";
 function readBackgroundShellOutput(path, maxBytes = OUTPUT_TAIL_BYTES) {
   let fd;
   try {
-    fd = openSync12(path, "r");
+    fd = openSync13(path, "r");
     const size = fstatSync5(fd).size;
     const length = Math.min(size, maxBytes);
     const offset = Math.max(0, size - length);
@@ -36680,7 +37092,7 @@ var init_background_shell_output = __esm({
 
 // packages/server/src/router.ts
 import { readFileSync as readFileSync18 } from "node:fs";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 function validateGithubDispatchProfile(input) {
   validateThreadProfile(input.backend, input.model, input.effort);
 }
@@ -36821,7 +37233,7 @@ async function stopAndForgetRegisteredRuntime(storage, row, runtime = tmux_expor
   return forgotten;
 }
 function createRouter(ctx) {
-  const frayDir = join28(ctx.project.dir, ".fray");
+  const frayDir = join29(ctx.project.dir, ".fray");
   const openRoots = openableFileRoots(ctx.project);
   const claudeRename = createClaudeRenameController({ storage: ctx.storage, tailer: ctx.tailer, board: ctx.board });
   function isAutoTitledSession(slug) {
@@ -37159,6 +37571,14 @@ function createRouter(ctx) {
         if (hasPendingPermissionChange(row)) {
           throw new Error("Wait for the current permission change to finish before sending a follow-up");
         }
+        if (input.freshProcess) {
+          if (!(row?.backend === "claude" && row.claude_runtime === "broker")) {
+            throw new Error("Only a broker-backed Claude worker can be restarted in place");
+          }
+          if ((ctx.tailer.get(input.slug)?.subAgents ?? []).some((agent) => agent.state === "running")) {
+            throw new Error("This worker has sub-agents still running; restarting it would kill them. Wait for them to finish, then restart.");
+          }
+        }
         if (row?.backend === "codex") {
           const bridge = ctx.codexAppServer;
           if (!bridge) throw new Error("Codex app-server is unavailable; cannot deliver this follow-up");
@@ -37220,7 +37640,12 @@ function createRouter(ctx) {
             // needs the same treatment: while the process is still latched on its own 429, delivering
             // into it does nothing at all. Restart it instead — otherwise the button is a no-op and
             // reads as fray having ignored the click.
-            freshProcess: needsFreshProcessForLimit(
+            //
+            // `input.freshProcess` is the operator asking for it OUTRIGHT (the "Restart worker" verb),
+            // which the server cannot derive: only the human knows they want the worker back on a newer
+            // build. It is OR'd in rather than replacing the derivation, so a restart clicked on a
+            // limit-latched thread still behaves. The live-sub-agent refusal above applies to both.
+            freshProcess: input.freshProcess === true || needsFreshProcessForLimit(
               ctx.tailer.get(input.slug)?.limitFault,
               Date.now(),
               (ctx.tailer.get(input.slug)?.subAgents ?? []).some((agent) => agent.state === "running")
@@ -37567,7 +37992,7 @@ function createRouter(ctx) {
         const row = ctx.storage.getSession(input.slug);
         if (!row) return { markdown: "" };
         try {
-          return { markdown: readFileSync18(join28(ctx.project.dir, scratchpadRelPath(row.session_id)), "utf8") };
+          return { markdown: readFileSync18(join29(ctx.project.dir, scratchpadRelPath(row.session_id)), "utf8") };
         } catch {
           return { markdown: "" };
         }
@@ -38054,7 +38479,7 @@ var init_local_origin = __esm({
 });
 
 // packages/server/src/local-image.ts
-import { readFileSync as readFileSync19, realpathSync as realpathSync8, statSync as statSync15 } from "node:fs";
+import { readFileSync as readFileSync19, realpathSync as realpathSync8, statSync as statSync16 } from "node:fs";
 import { extname, isAbsolute as isAbsolute6 } from "node:path";
 function resolveLocalImage(rawPath) {
   if (!rawPath || !isAbsolute6(rawPath)) return { status: 400 };
@@ -38067,7 +38492,7 @@ function resolveLocalImage(rawPath) {
     return { status: 404 };
   }
   try {
-    if (!statSync15(real).isFile()) return { status: 404 };
+    if (!statSync16(real).isFile()) return { status: 404 };
     return { status: 200, contentType, body: readFileSync19(real) };
   } catch {
     return { status: 404 };
@@ -38088,11 +38513,11 @@ var init_local_image = __esm({
 });
 
 // packages/server/src/local-visualization.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync20, realpathSync as realpathSync9, statSync as statSync16 } from "node:fs";
-import { join as join29, sep as sep3 } from "node:path";
+import { readdirSync as readdirSync10, readFileSync as readFileSync20, realpathSync as realpathSync9, statSync as statSync17 } from "node:fs";
+import { join as join30, sep as sep3 } from "node:path";
 function children(path, pattern) {
   try {
-    return readdirSync9(path, { withFileTypes: true }).filter((entry) => entry.isDirectory() && pattern.test(entry.name)).map((entry) => entry.name).sort().reverse();
+    return readdirSync10(path, { withFileTypes: true }).filter((entry) => entry.isDirectory() && pattern.test(entry.name)).map((entry) => entry.name).sort().reverse();
   } catch {
     return [];
   }
@@ -38101,7 +38526,7 @@ function isUnder2(path, root) {
   return path === root || path.startsWith(root.endsWith(sep3) ? root : root + sep3);
 }
 function resolveFragment(projectDir, sessionId, file) {
-  const base = join29(projectDir, ".codex", "visualizations");
+  const base = join30(projectDir, ".codex", "visualizations");
   let projectReal;
   let baseReal;
   try {
@@ -38112,15 +38537,15 @@ function resolveFragment(projectDir, sessionId, file) {
   }
   if (!isUnder2(baseReal, projectReal)) return null;
   for (const year of children(base, YEAR_PART)) {
-    const yearDir = join29(base, year);
+    const yearDir = join30(base, year);
     for (const month of children(yearDir, DATE_PART)) {
-      const monthDir = join29(yearDir, month);
+      const monthDir = join30(yearDir, month);
       for (const day of children(monthDir, DATE_PART)) {
-        const sessionRoot = join29(baseReal, year, month, day, sessionId);
-        const candidate = join29(monthDir, day, sessionId, file);
+        const sessionRoot = join30(baseReal, year, month, day, sessionId);
+        const candidate = join30(monthDir, day, sessionId, file);
         try {
           const real = realpathSync9(candidate);
-          if (isUnder2(real, sessionRoot) && statSync16(real).isFile()) return real;
+          if (isUnder2(real, sessionRoot) && statSync17(real).isFile()) return real;
         } catch {
         }
       }
@@ -38201,7 +38626,7 @@ function resolveLocalVisualization(projectDir, sessionId, file) {
   if (!path) return { status: 404 };
   let fragment;
   try {
-    const size = statSync16(path).size;
+    const size = statSync17(path).size;
     if (size > MAX_FRAGMENT_BYTES) return { status: 413 };
     fragment = readFileSync20(path, "utf8");
   } catch {
@@ -38245,8 +38670,8 @@ var init_local_visualization = __esm({
 });
 
 // packages/server/src/app.ts
-import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join30 } from "node:path";
+import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync11 } from "node:fs";
+import { join as join31 } from "node:path";
 import { randomUUID as randomUUID18 } from "node:crypto";
 function createApp(ctx, options = {}) {
   const app = new Hono2();
@@ -38323,11 +38748,11 @@ function createApp(ctx, options = {}) {
     if (typeof body.data !== "string" || body.data.length > ATTACHMENT_MAX_BASE64_CHARS) return c.json({ error: "bad payload" }, 400);
     const ext = `.${attachmentExtension(name)}`;
     const buf = Buffer.from(body.data, "base64");
-    const dir = join30(ctx.project.stateDir, "attachments");
-    mkdirSync13(dir, { recursive: true });
+    const dir = join31(ctx.project.stateDir, "attachments");
+    mkdirSync14(dir, { recursive: true });
     const base = name.replace(/\.[^.]+$/, "").replace(/[^a-zA-Z0-9_-]+/g, "-").slice(0, 40) || "file";
-    const path = join30(dir, `${Date.now()}-${randomUUID18().slice(0, 8)}-${base}${ext}`);
-    writeFileSync10(path, buf);
+    const path = join31(dir, `${Date.now()}-${randomUUID18().slice(0, 8)}-${base}${ext}`);
+    writeFileSync11(path, buf);
     return c.json({ path });
   });
   app.get(
@@ -39599,10 +40024,10 @@ var init_app_socket = __esm({
 });
 
 // packages/server/src/boot-progress.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync21, renameSync as renameSync8, rmSync as rmSync6, writeFileSync as writeFileSync11 } from "node:fs";
-import { basename as basename8, dirname as dirname10, join as join31 } from "node:path";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync21, renameSync as renameSync8, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
+import { basename as basename8, dirname as dirname10, join as join32 } from "node:path";
 function bootProgressPath(stateDir) {
-  return join31(stateDir, BOOT_PROGRESS_NAME);
+  return join32(stateDir, BOOT_PROGRESS_NAME);
 }
 function createBootProgressPublisher(stateDir, minIntervalMs = 200) {
   if (!stateDir) {
@@ -39622,9 +40047,9 @@ function createBootProgressPublisher(stateDir, minIntervalMs = 200) {
     lastAt = now;
     step++;
     try {
-      mkdirSync14(dirname10(path), { recursive: true, mode: 448 });
-      const temp = join31(dirname10(path), `.${basename8(path)}.${process.pid}.tmp`);
-      writeFileSync11(temp, `${JSON.stringify({ pid: process.pid, step, phase, at: new Date(now).toISOString() })}
+      mkdirSync15(dirname10(path), { recursive: true, mode: 448 });
+      const temp = join32(dirname10(path), `.${basename8(path)}.${process.pid}.tmp`);
+      writeFileSync12(temp, `${JSON.stringify({ pid: process.pid, step, phase, at: new Date(now).toISOString() })}
 `, "utf8");
       renameSync8(temp, path);
     } catch {
@@ -39633,7 +40058,7 @@ function createBootProgressPublisher(stateDir, minIntervalMs = 200) {
   return Object.assign(write, {
     done: () => {
       try {
-        rmSync6(path, { force: true });
+        rmSync7(path, { force: true });
       } catch {
       }
     }
@@ -39659,7 +40084,7 @@ __export(index_exports, {
 });
 import { createServer } from "node:http";
 import { readFileSync as readFileSync22, existsSync as existsSync9 } from "node:fs";
-import { join as join32, resolve as resolve9, extname as extname2, normalize } from "node:path";
+import { join as join33, resolve as resolve9, extname as extname2, normalize } from "node:path";
 async function pipeToApp(app, req, res, port2, controller) {
   const url = `http://127.0.0.1:${port2}${req.url ?? "/"}`;
   res.on("close", () => {
@@ -39728,9 +40153,9 @@ function createShutdownSignalHandler(options) {
 }
 function serveStatic(distDir, req, res) {
   const rel = normalize((req.url ?? "/").split("?")[0]).replace(/^(\.\.[/\\])+/, "");
-  let file = join32(distDir, rel === "/" ? "index.html" : rel);
-  if (!file.startsWith(distDir)) file = join32(distDir, "index.html");
-  if (!existsSync9(file)) file = join32(distDir, "index.html");
+  let file = join33(distDir, rel === "/" ? "index.html" : rel);
+  if (!file.startsWith(distDir)) file = join33(distDir, "index.html");
+  if (!existsSync9(file)) file = join33(distDir, "index.html");
   try {
     const body = readFileSync22(file);
     res.writeHead(200, { "content-type": MIME[extname2(file)] ?? "application/octet-stream" });
@@ -39780,8 +40205,9 @@ async function startServer(opts = {}) {
     diagnostics.push(event);
     if (opts.shutdownDiagnostic) opts.shutdownDiagnostic(event);
     else {
-      console.error(
-        `[fray-ui] shutdown ${event.phase}: ${event.message}${event.error instanceof Error ? ` \u2014 ${event.error.message}` : ""}`
+      log.warn(
+        "shutdown",
+        `${event.phase}: ${event.message}${event.error instanceof Error ? ` \u2014 ${event.error.message}` : ""}`
       );
     }
   };
@@ -40028,9 +40454,9 @@ async function startServer(opts = {}) {
     } else {
       await phase("wake scheduler", () => void 0);
     }
-    statusPath = join32(ctx.project.stateDir, "server.lock");
+    statusPath = join33(ctx.project.stateDir, "server.lock");
     const webRoot = resolve9(import.meta.dirname, "..", "..", "web");
-    const distDir = opts.webDistDir ? resolve9(opts.webDistDir) : join32(webRoot, "dist");
+    const distDir = opts.webDistDir ? resolve9(opts.webDistDir) : join33(webRoot, "dist");
     startupPhase = "Vite";
     if (opts.dev) {
       try {
@@ -40042,8 +40468,9 @@ async function startServer(opts = {}) {
         });
       } catch (error) {
         if (opts.requireDevWeb) throw error;
-        console.warn(
-          `[fray-ui] vite dev middleware unavailable \u2014 serving API only: ${error instanceof Error ? error.message : error}`
+        log.warn(
+          "server",
+          `vite dev middleware unavailable \u2014 serving API only: ${error instanceof Error ? error.message : error}`
         );
       }
     }
@@ -40073,7 +40500,7 @@ async function startServer(opts = {}) {
       if (vite) {
         vite.middlewares(req, res, () => {
           try {
-            const html = readFileSync22(join32(webRoot, "index.html"), "utf8");
+            const html = readFileSync22(join33(webRoot, "index.html"), "utf8");
             void vite.transformIndexHtml(url, html).then((out) => {
               res.writeHead(200, { "content-type": "text/html" });
               res.end(out);
@@ -40128,8 +40555,9 @@ async function startServer(opts = {}) {
       port: port2,
       bootId: ctx.bootId
     }));
-    console.log(
-      `[fray-ui] server on http://127.0.0.1:${port2} (${opts.dev ? "dev" : "prod"}) \u2014 project ${ctx.project.name}`
+    log.info(
+      "server",
+      `control plane listening on 127.0.0.1:${port2} (${opts.dev ? "dev" : "prod"}) \u2014 project ${ctx.project.name}`
     );
     startupPhase = "signal handlers";
     if (!opts.requestOwnerStop) {
@@ -40197,6 +40625,7 @@ var init_index = __esm({
     init_project_launch();
     init_tmux();
     init_boot_progress();
+    init_logging();
     SERVER_SHUTDOWN_TIMEOUT_MS = 4e3;
     SERVER_FORCE_EXIT_MS = 5e3;
     defaultStartServerRuntime = {
@@ -40251,12 +40680,20 @@ var init_index = __esm({
 init_project();
 init_project_launch();
 init_shutdown();
+init_logging();
 import { existsSync as existsSync10 } from "node:fs";
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
+process.on("uncaughtException", (error) => {
+  log.error("dev-child", `uncaught exception: ${error instanceof Error ? error.stack ?? error.message : error}`);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  log.error("dev-child", `unhandled rejection: ${reason instanceof Error ? reason.stack ?? reason.message : reason}`);
+});
 var rawPort = process.env.FRAY_DEV_PORT;
 var port = Number(rawPort);
 if (!Number.isInteger(port) || port < 1 || port > 65535) {
-  console.error(`[fray-ui] invalid FRAY_DEV_PORT for dev child: ${rawPort ?? "<unset>"}`);
+  log.error("dev-child", `invalid FRAY_DEV_PORT: ${rawPort ?? "<unset>"}`);
   process.exit(1);
 }
 function notifySupervisor(message) {
@@ -40285,7 +40722,7 @@ try {
     ];
     if (!existsSync10(stableWebDist)) throw new Error("stable artifact launch is missing its verified web directory");
     for (const [name, directory, requiredFile] of required) {
-      if (!directory || !existsSync10(join33(directory, requiredFile)))
+      if (!directory || !existsSync10(join34(directory, requiredFile)))
         throw new Error(`stable artifact launch is missing verified ${name}`);
     }
   }
@@ -40316,16 +40753,16 @@ try {
       process.exit(0);
     } catch (err) {
       if (err instanceof ShutdownTimeoutError) {
-        console.warn(`[fray-ui] dev child shutdown exceeded ${err.timeoutMs}ms; retaining ownership while the drain completes`);
+        log.warn("dev-child", `shutdown exceeded ${err.timeoutMs}ms; retaining ownership while the drain completes`);
         try {
           await server.shutdownFence.whenSafe();
           process.exit(0);
           return;
         } catch (drainError) {
-          console.error(`[fray-ui] dev child late shutdown drain failed: ${drainError instanceof Error ? drainError.stack ?? drainError.message : drainError}`);
+          log.error("dev-child", `late shutdown drain failed: ${drainError instanceof Error ? drainError.stack ?? drainError.message : drainError}`);
         }
       }
-      console.error(`[fray-ui] dev child shutdown failed: ${err instanceof Error ? err.stack ?? err.message : err}`);
+      log.error("dev-child", `shutdown failed: ${err instanceof Error ? err.stack ?? err.message : err}`);
       process.exit(1);
     }
   };
@@ -40333,6 +40770,6 @@ try {
   process.on("SIGTERM", () => void shutdown());
   process.once("disconnect", () => void shutdown());
 } catch (err) {
-  console.error(`[fray-ui] dev child failed to start: ${err instanceof Error ? err.stack ?? err.message : err}`);
+  log.error("dev-child", `failed to start: ${err instanceof Error ? err.stack ?? err.message : err}`);
   process.exit(1);
 }