frizz 0.13.13 → 0.13.14

package/README.md

@@ -43,7 +43,7 @@ $ npx frizz
 A browser tab opens on the dashboard at `http://127.0.0.1:9393/`. Add a **project** there — any folder: a repo, a jj checkout, or a folder of scripts. Frizz has no opinion about version control and does not require Git. Each project gets its own board at `/project/<name>`, and from then on running `npx frizz` inside that folder opens its board. Frizz always listens on port 9393 (19393 if something else holds it), and one server serves every project on the machine, so a second run joins the server already running rather than starting another. Runs on macOS, Linux, and Windows.
 
 <p align="center">
-  <img src="assets/board.png" alt="The Frizz board: the project rail down the left, the composer and the queue of threads beside it, and on the right a card where an agent is asking an answerable question with numbered options drawn as keycaps, with its snooze clock and done check in the card's header." width="100%">
+  <img src="assets/board.png" alt="The Frizz board: the project rail down the left, the composer and the queue of threads beside it, and on the right a card where an agent is asking an answerable question with lettered options, with its snooze clock and done check in the card's header." width="100%">
 </p>
 
 <br/>
@@ -84,21 +84,23 @@ The queue is strict about what earns a card, which is what keeps it a real todo
 **Threads are built to run without you.** A worker keeps going until it reaches something only you can settle — a product call, a fork where guessing wrong is expensive to undo, an irreversible action — and then it hands back an answerable *question* rather than a wall of text for you to re-read and interpret.
 
 <p align="center">
-  <img src="assets/question.png" alt="A question card titled Question: 'Should the settings store use SQLite or a JSON file?' with two options numbered 1 and 2 on keycaps, the first tagged RECOMMENDED, and a third row numbered 3 for typing something else, above the prompt box and its Send button." width="100%">
+  <img src="assets/question.png" alt="A question card titled Question: 'Should the settings store use SQLite or a JSON file?' with two options lettered A and B, the first tagged RECOMMENDED, and a third row lettered C for typing something else, above the prompt box and its Send button." width="100%">
 </p>
 
-Options are numbered: press an option's number or click it to pick it, then Enter to send it, along with anything typed in the prompt box below. A worker marks its own recommendation when it has one. There is always a row for writing something else instead.
+Options are lettered: click one to pick it, then Enter to send it, along with anything typed in the prompt box below. A worker marks its own recommendation when it has one. There is always a row for writing something else instead.
 
 When the answer isn't one thing, the same card takes several: check any combination and add a note.
 
 <p align="center">
-  <img src="assets/question-multi.png" alt="A question card titled Select multiple: 'Which of these findings should I fix in this pass?' with three numbered checkbox options, the first two ticked, and a fourth numbered row for adding a note, above the prompt box, whose Send button is lit." width="100%">
+  <img src="assets/question-multi.png" alt="A question card titled Select multiple: 'Which of these findings should I fix in this pass?' with three lettered checkbox options, the first two ticked, and a fourth lettered row for adding a note, above the prompt box, whose Send button is lit." width="100%">
 </p>
 
 ### GitHub
 
 Browse the repo's issues and pull requests from the composer, select any number of them, and each becomes its own thread.
 
+Sign Frizz in once from Settings → GitHub, with a device code. The sign-in is read-only with one exception GitHub builds in: it can read code, issues, pull requests and checks on the accounts where you install [the Frizz GitHub App](https://github.com/apps/frizz-agent-console), plus public repos, and the only thing it can do beyond reading is comment on a commit. It's what watches pull requests and issues for your workers, overnight included, and it's separate from any `gh` sign-in of your own. It's stored encrypted, with a key unique to your machine: in the keychain on a Mac, and in a separate private file elsewhere. That keeps it from token scanners and copied files, but not from a program running as you that goes after Frizz on purpose.
+
 <p align="center">
   <img src="assets/github.png" alt="The GitHub picker open over the composer, listing real open issues from colinhacks/zod with numbers, authors, and reaction counts; three are checked and a Start investigations button is enabled." width="100%">
 </p>
@@ -121,6 +123,12 @@ Give a thread a standing goal. Frizz sends it as a prompt every time the agent c
   <img src="assets/goal.png" alt="The goal panel open above a queue card's prompt box: a goal saying to keep going until the test suite is green, sent at every rest and every 30 minutes." width="100%">
 </p>
 
+### Launch prefix
+
+Start every worker through a command of your own: a secret injector, a token proxy, a sandbox. Set it per project under the gear beside **Claude Code** or **Codex** in the model picker. With `op run --env-file .env --` there, a new Claude worker starts as `op run --env-file .env -- claude …`, so the variables 1Password injects are in the worker's environment and nowhere on disk.
+
+The command gets the worker's environment, and must run the command after it with stdin and stdout passed through and stay running until it exits (`exec` does both). Frizz splits the prefix into words like a shell would but never runs it in one, so for variables or pipes, write the shell in: `sh -c 'export ANTHROPIC_BASE_URL="$(my-proxy url)"; exec "$@"' sh`. Claude picks up a change on the next thread you dispatch. Codex's prefix wraps the app-server a project's Codex threads share, and Frizz restarts it once no Codex turn is running. With a prefix set, Frizz no longer refuses to dispatch when it finds no local sign-in, since the prefix may be what supplies the credentials.
+
 <br/>
 
 <h2 align="center">CLI</h2>
@@ -142,18 +150,18 @@ 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
   --debug                stream the full event feed to the terminal instead of the compact readout
   -h, --help             show this help
 
 
 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.
 ```
 
 <br/>
@@ -170,7 +178,7 @@ shows a single-use sign-in link as a QR; press L for a fresh one, or run --link
 <details>
 <summary><b>Does anything leave my machine?</b></summary>
 
-> Nothing from Frizz. There's no account, no telemetry, and the server binds to `127.0.0.1`; reaching it from another device is something you switch on yourself (press R in its terminal). The agents themselves talk to their providers, and `gh` talks to GitHub, but Frizz is a local process looking at local files.
+> Nothing from Frizz. There's no account, no telemetry, and the server binds to `127.0.0.1`; reaching it from another device is something you switch on yourself (press R in its terminal). The agents themselves talk to their providers, and Frizz reads GitHub directly with the read-only sign-in you give it, but Frizz is a local process looking at local files.
 
 </details>
 
@@ -205,7 +213,7 @@ shows a single-use sign-in link as a QR; press L for a fresh one, or run --link
 <details>
 <summary><b>Can I reach it from another machine?</b></summary>
 
-> Yes. Press **R** in the terminal running Frizz. A short walkthrough sets up one of four ways to reach the board — a name on frizz.sh, a Cloudflare Tunnel you own, Tailscale, or any proxy you run — checks what each needs, prints the commands, and remembers your choice. From then on a plain `npx frizz` serves it; pick **Off** in the same place to go back to loopback only.
+> Yes. Press **R** in the terminal running Frizz. A short walkthrough sets up one of four ways to reach the board — a frizz.sh subdomain, a Cloudflare Tunnel you own, Tailscale, or any proxy you run — checks what each needs, prints the commands, and remembers your choice. From then on a plain `npx frizz` serves it; pick **Off** in the same place to go back to loopback only.
 >
 > To try any of this without touching the board you run, launch a second one with `npx frizz --sandbox` — a throwaway home and project on its own port, deleted on ctrl-c.
 >
@@ -216,7 +224,7 @@ shows a single-use sign-in link as a QR; press L for a fresh one, or run --link
 <details>
 <summary><b>Can I reach it from anywhere, not just my LAN?</b></summary>
 
-> Same answer: press **R** and pick a private frizz.sh name (unguessable, no account), a Cloudflare Tunnel, or Tailscale. (Custom frizz.sh names are paused for now; a board that already holds one keeps it.) Each is reachable from anywhere the transport is — a frizz.sh name and a Cloudflare Tunnel from the open internet, Tailscale from your own devices.
+> Same answer: press **R** and pick a private frizz.sh subdomain (unguessable, no account), a Cloudflare Tunnel, or Tailscale. (Custom frizz.sh subdomains are paused for now; a board that already holds one keeps it.) Each is reachable from anywhere the transport is — a frizz.sh subdomain and a Cloudflare Tunnel from the open internet, Tailscale from your own devices.
 >
 > Frizz has no accounts, so the single-use sign-in link **is** the door: a phone that scans it gets a session; nobody else gets in. Sessions are per device and can be listed and revoked with `npx frizz --sessions` and `npx frizz --sign-out`. Every project added or removed, thread started, message sent and question answered is recorded in `logs/audit.jsonl` under Frizz's data folder, with the session id of the device that did it and whether it came through that public address.
 

package/dist/frizz.js

@@ -13145,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);
@@ -13298,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"() {
@@ -13502,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 `frizzctl 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:",
     "",
-    "- `frizzctl 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**.",
@@ -13527,14 +13549,14 @@ function signoffNudgeText(needsInput) {
     "  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",
-    "  `frizzctl unask <id>`: 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",
     "`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",
@@ -13556,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, COMMAND_WATCH_EVERY_MAX_MS, COMMAND_WATCH_FOR_MAX_MS, COMMAND_WATCH_COMMAND_MAX, COMMAND_WATCH_RUN_TIMEOUT_MS, CommandWatchRun, CommandWatchState, CommandWatchView, AddOwnCommandWatchInput, AddOwnCommandWatchResult, DropOwnCommandWatchInput, DropOwnCommandWatchResult, ListOwnCommandWatchesInput, OwnCommandWatchesResult, 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, 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();
@@ -13897,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", "command", "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"];
@@ -13938,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({
@@ -13976,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. */
@@ -13992,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,
@@ -14013,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;
@@ -14147,12 +14221,6 @@ var init_src = __esm({
     COMMAND_WATCH_FOR_MAX_MS = 7 * 24 * 60 * 60 * 1e3;
     COMMAND_WATCH_COMMAND_MAX = 4e3;
     COMMAND_WATCH_RUN_TIMEOUT_MS = 2 * 6e4;
-    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();
     CommandWatchState = external_exports.enum(["armed", "dropped", "passed", "expired", "cancelled"]);
     CommandWatchView = external_exports.object({
       id: external_exports.string(),
@@ -14164,7 +14232,11 @@ var init_src = __esm({
       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()
+      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,
@@ -14205,6 +14277,38 @@ var init_src = __esm({
     }).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
@@ -14223,15 +14327,17 @@ 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({
@@ -14244,11 +14350,32 @@ var init_src = __esm({
       /** 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({
@@ -14262,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({
@@ -14305,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)
@@ -14475,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
@@ -14514,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.
@@ -14527,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.
@@ -14535,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
@@ -14690,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)
@@ -14705,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,
@@ -14768,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,
@@ -14807,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
@@ -14911,8 +15141,10 @@ var init_src = __esm({
       // 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. At rest it is an
-      // ordinary send — there is nothing to wait for. See `held` in the server's delivery-ledger.ts.
+      // 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(),
@@ -14922,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
@@ -14947,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)
@@ -15009,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),
@@ -15065,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", "command"]),
+      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(),
@@ -15094,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(),
@@ -15159,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),
@@ -15219,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"]),
@@ -15318,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"),
@@ -15329,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,
@@ -15366,6 +15738,14 @@ ${DISPATCH_TASK_BANNER}
         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(),
@@ -15733,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(),
@@ -15743,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.
@@ -21281,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()) {
@@ -21448,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
@@ -24025,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"
     );
   }
@@ -24563,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;
 }
@@ -24583,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?.(
@@ -24665,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);
@@ -24681,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 {
@@ -24881,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" },
@@ -24892,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");
@@ -24953,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}`;
         }),
@@ -25008,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.")] : [],
         "",
@@ -25035,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.`
         )
       ];
     }
@@ -25145,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: () => {
@@ -25618,7 +26007,7 @@ 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);
@@ -25760,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)) {
@@ -27347,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"],
@@ -27543,6 +27936,7 @@ function npmServerPackageInstaller(env = process.env, options2 = {}) {
         prefix,
         "--global=false",
         "--ignore-scripts",
+        "--min-release-age=0",
         "--no-audit",
         "--no-fund",
         "--engine-strict",
@@ -27898,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
@@ -27910,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);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frizz",
-  "version": "0.13.13",
+  "version": "0.13.14",
   "private": false,
   "description": "A local web UI for running many coding agents at once",
   "keywords": [
@@ -66,7 +66,7 @@
   },
   "frizzServer": {
     "package": "frizz-server",
-    "version": "0.15.23",
+    "version": "0.15.45",
     "minimum": "0.15.21",
     "protocol": 1,
     "dataEpoch": 1