frizz 0.13.12 → 0.13.14

package/dist/frizz.js

@@ -182,7 +182,7 @@ var init_local_origin = __esm({
 
 // packages/server/src/access-codes.ts
 import { randomBytes, timingSafeEqual, createHmac } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join as join2 } from "node:path";
 function memorySessionDirectory(seed = []) {
   const records = new Map(seed.map((r) => [r.id, r]));
@@ -227,7 +227,7 @@ function secretsMatch(a, b) {
   return left.length === right.length && timingSafeEqual(left, right);
 }
 function fileSessionDirectory(stateDir, now = Date.now) {
-  const path = join2(stateDir, "sessions.json");
+  const path = join2(stateDir, SESSION_DIRECTORY_FILE);
   let records = [];
   try {
     const parsed = JSON.parse(readFileSync(path, "utf8"));
@@ -283,6 +283,39 @@ function loadOrCreateSessionKey(stateDir) {
   }
   return rotateSessionKey(stateDir);
 }
+function adoptSessionState(stateDir, others) {
+  if (existsSync(join2(stateDir, SESSION_KEY_FILE))) return void 0;
+  const usedAt = (dir) => {
+    try {
+      const key = statSync(join2(dir, SESSION_KEY_FILE));
+      if (!key.isFile() || key.size < 32) return void 0;
+      try {
+        return Math.max(key.mtimeMs, statSync(join2(dir, SESSION_DIRECTORY_FILE)).mtimeMs);
+      } catch {
+        return key.mtimeMs;
+      }
+    } catch {
+      return void 0;
+    }
+  };
+  let newest;
+  for (const dir of others) {
+    if (dir === stateDir) continue;
+    const at = usedAt(dir);
+    if (at !== void 0 && (!newest || at > newest.at)) newest = { dir, at };
+  }
+  if (!newest) return void 0;
+  mkdirSync(stateDir, { recursive: true });
+  for (const name of [SESSION_EPOCH_FILE, SESSION_DIRECTORY_FILE, SESSION_KEY_FILE]) {
+    try {
+      copyFileSync(join2(newest.dir, name), join2(stateDir, name));
+      chmodSync(join2(stateDir, name), 384);
+    } catch (error) {
+      if (name === SESSION_KEY_FILE) throw error;
+    }
+  }
+  return newest.dir;
+}
 function rotateSessionKey(stateDir) {
   const key = randomBytes(32);
   writeSessionKey(join2(stateDir, SESSION_KEY_FILE), key);
@@ -327,7 +360,7 @@ function loadSessionState(stateDir, epoch = SESSION_EPOCH) {
   const signedOut = advance.advanced ? directory.revokeAll() : 0;
   return { key, directory, rotateKey: () => rotateSessionKey(stateDir), advance, signedOut };
 }
-var CODE_BYTES, SESSION_BYTES, SESSION_ID_BYTES, DEFAULT_CODE_TTL_MS, DEFAULT_SESSION_TTL_MS, SESSION_EPOCH, AccessStore, SESSION_KEY_FILE, SESSION_EPOCH_FILE;
+var CODE_BYTES, SESSION_BYTES, SESSION_ID_BYTES, DEFAULT_CODE_TTL_MS, DEFAULT_SESSION_TTL_MS, SESSION_EPOCH, AccessStore, SESSION_KEY_FILE, SESSION_EPOCH_FILE, SESSION_DIRECTORY_FILE;
 var init_access_codes = __esm({
   "packages/server/src/access-codes.ts"() {
     "use strict";
@@ -504,6 +537,7 @@ var init_access_codes = __esm({
     };
     SESSION_KEY_FILE = "session-key";
     SESSION_EPOCH_FILE = "session-epoch";
+    SESSION_DIRECTORY_FILE = "sessions.json";
   }
 });
 
@@ -518,7 +552,7 @@ var init_local_path = __esm({
 });
 
 // packages/server/src/local-image.ts
-import { createReadStream, realpathSync, statSync } from "node:fs";
+import { createReadStream, realpathSync, statSync as statSync2 } from "node:fs";
 import { extname, isAbsolute } from "node:path";
 function resolveLocalImage(rawPath, range) {
   if (rawPath) rawPath = normalizeLocalPath(rawPath);
@@ -533,7 +567,7 @@ function resolveLocalImage(rawPath, range) {
   }
   let size;
   try {
-    const stat = statSync(real);
+    const stat = statSync2(real);
     if (!stat.isFile()) return { status: 404 };
     size = stat.size;
   } catch {
@@ -944,7 +978,7 @@ import {
   openSync,
   readdirSync,
   rmSync,
-  statSync as statSync2,
+  statSync as statSync3,
   symlinkSync,
   writeFileSync as writeFileSync2,
   writeSync
@@ -989,7 +1023,7 @@ function pruneRunLogs(dir, keep = RETAINED_RUNS, days = RETAINED_DAYS, now = Dat
   }
   const dated = entries.map((name) => {
     try {
-      return { name, at: statSync2(join4(dir, name)).mtimeMs };
+      return { name, at: statSync3(join4(dir, name)).mtimeMs };
     } catch {
       return { name, at: 0 };
     }
@@ -13111,6 +13145,15 @@ var init_interactions = __esm({
   }
 });
 
+// packages/shared/src/launch-prefix.ts
+var LAUNCH_PREFIX_MAX_LENGTH;
+var init_launch_prefix = __esm({
+  "packages/shared/src/launch-prefix.ts"() {
+    "use strict";
+    LAUNCH_PREFIX_MAX_LENGTH = 2048;
+  }
+});
+
 // packages/shared/src/claim.ts
 function isAnonymousClaimName(name) {
   return ANONYMOUS_CLAIM_PATTERN.test(name);
@@ -13264,6 +13307,17 @@ var init_code_fences = __esm({
   }
 });
 
+// packages/shared/src/question-fence.ts
+var import_yaml;
+var init_question_fence = __esm({
+  "packages/shared/src/question-fence.ts"() {
+    "use strict";
+    import_yaml = __toESM(require_dist(), 1);
+    init_code_fences();
+    init_src();
+  }
+});
+
 // packages/shared/src/delta.ts
 var init_delta = __esm({
   "packages/shared/src/delta.ts"() {
@@ -13468,16 +13522,18 @@ function signoffNudgeText(needsInput) {
     "the write-up.",
     "",
     "**DECIDE RATHER THAN ASK.** Stop only for a decision that is genuinely the human's AND that blocks you",
-    "right now: register that one with `mcp__frizz__ask`. Every other open choice INSIDE the task \u2014 a name, a",
+    "right now: ask that one in a ```question fence. Every other open choice INSIDE the task \u2014 a name, a",
     "default, a reversible design call \u2014 is yours to make: decide it, say in one line which way you went and",
     "what would reverse it, and carry on. A choice that would ENLARGE the task is not one of those: an",
     "unanswered question is not permission to go build the answer.",
     "",
-    "Otherwise, sign off \u2014 a registration, or a fence at the END of your next message:",
+    "Otherwise, sign off \u2014 a question in your prose, or a fence at the END of your next message:",
     "",
-    "- `mcp__frizz__ask` \u2014 you need the human. NOT a fence: the ```question fence is retired, and a fence",
-    "  with a question in its body is plain prose. Register it (options with one-line trade-offs, the",
-    "  recommended one first), then rest normally \u2014 an open registered question is the sign-off.",
+    "- `` ```question `` \u2014 you need the human's decision. Write each fence right under the paragraph it",
+    "  decides, never stacked at the bottom: `id:` (a slug of your choosing), `kind:` (`choice`, `multi`,",
+    "  `text` or `secret`), a one-line `question:`, and `options:` with one-line trade-offs, the recommended",
+    "  one first. Frizz registers it when the message lands, and a question asked at this rest is its",
+    "  sign-off: rest normally.",
     "- `` ```done `` \u2014 genuinely FINISHED. A DISMISSAL: the card is filed away and nobody looks again, so",
     "  if anything is still owed, it is not done. Body: 1-3 sentences, then bullets, each opening with a",
     "  **bolded verb phrase**.",
@@ -13485,24 +13541,24 @@ function signoffNudgeText(needsInput) {
     "",
     "  Frizz CHECKS every line: name something that is not running and you are bumped rather than parked.",
     "  A fence that names NOTHING is not a park at all \u2014 if you are not waiting on anything, you are not",
-    "  awaiting, you are done. Register a PR with `mcp__frizz__watch_pr` and a timer with",
-    "  `mcp__frizz__timer`; `mcp__frizz__activity` reads back everything you have running, with its id.",
+    "  awaiting, you are done. Register a PR with `frizzctl watch-pr add` and a timer with",
+    "  `frizzctl timer set`; `frizzctl activity` reads back everything you have running, with its id.",
     "- `` ```awaiting `` with `steps:` \u2014 the human must PERFORM something you cannot: sign in, approve,",
     "  merge, press a button you may not. List each step as a `- ` line under `steps:`, written to be",
     "  followed cold: a real Markdown link to every page and file it names, every command in a code span,",
     "  every value the act needs written in. Frizz reads them verbatim. Steps name the HUMAN as the wait,",
     "  so the fence needs no other name and no `for:`, and the thread goes into their queue. Their Done",
     "  comes back to you as their reply; anything else they need to say comes as a message of their own.",
-    "- `` ```awaiting `` with `questions:` \u2014 a question you registered at an EARLIER rest is still open and",
-    "  you still need its answer. Name every such question (`questions: [qst_\u2026]`) and withdraw the rest with",
-    "  `mcp__frizz__unask`: a fence that leaves an open question out is refused. A named card is drawn at",
-    "  this rest; an unnamed one stays where you asked it.",
+    "- A question you asked at an EARLIER rest, whose answer you still need: write a ```question fence",
+    "  carrying its `id:` alone. That draws its card in this message and keeps the thread in the human's",
+    "  queue. One you no longer need, withdraw with `frizzctl unask <id>`; one you leave unmentioned stays",
+    "  answerable where you asked it.",
     "",
     "**STILL OWED counts things you are not going to do yourself.** A decision you are RECOMMENDING, a",
     "draft you wrote but did not send, follow-up work you discovered \u2014 all of it dies with the card, even",
-    "the part that is someone else's to do. Each ends on a question with your recommendation as option 1,",
+    "the part that is someone else's to do. Each ends on a question with your recommendation as option A,",
     "or you DO it first \u2014 a sub-agent's result comes BACK to you, so it lands on your card; a new card via",
-    "`mcp__frizz__spawn_thread` is the LAST resort, since nothing it learns returns to you or its siblings.",
+    "`frizzctl spawn-thread` is the LAST resort, since nothing it learns returns to you or its siblings.",
     "None of them is a `done`. And what is not",
     'worth a card is not worth a SENTENCE: delete the dangling "one thing to carry forward", never park it',
     "in the handoff.",
@@ -13522,23 +13578,37 @@ function requireEffortOutsideAcp(profile, ctx) {
     ctx.addIssue({ code: external_exports.ZodIssueCode.custom, path: ["effort"], message: `effort is required for a ${profile.backend} profile` });
   }
 }
+function formatElapsed(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "an unknown time";
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return m % 60 === 0 ? `${h}h` : `${h}h ${m % 60}m`;
+  const d = Math.floor(h / 24);
+  return h % 24 === 0 ? `${d}d` : `${d}d ${h % 24}h`;
+}
 function fallbackPort(base) {
   return base + 1e4;
 }
-var import_yaml, ATTACHMENT_IMAGE_EXTENSIONS, ATTACHMENT_TEXT_EXTENSIONS, ATTACHMENT_OFFICE_EXTENSIONS, ATTACHMENT_DATA_EXTENSIONS, ATTACHMENT_ARCHIVE_EXTENSIONS, ATTACHMENT_DOC_EXTENSIONS, ATTACHMENT_EXTENSIONS, ATTACHMENT_MAX_BASE64_CHARS, ATTACHMENT_MAX_BYTES, ATTACHMENT_EXT_SET, ATTACHMENT_ACCEPT, FrizzStatus, BlockMechanism, RuntimeState, Backend, CodexModel, ClaudeModel, AcpAgent, AcpAgentModel, AcpAgentModels, AcpAgentModelsInput, ThreadProfileOption, ThreadAgent, SubAgentView, BgShellView, CompletionHoldOp, CompletionHold, AskOption, AskQuestion, PendingAsk, AwaitingHint, RETIRED_AWAITING_KINDS, RETIRED_LINE_RE, AWAITING_FOR_MAX_MS, SnoozeUntil, SNOOZE_PROMPT_MAX, SnoozePrompt, RECURRING_PROMPT_MAX, RECURRING_MIN_INTERVAL_SECONDS, RECURRING_MAX_INTERVAL_SECONDS, RecurringPromptText, RecurringIntervalSeconds, ThreadRecurringPrompt, TIMER_PROMPT_MAX, TIMER_MAX_DELAY_SECONDS, TimerPromptText, SIGNOFF_NUDGE_MARKER, SIGNOFF_NUDGE_MESSAGE, SIGNOFF_NUDGE_MESSAGE_NEEDS_INPUT, ThreadWatchKind, GithubChecksState, GithubMergeState, GithubWatchStatus, GithubIssueStatus, ThreadWatchView, PR_WATCH_FOR_MAX_MS, PR_WATCH_DEFAULT_FOR_MS, PrWatchView, AddOwnPrWatchInput, AddOwnPrWatchResult, DropOwnPrWatchInput, DropOwnPrWatchResult, OwnWatchKind, AddOwnWatchInput, OwnWatchView, AddOwnWatchResult, DropOwnWatchInput, DropOwnWatchResult, AskQuestionKind, AskedOptionSchema, AskedQuestionSchema, AskInput, RegisteredQuestionView, SECRET_TTL_MS, AskResult, UnaskInput, UnaskResult, QuestionAnswerSchema, AnswerQuestionsInput, AnswerQuestionsResult, DismissQuestionsInput, DismissQuestionsResult, SettledQuestionView, ThreadSettledQuestionsResult, MarkOwnDoneInput, MarkOwnDoneResult, ListOwnPrWatchesInput, OwnPrWatchesResult, ThreadTimerView, ThreadFence, LimitWindow, LimitPause, ProviderError, ThreadLinkView, UpsertOwnLinkInput, UpsertOwnLinkResult, DropOwnLinkInput, DropOwnLinkResult, LiveTool, ThreadView, BoardErrorItem, BoardSnapshot, QuotaWindow, ProviderQuota, QuotaSnapshot, ProviderAuth, AccountEmails, AuthSnapshot, AccountBackend, AccountLogoutInput, AccountLogoutResult, PermissionMode, LocalFileOpener, Settings, DispatchProviderPreferences, DispatchPreferences, DispatchProfileSnapshotShape, DispatchProfileSnapshot, SetDispatchPreferenceInput, DispatchInput, ADOPT_THREAD_MESSAGE_MAX_CHARS, AdoptThreadInput, AdoptThreadResult, AdoptSessionInput, FollowUpInput, SteerThreadInput, SteerThreadResult, DismissFailedFollowUpInput, DismissFailedFollowUpResult, UnqueueFollowUpInput, UnqueueFollowUpResult, DeliverQueuedNowInput, DeliverQueuedNowResult, CompactThreadInput, SetThreadSnoozeInput, SetThreadPinnedInput, SetThreadRecurringPromptInput, SetOwnThreadRecurringPromptInput, SetOwnThreadRecurringPromptResult, GetOwnThreadRecurringPromptInput, OwnThreadRecurringPromptResult, SetOwnThreadTimerInput, CancelOwnThreadTimerInput, ListOwnThreadTimersInput, OwnThreadTimersResult, ThreadActivityItem, ListOwnThreadActivityInput, OwnThreadActivityResult, SetOwnThreadTimerResult, CancelOwnThreadTimerResult, SetOwnThreadStopHookInput, SetOwnThreadHeartbeatInput, ThreadPluginReloadResult, RenameThreadInput, AiRenameThreadInput, AiRenameThreadResult, SetOwnThreadTitleInput, SetOwnThreadTitleResult, SetThreadPermissionInput, SetThreadPermissionResult, ThreadProfileOptionsInput, ThreadProfileOptionsResult, ThreadSkillSource, ThreadSkill, ThreadSkillsInput, ThreadSkillsResult, SetThreadProfileInput, SetThreadProfileResult, UpgradeThreadModelInput, UpgradeThreadModelResult, DISPATCH_TASK_BANNER, DISPATCH_TASK_BANNER_MARKER, HUMAN_GAP_FLOOR_MS, GithubWakeItem, GithubWakeSteer, WAKE_SCOPE, WAKE_REF, WAKE_SINGLE, WAKE_MULTI_HEAD, PR_WATCH_FINISHED, PR_WATCH_CI_PASSED, PR_WATCH_CI_GATED, PR_WATCH_STATE, PR_WATCH_CI_FAILED, GithubStatus, GithubRefCard, GithubRefPreviewInput, GithubRefPreviewResult, GithubItem, GithubListInput, GithubListResult, GithubBatchInput, GithubBatchResult, BoardMeta, ServerEvent, TranscriptEdit, TranscriptTodo, TranscriptToolCall, TranscriptPart, TranscriptMessage, TranscriptPageCursor, EditedFile, TranscriptPage, TranscriptEarlierInput, SocketTranscriptSlug, SocketFilePath, SocketTranscriptClientMsg, SocketFileClientMsg, SocketClientMsg, ProjectCard, ProjectRailCounts, PROJECT_ICON_MAX_BASE64_CHARS, DirectoryPickResult, ThreadLocation, FRIZZ_ROUTE_PREFIX, DEFAULT_PORT;
+var import_yaml2, ATTACHMENT_IMAGE_EXTENSIONS, ATTACHMENT_TEXT_EXTENSIONS, ATTACHMENT_OFFICE_EXTENSIONS, ATTACHMENT_DATA_EXTENSIONS, ATTACHMENT_ARCHIVE_EXTENSIONS, ATTACHMENT_DOC_EXTENSIONS, ATTACHMENT_EXTENSIONS, ATTACHMENT_MAX_BASE64_CHARS, ATTACHMENT_MAX_BYTES, ATTACHMENT_EXT_SET, ATTACHMENT_ACCEPT, FrizzStatus, BlockMechanism, RuntimeState, Backend, CodexModel, ClaudeModel, AcpAgent, AcpAgentModel, AcpAgentModels, AcpAgentModelsInput, ThreadProfileOption, ThreadAgent, SubAgentView, BgShellView, CompletionHoldOp, CompletionHold, AskOption, AskQuestion, PendingAsk, AwaitingHint, RETIRED_AWAITING_KINDS, RETIRED_LINE_RE, AWAITING_FOR_MAX_MS, SnoozeUntil, SNOOZE_PROMPT_MAX, SnoozePrompt, RECURRING_PROMPT_MAX, RECURRING_MIN_INTERVAL_SECONDS, RECURRING_MAX_INTERVAL_SECONDS, RecurringPromptText, RecurringIntervalSeconds, ThreadRecurringPrompt, TIMER_PROMPT_MAX, TIMER_MAX_DELAY_SECONDS, TimerPromptText, SIGNOFF_NUDGE_MARKER, SIGNOFF_NUDGE_MESSAGE, SIGNOFF_NUDGE_MESSAGE_NEEDS_INPUT, ThreadWatchKind, GithubChecksState, GithubMergeState, GithubWatchStatus, GithubIssueStatus, CommandWatchRun, MonitorStatus, ThreadWatchView, PR_WATCH_FOR_MAX_MS, PR_WATCH_DEFAULT_FOR_MS, PrWatchView, AddOwnPrWatchInput, AddOwnPrWatchResult, DropOwnPrWatchInput, DropOwnPrWatchResult, OwnWatchKind, AddOwnWatchInput, OwnWatchView, AddOwnWatchResult, DropOwnWatchInput, DropOwnWatchResult, COMMAND_WATCH_EVERY_MAX_MS, COMMAND_WATCH_FOR_MAX_MS, COMMAND_WATCH_COMMAND_MAX, COMMAND_WATCH_RUN_TIMEOUT_MS, CommandWatchState, CommandWatchView, AddOwnCommandWatchInput, AddOwnCommandWatchResult, DropOwnCommandWatchInput, DropOwnCommandWatchResult, ListOwnCommandWatchesInput, OwnCommandWatchesResult, MONITOR_FLOOD_MAX_EVENTS, MONITOR_FLOOD_WINDOW_MS, MONITOR_DESCRIPTION_MAX, AddOwnMonitorInput, AddOwnMonitorResult, MONITOR_FLOOD_REASON, AskQuestionKind, AskedOptionSchema, AskedQuestionSchema, AskInput, RegisteredQuestionView, QuestionFenceFaultView, ClosedQuestionView, SECRET_TTL_MS, AskResult, UnaskInput, UnaskResult, QuestionAnswerSchema, AnswerQuestionsInput, AnswerQuestionsResult, DismissQuestionsInput, DismissQuestionsResult, SettledQuestionView, ThreadSettledQuestionsResult, ANSWER_ROW_ID_PATTERN, ANSWER_ROW_ID, MarkOwnDoneInput, MarkOwnDoneResult, ListOwnPrWatchesInput, OwnPrWatchesResult, ThreadTimerView, ThreadFence, LimitWindow, LimitPause, ProviderError, ThreadLinkView, UpsertOwnLinkInput, UpsertOwnLinkResult, DropOwnLinkInput, DropOwnLinkResult, LiveTool, ThreadView, BoardErrorItem, BoardSnapshot, BoardState, QuotaWindow, ProviderQuota, QuotaSnapshot, ProviderAuth, AccountEmails, AuthSnapshot, AccountBackend, AccountLogoutInput, AccountLogoutResult, PermissionMode, LocalFileOpener, Settings, DispatchProviderPreferences, DispatchPreferences, DispatchProfileSnapshotShape, DispatchProfileSnapshot, SetDispatchPreferenceInput, DispatchInput, ADOPT_THREAD_MESSAGE_MAX_CHARS, AdoptThreadInput, AdoptThreadResult, AdoptSessionInput, FollowUpInput, SteerThreadInput, SteerThreadResult, SpawnThreadInput, SpawnThreadResult, SpawnChildInput, SpawnChildResult, DismissFailedFollowUpInput, DismissFailedFollowUpResult, UnqueueFollowUpInput, UnqueueFollowUpResult, DeliverQueuedNowInput, DeliverQueuedNowResult, CompactThreadInput, SetThreadSnoozeInput, SetThreadPinnedInput, ReorderPinnedThreadsInput, SetThreadConsolePinnedInput, ReorderConsolePinnedThreadsInput, SetThreadRecurringPromptInput, SetOwnThreadRecurringPromptInput, SetOwnThreadRecurringPromptResult, GetOwnThreadRecurringPromptInput, OwnThreadRecurringPromptResult, SetOwnThreadTimerInput, CancelOwnThreadTimerInput, ListOwnThreadTimersInput, OwnThreadTimersResult, ThreadActivityItem, ListOwnThreadActivityInput, OwnThreadActivityResult, ThreadBand, ThreadListing, ListThreadsInput, ListThreadsResult, SetOwnThreadTimerResult, CancelOwnThreadTimerResult, SetOwnThreadStopHookInput, SetOwnThreadHeartbeatInput, RenameThreadInput, AiRenameThreadInput, AiRenameThreadResult, SetOwnThreadTitleInput, SetOwnThreadTitleResult, SetThreadPermissionInput, SetThreadPermissionResult, ThreadProfileOptionsInput, ThreadProfileOptionsResult, ThreadSkillSource, ThreadSkill, ThreadSkillsInput, ThreadSkillsResult, McpTarget, McpServerState, McpServerReading, McpStatusResult, McpSignInInput, McpSignInState, McpSignInResult, McpSignInAttemptInput, McpSignInPollResult, McpSignInFinishInput, SetThreadProfileInput, SetThreadProfileResult, UpgradeThreadModelInput, UpgradeThreadModelResult, DISPATCH_TASK_BANNER, DISPATCH_TASK_BANNER_MARKER, HUMAN_GAP_FLOOR_MS, GithubWakeItem, GithubWakeSteer, WAKE_SCOPE, WAKE_REF, WAKE_SINGLE, WAKE_MULTI_HEAD, PR_WATCH_FINISHED, PR_WATCH_CI_PASSED, PR_WATCH_CI_GATED, PR_WATCH_STATE, PR_WATCH_CI_FAILED, GithubStatus, GithubAccount, GithubRefCard, GithubRefPreviewInput, GithubRefPreviewResult, GithubItem, GithubListInput, GithubListResult, GithubBatchInput, GithubBatchResult, BoardMeta, BoardDeltaEvent, ServerEvent, BoardDeltasInput, BoardDeltasResult, TranscriptEdit, TranscriptTodo, TranscriptToolCall, TranscriptPart, TranscriptMessage, TranscriptPageCursor, EditedFile, TranscriptPage, TranscriptEarlierInput, SocketTranscriptSlug, SocketFilePath, SocketTranscriptClientMsg, SocketFileClientMsg, SocketBoardClientMsg, SocketClientMsg, ProjectCard, ProjectRailCounts, PROJECT_ICON_MAX_BASE64_CHARS, DirectoryPickResult, ThreadLocation, FRIZZ_ROUTE_PREFIX, DEFAULT_PORT;
 var init_src = __esm({
   "packages/shared/src/index.ts"() {
     "use strict";
-    import_yaml = __toESM(require_dist(), 1);
+    import_yaml2 = __toESM(require_dist(), 1);
     init_zod();
     init_interactions();
+    init_launch_prefix();
     init_thread_slug();
     init_claim();
     init_claude_editions();
     init_code_fences();
+    init_question_fence();
     init_delta();
     init_drainable_worker();
     init_interactions();
+    init_launch_prefix();
     init_receipt_bus();
     init_relay_protocol();
     init_shell_writes();
@@ -13863,7 +13933,7 @@ var init_src = __esm({
       questions: external_exports.array(AskQuestion)
     });
     AwaitingHint = external_exports.object({
-      kind: external_exports.enum(["shell", "agent", "timer", "pr", "issue", "for", "title", "status", "needs_input", "step", "question"]),
+      kind: external_exports.enum(["shell", "agent", "timer", "pr", "issue", "command", "thread", "for", "title", "status", "needs_input", "step", "question"]),
       value: external_exports.string()
     });
     RETIRED_AWAITING_KINDS = ["watch", "pr-watch", "human", "ci", "session", "shell", "agent", "timer", "pr", "reason"];
@@ -13904,7 +13974,7 @@ var init_src = __esm({
     SIGNOFF_NUDGE_MARKER = "**This message is from frizz, not from the human.**";
     SIGNOFF_NUDGE_MESSAGE = signoffNudgeText(false);
     SIGNOFF_NUDGE_MESSAGE_NEEDS_INPUT = signoffNudgeText(true);
-    ThreadWatchKind = external_exports.enum(["shell", "github", "timer"]);
+    ThreadWatchKind = external_exports.enum(["shell", "github", "timer", "command"]);
     GithubChecksState = external_exports.enum(["none", "running", "passing", "failing"]);
     GithubMergeState = external_exports.enum(["mergeable", "blocked", "conflicting", "unknown"]);
     GithubWatchStatus = external_exports.object({
@@ -13942,7 +14012,16 @@ var init_src = __esm({
       /** A digest of WHICH jobs are failing right now. The head commit alone cannot express a re-run of the
        *  same job, or a slower job going red after the first — both of which are a second failure the worker
        *  must hear about. Empty when nothing is failing. */
-      failureSig: external_exports.string().optional()
+      failureSig: external_exports.string().optional(),
+      /** WHO THE PR IS WAITING ON, the facts behind "will anything move here unless we act?"
+       *  (awaiting.prWaitsOnNoOne). Whether GitHub will merge it by itself (`queued` in a merge queue, `auto`
+       *  with auto-merge on, `none`), whether the signed-in `gh` account opened it and may merge it, and
+       *  whether a review is still requested of someone. Absent means unknown: the `gh` fallback and a
+       *  reading taken before 2026-10-27 carry none, and an unknown never counts as "nobody". */
+      mergePath: external_exports.enum(["none", "queued", "auto"]).optional(),
+      viewerAuthored: external_exports.boolean().optional(),
+      viewerCanMerge: external_exports.boolean().optional(),
+      reviewRequested: external_exports.boolean().optional()
     }).strict();
     GithubIssueStatus = external_exports.object({
       /** OPEN | CLOSED, lowercased. A closed issue ends the wait outright. */
@@ -13958,6 +14037,20 @@ var init_src = __esm({
       /** When frizz last heard from GitHub, for the same reason `GithubWatchStatus.polledAt` carries it. */
       polledAt: external_exports.string()
     }).strict();
+    CommandWatchRun = external_exports.object({
+      at: external_exports.string(),
+      outcome: external_exports.enum(["exit", "timeout", "signal", "error"]),
+      exitCode: external_exports.number().int().nullable(),
+      output: external_exports.string()
+    }).strict();
+    MonitorStatus = external_exports.object({
+      /** The worker's own words for what it watches ("errors in deploy.log"), when it gave any. */
+      description: external_exports.string().optional(),
+      /** Events printed so far: each batch of lines that woke (or will wake) the thread is one. */
+      events: external_exports.number().int().nonnegative(),
+      /** The newest event's text, trimmed, and when it was printed. */
+      lastEvent: external_exports.object({ at: external_exports.string(), text: external_exports.string() }).strict().optional()
+    }).strict();
     ThreadWatchView = external_exports.object({
       id: external_exports.string(),
       kind: ThreadWatchKind,
@@ -13979,7 +14072,22 @@ var init_src = __esm({
        *  worker's prompt is the row's NAME (a `tmr_…` id names nothing to a human) and the fire instant is
        *  its status. Unlike `github` there is no polled half to be absent: a timer that exists is fully
        *  known, so a timer row always carries this. */
-      timer: external_exports.object({ fireAt: external_exports.string(), prompt: external_exports.string() }).strict().optional()
+      timer: external_exports.object({ fireAt: external_exports.string(), prompt: external_exports.string() }).strict().optional(),
+      /** `command` rows only: the armed command watch's registration and its last check — what the worker's
+       *  own read-back carries (CommandWatchView), minus the id and state the row already has. The command is
+       *  the row's NAME and the cadence its status. Until 2026-10-13 a command watch had no row at all, so a
+       *  thread parked on nothing else drew a card that said only "Waiting for an external update." */
+      command: external_exports.object({
+        command: external_exports.string(),
+        /** The cadence in the house duration grammar (`2m`, `1h 30m`). */
+        every: external_exports.string(),
+        expiresAt: external_exports.string(),
+        runs: external_exports.number().int().nonnegative(),
+        lastRun: CommandWatchRun.optional(),
+        /** A MONITOR's own reading (`frizzctl monitor`), and present on nothing else: the row is a running
+         *  script, so its status is how many events it has printed, not a cadence. */
+        monitor: MonitorStatus.optional()
+      }).strict().optional()
     }).strict();
     PR_WATCH_FOR_MAX_MS = 365 * 24 * 60 * 60 * 1e3;
     PR_WATCH_DEFAULT_FOR_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -14021,7 +14129,7 @@ var init_src = __esm({
        *  still BOUNDS the poll; the point of the field is that a worker chooses, and one that cannot choose
        *  is better bounded than broken. */
       for: external_exports.string().trim().min(1).max(16).optional(),
-      /** What `target` names. `issue` (from `mcp__frizz__watch_issue`, 2026-09-14) registers a watcher on a
+      /** What `target` names. `issue` (from `frizzctl watch-issue`, 2026-09-14) registers a watcher on a
        *  GitHub issue — same registry, same poll cadence, same drop verb, but a different probe (`gh issue
        *  view`), a different GraphQL fragment and a report with no CI in it. ABSENT MEANS A PULL REQUEST,
        *  for the same reason `for` is optional on the wire: every `watch_pr` binary dispatched before this
@@ -14109,6 +14217,98 @@ var init_src = __esm({
       dropped: external_exports.boolean(),
       watches: external_exports.array(OwnWatchView)
     }).strict();
+    COMMAND_WATCH_EVERY_MAX_MS = 24 * 60 * 60 * 1e3;
+    COMMAND_WATCH_FOR_MAX_MS = 7 * 24 * 60 * 60 * 1e3;
+    COMMAND_WATCH_COMMAND_MAX = 4e3;
+    COMMAND_WATCH_RUN_TIMEOUT_MS = 2 * 6e4;
+    CommandWatchState = external_exports.enum(["armed", "dropped", "passed", "expired", "cancelled"]);
+    CommandWatchView = external_exports.object({
+      id: external_exports.string(),
+      command: external_exports.string(),
+      /** The cadence in the house duration grammar (`5m`, `1h 30m`). */
+      every: external_exports.string(),
+      state: CommandWatchState,
+      createdAt: external_exports.string(),
+      expiresAt: external_exports.string(),
+      /** How many checks have run since it was armed, the registration's own first check included. */
+      runs: external_exports.number().int().nonnegative(),
+      lastRun: CommandWatchRun.optional(),
+      /** Present on a MONITOR (`frizzctl monitor`) and nothing else: a script the server keeps RUNNING, whose
+       *  every printed line is a wake. A monitor has no cadence and no checks, so `every` reads `0s` and
+       *  `runs` 0 on one; read this instead. */
+      monitor: MonitorStatus.optional()
+    }).strict();
+    AddOwnCommandWatchInput = external_exports.object({
+      slug: ThreadSlug,
+      /** Run with `/bin/sh -c` in the project root, with the server's environment. Exit status 0 is "passed". */
+      command: external_exports.string().trim().min(1).max(COMMAND_WATCH_COMMAND_MAX),
+      /** How often to check, as a DURATION (`5m`; parseAwaitingDurationRaw). Clamped to [1m, 24h] and reported. */
+      every: external_exports.string().trim().min(1).max(16),
+      /** How long to keep checking, as a DURATION. Clamped to COMMAND_WATCH_FOR_MAX_MS and reported. */
+      for: external_exports.string().trim().min(1).max(16)
+    }).strict();
+    AddOwnCommandWatchResult = external_exports.object({
+      /** Present when the call was REFUSED — the thread may not run commands outside the CLI's permission
+       *  system, or the command cannot run here at all. A refusal is an answer, not a fault: the text says
+       *  why and what to use instead, and nothing was stored. */
+      refused: external_exports.string().optional(),
+      /** The armed row's id. Absent when nothing was armed: a refusal, or a first check that already passed. */
+      id: external_exports.string().optional(),
+      /** This exact command was already watched on this thread, so the call registered nothing new. */
+      alreadyArmed: external_exports.boolean().default(false),
+      /** The FIRST CHECK, run before anything was stored. Exit 0 there means the condition already holds:
+       *  nothing is armed, and the worker proceeds now rather than waiting a cadence to be told so. */
+      firstRun: CommandWatchRun.optional(),
+      passed: external_exports.boolean().default(false),
+      expiresAt: external_exports.string().optional(),
+      every: external_exports.string().optional(),
+      /** The `every` / `for` the worker wrote, present ONLY when it was clamped — a clamp nobody is told about
+       *  is a worker resting on coverage it does not have. */
+      clamped: external_exports.object({ every: external_exports.string().optional(), for: external_exports.string().optional() }).strict().optional(),
+      watches: external_exports.array(CommandWatchView)
+    }).strict();
+    DropOwnCommandWatchInput = external_exports.object({
+      slug: ThreadSlug,
+      id: external_exports.string().min(1).max(64)
+    }).strict();
+    DropOwnCommandWatchResult = external_exports.object({
+      dropped: external_exports.boolean(),
+      watches: external_exports.array(CommandWatchView)
+    }).strict();
+    ListOwnCommandWatchesInput = external_exports.object({ slug: ThreadSlug }).strict();
+    OwnCommandWatchesResult = external_exports.object({ watches: external_exports.array(CommandWatchView) }).strict();
+    MONITOR_FLOOD_MAX_EVENTS = 30;
+    MONITOR_FLOOD_WINDOW_MS = 10 * 6e4;
+    MONITOR_DESCRIPTION_MAX = 120;
+    AddOwnMonitorInput = external_exports.object({
+      slug: ThreadSlug,
+      /** Run with `/bin/sh -c` in the project root, with the server's environment. Each stdout line is an event. */
+      command: external_exports.string().trim().min(1).max(COMMAND_WATCH_COMMAND_MAX),
+      /** What it watches, in the worker's words — the name on its row and drawer, and the label on every wake.
+       *  Required (2026-11-03), as a sub-agent's description is: without one the row could only show the script. */
+      description: external_exports.string().trim().min(1).max(MONITOR_DESCRIPTION_MAX),
+      /** How long to keep it running, as a DURATION. Clamped to COMMAND_WATCH_FOR_MAX_MS and reported. */
+      for: external_exports.string().trim().min(1).max(16)
+    }).strict();
+    AddOwnMonitorResult = external_exports.object({
+      /** Present when the call was REFUSED: the gate, the caps, or a script that could not run here. Nothing
+       *  is armed, and the text says why and what to use instead. */
+      refused: external_exports.string().optional(),
+      id: external_exports.string().optional(),
+      /** This exact command already runs as a monitor on this thread; nothing new was registered. */
+      alreadyArmed: external_exports.boolean().default(false),
+      /** Still running when registration stopped watching it (MONITOR_REGISTRATION_WINDOW_MS). */
+      running: external_exports.boolean().default(false),
+      /** The events it printed while registration watched — handed back here rather than woken. */
+      events: external_exports.array(external_exports.string()).default([]),
+      /** It EXITED while registration watched: how, and the end of what it printed. Nothing stays armed. */
+      exited: CommandWatchRun.optional(),
+      expiresAt: external_exports.string().optional(),
+      /** The `for` the worker wrote, present ONLY when it was clamped. */
+      clamped: external_exports.object({ for: external_exports.string() }).strict().optional(),
+      watches: external_exports.array(CommandWatchView)
+    }).strict();
+    MONITOR_FLOOD_REASON = `it printed ${MONITOR_FLOOD_MAX_EVENTS} events inside ${formatElapsed(MONITOR_FLOOD_WINDOW_MS)}, and every event is a turn of yours. Register it again with a tighter filter: print only the lines you would act on (\`grep --line-buffered\`), never raw logs.`;
     AskQuestionKind = external_exports.enum(["question", "multi"]);
     AskedOptionSchema = external_exports.lazy(() => external_exports.object({
       // 400, not the 120 it launched with (2026-09-03): a label is a chip line, but "Post the drafted
@@ -14127,32 +14327,55 @@ var init_src = __esm({
       // 4000, not the 600 it launched with (2026-09-03): this field is the whole card context — everything
       // the human needs to answer cold — and a question that carries its own evidence needs the room. The
       // answer restates it, so QuestionAnswerSchema's cap matches.
+      handle: external_exports.string().trim().min(1).max(64).optional(),
       question: external_exports.string().trim().min(1).max(4e3),
+      context: external_exports.string().trim().max(2e4).optional(),
       header: external_exports.string().trim().max(24).optional(),
       kind: AskQuestionKind,
       danger: external_exports.boolean().optional(),
       secret: external_exports.boolean().optional(),
       // UNBOUNDED, deliberately. This carried `.max(8)` from launch until 2026-09-03, when the maintainer
       // asked for the cap to go ("allow arbitrary numbers of options"): a `multi` over a long list — which
-      // gates to run, which of twenty findings to act on — is a real shape, and the card numbers past 9
-      // (only 1–9 are keys) already. The count is the worker's to choose; the answer's `chosen` is unbounded to match.
+      // gates to run, which of twenty findings to act on — is a real shape, and the card letters past 26
+      // (`AA.`) already. The count is the worker's to choose; the answer's `chosen` is unbounded to match.
       options: external_exports.array(AskedOptionSchema).optional()
     }).strict());
     AskInput = external_exports.object({
       slug: ThreadSlug,
-      // No cap on the count (four until 2026-09-03): the tool's own text says "several at once is one
-      // call — register them together", and a cap here told a worker with six to batch and then refused it.
+      // No cap on the count (four until 2026-09-03): the command's own help says several at once is one
+      // run — register them together — and a cap here told a worker with six to batch and then refused it.
       questions: external_exports.array(AskedQuestionSchema).min(1)
     }).strict();
     RegisteredQuestionView = external_exports.object({
       /** Minted by frizz. The worker never chose it, which is why an answer RESTATES the question text —
        *  an id alone cannot be correlated back to what was asked. */
       id: external_exports.string(),
+      /** The worker's own id for it, from its ```question fence — what `unask` and every correction name it
+       *  by. Absent on a question `ask` registered, which only ever had the minted id. */
+      handle: external_exports.string().optional(),
       spec: AskedQuestionSchema,
       askedAt: external_exports.string(),
       /** A `secret` question only: the path its value will be served at. Known at registration, so the
        *  worker can prepare the command that reads it before the human has answered. */
-      secretPath: external_exports.string().optional()
+      secretPath: external_exports.string().optional(),
+      /** ON THE BOARD ONLY: does this question STAND at the thread's current rest — asked at it, or
+       *  referenced by it (server question-fences.ts standingQuestions)? `false` is a question that has
+       *  FADED: still open and answerable where it was asked, but not what this rest is waiting on, so it
+       *  neither queues the thread nor marks its row. Absent — the worker's own read-back, a snapshot from
+       *  before 2026-10-13 — reads as standing (hasStandingQuestion). */
+      standing: external_exports.boolean().optional()
+    }).strict();
+    QuestionFenceFaultView = external_exports.object({
+      at: external_exports.string(),
+      id: external_exports.string().optional(),
+      faults: external_exports.array(external_exports.string())
+    }).strict();
+    ClosedQuestionView = external_exports.object({
+      id: external_exports.string(),
+      /** The worker's own id for it — what its fence in the transcript carries. */
+      handle: external_exports.string(),
+      state: external_exports.enum(["dismissed", "withdrawn"]),
+      askedAt: external_exports.string()
     }).strict();
     SECRET_TTL_MS = 15 * 6e4;
     AskResult = external_exports.object({
@@ -14166,6 +14389,14 @@ var init_src = __esm({
     }).strict();
     UnaskResult = external_exports.object({
       withdrawn: external_exports.boolean(),
+      /** The question the id resolved to, by the name the WORKER knows it by (its fence's `id:`, or the
+       *  `qst_…` an `ask` minted) — absent when the id names nothing on this thread. It is the ROOT's: a
+       *  follow-up rides inside its parent's row and cannot be withdrawn alone, so `unask sqlite-path`
+       *  withdraws nothing and answers `settings-store` here — the id that takes the pair back. */
+      id: external_exports.string().optional(),
+      /** What that question was when the call arrived. `open` beside `withdrawn: true` is the ordinary
+       *  withdrawal; anything else is why nothing was withdrawn — and `answered` means a wake is on its way. */
+      state: external_exports.enum(["open", "answered", "withdrawn", "dismissed"]).optional(),
       open: external_exports.array(RegisteredQuestionView)
     }).strict();
     QuestionAnswerSchema = external_exports.lazy(() => external_exports.object({
@@ -14209,6 +14440,8 @@ var init_src = __esm({
     ThreadSettledQuestionsResult = external_exports.object({
       questions: external_exports.array(SettledQuestionView)
     }).strict();
+    ANSWER_ROW_ID_PATTERN = "[a-z0-9][a-z0-9._-]{0,63}";
+    ANSWER_ROW_ID = new RegExp(`^${ANSWER_ROW_ID_PATTERN}$`);
     MarkOwnDoneInput = external_exports.object({
       slug: ThreadSlug,
       body: external_exports.string().trim().min(1).max(2e4)
@@ -14235,7 +14468,7 @@ var init_src = __esm({
       body: external_exports.string(),
       // fence body minus hint lines, capped server-side; may be ""
       hints: external_exports.array(AwaitingHint).default([]),
-      // Present only on a completion the worker REGISTERED (`mcp__frizz__done`, board.registeredDoneFence)
+      // Present only on a completion the worker REGISTERED (`frizzctl done`, board.registeredDoneFence)
       // rather than wrote as a ```done fence in its final message. The two are one fence to every predicate,
       // but the TRANSCRIPT draws a fence card from the message text it parses — so a registered done, which
       // is in no message, needs the client to know it must draw the card itself at the bottom of the thread
@@ -14379,6 +14612,20 @@ var init_src = __esm({
       // outlive the message that carried it. These rows can, and they carry the question itself rather than
       // merely asserting one exists — the card renders from this instead of re-parsing prose.
       questions: external_exports.array(RegisteredQuestionView).default([]),
+      /** The ```question fences of this thread that could NOT register, from its latest sync — every one in
+       *  the server's ring of fenced messages, not only the current rest's. Present only when there is one.
+       *  A refused fence has no row, and so does a fence the registrar has not reached yet; this is what
+       *  tells them apart, so the transcript draws the first as the code block it is and only the second as
+       *  the question it is about to become (web lib/questionFaults). Its other job is the reused id: a fence
+       *  refused for naming a spent id must not move that id's card, which a name match alone would do. */
+      questionFaults: external_exports.array(QuestionFenceFaultView).optional(),
+      /** The questions this thread asked with a ```question fence that CLOSED WITHOUT AN ANSWER — dismissed
+       *  (the human's ×, or Frizz cancelling a question an autonomous thread wrote) or withdrawn by the
+       *  worker. Present only when there is one. Their fences are still in the transcript, and without this a
+       *  fence with no open and no answered row reads as a question about to become answerable; with it the
+       *  fence draws its question closed, saying which way (web ClosedQuestionCard). Compact on purpose — the
+       *  fence itself carries the question — because the board ships every thread on every keyframe. */
+      closedQuestions: external_exports.array(ClosedQuestionView).optional(),
       /** The answer the human has already SENT that the worker has not received yet, as the exact message
        *  the delivery will carry (board.answersInFlight → questionAnswerMessage). The chat parses it with
        *  the same reader it uses on the delivered turn, so the in-flight card and the landed one are the
@@ -14418,6 +14665,16 @@ var init_src = __esm({
       foreign: external_exports.boolean().optional(),
       // ui.db lifecycle for session threads (open|archived) — written ONLY by explicit Archive/Reopen.
       state: external_exports.enum(["open", "archived"]).optional(),
+      // The instant the thread was marked done (session.archived_at), present while it is archived. The
+      // Done band's order: the one marked done most recently is at its top (maintainer 2026-10-23). Absent
+      // on a thread archived before the column existed, which the band places by its rest time instead.
+      archivedAt: external_exports.string().optional(),
+      // The instant this thread last ENTERED the Running band (session.running_since), present while it is
+      // in it: the board stamps it the first build that finds the thread there and clears it the first
+      // build that does not. The Running band's order: the thread that most recently switched back to
+      // running is at its top (maintainer 2026-10-23). A thread that stays in the band keeps its instant, so
+      // a working rest, a sub-agent returning or a mid-turn message never moves it.
+      runningSince: external_exports.string().optional(),
       // Exact durable user snooze. While this instant is in the future, an otherwise-resting thread is
       // suppressed from Queue and shown dimmed in Held. Hard interactive gates (question, permission,
       // native approval, crash) deliberately break through it. Expired values are cleared server-side.
@@ -14431,6 +14688,23 @@ var init_src = __esm({
       // this instant's order. Lifecycle metadata like the snooze: written only by the pin/unpin verb, and
       // it outranks every derived state (a pinned thread that finishes stays pinned).
       pinnedAt: external_exports.string().optional(),
+      // The instant the human pinned this thread on the CONSOLE's "By status" view (absent = not pinned
+      // there). A second shelf, independent of `pinnedAt`: pinning on the Console does not pin on the
+      // project's board, nor the other way round. The instant is the Console's pinned band's order across
+      // every project, and like the project pin it outranks every derived state.
+      consolePinnedAt: external_exports.string().optional(),
+      /** CHILD THREADS (Settings.childThreads): the thread that spawned this one with `frizzctl spawn-child`.
+       *  Present only while that thread still exists. A child is never a row of its own on the board — not in
+       *  any band, the queue, a count or a badge — and is drawn under its parent instead, unless it stands at a
+       *  gate only the human can settle (drawnUnderParent). */
+      parentSlug: external_exports.string().optional(),
+      /** This child's rest is one that would have put it in the human's queue, so its handoff goes to its
+       *  PARENT instead (board.ts deriveChildHandoff; the scheduler delivers it once per rest). A permission
+       *  prompt, a secret request and a usage-limit stop are not handoffs: they still queue for the human. */
+      handoffToParent: external_exports.literal(true).optional(),
+      /** The instant of the rest `handoffToParent` describes (the tailer's lastAssistantAt), so the scheduler
+       *  can tell a verdict about the rest it sees from one a cached board still carries about an older rest. */
+      handoffRestAt: external_exports.string().optional(),
       /** The EVENT snooze on the resting card is armed for this exact rest — the human has said "hide this
        *  until something reports". Distinct from `snoozedUntil`, which is a wall-clock park on the whole
        *  thread: this one has no deadline and clears itself when the thread comes to a NEW rest.
@@ -14439,8 +14713,20 @@ var init_src = __esm({
        *  the reasoning that the card states a FACT the drawer must keep showing or it blanks at rest and
        *  reads as "the agent died". That reasoning holds for a thread nobody has parked; once the human has
        *  explicitly parked THIS rest, showing them the same card with the same button one surface over is
-       *  not information, and they said so. */
+       *  not information, and they said so.
+       *
+       *  The header's "Until activity" (SnoozeMenu, 2026-10-19) arms the same snooze on any rested thread. */
       bgSnoozed: external_exports.boolean().optional(),
+      /** Something of the thread's own can wake it without a person — a running sub-agent or shell, an
+       *  armed watch or timer, a Goal that fires on rest or on a clock (board.wakesOnItsOwn). The snooze
+       *  menu greys out "Until activity" without it, and the server stops honouring that snooze once it
+       *  goes false. Absent on a dead worker and on an archived thread. */
+      wakesOnItsOwn: external_exports.boolean().optional(),
+      /** A QUIET PARK THE BOARD REFUSED because an earlier `needs_input` handoff still stands: the human has
+       *  neither typed to the thread nor snoozed a rest since it (board handoffStands). The surfaces keep that
+       *  handoff's fence drawn (web lib/fenceBlocks heldHandoffIndex), since it is what the thread is in the
+       *  queue for. Set only while it is what queued the thread. */
+      heldHandoff: external_exports.boolean().optional(),
       // Which Claude transport serves this thread. "broker" — a session-broker-owned Agent SDK session with
       // a typed control channel — is the only one there is; ABSENT means a row dispatched before the broker
       // became the sole transport, which frizz can no longer reach that way. Only the broker can be asked to
@@ -14594,6 +14880,11 @@ var init_src = __esm({
       // falls back to rendering the plain `errors` strings.
       errorItems: external_exports.array(BoardErrorItem).optional()
     });
+    BoardState = external_exports.object({
+      board: BoardSnapshot,
+      seq: external_exports.number().int().min(0),
+      bootId: external_exports.string()
+    });
     QuotaWindow = external_exports.object({
       key: external_exports.string(),
       // stable id: "5h" | "weekly" (provider-neutral)
@@ -14609,8 +14900,20 @@ var init_src = __esm({
       planType: external_exports.string().optional(),
       // "pro" / "max" / etc. when the source reports it
       windows: external_exports.array(QuotaWindow),
-      detail: external_exports.string().optional()
+      detail: external_exports.string().optional(),
       // why unavailable, or an extra note
+      // Recovery evidence from a LIVE Codex read only. Rollout quota has no account identity or freshness
+      // guarantee and must never wake a failed thread. accountKey is a hash, not a credential/account id.
+      codexRecovery: external_exports.object({
+        observedAt: external_exports.number(),
+        // request start, unix milliseconds (not the later cache/read time)
+        accountKey: external_exports.string().optional(),
+        creditsAvailable: external_exports.boolean().optional(),
+        ordinaryUsageAllowed: external_exports.boolean().nullable().optional(),
+        // null is explicitly unavailable
+        blocked: external_exports.boolean().optional()
+        // explicit workspace/spend-control denial beats apparent headroom
+      }).optional()
     });
     QuotaSnapshot = external_exports.object({
       claude: ProviderQuota,
@@ -14672,6 +14975,16 @@ var init_src = __esm({
        * Machine-level: which chrome you want is a property of the person, not the repo.
        */
       projectRail: external_exports.boolean(),
+      /**
+       * CHILD THREADS, an experiment (2026-11-04). On, a worker may run `frizzctl spawn-child`: a new thread
+       * in this project, on either harness, linked to the thread that spawned it. Its rests that would
+       * have queued for the human wake its parent instead, it can own its own PR watchers, and it sits
+       * under its parent on the board rather than in the queue. Off (the default), the command refuses and
+       * the worker contract never mentions it. A child spawned while it was on keeps its link either way.
+       *
+       * Machine-level, like the rail: whether to try an experiment is the person's call, not the repo's.
+       */
+      childThreads: external_exports.boolean(),
       // There is no `font` key any more. The interface rendered in one of two type families as a machine
       // setting until 2026-09-19 (maintainer: "let's drop monospace as an option"); every surface is sans
       // now, and index.html pins `data-font="sans"` on <html> directly. Settings is a non-strict object,
@@ -14711,6 +15024,19 @@ var init_src = __esm({
         command: external_exports.string().trim().min(1).max(1024),
         args: external_exports.array(external_exports.string().max(1024)).max(32).optional()
       })).max(32).optional(),
+      // A command each runtime's workers are started THROUGH, per runtime: `op run --env-file .env --`
+      // makes a new Claude worker start as `op run --env-file .env -- /path/to/claude …`. Kept as the text
+      // the operator typed and split into words by parseLaunchPrefix (launch-prefix.ts), the one parser the
+      // settings field and the spawn share; it is never run in a shell. Claude applies it at every fork of a
+      // thread's worker; Codex to the app-server the project's Codex threads share, which is replaced at
+      // the next moment no Codex turn is running once the prefix changes. ACP agents need no key here:
+      // their `command` above is already the operator's own. A string rather than a refined argv so a
+      // stored value the parser later stops accepting fails ITS launch, not the whole settings parse
+      // (getSettings falls back to every default on a parse miss). Optional so an old blob parses.
+      launchPrefix: external_exports.object({
+        claude: external_exports.string().max(LAUNCH_PREFIX_MAX_LENGTH).optional(),
+        codex: external_exports.string().max(LAUNCH_PREFIX_MAX_LENGTH).optional()
+      }).optional(),
       // The GitHub batch-dispatch prompt template (the picker's per-item worker prompt). Optional: when
       // unset OR blank the server falls back to its exported DEFAULT_GITHUB_PROMPT. Substitution tokens
       // the server fills: {repo} {n} {title} {url} {labels} {body}. The leading `THREAD: <slug>` tag is
@@ -14805,7 +15131,21 @@ var init_src = __esm({
       // Binds the call to the session the tab is looking at, so a stale page cannot deliver a follow-up
       // into a thread that has since been re-dispatched (merged from origin/main, 2026-07-21).
       sessionId: external_exports.string().min(1),
-      message: external_exports.string().min(1),
+      // EMPTY only when `answers` ride: the staged answers alone are a message. The server refuses a send
+      // that carries neither.
+      message: external_exports.string(),
+      // REGISTERED-QUESTION ANSWERS SENT WITH THIS MESSAGE — the prompt box's one Send. The server settles
+      // each question exactly as `answerQuestions` does, then delivers ONE turn: the answers in their wire
+      // form (questionAnswerMessage) and `message` under them as the note (withAnswersNote). They ride the
+      // follow-up rather than the scheduler's answer wake so the pair arrives together, in the order the
+      // human wrote it, and as fast as a steer does.
+      answers: external_exports.array(QuestionAnswerSchema).optional(),
+      // SEND TO THE QUEUE: while the agent is mid-turn, Frizz keeps this message and delivers it when the
+      // thread comes to rest, so it opens the next turn instead of steering this one. The queue goes out ONE
+      // message per turn (2026-10-20), so a message also waits, even at rest, behind one already held or one
+      // whose turn has not ended. With nothing ahead of it, it is an ordinary send. See `held` and
+      // nextHeldRelease in the server's delivery-ledger.ts.
+      hold: external_exports.boolean().optional(),
       // Generated once before the optimistic clear so a transport replay can be idempotent.
       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
@@ -14814,17 +15154,19 @@ var init_src = __esm({
       // newer frizz 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(),
-      // PREEMPT the operation the worker is running right now, so this message is read at once instead of
-      // when that operation finishes. The operator's "Interrupt and send" verb, and opt-in for the same
-      // reason `freshProcess` is: it costs the in-flight tool call's result. (It no longer costs the
-      // worker's sub-agents: since 2026-09-24 the broker's SDK query declares `perTaskStopAffordance`,
-      // so the interrupt aborts only the turn and background agents run on.)
+      // SEND NOW: this message is read at once instead of when the operation the worker is running
+      // finishes. The operator's forced send (⌘⏎), and opt-in because it can cost work in flight. Since
+      // 2026-10-13 it usually does not: the runtime moves a running command or foreground sub-agent to the
+      // background and takes the message into the same turn. Only when it has nothing to move — the model
+      // is mid-answer, a wake Frizz wrote is waiting too — is the turn aborted, as it always was before,
+      // and that costs the in-flight call its result. (An abort has not cost the worker's BACKGROUND
+      // sub-agents since 2026-09-24: the broker's SDK query declares `perTaskStopAffordance`.)
       //
       // It exists because delivery is ALREADY as fast as queueing can be. Measured over 14 days of this
       // project's own transcripts, Claude Code drains its queue at the first sampling boundary that
       // exists; the wait an operator feels is the remaining time of whatever was in flight (a long `Bash`,
       // or one 73–133s reasoning+answer generation), which put mid-turn operator prose at p50 13.8s,
-      // p90 49s, p99 2.5m. Preempting is the only lever left.
+      // p90 49s, p99 2.5m. Getting that operation out of the way is the only lever left.
       //
       // Broker-backed Claude only — that is every Claude thread dispatched since the broker cutover. On
       // any other runtime the message is delivered normally and this is ignored, never refused: a send
@@ -14839,16 +15181,38 @@ var init_src = __esm({
     SteerThreadInput = external_exports.object({
       from: ThreadSlug,
       to: ThreadSlug,
+      project: external_exports.string().min(1).max(200).optional(),
       message: external_exports.string().min(1).max(1e5)
     }).strict();
     SteerThreadResult = external_exports.object({
       slug: ThreadSlug,
       title: external_exports.string(),
+      // The target's project URL slug — present only when it is NOT the caller's project, so the receipt's
+      // link can name it (`/project/<project>/thread/<slug>`) and a reply can be addressed back.
+      project: external_exports.string().optional(),
       // What the target was doing when the message arrived: `running` ⇒ it reads it at its next tool
       // boundary; `resting` ⇒ the message started its next turn; `reopened` ⇒ it was marked done and this
       // message put it back on the board.
       delivery: external_exports.enum(["running", "resting", "reopened"])
     }).strict();
+    SpawnThreadInput = DispatchInput.pick({ title: true, prompt: true, model: true, backend: true, effort: true }).extend({
+      from: ThreadSlug,
+      project: external_exports.string().min(1).max(200)
+    }).strict();
+    SpawnThreadResult = external_exports.object({
+      slug: ThreadSlug,
+      sessionId: external_exports.string(),
+      // The new thread's project URL slug — present only when it is NOT the caller's project, as on a steer.
+      project: external_exports.string().optional()
+    }).strict();
+    SpawnChildInput = DispatchInput.pick({ title: true, prompt: true, model: true, backend: true, effort: true }).extend({
+      from: ThreadSlug
+    }).strict();
+    SpawnChildResult = external_exports.union([
+      external_exports.object({ slug: ThreadSlug, sessionId: external_exports.string() }).strict(),
+      // The experiment is off, or the caller is itself a child. Exit 2 at the command, like every refusal.
+      external_exports.object({ refused: external_exports.string() }).strict()
+    ]);
     DismissFailedFollowUpInput = external_exports.object({
       slug: ThreadSlug,
       deliveryId: external_exports.string().min(1).max(200)
@@ -14867,11 +15231,19 @@ var init_src = __esm({
     DeliverQueuedNowInput = external_exports.object({
       slug: ThreadSlug,
       // Same staleness guard as unqueueFollowUp: a stale tab must not preempt a re-dispatched session.
-      sessionId: external_exports.string().min(1)
+      sessionId: external_exports.string().min(1),
+      // Hand over what Frizz is HOLDING for the agent's rest ("Send to queue") and stop there — no
+      // interrupt. The "Send now" under a held bubble: the operator changed their mind about waiting, not
+      // about interrupting, so the message goes in as the steer it would have been.
+      releaseOnly: external_exports.boolean().optional()
     }).strict();
     DeliverQueuedNowResult = external_exports.object({
       interrupted: external_exports.boolean(),
-      reason: external_exports.string().optional()
+      reason: external_exports.string().optional(),
+      // How many messages Frizz was HOLDING for the agent's rest ("Send to queue") and has now handed over.
+      // Those were never in a provider queue, so on a runtime that cannot be interrupted this is the whole
+      // of what "send now" did — and it is a success the surface must not report as a refusal.
+      released: external_exports.number().int().nonnegative().optional()
     }).strict();
     CompactThreadInput = external_exports.object({
       slug: ThreadSlug,
@@ -14893,6 +15265,17 @@ var init_src = __esm({
       sessionId: external_exports.string().min(1),
       pinned: external_exports.boolean()
     }).strict();
+    ReorderPinnedThreadsInput = external_exports.object({
+      slugs: external_exports.array(ThreadSlug).max(500)
+    }).strict();
+    SetThreadConsolePinnedInput = external_exports.object({
+      slug: ThreadSlug,
+      sessionId: external_exports.string().min(1),
+      pinned: external_exports.boolean()
+    }).strict();
+    ReorderConsolePinnedThreadsInput = external_exports.object({
+      pins: external_exports.array(external_exports.object({ slug: ThreadSlug, at: SnoozeUntil }).strict()).max(500)
+    }).strict();
     SetThreadRecurringPromptInput = external_exports.object({
       slug: ThreadSlug,
       sessionId: external_exports.string().min(1),
@@ -14949,7 +15332,7 @@ var init_src = __esm({
       timers: external_exports.array(ThreadTimerView)
     }).strict();
     ThreadActivityItem = external_exports.object({
-      kind: external_exports.enum(["shell", "agent", "timer", "pr", "issue"]),
+      kind: external_exports.enum(["shell", "agent", "timer", "pr", "issue", "command", "thread"]),
       /** The string a `<kind>:` fence line must carry. For a shell that is the runtime task id the worker
        *  was shown; for a PR, `owner/repo#N`; for a timer, its `tmr_…` row id. */
       id: external_exports.string(),
@@ -14978,6 +15361,62 @@ var init_src = __esm({
        *  agent to read out the current set of watchers and questions?"). */
       questions: external_exports.array(RegisteredQuestionView).default([])
     }).strict();
+    ThreadBand = external_exports.enum(["rested", "active", "snoozed", "done"]);
+    ThreadListing = external_exports.object({
+      slug: ThreadSlug,
+      /** The title the sidebar shows (displayTitle). */
+      title: external_exports.string(),
+      band: ThreadBand,
+      runtime: RuntimeState,
+      backend: Backend.optional(),
+      model: external_exports.string().optional(),
+      /** The human pinned it to the top of this board's sidebar. */
+      pinned: external_exports.literal(true).optional(),
+      /** The caption of the tool call in flight, while a turn is running ("Running the focused tests"). */
+      doing: external_exports.string().optional(),
+      /** The first line of its newest message — the verdict line of a handoff. Capped. */
+      lastLine: external_exports.string().optional(),
+      /** The signal fence its last rest ended on, while the board still reads it. */
+      fence: external_exports.enum(["done", "awaiting"]).optional(),
+      /** Questions standing at its current rest (hasStandingQuestion's rule), plus a native ask or a
+       *  permission prompt the human has not answered. */
+      questions: external_exports.number().int(),
+      /** Its own sub-agents still running (direct children only, as the board counts them). */
+      subAgents: external_exports.number().int(),
+      /** Background shells still running. */
+      shells: external_exports.number().int(),
+      /** CHILD THREADS it started (`frizzctl spawn-child`) that are still open. A child is never a row of its
+       *  own here, as on the board (drawnUnderParent), so this is how another thread finds one to steer. */
+      children: external_exports.array(external_exports.object({ slug: ThreadSlug, title: external_exports.string(), runtime: RuntimeState }).strict()).optional(),
+      /** What its armed watches are on: `owner/repo#N` for a PR or issue, the prompt for a timer, the
+       *  command for a command watch. */
+      watches: external_exports.array(external_exports.string()),
+      /** Killed by a usage limit, waiting for the window to reset. */
+      limited: external_exports.literal(true).optional(),
+      /** Its process is gone with the turn unfinished. */
+      crashed: external_exports.literal(true).optional(),
+      spawnedAt: external_exports.string().optional(),
+      /** When its own turn last came to rest (ThreadView.lastAssistantAt). */
+      restedAt: external_exports.string().optional(),
+      lastActivityAt: external_exports.string().optional(),
+      /** A wall-clock snooze still in the future. */
+      snoozedUntil: external_exports.string().optional(),
+      archivedAt: external_exports.string().optional()
+    }).strict();
+    ListThreadsInput = external_exports.object({
+      /** Another project's board — its slug, id or registered name — instead of the one the call lands on. */
+      project: external_exports.string().trim().min(1).optional(),
+      /** Include the Done band (archived threads), which on a long-lived board is nearly every thread. */
+      all: external_exports.boolean().optional()
+    }).strict();
+    ListThreadsResult = external_exports.object({
+      /** The board's project: its URL slug, its registry id, and the name the board shows. */
+      project: external_exports.object({ slug: external_exports.string(), id: external_exports.string(), name: external_exports.string() }).strict(),
+      /** Rested, then active, then snoozed, then done; newest activity first within each. */
+      threads: external_exports.array(ThreadListing),
+      /** Every band's size, the Done band's included when its threads are not listed. */
+      counts: external_exports.object({ rested: external_exports.number().int(), active: external_exports.number().int(), snoozed: external_exports.number().int(), done: external_exports.number().int() }).strict()
+    }).strict();
     SetOwnThreadTimerResult = external_exports.object({
       id: external_exports.string(),
       fireAt: external_exports.string(),
@@ -14998,13 +15437,6 @@ var init_src = __esm({
       intervalSeconds: RecurringIntervalSeconds.optional(),
       enabled: external_exports.boolean().optional()
     }).strict();
-    ThreadPluginReloadResult = external_exports.object({
-      plugins: external_exports.number().int().min(0),
-      commands: external_exports.number().int().min(0),
-      agents: external_exports.number().int().min(0),
-      mcpServers: external_exports.array(external_exports.string()),
-      errorCount: external_exports.number().int().min(0)
-    }).strict();
     RenameThreadInput = external_exports.object({
       slug: ThreadSlug,
       title: external_exports.string().trim().min(1).max(200)
@@ -15050,6 +15482,42 @@ var init_src = __esm({
     }).strict();
     ThreadSkillsInput = external_exports.object({ slug: ThreadSlug }).strict();
     ThreadSkillsResult = external_exports.object({ skills: external_exports.array(ThreadSkill).max(1024) }).strict();
+    McpTarget = external_exports.union([
+      external_exports.object({ slug: ThreadSlug }).strict(),
+      external_exports.object({ backend: Backend, model: external_exports.string().trim().max(200).optional() }).strict()
+    ]);
+    McpServerState = external_exports.enum(["connected", "needs-auth", "failed", "pending", "disabled"]);
+    McpServerReading = external_exports.object({
+      name: external_exports.string().min(1).max(256),
+      state: McpServerState,
+      tools: external_exports.number().int().nonnegative().optional(),
+      error: external_exports.string().max(2e3).optional(),
+      remote: external_exports.boolean().optional()
+    }).strict();
+    McpStatusResult = external_exports.object({
+      backend: Backend,
+      /** The agent's display name, for the empty state ("Gemini CLI doesn't support …"). */
+      agent: external_exports.string().max(200),
+      supported: external_exports.boolean(),
+      servers: external_exports.array(McpServerReading).max(256),
+      /**
+       * Why the servers can't be read right now (Claude Code isn't signed in on this machine), drawn as the
+       * menu's note. An answer, not an error: every prompt box asks on page load, and a machine without the
+       * agent's login is an ordinary machine, not a failing server.
+       */
+      note: external_exports.string().max(500).optional()
+    }).strict();
+    McpSignInInput = external_exports.object({ target: McpTarget, server: external_exports.string().min(1).max(256) }).strict();
+    McpSignInState = external_exports.enum(["waiting", "done", "failed", "expired", "cancelled"]);
+    McpSignInResult = external_exports.object({
+      attemptId: external_exports.string().min(1).max(64),
+      /** Absent when the agent finished without the human (a refresh token was still good). */
+      authUrl: external_exports.string().url().max(8192).optional(),
+      state: McpSignInState
+    }).strict();
+    McpSignInAttemptInput = external_exports.object({ attemptId: external_exports.string().min(1).max(64) }).strict();
+    McpSignInPollResult = external_exports.object({ state: McpSignInState, error: external_exports.string().max(2e3).optional() }).strict();
+    McpSignInFinishInput = external_exports.object({ attemptId: external_exports.string().min(1).max(64), callbackUrl: external_exports.string().trim().min(1).max(8192) }).strict();
     SetThreadProfileInput = external_exports.object({
       slug: ThreadSlug,
       model: external_exports.string().trim().min(1).max(200),
@@ -15110,6 +15578,21 @@ ${DISPATCH_TASK_BANNER}
       nameWithOwner: external_exports.string().nullable(),
       authed: external_exports.boolean()
     });
+    GithubAccount = external_exports.object({
+      signedIn: external_exports.boolean(),
+      /** "app" — Frizz's GitHub App, signed in here; "token" — a stored token; "env" — FRIZZ_GITHUB_TOKEN. */
+      source: external_exports.enum(["app", "token", "env"]).optional(),
+      login: external_exports.string().nullable(),
+      /** Why a stored sign-in stopped working. */
+      problem: external_exports.string().optional(),
+      /** Whether this build knows Frizz's GitHub App, i.e. whether "Sign in" can be offered at all. */
+      appRegistered: external_exports.boolean(),
+      signIn: external_exports.discriminatedUnion("phase", [
+        external_exports.object({ phase: external_exports.literal("idle") }),
+        external_exports.object({ phase: external_exports.literal("pending"), userCode: external_exports.string(), verificationUri: external_exports.string(), expiresAt: external_exports.number() }),
+        external_exports.object({ phase: external_exports.literal("failed"), message: external_exports.string() })
+      ])
+    });
     GithubRefCard = external_exports.object({
       ref: external_exports.string(),
       kind: external_exports.enum(["issue", "pr", "commit"]),
@@ -15209,6 +15692,14 @@ ${DISPATCH_TASK_BANNER}
       // same pre-restart back-compat reason as on BoardSnapshot.
       errorItems: external_exports.array(BoardErrorItem).optional()
     });
+    BoardDeltaEvent = external_exports.object({
+      type: external_exports.literal("board-delta"),
+      seq: external_exports.number(),
+      bootId: external_exports.string(),
+      upserts: external_exports.array(ThreadView),
+      removed: external_exports.array(ThreadSlug),
+      meta: BoardMeta.optional()
+    });
     ServerEvent = external_exports.discriminatedUnion("type", [
       external_exports.object({
         type: external_exports.literal("board"),
@@ -15220,17 +15711,7 @@ ${DISPATCH_TASK_BANNER}
         seq: external_exports.number().optional(),
         bootId: external_exports.string().optional()
       }),
-      external_exports.object({
-        // Keyed per-thread delta. `upserts` are COMPLETE ThreadViews for threads whose serialization
-        // changed (or are new); `removed` are ids gone from the board; `meta` is present only when a
-        // board-level field changed. Emitted only by a post-restart server → seq/bootId are required here.
-        type: external_exports.literal("board-delta"),
-        seq: external_exports.number(),
-        bootId: external_exports.string(),
-        upserts: external_exports.array(ThreadView),
-        removed: external_exports.array(ThreadSlug),
-        meta: BoardMeta.optional()
-      }),
+      BoardDeltaEvent,
       external_exports.object({
         type: external_exports.literal("notify"),
         slug: ThreadSlug,
@@ -15247,8 +15728,24 @@ ${DISPATCH_TASK_BANNER}
         interactionId: InteractionOpaqueId,
         lifecycle: InteractionLifecycle,
         recordRevision: InteractionRevision
+      }).strict(),
+      external_exports.object({
+        // The machine's PROJECT LIST changed: a reorder, a rename, an icon, a project added or forgotten.
+        // Payload-free for the same reason as above — the list is one cheap read, and a client that
+        // re-reads it cannot apply a stale copy out of order. It is the one event that is not about this
+        // stream's own project: the server publishes it on EVERY open project's stream, because the rail
+        // and the grid draw the same list in every tab whichever board that tab is on.
+        type: external_exports.literal("projects-changed")
       }).strict()
     ]);
+    BoardDeltasInput = external_exports.object({
+      bootId: external_exports.string().min(1).max(200),
+      seq: external_exports.number().int().min(0)
+    });
+    BoardDeltasResult = external_exports.union([
+      external_exports.object({ bootId: external_exports.string(), deltas: external_exports.array(BoardDeltaEvent) }),
+      external_exports.object({ bootId: external_exports.string(), resync: external_exports.enum(["boot", "expired", "ahead"]) })
+    ]);
     TranscriptEdit = external_exports.object({
       file: external_exports.string(),
       old: external_exports.string(),
@@ -15490,7 +15987,8 @@ ${DISPATCH_TASK_BANNER}
       // the server's from the instant it arrives. "failed": the transport threw, or never answered — the
       // text is kept until the operator retries, edits or dismisses it, and nothing retries it on its own.
       // Additive + optional: an older client renders both as a plain bubble (gray for "sending").
-      deliveryState: external_exports.enum(["sending", "pending", "enqueued", "delivered", "unconfirmed", "failed"]).optional(),
+      // "held": the operator sent it TO THE QUEUE — Frizz has it and no transport does, until the agent rests.
+      deliveryState: external_exports.enum(["sending", "pending", "enqueued", "delivered", "unconfirmed", "failed", "held"]).optional(),
       // Why a "failed" send failed, verbatim from the transport. Set only alongside deliveryState "failed".
       deliveryError: external_exports.string().optional(),
       // FRIZZ wrote this user turn, not the human: it is a scheduler wake delivery (isWakeDelivery). The
@@ -15615,7 +16113,12 @@ ${DISPATCH_TASK_BANNER}
       external_exports.object({ t: external_exports.literal("sub"), topic: external_exports.literal("file"), path: SocketFilePath }).strict(),
       external_exports.object({ t: external_exports.literal("unsub"), topic: external_exports.literal("file"), path: SocketFilePath }).strict()
     ]);
-    SocketClientMsg = external_exports.union([SocketTranscriptClientMsg, SocketFileClientMsg]);
+    SocketBoardClientMsg = external_exports.object({
+      t: external_exports.literal("board"),
+      bootId: external_exports.string().min(1).max(200),
+      seq: external_exports.number().int().min(0)
+    }).strict();
+    SocketClientMsg = external_exports.union([SocketTranscriptClientMsg, SocketFileClientMsg, SocketBoardClientMsg]);
     ProjectCard = external_exports.object({
       id: external_exports.string(),
       slug: external_exports.string(),
@@ -15625,12 +16128,15 @@ ${DISPATCH_TASK_BANNER}
       /** The directory is gone — moved or deleted. The card stays so it can be reopened or forgotten. */
       stale: external_exports.boolean(),
       /**
-       * When this project's icon was last established, or absent if it never has been.
+       * A hash of the icon's bytes; for a project with no icon, when it was last scanned. Absent if it
+       * never has been.
        *
        * Carried purely so the client can hang it off the `/_frizz/project-icon` URL: the icon bytes are
        * cached hard (a rail of forty squares is forty requests, and none of them should recur), which
        * means a newly uploaded icon would otherwise stay invisible behind the cached old one. A changed
        * version is a changed URL, so the swap is immediate without weakening the caching for everyone.
+       * It is the HASH, not the scan time, because a rescan restamps the time every ten minutes whether
+       * or not the picture changed, and every restamp was a fresh download of every icon.
        *
        * Deliberately NOT "does this project have an icon". Answering that for a project nobody has
        * scanned yet would mean scanning it, and this list is one file read on purpose.
@@ -15642,8 +16148,9 @@ ${DISPATCH_TASK_BANNER}
        * Three states, not a boolean, because the two "no icon to draw right now" cases must behave
        * differently and a boolean collapses them:
        *   · `icon`    — one is stored; draw it.
-       *   · `none`    — scanned, nothing found. Draw the monogram and DO NOT request the icon route,
-       *                 which is what stops an iconless project flashing its initials and then swapping.
+       *   · `none`    — scanned recently, nothing found. Draw the monogram and DO NOT request the icon
+       *                 route, which is what stops an iconless project flashing its initials and then
+       *                 swapping. An OLD miss reads `unknown` again, so an icon added since is found.
        *   · `unknown` — never scanned. The monogram shows, but the request MUST still go out, because
        *                 that request is what triggers the (lazy, cached) scan in the first place.
        *
@@ -20120,7 +20627,7 @@ import {
   realpathSync as realpathSync2,
   renameSync,
   rmSync as rmSync3,
-  statSync as statSync3,
+  statSync as statSync4,
   writeFileSync as writeFileSync5
 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
@@ -20171,7 +20678,7 @@ function syncDirectory(path) {
 }
 function lockOwnerPath(lockPath) {
   try {
-    return statSync3(lockPath).isDirectory() ? join8(lockPath, GLOBAL_LOCK_OWNER) : lockPath;
+    return statSync4(lockPath).isDirectory() ? join8(lockPath, GLOBAL_LOCK_OWNER) : lockPath;
   } catch {
     return lockPath;
   }
@@ -20202,10 +20709,10 @@ function observeLock(lockPath, adapter) {
   }
   try {
     const ownerPath = lockOwnerPath(lockPath);
-    let modified = statSync3(lockPath).mtimeMs;
+    let modified = statSync4(lockPath).mtimeMs;
     if (ownerPath !== lockPath) {
       try {
-        modified = Math.max(modified, statSync3(ownerPath).mtimeMs);
+        modified = Math.max(modified, statSync4(ownerPath).mtimeMs);
       } catch {
       }
     }
@@ -20536,7 +21043,7 @@ import {
   readFileSync as readFileSync6,
   renameSync as renameSync2,
   rmSync as rmSync4,
-  statSync as statSync4,
+  statSync as statSync5,
   writeFileSync as writeFileSync6
 } from "node:fs";
 import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join9 } from "node:path";
@@ -20603,7 +21110,7 @@ function quarantine(path, suffix) {
 }
 function pathAge(path) {
   try {
-    return Date.now() - statSync4(path).mtimeMs;
+    return Date.now() - statSync5(path).mtimeMs;
   } catch {
     return void 0;
   }
@@ -21009,7 +21516,7 @@ var init_boot_progress = __esm({
 
 // packages/server/src/project-root.ts
 import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
-import { closeSync as closeSync3, existsSync as existsSync4, fsyncSync as fsyncSync3, mkdirSync as mkdirSync8, openSync as openSync4, readFileSync as readFileSync8, realpathSync as realpathSync3, renameSync as renameSync4, rmSync as rmSync6, statSync as statSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import { closeSync as closeSync3, existsSync as existsSync4, fsyncSync as fsyncSync3, mkdirSync as mkdirSync8, openSync as openSync4, readFileSync as readFileSync8, realpathSync as realpathSync3, renameSync as renameSync4, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { dirname as dirname8, join as join11, parse, resolve as resolve3 } from "node:path";
 function projectIdPath(root) {
@@ -21103,17 +21610,6 @@ function isHomeDirectory(dir, home = homedir8()) {
     return false;
   }
 }
-function isWorldWritable(dir, platform = process.platform) {
-  if (platform === "win32") return false;
-  try {
-    return (statSync5(dir).mode & 2) !== 0;
-  } catch {
-    return false;
-  }
-}
-function refuseWorldWritableProject(dir) {
-  if (isWorldWritable(dir)) throw new Error(`A folder every account can write to cannot be a project: ${dir}`);
-}
 function existingProjectId(dir) {
   const fromFile = readProjectIdFile(dir);
   if (fromFile) return fromFile;
@@ -21173,7 +21669,7 @@ var init_project_root = __esm({
 });
 
 // packages/server/src/project-registry.ts
-import { closeSync as closeSync4, existsSync as existsSync5, fsyncSync as fsyncSync4, mkdirSync as mkdirSync9, openSync as openSync5, readFileSync as readFileSync9, readdirSync as readdirSync2, realpathSync as realpathSync4, renameSync as renameSync5, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync5, fsyncSync as fsyncSync4, lstatSync, mkdirSync as mkdirSync9, openSync as openSync5, readFileSync as readFileSync9, readdirSync as readdirSync2, realpathSync as realpathSync4, renameSync as renameSync5, rmSync as rmSync7, unlinkSync, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir9 } from "node:os";
 import { basename as basename4, dirname as dirname9, join as join12 } from "node:path";
 function registryPath(home = homedir9()) {
@@ -21190,10 +21686,11 @@ function readRegistry(home = homedir9()) {
     const parsed = JSON.parse(raw);
     if (parsed?.version !== 1 || !Array.isArray(parsed.projects)) return { ...EMPTY, projects: [] };
     const forgotten = Array.isArray(parsed.forgotten) ? parsed.forgotten.filter((id) => typeof id === "string") : [];
+    const host = canonicalPath(launchHostDir(home));
     return {
       version: 1,
       projects: parsed.projects.filter(
-        (p) => p && typeof p.id === "string" && typeof p.path === "string" && typeof p.slug === "string"
+        (p) => p && typeof p.id === "string" && typeof p.path === "string" && typeof p.slug === "string" && p.path !== host
       ),
       ...forgotten.length > 0 ? { forgotten } : {}
     };
@@ -21227,6 +21724,12 @@ function writeRegistry(registry, home = homedir9()) {
     }
     throw error;
   }
+  for (const listener of writeListeners) {
+    try {
+      listener(path);
+    } catch {
+    }
+  }
 }
 function slugifyProject(value) {
   const s = slugify(value);
@@ -21297,20 +21800,11 @@ function registerProject(input, home = homedir9()) {
   writeRegistry(registry, home);
   return { entry, action: "created" };
 }
-function listProjects(home = homedir9()) {
-  const byRecency = (a, b) => a.lastOpenedAt < b.lastOpenedAt ? 1 : a.lastOpenedAt > b.lastOpenedAt ? -1 : 0;
-  return readRegistry(home).projects.map((p) => ({ ...p, stale: !existsSync5(p.path) })).sort((a, b) => {
-    if (a.order === void 0 && b.order === void 0) return byRecency(a, b);
-    if (a.order === void 0) return 1;
-    if (b.order === void 0) return -1;
-    return a.order - b.order;
-  });
-}
 function findByPath(path, home = homedir9()) {
   const canonical = canonicalPath(path);
   return readRegistry(home).projects.find((p) => p.path === canonical || p.path === path);
 }
-var EMPTY, GENERIC, RESERVED;
+var EMPTY, GENERIC, RESERVED, writeListeners, ICON_RESCAN_AFTER_MS;
 var init_project_registry = __esm({
   "packages/server/src/project-registry.ts"() {
     "use strict";
@@ -21342,6 +21836,7 @@ var init_project_registry = __esm({
       "term",
       "attach",
       "local-image",
+      "local-file",
       "local-visualization",
       // `control` answers `/control/stop` and `/control/status` — the supervisor channel the board polls
       // every few seconds. It was missing from this list, so a directory called `control` could have taken
@@ -21356,15 +21851,55 @@ var init_project_registry = __esm({
       "api",
       "health"
     ]);
+    writeListeners = /* @__PURE__ */ new Set();
+    ICON_RESCAN_AFTER_MS = 10 * 60 * 1e3;
+  }
+});
+
+// packages/server/src/launch-routing.ts
+import { realpathSync as realpathSync5 } from "node:fs";
+import { homedir as homedir10 } from "node:os";
+function classifyLaunch(dir, home = homedir10()) {
+  const candidate = realpathSync5(discoverProjectRoot(dir, home));
+  const refused = isHomeDirectory(candidate, home);
+  if (!refused && (isExistingProjectRoot(candidate) || findByPath(candidate, home) !== void 0)) {
+    return { kind: "open", root: candidate };
+  }
+  return !refused && hasProjectMarker(candidate) ? { kind: "offer", directory: candidate } : { kind: "grid" };
+}
+function offerPath(directory) {
+  return `/?add=${encodeURIComponent(directory)}`;
+}
+function parseLaunchRoute(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) return void 0;
+  const { protocol, path, project, notice } = body;
+  if (protocol !== LAUNCH_ROUTE_PROTOCOL || typeof path !== "string") return void 0;
+  if (!path.startsWith("/") || path.startsWith("//") || path.includes("\\") || /[\u0000-\u001f]/u.test(path)) return void 0;
+  const named = project && typeof project === "object" ? project : void 0;
+  return {
+    path,
+    ...named && typeof named.name === "string" && typeof named.dir === "string" ? { project: { name: named.name, dir: named.dir } } : {},
+    ...typeof notice === "string" && notice.length > 0 ? { notice: notice.slice(0, 500) } : {}
+  };
+}
+var LAUNCH_ROUTE_PROTOCOL, LAUNCH_ROUTE_PATH, LAUNCH_TOKEN_HEADER;
+var init_launch_routing = __esm({
+  "packages/server/src/launch-routing.ts"() {
+    "use strict";
+    init_project_registry();
+    init_project_root();
+    LAUNCH_ROUTE_PROTOCOL = 1;
+    LAUNCH_ROUTE_PATH = "/control/launch";
+    LAUNCH_TOKEN_HEADER = "x-frizz-launch-token";
   }
 });
 
 // src/production.ts
 init_local_origin();
-import { readFileSync as readFileSync14 } from "node:fs";
-import { homedir as homedir11 } from "node:os";
+import { readdirSync as readdirSync4, readFileSync as readFileSync14 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { join as join17 } from "node:path";
+import { dirname as dirname14, join as join17 } from "node:path";
 
 // src/browser.ts
 import { spawn, execFile } from "node:child_process";
@@ -23879,7 +24414,7 @@ async function runDeviceFlow(options2) {
   const clientId = options2.clientId === void 0 ? githubClientId() : options2.clientId;
   if (!clientId) {
     throw new GithubSignInError(
-      "custom frizz.sh names are not available in this version of Frizz yet: its GitHub sign-in is not set up. A private frizz.sh name needs no account and works today.",
+      "custom frizz.sh subdomains are not available in this version of Frizz yet: its GitHub sign-in is not set up. A private frizz.sh subdomain needs no account and works today.",
       "not-configured"
     );
   }
@@ -24417,7 +24952,7 @@ var CUSTOM_NAMES_OFFERED = false;
 function customNamesOffered(env = process.env) {
   return CUSTOM_NAMES_OFFERED || env.FRIZZ_CUSTOM_NAMES === "1";
 }
-var CUSTOM_NAMES_PAUSED = "custom frizz.sh names are paused for now \u2014 press enter for a private name (no account needed), or answer with the hostname of a tunnel you run";
+var CUSTOM_NAMES_PAUSED = "custom frizz.sh subdomains are paused for now \u2014 press enter for a private subdomain (no account needed), or answer with the hostname of a tunnel you run";
 function isClaimedConfig(config) {
   return typeof config.claim === "string" && config.claim.length > 0;
 }
@@ -24437,7 +24972,7 @@ async function reconcileCloudConfig(config, port, home = homedir5(), onNotice, o
   if (!label) return config;
   if (!isAnonymousClaimName(label) && !customNamesOffered()) {
     throw new Error(
-      `${config.hostname} needs moving onto the Frizz relay, which means claiming it again, and custom frizz.sh names are paused for now \u2014 press R to pick a private name or another setup`
+      `${config.hostname} needs moving onto the Frizz relay, which means claiming it again, and custom frizz.sh subdomains are paused for now \u2014 press R to pick a private subdomain or another setup`
     );
   }
   onNotice?.(
@@ -24519,7 +25054,7 @@ async function establishCloudConfig(answer, port, home = homedir5(), origin, git
   }
   if (!REGISTRAR_IS_LIVE && !origin && !process.env.FRIZZ_REGISTRAR) {
     throw new Error(
-      "claiming a name on frizz.sh is not available yet.\n       Reach this board through a tunnel of your own instead \u2014 see docs/remote-access.md \u2014 and\n       answer with its hostname rather than a bare name."
+      "claiming a frizz.sh subdomain is not available yet.\n       Reach this board through a tunnel of your own instead \u2014 see docs/remote-access.md \u2014 and\n       answer with its hostname rather than a bare name."
     );
   }
   const anonymous = answer === "" || isAnonymousClaimName(answer);
@@ -24535,7 +25070,7 @@ async function establishCloudConfig(answer, port, home = homedir5(), origin, git
     token = authorization.token;
     if (authorization.login) console.log(`  claiming ${name}.frizz.sh for GitHub user ${authorization.login}`);
   } else {
-    console.log("  claiming a private name on frizz.sh \u2014 no account needed");
+    console.log("  claiming a private frizz.sh subdomain \u2014 no account needed");
   }
   let result;
   try {
@@ -24735,8 +25270,8 @@ async function probeTailscale() {
 // src/remote-pane.ts
 init_src();
 var CHOICES = [
-  { kind: "private", title: "Private name", blurb: "an unguessable name on frizz.sh \u2014 no account, nothing to install" },
-  { kind: "frizz", title: "Custom name", blurb: "<name>.frizz.sh of your choosing; needs a GitHub account" },
+  { kind: "private", title: "frizz.sh subdomain", blurb: "a private, unguessable address; no account, nothing to install" },
+  { kind: "frizz", title: "Custom subdomain", blurb: "<name>.frizz.sh of your choosing; needs a GitHub account" },
   { kind: "cloudflare", title: "Cloudflare Tunnel", blurb: "a domain you own on Cloudflare; cloudflared on this machine" },
   { kind: "tailscale", title: "Tailscale", blurb: "your tailnet; tailscale serve does the TLS" },
   { kind: "other", title: "Something else", blurb: "any proxy or tunnel you run \u2014 tell Frizz its address" },
@@ -24746,7 +25281,7 @@ function choicesFor(current) {
   if (customNamesOffered()) return CHOICES;
   if (kindOf(current) === "frizz") {
     return CHOICES.map(
-      (choice) => choice.kind === "frizz" ? { ...choice, blurb: `${current.hostname} \u2014 kept and renewed; new custom names are paused` } : choice
+      (choice) => choice.kind === "frizz" ? { ...choice, blurb: `${current.hostname} \u2014 kept and renewed; new custom subdomains are paused` } : choice
     );
   }
   return CHOICES.filter((choice) => choice.kind !== "frizz");
@@ -24807,7 +25342,7 @@ function createRemotePane(options2) {
         "",
         ...choices().map((choice, index) => {
           const marker = index === s.index ? "\u276F" : " ";
-          const title = choice.title.padEnd(18);
+          const title = choice.title.padEnd(20);
           const now = choice.kind === current ? `  ${DIM}(current)${RESET2}` : "";
           return `${marker} ${title}${DIM}${choice.blurb}${RESET2}${now}`;
         }),
@@ -24862,10 +25397,10 @@ function createRemotePane(options2) {
   const formHead = (kind) => {
     if (kind === "frizz") {
       return [
-        "Custom frizz.sh name",
+        "Custom frizz.sh subdomain",
         "",
         ...wrap(
-          "Claims <name>.frizz.sh of your choosing, tied to your GitHub account so names cannot be squatted. The board dials out to frizz.sh \u2014 no port, no DNS record, no tunnel binary. One name per account; a name nobody runs for 30 days is released. (A private name needs none of this.)"
+          "Claims <name>.frizz.sh of your choosing, tied to your GitHub account so names cannot be squatted. The board dials out to frizz.sh \u2014 no port, no DNS record, no tunnel binary. One name per account; a name nobody runs for 30 days is released. (A private subdomain needs none of this.)"
         ),
         ...options2.sandbox ? ["", ...wrap("This is a sandbox, but a claim is real: it binds this machine's one name to your account, and your real board keeps it. Only the setup saved here is thrown away.")] : [],
         "",
@@ -24889,7 +25424,7 @@ function createRemotePane(options2) {
         "  cloudflared tunnel route dns my-board board.example.com",
         "",
         ...wrap(
-          `Then name them here. Frizz writes ~/.cloudflared/frizz.yml (ingress to http://127.0.0.1:${options2.port}) and runs the tunnel beside the board, so the two share a lifetime.`
+          `Point it at this board in ~/.cloudflared/frizz.yml (ingress to http://127.0.0.1:${options2.port}; https://frizz.sh/docs/cloudflare-tunnel has the file), then name them here. Frizz runs the tunnel beside the board, so the two share a lifetime.`
         )
       ];
     }
@@ -24999,7 +25534,7 @@ function createRemotePane(options2) {
   };
   const claimPrivate = async () => {
     const back = { name: "menu", index: 0 };
-    screen = { name: "busy", message: "claiming a private name on frizz.sh\u2026" };
+    screen = { name: "busy", message: "claiming a private frizz.sh subdomain\u2026" };
     paint();
     try {
       const next = await options2.claim("", { signal: new AbortController().signal, onDeviceCode: () => {
@@ -25459,20 +25994,20 @@ init_frizz_paths();
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { createServer as createServer2 } from "node:net";
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync10, mkdtempSync, readdirSync as readdirSync3, readFileSync as readFileSync10, realpathSync as realpathSync5, rmSync as rmSync8, symlinkSync as symlinkSync2, writeFileSync as writeFileSync10 } from "node:fs";
-import { homedir as homedir10, tmpdir as tmpdir2 } from "node:os";
+import { existsSync as existsSync6, mkdirSync as mkdirSync10, mkdtempSync, readdirSync as readdirSync3, readFileSync as readFileSync10, realpathSync as realpathSync6, rmSync as rmSync8, symlinkSync as symlinkSync2, writeFileSync as writeFileSync10 } from "node:fs";
+import { homedir as homedir11, tmpdir as tmpdir2 } from "node:os";
 import { basename as basename5, dirname as dirname10, join as join13, resolve as resolve4 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 init_project_root();
+init_launch_routing();
 init_logging();
 init_src();
-init_project_registry();
 var PORT_SCAN_COUNT = 100;
 var LAUNCH_TIMEOUT_MS = BOOT_STALL_TIMEOUT_MS;
 var LAUNCH_HARD_TIMEOUT_MS = BOOT_HARD_TIMEOUT_MS;
 var RETIRED_NETWORK_FLAGS = ["--host", "--allowed-host", "--public-origin", "--cloud"];
 function retiredFlagMessage(flag) {
-  return `${flag} was retired \u2014 how a board is reached is set up from the running board now: press R in its terminal to pick a private frizz.sh name, a Cloudflare Tunnel, Tailscale or a proxy of your own. The choice is remembered, so a plain launch serves it.`;
+  return `${flag} was retired \u2014 how a board is reached is set up from the running board now: press R in its terminal to pick a private frizz.sh subdomain, a Cloudflare Tunnel, Tailscale or a proxy of your own. The choice is remembered, so a plain launch serves it.`;
 }
 function parseCliArgs(argv) {
   const args2 = new Set(argv);
@@ -25583,7 +26118,7 @@ function boardAddress(url) {
   return url.includes("?") || url.endsWith("/") ? url : `${url}/`;
 }
 var SANDBOX_DROPPED_XDG_ROOTS = ["XDG_DATA_HOME", "XDG_STATE_HOME", "XDG_CACHE_HOME"];
-function prepareSandbox(env = process.env, realHome = homedir10()) {
+function prepareSandbox(env = process.env, realHome = homedir11()) {
   const home = mkdtempSync(join13(tmpdir2(), "frizz-sandbox-"));
   const inherited = { ...env };
   env.HOME = home;
@@ -25614,9 +26149,13 @@ function shareCredentials(realHome, home, realEnv, sandboxEnv) {
   mkdirSync10(dirname10(realKey), { recursive: true });
   mkdirSync10(dirname10(sandboxKey), { recursive: true });
   link(realKey, sandboxKey);
-  if (existsSync6(join13(realHome, ".config", "gh"))) {
-    mkdirSync10(join13(home, ".config"), { recursive: true });
-    link(join13(realHome, ".config", "gh"), join13(home, ".config", "gh"));
+  const realGithub = join13(frizzPaths({ home: realHome, env: realEnv }).data, "github");
+  if (existsSync6(realGithub)) {
+    const sandboxGithub = join13(frizzPaths({ home, env: sandboxEnv }).data, "github");
+    mkdirSync10(dirname10(sandboxGithub), { recursive: true });
+    link(realGithub, sandboxGithub);
+    const keychain = join13(realHome, "Library", "Keychains", "login.keychain-db");
+    if (process.platform === "darwin" && existsSync6(keychain)) sandboxEnv.FRIZZ_GITHUB_KEYCHAIN = keychain;
   }
   const cloudflared = join13(realHome, ".cloudflared");
   if (existsSync6(cloudflared)) {
@@ -25639,34 +26178,46 @@ function cleanupSandbox(home) {
   } catch {
   }
 }
-function resolveLaunchIntent(cwd = process.cwd(), home = homedir10(), env = process.env) {
-  const candidate = realpathSync5(discoverProjectRoot(cwd, home));
-  const known = isExistingProjectRoot(candidate) || findByPath(candidate, home) !== void 0;
-  const refused = isHomeDirectory(candidate, home) || isWorldWritable(candidate);
-  if (known && !refused) return { kind: "open", workspace: resolveWorkspace(cwd, home, env) };
-  const host = mostRecentProject(home, env) ?? hostWorkspace(home);
-  return !refused && hasProjectMarker(candidate) ? { kind: "offer", workspace: host, directory: candidate } : { kind: "grid", workspace: host };
+function resolveLaunchIntent(cwd = process.cwd(), home = homedir11(), env = process.env) {
+  const launch = classifyLaunch(cwd, home);
+  if (launch.kind === "open") return { kind: "open", workspace: resolveWorkspace(cwd, home, env) };
+  const host = hostWorkspace(home);
+  return launch.kind === "offer" ? { kind: "offer", workspace: host, directory: launch.directory } : { kind: "grid", workspace: host };
+}
+async function askLaunchRoute(port, ownerToken, dir, options2 = {}) {
+  const fetcher = options2.fetcher ?? fetch;
+  const deadline = Date.now() + (options2.patienceMs ?? 6e3);
+  for (; ; ) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options2.timeoutMs ?? 5e3);
+    timeout.unref?.();
+    try {
+      const response = await fetcher(`http://127.0.0.1:${port}${FRIZZ_ROUTE_PREFIX}${LAUNCH_ROUTE_PATH}`, {
+        method: "POST",
+        headers: { "content-type": "application/json", [LAUNCH_TOKEN_HEADER]: ownerToken },
+        body: JSON.stringify({ protocol: LAUNCH_ROUTE_PROTOCOL, dir, ...options2.args?.length ? { args: options2.args } : {} }),
+        signal: controller.signal
+      });
+      if (response.status === 200) return parseLaunchRoute(await response.json());
+      if (response.status !== 503 || Date.now() >= deadline) return void 0;
+    } catch {
+      return void 0;
+    } finally {
+      clearTimeout(timeout);
+    }
+    await delay2(250);
+  }
 }
-function hostWorkspace(home = homedir10()) {
+function hostWorkspace(home = homedir11()) {
   const dir = launchHostDir(home);
   mkdirSync10(dir, { recursive: true });
-  const root = realpathSync5(dir);
+  const root = realpathSync6(dir);
   const id = ensureProjectIdFile(root, home);
   const stateDir = projectStateDir(id, home);
   mkdirSync10(stateDir, { recursive: true });
   return { root, id, stateDir, name: basename5(root), identityScope: "repository" };
 }
-function mostRecentProject(home, env) {
-  for (const entry of listProjects(home)) {
-    if (entry.stale || isHomeDirectory(entry.path, home) || isWorldWritable(entry.path)) continue;
-    try {
-      return resolveWorkspace(entry.path, home, env);
-    } catch {
-    }
-  }
-  return void 0;
-}
-function resolveWorkspace(cwd = process.cwd(), home = homedir10(), env = process.env) {
+function resolveWorkspace(cwd = process.cwd(), home = homedir11(), env = process.env) {
   let gitRoot;
   try {
     gitRoot = execFileSync3("git", ["rev-parse", "--show-toplevel"], {
@@ -25680,8 +26231,7 @@ function resolveWorkspace(cwd = process.cwd(), home = homedir10(), env = process
     if (!isNotAGitWorktree(error)) throw new Error("unable to resolve Git repository root");
     gitRoot = void 0;
   }
-  const root0 = realpathSync5(gitRoot ?? discoverProjectRoot(cwd, home));
-  refuseWorldWritableProject(root0);
+  const root0 = realpathSync6(gitRoot ?? discoverProjectRoot(cwd, home));
   const identity = gitRoot ? resolveGitProjectIdentity(root0, home) : void 0;
   const root = identity?.root ?? root0;
   const id = ensureProjectIdFile(root, home, identity?.id);
@@ -25712,7 +26262,7 @@ function workspaceLaunchTarget(workspace2) {
 function workspaceFromLaunchTarget(target2, env = process.env) {
   let root;
   try {
-    root = realpathSync5(target2.projectDir);
+    root = realpathSync6(target2.projectDir);
   } catch {
     throw new Error("pinned Frizz workspace is no longer available");
   }
@@ -26483,9 +27033,25 @@ var Supervisor = class {
       if (this.restartCompletion === completion) this.restartCompletion = null;
     }
   }
+  /**
+   * A restart or an update drains the running child and forks its replacement in the project the
+   * server is hosted on. Once that folder is deleted the fork fails with ENOENT, and a child given
+   * any other cwd refuses to boot without its project — and so does the one that would put the old
+   * child back, so the click meant to refresh the board stops it. The running child is unharmed by
+   * the missing folder, so refuse before draining and leave it serving.
+   *
+   * Measured 2026-10-11 on a board hosted on a folder deleted a day later: its Update failed one
+   * step earlier, on npm dying with `uv_cwd ENOENT`, and that accident was all that kept it up.
+   */
+  missingLaunchFolder() {
+    if (existsSync7(this.cwd)) return void 0;
+    return `Frizz is running on ${this.cwd}, which no longer exists, so a new server cannot start there. Stop Frizz and start it again.`;
+  }
   /** Called only by the public supervisor control endpoint, never by ordinary document reloads. */
   restartFromBrowser() {
     if (this.browserRestart) return this.browserRestart;
+    const missing = this.missingLaunchFolder();
+    if (missing) return Promise.resolve({ state: "failed", message: missing });
     const previousBoot = this.boot?.bootId;
     const work = (async () => {
       this.lastRestartFailure = void 0;
@@ -26511,6 +27077,8 @@ var Supervisor = class {
   }
   async updateFromBrowser() {
     if (!this.updateRestart) return { state: "failed", message: "Update & Restart is unavailable in this launcher mode" };
+    const missing = this.missingLaunchFolder();
+    if (missing) return { state: "failed", message: missing };
     if (this.updateMode === "child") return this.updateChildFromBrowser();
     this.emitActivity("updating", "preparing the update \u2014 the running Frizz is untouched until it is ready");
     const candidate = await this.updateRestart();
@@ -27172,7 +27740,7 @@ function createNpmRegistryReleaseAdapter(options2 = {}) {
           return settle({ code: null, signal: null, stdout: "", stderr: error instanceof Error ? error.message : String(error) });
         }
         const started = Date.now();
-        const child = spawn3(npm.command, [...npm.prefixArgs, "exec", "--yes", `--package=${packageSpec}`, "--", bin, ...args2], {
+        const child = spawn3(npm.command, [...npm.prefixArgs, "exec", "--yes", "--min-release-age=0", `--package=${packageSpec}`, "--", bin, ...args2], {
           cwd,
           env,
           stdio: ["ignore", "pipe", "pipe"],
@@ -27220,12 +27788,13 @@ import {
   mkdirSync as mkdirSync12,
   openSync as openSync6,
   readFileSync as readFileSync12,
-  realpathSync as realpathSync6,
+  realpathSync as realpathSync7,
   renameSync as renameSync6,
   rmSync as rmSync9,
   statSync as statSync6,
   writeFileSync as writeFileSync11
 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
 import { delimiter as delimiter2, dirname as dirname13, isAbsolute as isAbsolute6, join as join15, relative as relative3, resolve as resolve6, sep as sep4 } from "node:path";
 var SERVER_PROTOCOL = 1;
 var SERVER_DATA_EPOCH = 1;
@@ -27262,9 +27831,18 @@ function serverReleaseSpec(manifest, packageOverride) {
   assertSpec(spec);
   return spec;
 }
+function serverReleaseMinimum(manifest) {
+  const metadata = record(record(manifest).frizzServer);
+  const minimum = metadata.minimum;
+  if (minimum === void 0) return void 0;
+  if (typeof minimum !== "string" || !VERSION.test(minimum)) throw new Error("invalid minimum Frizz server version");
+  const order = typeof metadata.version === "string" ? compareReleaseVersions(metadata.version, minimum) : null;
+  if (order === null || order < 0) throw new Error("the pinned Frizz server is older than the minimum this launcher declares");
+  return minimum;
+}
 function containedFile(root, name, directory = false) {
-  const path = realpathSync6(join15(root, name));
-  const rel = relative3(realpathSync6(root), path);
+  const path = realpathSync7(join15(root, name));
+  const rel = relative3(realpathSync7(root), path);
   if (rel === ".." || rel.startsWith(`..${sep4}`) || isAbsolute6(rel))
     throw new Error(`Frizz server artifact escapes its package: ${name}`);
   const stat = statSync6(path);
@@ -27286,7 +27864,7 @@ function validateServerGeneration(root, spec, id, compatibility = CURRENT_COMPAT
   containedFile(root, "web-dist/index.html");
   containedFile(root, "runtime/board/index.mjs");
   containedFile(root, "runtime/cc-worker/.claude-plugin/plugin.json");
-  return { ...spec, id, root: realpathSync6(root), entry };
+  return { ...spec, id, root: realpathSync7(root), entry };
 }
 function serverGenerationLaunch(generation) {
   return {
@@ -27305,7 +27883,7 @@ function resolveNpmCli(env = process.env, executable = process.execPath) {
   for (const directory of [dirname13(executable), ...(env.PATH ?? env.Path ?? "").split(delimiter2).filter(Boolean)]) {
     candidates.push(join15(directory, "node_modules/npm/bin/npm-cli.js"), join15(directory, "../lib/node_modules/npm/bin/npm-cli.js"));
     try {
-      const path = realpathSync6(join15(directory, "npm"));
+      const path = realpathSync7(join15(directory, "npm"));
       if (path.endsWith("npm-cli.js")) candidates.push(path);
     } catch {
     }
@@ -27314,7 +27892,15 @@ function resolveNpmCli(env = process.env, executable = process.execPath) {
   if (!found) throw new Error("npm was not found beside Node or on PATH; install Node with npm to install Frizz server releases");
   return resolve6(found);
 }
-function npmServerPackageInstaller(env = process.env) {
+var NPM_OPERATION_TIMEOUT_MS = 18e4;
+function npmFailureSummary(stderr) {
+  const lines = stderr.trim().split("\n");
+  const tail = lines.slice(-8);
+  const cause = lines.find((line) => /^(?:[A-Z]\w*)?Error(?: \[\w+\])?: /u.test(line));
+  return (cause && !tail.includes(cause) ? [cause, ...tail] : tail).join("\n");
+}
+function npmServerPackageInstaller(env = process.env, options2 = {}) {
+  const timeoutMs = options2.timeoutMs ?? NPM_OPERATION_TIMEOUT_MS;
   const run2 = (args2, cwd) => new Promise((resolveOutput, reject) => {
     let cli;
     try {
@@ -27328,14 +27914,17 @@ function npmServerPackageInstaller(env = process.env) {
       cwd,
       encoding: "utf8",
       windowsHide: true,
-      timeout: 18e4,
+      timeout: timeoutMs,
       killSignal: "SIGKILL",
       maxBuffer: 4 * 1024 * 1024
     }, (error, stdout, stderr) => {
-      if (error) {
-        const tail = stderr.trim().split("\n").slice(-8).join("\n");
-        reject(new Error(`Frizz server npm operation failed: ${tail || error.message}`));
-      } else resolveOutput(stdout);
+      if (!error) {
+        resolveOutput(stdout);
+        return;
+      }
+      const limit = timeoutMs >= 6e4 ? `${Math.ceil(timeoutMs / 6e4)}m` : `${Math.ceil(timeoutMs / 1e3)}s`;
+      const why = error.killed ? `npm ${args2[0]} did not finish within ${limit} and was stopped` : npmFailureSummary(stderr) || error.message;
+      reject(new Error(`Frizz server npm operation failed: ${why}`));
     });
   });
   return {
@@ -27347,6 +27936,7 @@ function npmServerPackageInstaller(env = process.env) {
         prefix,
         "--global=false",
         "--ignore-scripts",
+        "--min-release-age=0",
         "--no-audit",
         "--no-fund",
         "--engine-strict",
@@ -27359,7 +27949,7 @@ function npmServerPackageInstaller(env = process.env) {
     },
     async latestVersion(packageName) {
       if (!PACKAGE.test(packageName)) throw new Error("invalid Frizz server package name");
-      const parsed = JSON.parse(await run2(["view", `${packageName}@latest`, "version", "--json"]));
+      const parsed = JSON.parse(await run2(["view", `${packageName}@latest`, "version", "--json"], tmpdir3()));
       const version = Array.isArray(parsed) && parsed.length === 1 ? parsed[0] : parsed;
       if (typeof version !== "string" || !VERSION.test(version)) throw new Error("npm returned an invalid Frizz server version");
       return version;
@@ -27393,11 +27983,12 @@ function atomicJson2(path, value) {
   }
 }
 var ServerReleaseStore = class {
-  constructor(spec, installer, roots = frizzPaths(), compatibility = CURRENT_COMPATIBILITY) {
+  constructor(spec, installer, roots = frizzPaths(), compatibility = CURRENT_COMPATIBILITY, minimum) {
     this.spec = spec;
     this.installer = installer;
     this.roots = roots;
     this.compatibility = compatibility;
+    this.minimum = minimum;
     assertSpec(spec, compatibility);
     const key = createHash4("sha256").update(spec.package).digest("hex").slice(0, 16);
     this.generations = join15(roots.cache, "server-releases", key);
@@ -27447,6 +28038,22 @@ var ServerReleaseStore = class {
     this.markCompatibilityBeforeLaunch();
     return generation;
   }
+  /**
+   * The selected release, when it is older than this shell works with: `load` will start the pinned
+   * one instead. Undefined for a machine with no selection, an unreadable one (`load` reports that),
+   * and any selection at or above the minimum.
+   */
+  belowMinimum() {
+    if (this.minimum === void 0 || !existsSync9(this.selection)) return void 0;
+    let selected;
+    try {
+      selected = record(readJson(this.selection)).version;
+    } catch {
+      return void 0;
+    }
+    if (typeof selected !== "string" || compareReleaseVersions(selected, this.minimum) !== -1) return void 0;
+    return { selected, minimum: this.minimum, pinned: this.spec.version };
+  }
   async load() {
     this.assertMarkerIsSupported();
     if (!existsSync9(this.selection)) return this.prepareInitial(this.spec.version);
@@ -27460,6 +28067,7 @@ var ServerReleaseStore = class {
     if (spec.dataEpoch < this.compatibility.dataEpoch) return this.prepareInitial(this.spec.version);
     if (spec.dataEpoch > this.compatibility.dataEpoch)
       throw new Error("this Frizz server requires a newer launcher or a data migration; restart with a compatible Frizz release");
+    if (this.belowMinimum()) return this.prepareInitial(this.spec.version);
     const root = this.packageRoot(selected.id);
     const generation = !existsSync9(root) ? await this.prepare(spec.version) : validateServerGeneration(root, spec, selected.id, this.compatibility);
     this.markCompatibilityBeforeLaunch();
@@ -27484,7 +28092,7 @@ var ServerReleaseStore = class {
     }
   }
   commit(generation) {
-    if (generation.package !== this.spec.package || generation.root !== realpathSync6(this.packageRoot(generation.id)))
+    if (generation.package !== this.spec.package || generation.root !== realpathSync7(this.packageRoot(generation.id)))
       throw new Error("cannot select a Frizz server outside this release store");
     validateServerGeneration(generation.root, generation, generation.id, this.compatibility);
     const { package: packageName, version, protocol, dataEpoch, id } = generation;
@@ -27496,7 +28104,7 @@ var ServerReleaseStore = class {
 init_frizz_paths();
 init_project_launch();
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync13, realpathSync as realpathSync7 } from "node:fs";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync13, realpathSync as realpathSync8 } from "node:fs";
 import { join as join16 } from "node:path";
 var STABLE_SERVER_OWNER_NAME = "frizz-server";
 var STABLE_SERVER_OWNER_PROJECT_ID = "c1fd5810-0f8a-4c1d-91a0-6d7445d28e5a";
@@ -27510,7 +28118,7 @@ function stableServerOwnerTarget(roots) {
   mkdirSync13(resolved.data, { recursive: true, mode: 448 });
   return {
     projectId: STABLE_SERVER_OWNER_PROJECT_ID,
-    projectDir: realpathSync7(resolved.data),
+    projectDir: realpathSync8(resolved.data),
     stateDir: join16(resolved.state, STABLE_SERVER_OWNER_NAME)
   };
 }
@@ -27587,6 +28195,9 @@ function releaseHeldLease(lease) {
   return true;
 }
 
+// src/production.ts
+init_launch_routing();
+
 // src/preflight.ts
 import { spawnSync } from "node:child_process";
 var SUPPORTED_NODE_LINES = [
@@ -27681,8 +28292,9 @@ Options:
   --no-app               print the URL without opening a browser
   --port <port>          request a fixed port for a new workspace server
   --sandbox              a disposable Frizz to try things in: throwaway home and project, its
-                         own port, deleted when this terminal closes; credentials (gh,
-                         cloudflared, Claude, Codex, the machine's frizz.sh key) are shared
+                         own port, deleted when this terminal closes; credentials (Frizz's
+                         GitHub sign-in, cloudflared, Claude, Codex, the machine's frizz.sh
+                         key) are shared
   --link                 print a fresh single-use access link for the running board
   --sessions             list the devices signed in to the running board
   --sign-out <id|all>    sign one device out, or every one of them
@@ -27693,10 +28305,10 @@ Options:
 
 
 To reach the board from a phone or another machine, press R in the terminal running it: a short
-walkthrough sets up a private frizz.sh name (no account needed), a Cloudflare
-Tunnel, Tailscale, or a proxy of your own, and
-remembers the choice, so a plain launch serves it from then on. The board stays on loopback and
-shows a single-use sign-in link as a QR; press L for a fresh one, or run --link from another shell.`
+walkthrough sets up a private frizz.sh subdomain (no account needed), a Cloudflare Tunnel,
+Tailscale, or a proxy of your own, and remembers the choice, so a plain launch serves it from then
+on. The board stays on loopback and shows a single-use sign-in link as a QR; press L for a fresh
+one, or run --link from another shell.`
   );
   process.exit(0);
 }
@@ -27713,7 +28325,13 @@ var serverOwner;
 process.on("exit", () => {
   if (serverOwner) releaseStableServerOwner(serverOwner);
 });
-var launchIntent;
+var launchDir = (() => {
+  try {
+    return process.cwd();
+  } catch {
+    return homedir12();
+  }
+})();
 var workspace = (() => {
   try {
     if (!reexec) {
@@ -27725,21 +28343,26 @@ var workspace = (() => {
       if (!pinned) throw new Error("registry successor is missing its pinned project identity");
       return workspaceFromLaunchTarget(pinned);
     }
-    const intent = resolveLaunchIntent();
-    launchIntent = intent;
-    return intent.workspace;
+    return hostWorkspace();
   } catch (error) {
     return fail(error);
   }
 })();
-process.chdir(workspace.root);
+function runningBoardPort() {
+  const machine = readStableServerOwner();
+  if (machine.kind === "running") return machine.port;
+  return liveWorkspaceOwner(workspace.stateDir, workspaceLaunchTarget(workspace))?.port;
+}
+function controlPorts() {
+  const machine = readStableServerOwner();
+  return [.../* @__PURE__ */ new Set([...machine.kind === "running" ? [machine.port] : [], DEFAULT_PORT, fallbackPort(DEFAULT_PORT)])];
+}
 if (options.stop) {
   try {
-    const control = await resolveLaunchControlTarget({ stateDir: workspace.stateDir, target: workspaceLaunchTarget(workspace) });
-    const where = control.host ? workspace.root : `${workspace.root} (the board was launched from ${control.target.projectDir})`;
+    const control = await resolveLaunchControlTarget({ stateDir: workspace.stateDir, target: workspaceLaunchTarget(workspace), ports: controlPorts() });
     const result = await stopProjectLaunch({ stateDir: control.stateDir, target: control.target });
     console.log(
-      result.kind !== "stopped" ? `Frizz is not running for ${where}` : result.stale ? `Frizz was not running for ${where}; cleared the record a dead board left behind` : `stopped Frizz for ${where}; running agents keep going \u2014 they are detached daemons`
+      result.kind !== "stopped" ? "Frizz is not running" : result.stale ? "Frizz was not running; cleared the record a dead board left behind" : "stopped Frizz; running agents keep going \u2014 they are detached daemons"
     );
     process.exit(0);
   } catch (error) {
@@ -27747,14 +28370,13 @@ if (options.stop) {
   }
 }
 if (options.status) {
-  const control = await resolveLaunchControlTarget({ stateDir: workspace.stateDir, target: workspaceLaunchTarget(workspace) });
+  const control = await resolveLaunchControlTarget({ stateDir: workspace.stateDir, target: workspaceLaunchTarget(workspace), ports: controlPorts() });
   const running = await runningFrizzStatus({ stateDir: control.stateDir, target: control.target });
   if (!running) {
-    console.log(`Frizz is not running for ${workspace.root}`);
+    console.log("Frizz is not running");
     process.exit(1);
   }
   console.log(`running: http://127.0.0.1:${running.port}`);
-  console.log(`workspace: ${workspace.root}`);
   if (!control.host) console.log(`launched from: ${control.target.projectDir} (one server serves every project)`);
   console.log(`supervisor pid: ${running.pid}`);
   console.log(`version: ${running.version ?? "unknown"}`);
@@ -27762,23 +28384,23 @@ if (options.status) {
   process.exit(0);
 }
 if (options.sessions || options.signOut !== void 0) {
-  const running = liveWorkspaceOwner(workspace.stateDir, workspaceLaunchTarget(workspace));
-  if (!running?.port) {
-    console.error("frizz: no board is running for this workspace");
+  const port = runningBoardPort();
+  if (!port) {
+    console.error("frizz: Frizz is not running");
     process.exit(1);
   }
-  if (options.signOut !== void 0) await signOutSession(running.port, options.signOut);
-  await listSessions(running.port);
+  if (options.signOut !== void 0) await signOutSession(port, options.signOut);
+  await listSessions(port);
 }
 if (options.link) {
-  const running = liveWorkspaceOwner(workspace.stateDir, workspaceLaunchTarget(workspace));
-  if (!running?.port) {
-    console.error("frizz: no board is running for this workspace");
+  const port = runningBoardPort();
+  if (!port) {
+    console.error("frizz: Frizz is not running");
     process.exit(1);
   }
-  const response = await fetch(`http://127.0.0.1:${running.port}${SUPERVISOR_ACCESS_CODE_PATH}`, {
+  const response = await fetch(`http://127.0.0.1:${port}${SUPERVISOR_ACCESS_CODE_PATH}`, {
     method: "POST",
-    headers: { origin: `http://127.0.0.1:${running.port}` }
+    headers: { origin: `http://127.0.0.1:${port}` }
   }).catch(() => void 0);
   if (!response?.ok) {
     const detail = response ? (await response.json().catch(() => void 0))?.error : void 0;
@@ -27802,7 +28424,7 @@ readout?.plan([
   { key: "browser", label: options.noApp ? "Address" : "Browser" }
 ]);
 readout?.begin("server", "starting");
-logger.info("launcher", `Frizz launcher ${PACKAGE_VERSION} starting for ${workspace.root}`);
+logger.info("launcher", `Frizz launcher ${PACKAGE_VERSION} starting in ${launchDir}`);
 var target = workspaceLaunchTarget(workspace);
 var expected = expectedOwnerHealth(target, readProjectLaunchOwner(workspace.stateDir));
 async function existingPort() {
@@ -27811,39 +28433,54 @@ async function existingPort() {
   for (const port of new Set(ports)) if (await probeFrizz(port, expected)) return port;
   return void 0;
 }
-function ownSlug() {
+var legacyIntentCache;
+function legacyIntent() {
+  return legacyIntentCache ??= resolveLaunchIntent(launchDir);
+}
+function legacyProject() {
+  const intent = legacyIntent();
+  if (intent.kind !== "open") return void 0;
+  const { id, root, name } = intent.workspace;
   try {
-    return registerProject(
-      { dir: workspace.root, id: target.projectId, remoteOwner: resolveProjectLabel(workspace.root)?.split("/")[0] },
-      homedir11()
-    ).entry?.slug;
+    const slug = registerProject({ dir: root, id, remoteOwner: resolveProjectLabel(root)?.split("/")[0] }, homedir12()).entry?.slug;
+    return slug ? { id, root, name, slug } : void 0;
   } catch {
     return void 0;
   }
 }
-var cachedSlugPath;
-function slugPath() {
-  if (cachedSlugPath === void 0) {
-    if (launchIntent?.kind === "grid") cachedSlugPath = "/";
-    else if (launchIntent?.kind === "offer") cachedSlugPath = `/?add=${encodeURIComponent(launchIntent.directory)}`;
-    else {
-      const slug = ownSlug();
-      cachedSlugPath = slug ? `/project/${slug}` : "";
-    }
+function legacyLanding() {
+  try {
+    const intent = legacyIntent();
+    if (intent.kind === "grid") return { path: "/" };
+    if (intent.kind === "offer") return { path: offerPath(intent.directory) };
+    const project = legacyProject();
+    return project ? { path: `/project/${project.slug}`, project: { name: project.name, dir: project.root } } : { path: "/" };
+  } catch (error) {
+    return { path: "/", notice: `Could not open ${launchDir}: ${error instanceof Error ? error.message : String(error)}` };
   }
-  return cachedSlugPath;
 }
-async function joinRunningFrizz() {
-  const slug = ownSlug();
-  if (!slug) return void 0;
+async function resolveLanding(port, ownerToken) {
+  const answered = ownerToken ? await askLaunchRoute(port, ownerToken, launchDir) : void 0;
+  if (answered) return answered;
+  logger.info("launcher", "the running server did not say where this launch lands; using this launcher's own rules");
+  return legacyLanding();
+}
+async function joinPreSplitFrizz() {
   for (const port of /* @__PURE__ */ new Set([DEFAULT_PORT, fallbackPort(DEFAULT_PORT)])) {
-    if (await probeFrizz(port, { projectId: target.projectId, projectDir: target.projectDir, slug }))
-      return { port, slug };
+    if (!await readFrizzHealth(port)) continue;
+    let project;
+    try {
+      project = legacyProject();
+    } catch {
+      return void 0;
+    }
+    if (!project) return void 0;
+    if (await probeFrizz(port, { projectId: project.id, projectDir: project.root, slug: project.slug })) return port;
   }
   return void 0;
 }
-async function openOrPrint(port, reused, path = "") {
-  const url = `http://127.0.0.1:${port}${path}`;
+async function openOrPrint(port, reused, landing) {
+  const url = `http://127.0.0.1:${port}${landing.path}`;
   logger.info("launcher", `${reused ? "reusing" : "started"} Frizz at ${url}`);
   readout?.settle("server", "done", reused ? `already running on port ${port}` : `port ${port}`);
   let browser;
@@ -27870,26 +28507,27 @@ async function openOrPrint(port, reused, path = "") {
   const warnings = [];
   if (sandbox) warnings.push(`Sandbox: everything here is throwaway (${sandbox.home}) and is deleted when this terminal closes.`);
   if (sessionNotice && !reused) warnings.push(sessionNotice);
+  if (landing.notice) warnings.push(landing.notice);
   if (!readout) {
-    console.log(`${reused ? "reusing" : "started"} Frizz${launchIntent && launchIntent.kind !== "open" ? "" : ` for ${workspace.root}`}`);
+    console.log(`${reused ? "reusing" : "started"} Frizz${landing.project ? ` for ${landing.project.dir}` : ""}`);
     console.log(url);
     if (publicOrigin) console.log(activeAccessLink?.url ?? `${publicOrigin}/`);
     for (const warning of warnings) console.log(warning);
     return;
   }
-  const home = homedir11();
+  const home = homedir12();
   readout.ready(
     [
       { label: "Local", value: boardAddress(url), accent: true },
       ...publicOrigin ? [{ label: "Public", value: activeAccessLink?.url ?? `${publicOrigin}/`, accent: true }] : [],
-      // Only an `open` launch is ABOUT its workspace; any other is hosted on a project the operator
-      // did not pick (launcher.ts resolveLaunchIntent), and naming it here reads as "you opened this".
-      ...launchIntent && launchIntent.kind !== "open" ? [] : [{ label: "Project", value: `${workspace.name} \u2014 ${tildePath(workspace.root, home)}` }],
+      // Only a launch that OPENED a project names one: the dashboard and an offer are about no
+      // project, and the folder the server runs on is Frizz's own.
+      ...landing.project ? [{ label: "Project", value: `${landing.project.name} \u2014 ${tildePath(landing.project.dir, home)}` }] : [],
       ...logger.file ? [{ label: "Logs", value: tildePath(logger.file, home) }] : []
     ],
     reused ? (
       // This launch owns nothing and exits immediately, so ctrl-c would not stop what it reopened.
-      "reopened the server already running for this project \xB7 stop it from the terminal that started it"
+      "reopened the Frizz already running on this machine \xB7 stop it from the terminal that started it"
     ) : options.debug ? void 0 : publicOrigin ? "press L for a fresh sign-in link \xB7 R to change how this board is reached \xB7 ctrl-c to stop" : "press R to reach this board from a phone or another machine \xB7 ctrl-c to stop",
     {
       ...reused ? { status: `already running on port ${port}` } : {},
@@ -27914,32 +28552,49 @@ async function runSupervisor(port, token, onPrepared = () => {
     target,
     owner.token
   );
-  const spec = serverReleaseSpec(
-    JSON.parse(readFileSync14(join17(import.meta.dirname, "..", "package.json"), "utf8")),
-    process.env.FRIZZ_SERVER_PACKAGE
-  );
+  const manifest = JSON.parse(readFileSync14(join17(import.meta.dirname, "..", "package.json"), "utf8"));
+  const spec = serverReleaseSpec(manifest, process.env.FRIZZ_SERVER_PACKAGE);
   const installer = npmServerPackageInstaller(env);
-  const store = new ServerReleaseStore(spec, installer);
-  activityReadout?.notice("progress", "Starting", "loading the selected Frizz server release");
+  const store = new ServerReleaseStore(spec, installer, void 0, void 0, serverReleaseMinimum(manifest));
+  const raise = store.belowMinimum();
+  if (raise)
+    logger.info("launcher", `the installed Frizz server ${raise.selected} is older than this launcher works with (${raise.minimum}); starting on ${raise.pinned}`);
+  activityReadout?.notice(
+    "progress",
+    "Starting",
+    raise ? `installing Frizz server ${raise.pinned}: ${raise.selected} is older than this launcher works with` : "loading the selected Frizz server release"
+  );
   let active = await store.load();
   let pending;
   let previous = active;
   onPrepared();
   let updateAvailable = false;
   let updateVersion;
+  let probeFailure;
   const refreshUpdateAvailable = async () => {
     try {
       const checkedVersion = active.version;
       const plan = await planRegistryUpdate(spec.package, checkedVersion, installer);
+      probeFailure = void 0;
       if (active.version !== checkedVersion) return;
       updateAvailable = plan !== null;
       updateVersion = plan?.latestVersion;
-    } catch {
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message !== probeFailure) logger.warn("launcher", `could not check npm for a newer Frizz server: ${message}`);
+      probeFailure = message;
     }
   };
   void refreshUpdateAvailable();
   const updateAvailablePoll = setInterval(() => void refreshUpdateAvailable(), 30 * 60 * 1e3);
   updateAvailablePoll.unref();
+  try {
+    const projects = dirname14(workspace.stateDir);
+    const adopted = adoptSessionState(workspace.stateDir, readdirSync4(projects).map((name) => join17(projects, name)));
+    if (adopted) logger.info("launcher", `carried the remote sign-in state over from ${adopted}`);
+  } catch (error) {
+    logger.warn("launcher", `could not carry the remote sign-in state over: ${error instanceof Error ? error.message : String(error)}`);
+  }
   const sessions = loadSessionState(workspace.stateDir);
   const epochRecord = sessionEpochLogLine(sessions.advance, sessions.signedOut);
   if (epochRecord) logger.warn("launcher", epochRecord);
@@ -28043,7 +28698,7 @@ async function runSupervisor(port, token, onPrepared = () => {
       paneHost?.dispose();
       remote?.stop();
       const suffix = logger.file ? `
-  log: ${tildePath(logger.file, homedir11())}` : "";
+  log: ${tildePath(logger.file, homedir12())}` : "";
       process.stdout.write(
         code === 0 ? `
   Frizz stopped. Running agents keep going \u2014 they are detached daemons.${suffix}
@@ -28080,7 +28735,7 @@ try {
   if (globalClaim.kind === "running") {
     if (options.port && options.port !== globalClaim.port)
       throw new Error(`Frizz is already running on port ${globalClaim.port}; --port cannot change a running server`);
-    await openOrPrint(globalClaim.port, true, slugPath());
+    await openOrPrint(globalClaim.port, true, await resolveLanding(globalClaim.port, globalClaim.owner.token));
     process.exit(0);
   }
   serverOwner = globalClaim.lease;
@@ -28092,16 +28747,16 @@ try {
   }
   const existing = await existingPort();
   if (existing) {
-    await openOrPrint(existing, true, slugPath());
+    await openOrPrint(existing, true, await resolveLanding(existing, readProjectLaunchOwner(workspace.stateDir)?.token));
     process.exit(0);
   }
-  const joined = await joinRunningFrizz();
-  if (joined) {
-    await openOrPrint(joined.port, true, slugPath());
+  const preSplit = await joinPreSplitFrizz();
+  if (preSplit) {
+    await openOrPrint(preSplit, true, legacyLanding());
     process.exit(0);
   }
   const claim = tryAcquireProjectLaunchOwner(target, "launcher");
-  if (claim.kind !== "acquired") throw new Error("Frizz is starting for this project; retry shortly");
+  if (claim.kind !== "acquired") throw new Error("Frizz is starting on this machine; retry shortly");
   let release = await acquireGlobalLaunchLock();
   let portReservation;
   try {
@@ -28127,7 +28782,7 @@ try {
     ]);
     portReservation();
     portReservation = void 0;
-    await openOrPrint(port, false, slugPath());
+    await openOrPrint(port, false, await resolveLanding(port, serverOwner.token));
     await running;
   } finally {
     release?.();