frizz 0.3.0 → 0.5.0

package/dist/dev-child.js

@@ -5541,13 +5541,27 @@ function isAllowedAttachmentName(name) {
 function isDirectSubAgent(agent) {
   return (agent.depth ?? 1) === 1;
 }
-function isValidAwaitingTimer(value) {
-  const s = value.trim();
-  return AWAITING_TIMER_RE.test(s) && Number.isFinite(Date.parse(s));
+function retiredAwaitingKindsIn(body) {
+  if (!body || !RETIRED_LINE_RE.test(body)) return [];
+  const found = [];
+  for (const line of body.split("\n")) {
+    const m = /^\s*([a-z-]+):\s*\S/i.exec(line);
+    const kind = m?.[1].toLowerCase();
+    if (!kind) continue;
+    const hit = RETIRED_AWAITING_KINDS.find((k) => k === kind);
+    if (hit && !found.includes(hit)) found.push(hit);
+  }
+  return found;
 }
-function canonicalSnoozeInstant(value) {
-  if (!isValidAwaitingTimer(value)) return null;
-  return new Date(Date.parse(value.trim())).toISOString();
+function isAwaitingItemKind(kind) {
+  return AWAITING_ITEM_KINDS.includes(kind);
+}
+function parseAwaitingDuration(value) {
+  const m = AWAITING_DURATION_RE.exec(value.trim());
+  if (!m) return null;
+  const ms = Number(m[1]) * DURATION_UNIT_MS[m[2]];
+  if (!Number.isFinite(ms) || ms <= 0) return null;
+  return Math.min(ms, AWAITING_FOR_MAX_MS);
 }
 function saysAllDone(text) {
   if (typeof text !== "string") return false;
@@ -5557,10 +5571,11 @@ function saysAllDone(text) {
   }
   return false;
 }
-function restPromptMessage(prompt) {
+function restPromptMessage(prompt, opts = {}) {
+  const note = opts.overQuestion ? `${OVER_QUESTION_NOTE} ${OPT_OUT_NOTE}` : OPT_OUT_NOTE;
   return `${prompt.trim()}
 
-(Goal \u2014 sent each time you come to rest. ${OPT_OUT_NOTE})`;
+(Goal \u2014 sent each time you come to rest. ${note})`;
 }
 function compactionPromptMessage(prompt) {
   return `${prompt.trim()}
@@ -5580,11 +5595,55 @@ function formatIntervalLabel(seconds) {
   const hours = minutes / 60;
   return `${Number.isInteger(hours) ? hours : hours.toFixed(1)} hr`;
 }
-function watchWakeMessage(kind, target, detail) {
-  const what = kind === "shell" ? `your background shell \`${target}\`` : `${target}`;
-  return `\u23F0 ${detail} (${what}).
+function prWatchWakeMessage(input) {
+  const lines = [];
+  if (input.merged || input.closed) {
+    lines.push(`\u23F0 ${input.target} was ${input.merged ? "MERGED" : "CLOSED"}.`, "");
+    lines.push("(This watcher is spent \u2014 there is nothing further to report on a finished PR.)");
+    return lines.join("\n");
+  }
+  if (input.checks) {
+    const c = input.checks;
+    lines.push(
+      c.verdict === "passing" ? `\u2705 CI PASSED on ${input.target} \u2014 ${c.passed} check${c.passed === 1 ? "" : "s"} green.` : `\u274C CI FAILED on ${input.target}${c.failing.length ? `: ${c.failing.join(", ")}` : ""}.`
+    );
+  }
+  if (input.review) {
+    if (lines.length) lines.push("");
+    lines.push(input.review);
+  }
+  lines.push("", "(Registered PR watcher \u2014 STILL ARMED. It reports again on the next CI change, review or comment. Drop it with `mcp__frizz__watch_pr` when it stops mattering.)");
+  return lines.join("\n");
+}
+function shellDoneMessage(shell) {
+  const what = shell.taskId ? `\`${shell.taskId}\` \u2014 ${shell.label}` : shell.label;
+  const verb = shell.status === "failed" ? "FAILED" : shell.status === "killed" ? "was STOPPED" : "finished";
+  return `\u23F0 Your background shell ${verb}: ${what}.
 
-(Registered watcher \u2014 it has fired and is no longer armed. Register another with \`mcp__frizz__watch\` if you need to keep waiting.)`;
+(Frizz sends this because it finished after you came to rest, where your runtime's own completion notification does not reach you. Read its output if you still need it.)`;
+}
+function liveOpsLines(ops) {
+  const lines = [];
+  const section = (heading, kind, items) => {
+    if (!items.length) return;
+    lines.push("", heading);
+    for (const i of items) lines.push(`- \`${kind}: ${i.id ?? "?"}\`  \u2014 ${i.label}`);
+  };
+  section("Background shells still running:", "shell", ops?.shells ?? []);
+  section("Sub-agents still running (they re-invoke you on their own, so parking on one is optional):", "agent", ops?.subAgents ?? []);
+  section("Timers you have armed:", "timer", ops?.timers ?? []);
+  section("Pull requests you registered:", "pr", ops?.prs ?? []);
+  return lines;
+}
+function signoffNudgeMessage(ops) {
+  const lines = liveOpsLines(ops);
+  if (lines.length) {
+    lines.push("", "An ```awaiting fence takes one such line per thing you are ACTUALLY waiting on, plus a");
+    lines.push("required `for:` duration (`30s`/`15m`/`2h`/`3d`) and a one-line `reason:`. Frizz checks every");
+    lines.push("id: name something that is not running and you are bumped rather than parked.");
+  }
+  return lines.length === 0 ? SIGNOFF_NUDGE_MESSAGE : `${SIGNOFF_NUDGE_MESSAGE}
+${lines.join("\n")}`;
 }
 function timerPromptMessage(prompt, fireAt) {
   return `${prompt.trim()}
@@ -5692,7 +5751,7 @@ function parseGithubWakeSteer(text) {
 function frizzRoute(path) {
   return `${FRIZZ_ROUTE_PREFIX}${path.startsWith("/") ? path : `/${path}`}`;
 }
-var ATTACHMENT_IMAGE_EXTENSIONS, ATTACHMENT_DOC_EXTENSIONS, ATTACHMENT_EXTENSIONS, ATTACHMENT_MAX_BASE64_CHARS, ATTACHMENT_MAX_BYTES, ATTACHMENT_EXT_SET, ATTACHMENT_ACCEPT, FrizzStatus, BlockMechanism, RuntimeState, Backend, CodexModel, ThreadProfileOption, ThreadAgent, SubAgentView, BgShellView, CompletionHoldOp, CompletionHold, AskOption, AskQuestion, PendingAsk, NativeInputRequired, AwaitingHint, AWAITING_TIMER_RE, SnoozeUntil, SNOOZE_PROMPT_MAX, SnoozePrompt, RECURRING_PROMPT_MAX, RECURRING_MIN_INTERVAL_SECONDS, RECURRING_MAX_INTERVAL_SECONDS, RecurringPromptText, DEFAULT_GOAL_TRIGGERS, DEFAULT_RECURRING_PROMPT, RecurringIntervalSeconds, ThreadRecurringPrompt, ALLDONE_SENTINEL, OPT_OUT_NOTE, TIMER_PROMPT_MAX, TIMER_MAX_DELAY_SECONDS, TIMER_MAX_ARMED, WATCH_MAX_ARMED, TimerPromptText, SIGNOFF_NUDGE_MARKER, SIGNOFF_NUDGE_MESSAGE, ThreadWatchKind, RegisterableThreadWatchKind, ThreadWatchTarget, ThreadWatchView, ThreadTimerView, ThreadFence, PlanView, LimitWindow, LimitPause, ThreadView, BoardErrorItem, BoardSnapshot, QuotaWindow, ProviderQuota, QuotaSnapshot, ProviderAuth, AccountEmails, AuthSnapshot, AccountLogoutInput, AccountLogoutResult, AccountLoginStartInput, AccountLoginStartResult, AccountLoginStatusInput, AccountLoginStatusResult, PermissionMode, LocalFileOpener, Settings, DispatchProviderPreferences, DispatchPreferences, DispatchProfileSnapshot, SetDispatchPreferenceInput, DispatchInput, ADOPT_THREAD_MESSAGE_MAX_CHARS, AdoptThreadInput, AdoptThreadResult, FollowUpInput, UnqueueFollowUpInput, UnqueueFollowUpResult, DeliverQueuedNowInput, DeliverQueuedNowResult, SetThreadSnoozeInput, SetThreadRecurringPromptInput, SetOwnThreadRecurringPromptInput, SetOwnThreadRecurringPromptResult, GetOwnThreadRecurringPromptInput, OwnThreadRecurringPromptResult, SetOwnThreadTimerInput, CancelOwnThreadTimerInput, ListOwnThreadTimersInput, OwnThreadTimersResult, SetOwnThreadTimerResult, CancelOwnThreadTimerResult, AddOwnThreadWatchInput, PromoteOwnThreadWatchInput, PromoteOwnThreadWatchResult, DropOwnThreadWatchInput, ListOwnThreadWatchesInput, OwnThreadWatchesResult, AddOwnThreadWatchResult, DropOwnThreadWatchResult, SetOwnThreadStopHookInput, SetOwnThreadHeartbeatInput, ThreadPluginReloadResult, ConfirmAwaitingInput, RenameThreadInput, AiRenameThreadInput, AiRenameThreadResult, SetThreadPermissionInput, SetThreadPermissionResult, ThreadProfileOptionsInput, ThreadProfileOptionsResult, SetThreadProfileInput, SetThreadProfileResult, DISPATCH_TASK_BANNER, DISPATCH_TASK_BANNER_MARKER, GITHUB_DISPATCH_UI_BOUNDARY, WAKE_DELIVERY_TOKEN_TAIL, WAKE_DELIVERY_TOKEN_LINE, AGENT_MESSAGE_WRAPPER, GithubWakeItem, GithubWakeSteer, WAKE_SCOPE, WAKE_REVIEW_LEAD, WAKE_BACKLOG_TAIL, WAKE_REF, WAKE_SINGLE, WAKE_MULTI_HEAD, WAKE_ITEM, WAKE_MORE, GithubStatus, GithubItem, GithubListInput, GithubListResult, GithubBatchInput, GithubBatchResult, BoardMeta, ServerEvent, TranscriptEdit, TranscriptTodo, TranscriptToolCall, TranscriptPart, TranscriptMessage, TranscriptPageCursor, TranscriptPage, TranscriptEarlierInput, SocketTranscriptSlug, SocketClientMsg, ProjectCard, PROJECT_ICON_EXTENSIONS, PROJECT_ICON_MAX_BASE64_CHARS, DirectoryPickResult, ThreadLocation, FRIZZ_ROUTE_PREFIX, DEFAULT_PORT, threadIdentityName;
+var ATTACHMENT_IMAGE_EXTENSIONS, ATTACHMENT_DOC_EXTENSIONS, ATTACHMENT_EXTENSIONS, ATTACHMENT_MAX_BASE64_CHARS, ATTACHMENT_MAX_BYTES, ATTACHMENT_EXT_SET, ATTACHMENT_ACCEPT, FrizzStatus, BlockMechanism, RuntimeState, Backend, CodexModel, ThreadProfileOption, ThreadAgent, SubAgentView, BgShellView, CompletionHoldOp, CompletionHold, AskOption, AskQuestion, PendingAsk, NativeInputRequired, AwaitingHint, RETIRED_AWAITING_KINDS, RETIRED_LINE_RE, RETIRED_AWAITING_REPLACEMENT, AWAITING_ITEM_KINDS, AWAITING_DURATION_RE, DURATION_UNIT_MS, AWAITING_FOR_MAX_MS, SnoozeUntil, SNOOZE_PROMPT_MAX, SnoozePrompt, RECURRING_PROMPT_MAX, RECURRING_MIN_INTERVAL_SECONDS, RECURRING_MAX_INTERVAL_SECONDS, RecurringPromptText, RecurringIntervalSeconds, ThreadRecurringPrompt, ALLDONE_SENTINEL, OPT_OUT_NOTE, OVER_QUESTION_NOTE, TIMER_PROMPT_MAX, TIMER_MAX_DELAY_SECONDS, TIMER_MAX_ARMED, TimerPromptText, SIGNOFF_NUDGE_MARKER, SIGNOFF_NUDGE_MESSAGE, ThreadWatchKind, GithubChecksState, GithubMergeState, GithubWatchStatus, ThreadWatchView, PR_WATCH_DEFAULT_FOR_MS, PR_WATCH_MAX_ARMED, PrWatchView, AddOwnPrWatchInput, AddOwnPrWatchResult, DropOwnPrWatchInput, DropOwnPrWatchResult, ListOwnPrWatchesInput, OwnPrWatchesResult, ThreadTimerView, ThreadFence, PlanView, LimitWindow, LimitPause, ThreadView, BoardErrorItem, BoardSnapshot, QuotaWindow, ProviderQuota, QuotaSnapshot, ProviderAuth, AccountEmails, AuthSnapshot, AccountLogoutInput, AccountLogoutResult, AccountLoginStartInput, AccountLoginStartResult, AccountLoginStatusInput, AccountLoginStatusResult, PermissionMode, LocalFileOpener, Settings, DispatchProviderPreferences, DispatchPreferences, DispatchProfileSnapshot, SetDispatchPreferenceInput, DispatchInput, ADOPT_THREAD_MESSAGE_MAX_CHARS, AdoptThreadInput, AdoptThreadResult, FollowUpInput, UnqueueFollowUpInput, UnqueueFollowUpResult, DeliverQueuedNowInput, DeliverQueuedNowResult, SetThreadSnoozeInput, SetThreadRecurringPromptInput, SetOwnThreadRecurringPromptInput, SetOwnThreadRecurringPromptResult, GetOwnThreadRecurringPromptInput, OwnThreadRecurringPromptResult, SetOwnThreadTimerInput, CancelOwnThreadTimerInput, ListOwnThreadTimersInput, OwnThreadTimersResult, ThreadActivityItem, ListOwnThreadActivityInput, OwnThreadActivityResult, SetOwnThreadTimerResult, CancelOwnThreadTimerResult, SetOwnThreadStopHookInput, SetOwnThreadHeartbeatInput, ThreadPluginReloadResult, ConfirmAwaitingInput, RenameThreadInput, AiRenameThreadInput, AiRenameThreadResult, SetThreadPermissionInput, SetThreadPermissionResult, ThreadProfileOptionsInput, ThreadProfileOptionsResult, SetThreadProfileInput, SetThreadProfileResult, DISPATCH_TASK_BANNER, DISPATCH_TASK_BANNER_MARKER, GITHUB_DISPATCH_UI_BOUNDARY, WAKE_DELIVERY_TOKEN_TAIL, WAKE_DELIVERY_TOKEN_LINE, AGENT_MESSAGE_WRAPPER, GithubWakeItem, GithubWakeSteer, WAKE_SCOPE, WAKE_REVIEW_LEAD, WAKE_BACKLOG_TAIL, WAKE_REF, WAKE_SINGLE, WAKE_MULTI_HEAD, WAKE_ITEM, WAKE_MORE, PR_WATCH_FINISHED, PR_WATCH_CI_PASSED, PR_WATCH_CI_FAILED, GithubStatus, GithubRefCard, GithubRefPreviewInput, GithubRefPreviewResult, GithubItem, GithubListInput, GithubListResult, GithubBatchInput, GithubBatchResult, BoardMeta, ServerEvent, TranscriptEdit, TranscriptTodo, TranscriptToolCall, TranscriptPart, TranscriptMessage, TranscriptPageCursor, TranscriptPage, TranscriptEarlierInput, SocketTranscriptSlug, SocketClientMsg, ProjectCard, PROJECT_ICON_EXTENSIONS, PROJECT_ICON_MAX_BASE64_CHARS, DirectoryPickResult, ThreadLocation, FRIZZ_ROUTE_PREFIX, DEFAULT_PORT, threadIdentityName;
 var init_src = __esm({
   "packages/shared/src/index.ts"() {
     "use strict";
@@ -5904,7 +5963,15 @@ var init_src = __esm({
       command: external_exports.string().optional(),
       // ISO8601 of the shell output file's last write — "last active 6 min ago" for a quiet-but-live
       // watcher. Optional (see SubAgentView.lastActivityAt).
-      lastActivityAt: external_exports.string().optional()
+      lastActivityAt: external_exports.string().optional(),
+      // The PROVIDER's session-wide background-task handle (`bzvtnt3ig`), as distinct from `id`, which is
+      // the launch tool_use id. Both name the same shell and neither is a substitute for the other:
+      // `id` is what the two copies of a row reconcile on, and this is the handle the runtime hands the
+      // MODEL — "Command running in background with ID: bzvtnt3ig" is the only id a worker ever sees, so
+      // it is the one it registers a `shell` watcher against. Matching on `id`/`label` alone meant every
+      // such watcher was unfireable (scheduler.evalWatchers, 2026-08-14). Absent for a CODEX row, whose
+      // single `processId` IS its `id`, and for a Claude row between its tool_use and its launch ack.
+      taskId: external_exports.string().optional()
     });
     CompletionHoldOp = external_exports.object({
       label: external_exports.string(),
@@ -5941,10 +6008,22 @@ var init_src = __esm({
       title: external_exports.string().max(120)
     });
     AwaitingHint = external_exports.object({
-      kind: external_exports.enum(["pr-watch", "human", "timer", "pr", "ci", "session"]),
+      kind: external_exports.enum(["shell", "agent", "timer", "pr", "for", "reason"]),
       value: external_exports.string()
     });
-    AWAITING_TIMER_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:\d{2})$/;
+    RETIRED_AWAITING_KINDS = ["watch", "pr-watch", "human", "ci", "session"];
+    RETIRED_LINE_RE = new RegExp(`^\\s*(${RETIRED_AWAITING_KINDS.join("|")}):\\s*\\S`, "im");
+    RETIRED_AWAITING_REPLACEMENT = {
+      "watch": "`shell: <the id your runtime gave you>` (or `agent: <id>`) \u2014 the same id, on the current line kind",
+      "pr-watch": "register the PR with `mcp__frizz__watch_pr`, then name it `pr: owner/repo#123`",
+      "human": "there is no human gate any more \u2014 if you need a person, ask a ```question instead of parking",
+      "ci": "CI is not a wait of its own: register the PR with `mcp__frizz__watch_pr` and you are woken when its checks settle",
+      "session": "there is no cross-session wait \u2014 name the sub-agent you dispatched with `agent: <id>`"
+    };
+    AWAITING_ITEM_KINDS = ["shell", "agent", "timer", "pr"];
+    AWAITING_DURATION_RE = /^(\d{1,5})(s|m|h|d)$/;
+    DURATION_UNIT_MS = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
+    AWAITING_FOR_MAX_MS = 24 * 60 * 60 * 1e3;
     SnoozeUntil = external_exports.string().regex(
       /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/,
       "Snooze time must be an ISO-8601 UTC instant"
@@ -5958,13 +6037,6 @@ var init_src = __esm({
     RECURRING_MIN_INTERVAL_SECONDS = 60;
     RECURRING_MAX_INTERVAL_SECONDS = 24 * 60 * 60;
     RecurringPromptText = external_exports.string().trim().min(1).max(RECURRING_PROMPT_MAX);
-    DEFAULT_GOAL_TRIGGERS = {
-      stopHook: true,
-      heartbeat: false,
-      postCompaction: false,
-      pauseOnQuestions: true
-    };
-    DEFAULT_RECURRING_PROMPT = "If further work towards the original task/goal remains, keep going. If there are open questions that require human input, ask them with question fences.";
     RecurringIntervalSeconds = external_exports.number().int().min(RECURRING_MIN_INTERVAL_SECONDS).max(RECURRING_MAX_INTERVAL_SECONDS);
     ThreadRecurringPrompt = external_exports.object({
       prompt: external_exports.string(),
@@ -5974,12 +6046,6 @@ var init_src = __esm({
       stopHook: external_exports.boolean(),
       heartbeat: external_exports.boolean(),
       postCompaction: external_exports.boolean(),
-      /** NOT a fourth trigger — a HOLD over all three. While it is on, nothing is sent for as long as the
-       *  thread is blocked on the human: an unanswered ```question fence, a native ask, or a permission
-       *  prompt. The footer panel seeds it ON for a fresh arming, with the stop hook, because they are one
-       *  intent — see scheduler.ts, "WHAT A PENDING QUESTION DOES TO ALL THREE TRIGGERS". The stored column
-       *  still defaults OFF, so an existing row and an older caller both keep the behaviour they had. */
-      pauseOnQuestions: external_exports.boolean(),
       intervalSeconds: external_exports.number().int().positive().optional(),
       armedAt: external_exports.string(),
       /** Last delivery per trigger; stamped separately so each reads its own clock. */
@@ -5989,40 +6055,164 @@ var init_src = __esm({
     }).strict();
     ALLDONE_SENTINEL = "ALLDONE";
     OPT_OUT_NOTE = "To stop these, sign off with a ```done fence \u2014 but ONLY when the work is genuinely finished: it files this thread away, and nothing but new work from the human reopens it.";
+    OVER_QUESTION_NOTE = "Your ```question is still unanswered, and a Goal armed at rest means the operator is not waiting to answer it: decide it yourself, say in one line which way you went and what would reverse it, and carry on. Do NOT re-ask it.";
     TIMER_PROMPT_MAX = SNOOZE_PROMPT_MAX;
     TIMER_MAX_DELAY_SECONDS = 30 * 24 * 60 * 60;
     TIMER_MAX_ARMED = 64;
-    WATCH_MAX_ARMED = 32;
     TimerPromptText = external_exports.string().trim().min(1).max(TIMER_PROMPT_MAX);
     SIGNOFF_NUDGE_MARKER = "**This message is from frizz, not from the human.**";
     SIGNOFF_NUDGE_MESSAGE = [
-      `${SIGNOFF_NUDGE_MARKER} Nothing about your task has changed, and this is not a request to do more work.`,
+      `${SIGNOFF_NUDGE_MARKER} Nothing about your task has changed, and no new work is being asked of you.`,
+      "",
+      "You rested without a fence, so this thread cannot be triaged.",
+      "",
+      "**IF THE TASK STILL HAS PARTS LEFT, THE FENCE IS NOT WHAT YOU OWE \u2014 THE WORK IS.** If ANY part of the",
+      "original task is unfinished, unverified, or deferred, resume it NOW, in THIS turn, and sign off once it",
+      "is genuinely finished. A milestone, a green test run and a long turn are none of them endings, and",
+      "neither is naming the next step or writing it into a scratch file.",
       "",
-      "You rested without a fence, so this thread cannot be triaged. Add one at the END of your next message:",
+      "**AND THAT TASK IS ALSO THE CEILING \u2014 finish it, and nothing else.** Work you notice on the way is a",
+      "FINDING TO REPORT in your sign-off, never work to take on: the bug beside the one you were sent for,",
+      "the refactor the code obviously wants, the second issue the first one touches. Widening the job is not",
+      "thoroughness \u2014 it is a different job nobody asked for, and it buries the answer they did ask for under",
+      "changes they now have to review. If it should be done, name it in one line and let the human dispatch",
+      "it.",
+      "",
+      "**IF WHAT YOU WERE ASKED FOR IS A DOCUMENT, THE DOCUMENT IS THE ENDING.** A triage, a review, an",
+      "investigation, a recommendation, a plan \u2014 when that is the deliverable, the finished write-up IS the",
+      "work. Implementing what it proposes is the NEXT job, and not yours unless you were asked. Sign off with",
+      "the write-up.",
+      "",
+      "**DECIDE RATHER THAN ASK.** Stop only for a decision that is genuinely the human's AND that blocks you",
+      "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, add a fence at the END of your next message:",
       "",
       "- `` ```question `` \u2014 you need the human. One question per fence, lettered options, one recommended.",
       "- `` ```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**.",
-      "- Blocked on a PR, CI, or your own background shell? Register it with `mcp__frizz__watch` and rest.",
+      "- `` ```awaiting `` \u2014 you are WAITING on work that is actually running. It is PURE STRUCTURE: one line",
+      "  per thing you are waiting on, a REQUIRED `for:` duration, and one line of `reason:` prose.",
+      "",
+      "  ```awaiting",
+      "  shell: <the id your runtime gave you>",
+      "  pr: owner/repo#123",
+      "  for: 2h",
+      "  reason: what you are waiting for, in one line",
+      "  ```",
+      "",
+      "  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.",
+      "",
+      "**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 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.",
+      "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.",
       "",
       "**DO NOT REPEAT YOURSELF.** If the message you just wrote already stands on its own, reply with the",
       "fence ALONE \u2014 the human reads both together, so restating it costs them the second read for nothing.",
+      "The same holds inside one message: the card is the ledger of what shipped, the prose is only what a",
+      "ledger cannot hold, and a sentence that reads the same in either belongs in exactly one of them.",
       "",
       "Only if it does NOT stand alone, fix that first, briefly. It has to be readable cold: the human has",
       "seen nothing since their own last message \u2014 the Goal, this reminder, a watcher wake all came from",
       "frizz \u2014 so anything you assumed they had followed, they have not."
     ].join("\n");
     ThreadWatchKind = external_exports.enum(["shell", "github"]);
-    RegisterableThreadWatchKind = external_exports.enum(["shell"]);
-    ThreadWatchTarget = external_exports.string().trim().min(1).max(200);
+    GithubChecksState = external_exports.enum(["none", "running", "passing", "failing"]);
+    GithubMergeState = external_exports.enum(["mergeable", "blocked", "conflicting", "unknown"]);
+    GithubWatchStatus = external_exports.object({
+      checks: GithubChecksState,
+      /** The counts behind the verdict, so the card can say "3 running, 12 passed" the way GitHub does
+       *  rather than only "checks are running". */
+      running: external_exports.number().int().nonnegative(),
+      passed: external_exports.number().int().nonnegative(),
+      failed: external_exports.number().int().nonnegative(),
+      /** The failing job NAMES, capped — what a human actually needs to decide whether to look. */
+      failing: external_exports.array(external_exports.string()).max(8).default([]),
+      merge: GithubMergeState,
+      /** OPEN | CLOSED | MERGED, lowercased. A merged or closed PR ends the wait outright. */
+      state: external_exports.enum(["open", "closed", "merged"]),
+      /** When frizz last heard from GitHub. A poll can fail or be rate-limited, and a stale reading stated
+       *  as current is worse than no reading. */
+      polledAt: external_exports.string(),
+      /** The head commit this verdict was reached on. A PR watcher reports a CI verdict when it is NEWS, and
+       *  "red again on a new commit" is news that the bare word `failing` cannot express. Optional because a
+       *  reading taken before 2026-08-17 carries none. */
+      head: external_exports.string().optional(),
+      /** 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()
+    }).strict();
     ThreadWatchView = external_exports.object({
       id: external_exports.string(),
       kind: ThreadWatchKind,
       target: external_exports.string(),
       state: external_exports.enum(["armed", "fired", "dropped"]),
-      createdAt: external_exports.string()
+      createdAt: external_exports.string(),
+      /** `github` rows only, and absent until the first successful poll. */
+      github: GithubWatchStatus.optional()
+    }).strict();
+    PR_WATCH_DEFAULT_FOR_MS = 6 * 60 * 60 * 1e3;
+    PR_WATCH_MAX_ARMED = 32;
+    PrWatchView = external_exports.object({
+      id: external_exports.string(),
+      /** `owner/repo#N`, normalized — the same string the board's row and the status book are keyed by. */
+      target: external_exports.string(),
+      state: external_exports.enum(["armed", "dropped", "settled"]),
+      createdAt: external_exports.string(),
+      /** The PR's checks/mergeability as the poller last saw it. Absent until the first successful poll. */
+      github: GithubWatchStatus.optional()
+    }).strict();
+    AddOwnPrWatchInput = external_exports.object({
+      slug: ThreadSlug,
+      /** `owner/repo#123` or a PR URL. Parsed server-side; an unparseable ref is refused rather than stored,
+       *  because a watcher that can never fire is worse than none — the worker rests believing it is covered. */
+      target: external_exports.string().trim().min(1).max(200),
+      /** How long to watch, as a DURATION (`30m`, `2h`, `3d` — parseAwaitingDuration).
+       *
+       *  A PR nobody ever reviews would otherwise be polled forever, and a thread parked on it would wait
+       *  forever with it — the same unbounded wait the awaiting fence's `for:` closes, one level down. A
+       *  duration rather than an instant for the same reason it is one there: it cannot be written in the
+       *  past (maintainer 2026-08-15, asking for it explicitly).
+       *
+       *  REQUIRED BY THE TOOL, OPTIONAL ON THE WIRE, and the asymmetry is deliberate. A worker's MCP server
+       *  outlives every frizz restart, so a session dispatched before this existed still holds a binary that
+       *  cannot send it — and making the RPC reject that would break `watch_pr` outright for every thread
+       *  already running, with no recourse from inside those threads. Absent ⇒ PR_WATCH_DEFAULT_FOR, which
+       *  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()
+    }).strict();
+    AddOwnPrWatchResult = external_exports.object({
+      id: external_exports.string(),
+      target: external_exports.string(),
+      /** True when this exact PR was ALREADY watched by this thread, so the call registered nothing new.
+       *  Re-registering after a compaction is the common case, and a duplicate would double every wake. */
+      alreadyArmed: external_exports.boolean(),
+      watches: external_exports.array(PrWatchView)
+    }).strict();
+    DropOwnPrWatchInput = external_exports.object({
+      slug: ThreadSlug,
+      id: external_exports.string().min(1).max(64)
     }).strict();
+    DropOwnPrWatchResult = external_exports.object({
+      dropped: external_exports.boolean(),
+      watches: external_exports.array(PrWatchView)
+    }).strict();
+    ListOwnPrWatchesInput = external_exports.object({ slug: ThreadSlug }).strict();
+    OwnPrWatchesResult = external_exports.object({ watches: external_exports.array(PrWatchView) }).strict();
     ThreadTimerView = external_exports.object({
       id: external_exports.string(),
       prompt: external_exports.string(),
@@ -6180,6 +6370,16 @@ var init_src = __esm({
       // AUTO-bump (the scheduler resumes the agent with exactly this text) rather than a reminder, which is
       // the distinction the held row's tooltip renders. Absent ⇒ the card merely re-surfaces.
       snoozePrompt: 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.
+       *
+       *  It travels because the chat has to honour it too (2026-08-14). Until then only the QUEUE did, on
+       *  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. */
+      bgSnoozed: external_exports.boolean().optional(),
       // Which Claude transport serves this thread: "broker" = a session-broker-owned Agent SDK session
       // (typed control channel), "tmux" = the interactive TUI in a pane. Only the broker can be asked to
       // reload its plugin closure in place, so the board needs it to decide whether to offer that verb at
@@ -6297,6 +6497,13 @@ var init_src = __esm({
       // Optional so a pre-restart server keeps working; absent means "fall back to `/`", i.e. the old
       // behaviour. Registry-derived, so it is the same slug every other surface links to.
       projectSlug: external_exports.string().optional(),
+      // The server's home directory — the expansion of a `~` a worker wrote in prose. Agents reference
+      // files that way constantly (`~/.claude/CLAUDE.md`), and the browser has no way to derive it, so a
+      // `~`-anchored Markdown link had no absolute path to become and stayed a same-origin anchor that
+      // navigated out of Frizz. The client only ever uses it to build a path it then hands BACK to the
+      // server, which realpath-gates it exactly as it gates one the author typed in full. Optional so a
+      // pre-restart server keeps working; absent means `~` links stay unresolved, i.e. the old behaviour.
+      homeDir: external_exports.string().optional(),
       // (No `.frizz/ exists` bit here on purpose. Threads are session-first — the ui.db registry IS the
       // board — so `.frizz/` presence says nothing about whether this project has one. Its only consumer
       // was a shell gate that dead-ended `.frizz`-less repos; the server still probes the directory
@@ -6403,13 +6610,23 @@ var init_src = __esm({
       // Default action for a vetted non-image local path in agent markdown. Image clicks always use the
       // OS default viewer so screenshots retain their expected behavior.
       localFileOpener: LocalFileOpener.optional(),
-      // GitHub batch-dispatch prompt templates (the picker's per-item worker prompt). Optional: when
-      // unset OR blank the server falls back to its exported DEFAULT_ISSUE_PROMPT / DEFAULT_PR_PROMPT.
-      // Substitution tokens the server fills: {repo} {n} {title} {url} {labels} {body}. The leading
-      // `THREAD: <slug>` tag is prepended by the server (not part of the editable template) so a custom
-      // prompt can never break the thread↔.frizz-file binding. Optional so old settings blobs parse.
-      githubIssuePrompt: external_exports.string().optional(),
-      githubPrPrompt: external_exports.string().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
+      // prepended by the server (not part of the editable template) so a custom prompt can never break the
+      // thread↔.frizz-file binding. Optional so old settings blobs parse.
+      //
+      // ONE field, not one per kind. Issue and PR each had their own template until 2026-08-15, and the two
+      // said the same thing twice: read the whole thread, be skeptical, cite what you checked, post nothing.
+      // A person tuning "be more dubious" had to make the same edit in two boxes and keep them in step. The
+      // ONE thing that genuinely differs per kind — which `gh` command reads the item — is a line in the
+      // metadata block, so the merged template just carries both, and the worker picks the one that applies.
+      //
+      // There is no migration off the two old keys, and that is deliberate (the maintainer's call): Settings
+      // is a non-strict z.object, so `githubIssuePrompt`/`githubPrPrompt` are STRIPPED the moment an old
+      // blob is parsed. Any existing override is dropped and the reader gets the new shipped default —
+      // exactly the intended backfill. Merging two customized templates into one has no correct answer.
+      githubPrompt: external_exports.string().optional()
     });
     DispatchProviderPreferences = external_exports.object({
       model: external_exports.string().trim().min(1).max(200).optional(),
@@ -6538,9 +6755,6 @@ var init_src = __esm({
       // so a client that predates it — an older tab, an older MCP server — keeps writing the row correctly
       // with the trigger off, which is the honest reading of a caller that has never heard of it.
       postCompaction: external_exports.boolean().default(false),
-      // The QUESTION HOLD (2026-08-11). Defaulted for the same reason as the trigger above: a caller that
-      // has never heard of it means "don't hold", which is also this option's own default.
-      pauseOnQuestions: external_exports.boolean().default(false),
       intervalSeconds: RecurringIntervalSeconds.optional()
     }).strict();
     SetOwnThreadRecurringPromptInput = external_exports.object({
@@ -6552,8 +6766,14 @@ var init_src = __esm({
       // so a client that predates it — an older tab, an older MCP server — keeps writing the row correctly
       // with the trigger off, which is the honest reading of a caller that has never heard of it.
       postCompaction: external_exports.boolean().default(false),
-      // The QUESTION HOLD (2026-08-11), defaulted exactly as the trigger above and for the same reason.
-      pauseOnQuestions: external_exports.boolean().default(false),
+      /** ACCEPTED AND IGNORED. The question hold was deleted 2026-08-16 (see scheduler.ts) and no caller in
+       *  this repo sends it any more — but this object is `.strict()`, and the caller on the other end is a
+       *  DETACHED worker daemon holding the `frizz-mcp.mjs` it was spawned with. Those outlive a server
+       *  restart by design, so for as long as any pre-2026-08-16 worker is alive a `start` would otherwise
+       *  come back as a validation error on a field the model cannot see it is sending. Tolerated here rather
+       *  than in the router so the shape stays one declaration; delete it once no such worker can be running.
+       *  The BROWSER input above needs no such clause — a stale tab is one reload away. */
+      pauseOnQuestions: external_exports.boolean().optional(),
       intervalSeconds: RecurringIntervalSeconds.optional()
     }).strict();
     SetOwnThreadRecurringPromptResult = external_exports.object({
@@ -6580,6 +6800,23 @@ var init_src = __esm({
     OwnThreadTimersResult = external_exports.object({
       timers: external_exports.array(ThreadTimerView)
     }).strict();
+    ThreadActivityItem = external_exports.object({
+      kind: external_exports.enum(["shell", "agent", "timer", "pr"]),
+      /** 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(),
+      label: external_exports.string(),
+      /** ISO8601 of when it started or was armed — absent when frizz has no instant for it. */
+      since: external_exports.string().optional(),
+      /** A timer's fire instant, or a PR's expiry. Absent for shells and sub-agents. */
+      until: external_exports.string().optional()
+    }).strict();
+    ListOwnThreadActivityInput = external_exports.object({
+      slug: ThreadSlug
+    }).strict();
+    OwnThreadActivityResult = external_exports.object({
+      activity: external_exports.array(ThreadActivityItem)
+    }).strict();
     SetOwnThreadTimerResult = external_exports.object({
       id: external_exports.string(),
       fireAt: external_exports.string(),
@@ -6589,49 +6826,6 @@ var init_src = __esm({
       cancelled: external_exports.boolean(),
       timers: external_exports.array(ThreadTimerView)
     }).strict();
-    AddOwnThreadWatchInput = external_exports.object({
-      slug: ThreadSlug,
-      // REGISTERABLE kinds only, which is `shell` and nothing else — deliberately narrower than
-      // `ThreadWatchKind`, whose `github` member is a board-derived VIEW row with no registration behind it.
-      // The MCP tool already refuses a PR here in words ("a pr wait does not belong here — use an ```awaiting
-      // fence"); this is the same refusal at the wire, where it cannot be talked past.
-      kind: RegisterableThreadWatchKind,
-      target: ThreadWatchTarget,
-      /** The worker is BLOCKING on this one inside its tool call, so the scheduler settles it silently
-       *  instead of delivering a wake — see the column comment in storage.ts. Defaulted, so a caller that
-       *  has never heard of it registers an ordinary background watch. */
-      foreground: external_exports.boolean().default(false)
-    }).strict();
-    PromoteOwnThreadWatchInput = external_exports.object({
-      slug: ThreadSlug,
-      id: external_exports.string().min(1).max(64)
-    }).strict();
-    PromoteOwnThreadWatchResult = external_exports.object({
-      promoted: external_exports.boolean(),
-      watches: external_exports.array(ThreadWatchView)
-    }).strict();
-    DropOwnThreadWatchInput = external_exports.object({
-      slug: ThreadSlug,
-      id: external_exports.string().min(1).max(64)
-    }).strict();
-    ListOwnThreadWatchesInput = external_exports.object({
-      slug: ThreadSlug
-    }).strict();
-    OwnThreadWatchesResult = external_exports.object({
-      watches: external_exports.array(ThreadWatchView)
-    }).strict();
-    AddOwnThreadWatchResult = external_exports.object({
-      id: external_exports.string(),
-      /** True when this exact (kind, target) was ALREADY armed on the thread, so the call registered
-       *  nothing new. A worker re-registering after a compaction is the common case, and silently minting a
-       *  duplicate would mean two wakes for one event. */
-      alreadyArmed: external_exports.boolean(),
-      watches: external_exports.array(ThreadWatchView)
-    }).strict();
-    DropOwnThreadWatchResult = external_exports.object({
-      dropped: external_exports.boolean(),
-      watches: external_exports.array(ThreadWatchView)
-    }).strict();
     SetOwnThreadStopHookInput = external_exports.object({
       slug: ThreadSlug,
       prompt: RecurringPromptText.nullable(),
@@ -6736,12 +6930,52 @@ ${DISPATCH_TASK_BANNER}
     );
     WAKE_ITEM = /^- (👤|🤖) (.+?) from @(\S+?)(?: at (\S+?))?(?:: (\S+))?$/;
     WAKE_MORE = /^- …and (\d+) more not listed — check .+ for the rest$/;
+    PR_WATCH_FINISHED = new RegExp(String.raw`^⏰ (${WAKE_REF}) was (MERGED|CLOSED)\.$`);
+    PR_WATCH_CI_PASSED = new RegExp(String.raw`^✅ CI PASSED on (${WAKE_REF}) — (\d+) checks? green\.$`);
+    PR_WATCH_CI_FAILED = new RegExp(String.raw`^❌ CI FAILED on (${WAKE_REF})(?:: (.+?))?\.$`);
     GithubStatus = external_exports.object({
       installed: external_exports.boolean(),
       inRepo: external_exports.boolean(),
       nameWithOwner: external_exports.string().nullable(),
       authed: external_exports.boolean()
     });
+    GithubRefCard = external_exports.object({
+      ref: external_exports.string(),
+      kind: external_exports.enum(["issue", "pr", "commit"]),
+      repo: external_exports.string(),
+      // owner/repo, for the card's header line
+      url: external_exports.string(),
+      title: external_exports.string(),
+      body: external_exports.string(),
+      // already truncated server-side to the card's excerpt budget
+      state: external_exports.string(),
+      // OPEN | CLOSED | MERGED | DRAFT — empty for a commit, which has no state
+      stateReason: external_exports.string().optional(),
+      // COMPLETED | NOT_PLANNED | REOPENED — GitHub's closed-issue nuance
+      at: external_exports.string().optional(),
+      // ISO: opened-at for an issue/PR, committed-at for a commit
+      authorLogin: external_exports.string().optional(),
+      authorName: external_exports.string().optional(),
+      // commits carry a git author name with no GitHub account behind it
+      authorAvatar: external_exports.string().optional(),
+      labels: external_exports.array(external_exports.object({ name: external_exports.string(), color: external_exports.string() })).default([]),
+      additions: external_exports.number().int().nonnegative().optional(),
+      deletions: external_exports.number().int().nonnegative().optional(),
+      changedFiles: external_exports.number().int().nonnegative().optional(),
+      comments: external_exports.number().int().nonnegative().optional(),
+      // Epoch ms of the fetch this card came from. The CLIENT owns the freshness decision (render the
+      // cached card instantly, then revalidate if it is old), so it has to be able to see the age.
+      fetchedAt: external_exports.number().int().nonnegative()
+    });
+    GithubRefPreviewInput = external_exports.object({
+      refs: external_exports.array(external_exports.string().min(3).max(120)).min(1).max(100),
+      refresh: external_exports.boolean().default(false)
+    });
+    GithubRefPreviewResult = external_exports.object({
+      cards: external_exports.array(GithubRefCard),
+      missing: external_exports.array(external_exports.string()),
+      error: external_exports.string().optional()
+    });
     GithubItem = external_exports.object({
       kind: external_exports.enum(["issue", "pr"]),
       number: external_exports.number().int().positive(),
@@ -7798,11 +8032,11 @@ ${GITHUB_DISPATCH_UI_BOUNDARY}
 
 ${filled}`;
 }
-function effectiveTemplate(kind, custom2) {
+function effectiveTemplate(custom2) {
   if (custom2 && custom2.trim().length > 0) return custom2;
-  return kind === "issue" ? DEFAULT_ISSUE_PROMPT : DEFAULT_PR_PROMPT;
+  return DEFAULT_GITHUB_PROMPT;
 }
-var pexec, GH_TIMEOUT, GH_MAXBUF, SEARCH_SORT, SEARCH_RESULT_WINDOW, LINKED_PR_CHUNK, GITHUB_PAGE_SIZE, BODY_CAP, DEFAULT_ISSUE_PROMPT, DEFAULT_PR_PROMPT;
+var pexec, GH_TIMEOUT, GH_MAXBUF, SEARCH_SORT, SEARCH_RESULT_WINDOW, LINKED_PR_CHUNK, GITHUB_PAGE_SIZE, BODY_CAP, DEFAULT_GITHUB_PROMPT;
 var init_github = __esm({
   "packages/server/src/github.ts"() {
     "use strict";
@@ -7818,26 +8052,30 @@ var init_github = __esm({
     LINKED_PR_CHUNK = 25;
     GITHUB_PAGE_SIZE = 30;
     BODY_CAP = 8 * 1024;
-    DEFAULT_ISSUE_PROMPT = `Triage this GitHub issue and recommend what to do about it. This is a RESEARCH thread: the deliverable is FINDINGS and a recommendation, NOT a landed fix. Read the full thread first \u2014 body, labels, and the whole discussion \u2014 then classify the report as a BUG or a FEATURE request and say which it is and why. If it is a BUG: establish whether the reported behavior actually happens on the current tree (capture the exact steps, command and output if it reproduces; say what you saw instead if it does not), trace the cause to concrete code, and state the smallest correct fix \u2014 or the top 2 options with the tradeoff of each \u2014 plus the files it touches and the risk. If it is a FEATURE: restate the request precisely (the use-case behind it and any ambiguity a maintainer must resolve), map where it lands in the code and what public API / UX surface it changes, and sketch a concrete plan for the smallest viable version with its risks, open design questions and a rough size estimate. Cite exact file:line for every load-bearing claim \u2014 an uncited claim is a LEAD, so flag it. Do NOT implement anything unasked, and post NOTHING to GitHub (no comments, no labels, no close) unless the human explicitly asks \u2014 read-only. Put your findings and recommendation in your FINAL MESSAGE: this one is headed for a fix, so it is NOT \`\`\`done\`\`\` \u2014 close with a \`\`\`question\`\`\` when there's a fix to choose (recommendation marked, so one reply rolls into implementation), or bare-rest.
+    DEFAULT_GITHUB_PROMPT = `Triage this GitHub issue/PR and make recommendations. Be thoughtful, thorough, and dubious. Think through whether this is truly a good idea or not. Many ideas are bad.
 
----
+Read the full thread first \u2014 body, labels, and the whole discussion \u2014 then classify the report as a BUG or a FEATURE request and say which it is and why.
 
-Issue #{n}: {title}
-Repository: {repo}
-URL: {url}
-Labels: {labels}
-Body + full thread: \`gh issue view {n} -R {repo} --comments\``;
-    DEFAULT_PR_PROMPT = `Review this open pull request. This is an AUDIT thread: adversarially verify the change is correct, safe and complete before recommending merge. Read the PR description and discussion first, then read the full diff \u2014 the changed files in context, not just the hunks (pipe large output through toon). For each substantive change ask: is it correct? does it handle edges? does it break existing behavior or the public API? are there tests, and do they actually cover the change? Check CI too: pending automation is evidence to report, not a reason to park this audit; if later scope explicitly includes shepherding the PR, keep CI/bot/merge progression active with the backend wait primitive from the worker contract. Then recommend approve / request-changes / needs-discussion with a concise findings list \u2014 each concern citing exact file:line in the diff, blocking issues distinguished from nits. Post NOTHING to GitHub (no review, no comment, no approve/merge) unless the human explicitly asks \u2014 read-only. Put your review in your FINAL MESSAGE and close with a \`\`\`done\`\`\` fence listing the completed audit/evidence, or a two-option \`\`\`question\`\`\` if you want a go/no-go on posting the review to GitHub.
+If it is a BUG REPORT: establish whether the reported behavior actually happens on the current tree (capture the exact steps, command and output if it reproduces; say what you saw instead if it does not), trace the cause to concrete code, and state the smallest correct fix \u2014 or the top 2 options with the tradeoff of each \u2014 plus the files it touches and the risk. Be sure you have high confidence that the bug is real. There should be a clean and elegant solution. If there isn't an elegant way to do something, then it often means that it's not a good idea or that we are in need of a larger codebase refactor. The issue: you should stay in the codebase for similar categories of bugs. We are constantly seeking to proactively self-improve the codebase.
+
+If it is a FEATURE REQUEST: restate the request precisely (the use-case behind it and any ambiguity a maintainer must resolve), map where it lands in the code and what public API / UX surface it changes, and sketch a concrete plan for the smallest viable version with its risks, open design questions and a rough size estimate.
+
+If it is a PR: review it. Read the PR description, comments, and changes. You should be dubious. Do not assume that the PR is high quality, many are not. For each substantive change ask: is there a better approach? Is it correct? Does it handle edges? Is it elegant? Does it break existing behavior or the public API? Are there tests, and do they actually cover the change? Trace the impact of the changes thoughtfully. Check CI too. Recommend either closing, making changes (explain them), or merging. Test the changes yourself if necessary/possible.
+
+If it is a DOCS CHANGE: make sure that it is well written, minimal, no walls of text, well structured, consistent tonally with others docs/prose, and not AI slop.
+
+Bias always towards proactivity and taking immediate action. If you encounter issues, feel free to add fixes for those in the same PR. Do not worry about perfect git hygiene.
 
 ---
 
-PR #{n}: {title}
+Issue/PR #{n}: {title}
 Repository: {repo}
 URL: {url}
 Labels: {labels}
-Description + discussion: \`gh pr view {n} -R {repo} --comments\`
-Diff: \`gh pr diff {n} -R {repo}\`
-CI: \`gh pr checks {n} -R {repo}\``;
+Body + thread (issues): \`gh issue view {n} -R {repo} --comments\`
+Body + thread (PRs): \`gh pr view {n} -R {repo} --comments\`
+Diff (PRs): \`gh pr diff {n} -R {repo}\`
+CI (PRs): \`gh pr checks {n} -R {repo}\``;
   }
 });
 
@@ -10440,41 +10678,39 @@ function createStorage(dbPath) {
       ON thread_timer(state, fire_at);
     CREATE INDEX IF NOT EXISTS thread_timer_slug
       ON thread_timer(thread_slug, state, fire_at);
-    -- A worker's registered WATCHERS (2026-08-12). One row per thing a thread is waiting on, so a wait
-    -- has an IDENTITY: it can be listed after a compaction and DROPPED when it stops mattering.
-    --
-    -- This is the table the awaiting FENCE could never be. That fence is derived state \u2014 recomputed
-    -- from the final assistant message on every fold, and cleared by any newer record \u2014 so a park was
-    -- lost the moment the worker said one more sentence, there was no id to cancel, and nothing for a
-    -- Snooze button to be about. Maintainer 2026-08-11: "seems a little weird to register these watchers
-    -- with no identifer and no elegant mechanism for dismissing the watcher. they just live forever in
-    -- markdown\u2026i think that's why we dropped awaiting before."
+    -- A worker's registered PR WATCHERS (2026-08-14). Registered by tool call, never by a fence: the
+    -- fence states what a thread is waiting on, and watching is a separate, orthogonal thing that
+    -- happens whether or not anything is written down (maintainer: "We should have a tool for this. The
+    -- agent should have a tool to register a PR watcher").
     --
-    -- Shaped on thread_timer deliberately, which is the same lesson already learned once: a thread may
-    -- hold MANY, so the record of intent is a table rather than a column on the session row.
-    CREATE TABLE IF NOT EXISTS thread_watch (
+    -- REPEATING, not one-shot. It reports CI turning green or red and every later review or comment, so
+    -- it stays armed and carries a cursor; only a merge or a close settles it.
+    CREATE TABLE IF NOT EXISTS pr_watch (
       id          TEXT PRIMARY KEY,
       thread_slug TEXT NOT NULL,
-      kind        TEXT NOT NULL CHECK (kind IN ('pr', 'ci', 'shell')),
-      target      TEXT NOT NULL,
-      state       TEXT NOT NULL CHECK (state IN ('armed', 'fired', 'dropped')),
+      owner       TEXT NOT NULL,
+      repo        TEXT NOT NULL,
+      number      INTEGER NOT NULL,
+      state       TEXT NOT NULL CHECK (state IN ('armed', 'dropped', 'settled')),
       created_at  INTEGER NOT NULL,
       settled_at  INTEGER,
-      -- Opaque per-kind progress marker: for a pr watcher, the activity baseline that decides what
-      -- counts as NEW. Written by the scheduler, never read by anything else, so its grammar can change
-      -- without a migration.
       cursor      TEXT,
-      -- FOREGROUND (2026-08-12): the worker is BLOCKING on this one inside its own tool call, so the
-      -- scheduler must SETTLE it without delivering a wake. Waking a thread that is mid-turn waiting for
-      -- the very thing that woke it is noise at best; at worst the message lands while the tool is still
-      -- blocked and the worker reads its own answer twice. The tool polls the row and returns; if its
-      -- timeout expires first it PROMOTES the row (clears this), and the wake comes back.
-      foreground  INTEGER NOT NULL DEFAULT 0
+      -- When this watcher stops polling by itself. REQUIRED at registration (2026-08-15): a PR nobody
+      -- ever touches would otherwise be polled forever, and the thread parked on it would wait forever
+      -- with it. Nullable in the column only so an older row reads; the tool refuses to arm without one.
+      expires_at  INTEGER
     );
-    CREATE INDEX IF NOT EXISTS thread_watch_armed
-      ON thread_watch(state, kind);
-    CREATE INDEX IF NOT EXISTS thread_watch_slug
-      ON thread_watch(thread_slug, state, created_at);
+    CREATE INDEX IF NOT EXISTS pr_watch_armed
+      ON pr_watch(state);
+    CREATE INDEX IF NOT EXISTS pr_watch_slug
+      ON pr_watch(thread_slug, state, created_at);
+    -- thread_watch WAS HERE and is retired (2026-08-14). A worker's wait is a 'watch:' line in its own
+    -- awaiting fence again, which is BOTH the park and the wake -- the scheduler matches the name against
+    -- the thread's live shells and its retired-shell ring, so nothing needs registering and nothing can
+    -- outlive the fence that declares it. The registry existed because a fence had no identity to drop;
+    -- the answer turned out to be that a park nobody has to drop needs none. An old DB keeps the orphan
+    -- table, which costs nothing and is safer than a migration to remove it.
+    -- (No backticks in this comment: the whole schema is a template literal.)
   `);
   for (const col of [
     "archived INTEGER NOT NULL DEFAULT 0",
@@ -10549,16 +10785,21 @@ function createStorage(dbPath) {
     // which is the correct default: an existing prompt described the triggers its operator chose.
     "recurring_on_compact INTEGER NOT NULL DEFAULT 0",
     "recurring_compact_fired_at TEXT",
-    // The question hold (2026-08-11). Its own ALTER for the same reason as the trigger above: an existing
-    // armed row picks it up OFF on the next boot, which is the honest reading of a row whose operator has
-    // never been shown the option.
-    "recurring_pause_on_questions INTEGER NOT NULL DEFAULT 0",
+    // NO `recurring_pause_on_questions` HERE ANY MORE. It held every trigger while the thread was waiting
+    // on the human and the footer showed it inverted as "Autonomous mode"; both were deleted 2026-08-16
+    // (see scheduler.ts, "WHAT A PENDING QUESTION DOES TO THE THREE TRIGGERS"). A database created before
+    // that release still carries the column — it is `NOT NULL DEFAULT 0`, so nothing needs to write it,
+    // and dropping it would cost a table rebuild to reclaim one inert integer per row.
     // THE BUILT-IN SIGN-OFF NUDGE (scheduler SOURCE 9, 2026-08-12). How many times in a row frizz has
     // told this thread how to sign off without a fence appearing. Cleared ONLY when the thread signs
     // off — never by a user record, because frizz's own delivery is one. The second column holds the
     // last-nudged delivery id, for diagnosis.
     "signoff_nudges INTEGER NOT NULL DEFAULT 0",
     "signoff_nudge_anchor TEXT",
+    // Cleared by `resetParkBumps` when a park is actually HONOURED — the one event that proves the
+    // correction landed, and the one frizz cannot cause by correcting.
+    "park_bumps INTEGER NOT NULL DEFAULT 0",
+    "park_bump_anchor TEXT",
     // Title provenance for the CURRENT text (2026-08-07): 1 = the worker's own title signal wrote it,
     // 0 = the dispatch seeded it. DEFAULT 0 is the conservative direction — an existing row is assumed
     // to hold its dispatch chop until the repair below (or the next title signal) says otherwise.
@@ -10569,6 +10810,10 @@ function createStorage(dbPath) {
     } catch {
     }
   }
+  try {
+    db.exec("ALTER TABLE pr_watch ADD COLUMN expires_at INTEGER");
+  } catch {
+  }
   try {
     db.exec("UPDATE session SET tmux_name = 'frizz-' || substr(tmux_name, 6) WHERE tmux_name LIKE 'fray-%'");
   } catch {
@@ -10925,10 +11170,6 @@ function createStorage(dbPath) {
       recurring_on_rest = ?,
       recurring_on_schedule = ?,
       recurring_on_compact = ?,
-      -- The hold is deliberately absent from every CASE below it: it changes neither the WORDS nor the
-      -- cadence, so a delivery already queued still describes this row exactly. Flipping it must not
-      -- mint a generation or drop a "last sent" stamp.
-      recurring_pause_on_questions = ?,
       recurring_armed_at = CASE
         WHEN ? IS NULL THEN NULL
         WHEN recurring_armed_at IS NOT NULL AND recurring_prompt IS ? AND recurring_interval_ms IS ? THEN recurring_armed_at
@@ -10945,7 +11186,7 @@ function createStorage(dbPath) {
         WHEN ? IS NULL THEN NULL
         WHEN recurring_armed_at IS NOT NULL AND recurring_prompt IS ? THEN recurring_compact_fired_at
         ELSE NULL END`;
-  const recurringArgs = ({ prompt, stopHook, heartbeat, postCompaction, pauseOnQuestions, intervalMs, armedAt }) => {
+  const recurringArgs = ({ prompt, stopHook, heartbeat, postCompaction, intervalMs, armedAt }) => {
     const ms = prompt === null ? null : intervalMs;
     const flag = (on) => prompt === null || !on ? 0 : 1;
     return [
@@ -10955,7 +11196,6 @@ function createStorage(dbPath) {
       flag(stopHook),
       flag(heartbeat),
       flag(postCompaction),
-      flag(pauseOnQuestions),
       prompt,
       prompt,
       ms,
@@ -11015,35 +11255,41 @@ function createStorage(dbPath) {
     UPDATE session SET signoff_nudges = 0, signoff_nudge_anchor = NULL
     WHERE slug = ? AND signoff_nudges > 0
   `);
-  const armWatchStmt = db.prepare(`
-    INSERT INTO thread_watch (id, thread_slug, kind, target, state, created_at, settled_at, cursor, foreground)
-    VALUES (@id, @slug, @kind, @target, 'armed', @createdAtMs, NULL, NULL, @foreground)
+  const countParkBumpStmt = db.prepare(`
+    UPDATE session SET park_bumps = park_bumps + 1, park_bump_anchor = ?
+    WHERE slug = ?
+  `);
+  const resetParkBumpsStmt = db.prepare(`
+    UPDATE session SET park_bumps = 0, park_bump_anchor = NULL
+    WHERE slug = ? AND park_bumps > 0
   `);
-  const watchesBySlugStmt = db.prepare(
-    "SELECT * FROM thread_watch WHERE thread_slug = ? ORDER BY created_at, id"
+  const armPrWatchStmt = db.prepare(`
+    INSERT INTO pr_watch (id, thread_slug, owner, repo, number, state, created_at, settled_at, cursor, expires_at)
+    VALUES (@id, @slug, @owner, @repo, @number, 'armed', @createdAtMs, NULL, NULL, @expiresAtMs)
+  `);
+  const expiredPrWatchesStmt = db.prepare(
+    "SELECT * FROM pr_watch WHERE state = 'armed' AND expires_at IS NOT NULL AND expires_at <= ? ORDER BY expires_at, id"
   );
-  const armedWatchesBySlugStmt = db.prepare(
-    "SELECT * FROM thread_watch WHERE thread_slug = ? AND state = 'armed' ORDER BY created_at, id"
+  const prWatchesBySlugStmt = db.prepare(
+    "SELECT * FROM pr_watch WHERE thread_slug = ? ORDER BY created_at, id"
   );
-  const watchByIdStmt = db.prepare("SELECT * FROM thread_watch WHERE id = ?");
-  const armedWatchesStmt = db.prepare(
-    "SELECT * FROM thread_watch WHERE state = 'armed' ORDER BY created_at, id"
+  const armedPrWatchesBySlugStmt = db.prepare(
+    "SELECT * FROM pr_watch WHERE thread_slug = ? AND state = 'armed' ORDER BY created_at, id"
   );
-  const promoteWatchStmt = db.prepare(`
-    UPDATE thread_watch SET foreground = 0 WHERE id = ? AND thread_slug = ? AND state = 'armed'
-  `);
-  const dropWatchStmt = db.prepare(`
-    UPDATE thread_watch SET state = 'dropped', settled_at = ?
+  const prWatchByIdStmt = db.prepare("SELECT * FROM pr_watch WHERE id = ?");
+  const armedPrWatchesStmt = db.prepare(
+    "SELECT * FROM pr_watch WHERE state = 'armed' ORDER BY created_at, id"
+  );
+  const dropPrWatchStmt = db.prepare(`
+    UPDATE pr_watch SET state = 'dropped', settled_at = ?
     WHERE id = ? AND thread_slug = ? AND state = 'armed'
   `);
-  const fireWatchStmt = db.prepare(`
-    UPDATE thread_watch SET state = 'fired', settled_at = ?
+  const settlePrWatchStmt = db.prepare(`
+    UPDATE pr_watch SET state = 'settled', settled_at = ?
     WHERE id = ? AND state = 'armed'
   `);
-  const watchCursorStmt = db.prepare(`
-    UPDATE thread_watch SET cursor = ? WHERE id = ? AND state = 'armed'
-  `);
-  const delThreadWatches = db.prepare("DELETE FROM thread_watch WHERE thread_slug = ?");
+  const prWatchCursorStmt = db.prepare("UPDATE pr_watch SET cursor = ? WHERE id = ? AND state = 'armed'");
+  const delPrWatches = db.prepare("DELETE FROM pr_watch WHERE thread_slug = ?");
   const confirmAwaitingWaitStmt = db.prepare(`
     UPDATE session
     SET awaiting_fence_id = ?, awaiting_confirmed_at = ?, snoozed_until = ?
@@ -11106,7 +11352,7 @@ function createStorage(dbPath) {
     }
     delRetiredOps.run(existing.slug);
     delThreadTimers.run(existing.slug);
-    delThreadWatches.run(existing.slug);
+    delPrWatches.run(existing.slug);
     delSession.run(existing.slug);
     return existing;
   };
@@ -11544,14 +11790,16 @@ function createStorage(dbPath) {
     setRecurringPromptBySlug: (slug, write) => recurringBySlugStmt.run(...recurringArgs(write), slug).changes === 1,
     countSignoffNudge: (slug, anchor) => void countNudgeStmt.run(anchor, slug),
     resetSignoffNudges: (slug) => void resetNudgesStmt.run(slug),
-    armThreadWatch: (watch) => void armWatchStmt.run({ ...watch, foreground: watch.foreground ? 1 : 0 }),
-    promoteThreadWatch: (slug, id) => promoteWatchStmt.run(id, slug).changes === 1,
-    listThreadWatches: (slug, opts) => (opts?.armedOnly ? armedWatchesBySlugStmt : watchesBySlugStmt).all(slug),
-    getThreadWatch: (id) => watchByIdStmt.get(id),
-    armedThreadWatches: () => armedWatchesStmt.all(),
-    dropThreadWatch: (slug, id, settledAtMs) => dropWatchStmt.run(settledAtMs, id, slug).changes === 1,
-    markThreadWatchFired: (id, settledAtMs) => fireWatchStmt.run(settledAtMs, id).changes === 1,
-    setThreadWatchCursor: (id, cursor) => watchCursorStmt.run(cursor, id).changes === 1,
+    countParkBump: (slug, anchor) => void countParkBumpStmt.run(anchor, slug),
+    resetParkBumps: (slug) => void resetParkBumpsStmt.run(slug),
+    armPrWatch: (watch) => void armPrWatchStmt.run(watch),
+    listPrWatches: (slug, opts) => (opts?.armedOnly ? armedPrWatchesBySlugStmt : prWatchesBySlugStmt).all(slug),
+    getPrWatch: (id) => prWatchByIdStmt.get(id),
+    armedPrWatches: () => armedPrWatchesStmt.all(),
+    expiredPrWatches: (nowMs) => expiredPrWatchesStmt.all(nowMs),
+    dropPrWatch: (slug, id, settledAtMs) => dropPrWatchStmt.run(settledAtMs, id, slug).changes === 1,
+    settlePrWatch: (id, settledAtMs) => settlePrWatchStmt.run(settledAtMs, id).changes === 1,
+    setPrWatchCursor: (id, cursor) => prWatchCursorStmt.run(cursor, id).changes === 1,
     armThreadTimer: (timer) => void armTimerStmt.run(timer),
     listThreadTimers: (slug, opts) => (opts?.armedOnly ? armedTimersBySlugStmt : timersBySlugStmt).all(slug),
     getThreadTimer: (id) => timerByIdStmt.get(id),
@@ -13334,15 +13582,25 @@ function matchComposedText(items, recordText, contemporaneous) {
   }
   return matched;
 }
-function ageDeliveries(items, nowMs) {
+function ageDeliveries(items, nowMs, observedUserAt) {
   if (!items.length) return items;
   let changed = false;
+  const userAtMs = Date.parse(observedUserAt ?? "");
+  const supersededByUserTurn = (item) => {
+    if (!Number.isFinite(userAtMs)) return false;
+    const born = Date.parse(item.at);
+    return Number.isFinite(born) && userAtMs >= born;
+  };
   const next = [];
   for (const item of items) {
     if (item.state === "cancelled") {
       next.push(item);
       continue;
     }
+    if (supersededByUserTurn(item)) {
+      changed = true;
+      continue;
+    }
     const born = Date.parse(item.at);
     if (item.state === "pending" && Number.isFinite(born) && nowMs - born > PENDING_TIMEOUT_MS) {
       next.push({ ...item, state: "unconfirmed", updatedAt: new Date(nowMs).toISOString() });
@@ -14027,6 +14285,7 @@ function newTailState(slug, sessionId, path, foreign = false, nativeSessionId =
     paneDead: false,
     noTranscript: false,
     nextDiscoverMs: 0,
+    discoverMisses: 0,
     stallLogged: false,
     customTitleRevision: 0
   };
@@ -14086,18 +14345,23 @@ function parseSignalFence(text) {
   if (!kind) return void 0;
   if (norm.slice(end).trim() !== "") return void 0;
   if (kind === "done") return { kind, body: capFenceBody(raw2.trim()), hints: [] };
+  const lines = raw2.split("\n");
+  const delimiter2 = lines.findIndex((l) => /^\s*---+\s*$/.test(l));
+  const frontmatter = delimiter2 === -1 ? lines : lines.slice(0, delimiter2);
+  const prose = delimiter2 === -1 ? [] : lines.slice(delimiter2 + 1);
   const hints = [];
   const rest = [];
-  for (const line of raw2.split("\n")) {
+  for (const line of frontmatter) {
     const hm = line.match(AWAITING_HINT_RE);
     const k = hm?.[1].toLowerCase();
-    if (hm && (k === "pr-watch" || k === "human" || k === "timer" || k === "pr" || k === "ci" || k === "session")) {
+    if (hm && (k === "shell" || k === "agent" || k === "timer" || k === "pr" || k === "for" || k === "reason")) {
       const value = hm[2].trim();
       hints.push({ kind: k, value: value.length > HINT_VALUE_MAX ? value.slice(0, HINT_VALUE_MAX) : value });
     } else {
       rest.push(line);
     }
   }
+  rest.push(...prose);
   return { kind, body: capFenceBody(rest.join("\n").trim()), hints: hints.slice(0, HINT_MAX) };
 }
 function isRealUserMessage(content) {
@@ -14202,7 +14466,7 @@ function retireLive(state, entry, finishedAt, status) {
   state.subAgents.delete(entry.toolUseId);
   if (entry.kind === "shell") {
     state.retiredShells.delete(entry.toolUseId);
-    state.retiredShells.set(entry.toolUseId, { toolUseId: entry.toolUseId, command: entry.command, outputFile: entry.outputFile, status });
+    state.retiredShells.set(entry.toolUseId, { toolUseId: entry.toolUseId, command: entry.command, outputFile: entry.outputFile, status, taskId: entry.taskId, label: entry.label, finishedAt });
     while (state.retiredShells.size > RETAINED_SHELLS_MAX) {
       const oldest = state.retiredShells.keys().next().value;
       if (oldest === void 0) break;
@@ -14762,6 +15026,10 @@ function defaultBrokerDaemonAlive(project, now) {
     return alive;
   };
 }
+function rowIsArchived(row) {
+  if (row.state === "open" || row.state === "archived") return row.state === "archived";
+  return row.archived === 1;
+}
 function createTailer(deps) {
   const now = deps.now ?? Date.now;
   const paneDead = deps.paneDead ?? (() => true);
@@ -14977,10 +15245,17 @@ function createTailer(deps) {
     for (const e of state.subAgents.values()) {
       if (e.kind !== "shell") continue;
       const lastActivityAt = entryLastActivity(e);
-      out.push({ label: e.label, startedAt: e.startedAt, state: "running", id: e.toolUseId, ...e.taskId ? { stoppable: true } : {}, ...lastActivityAt ? { lastActivityAt } : {} });
+      const since = Date.parse(lastActivityAt ?? e.startedAt);
+      const shellState = Number.isFinite(since) && now() - since > BGSHELL_STALE_MS ? "stale" : "running";
+      out.push({ label: e.label, startedAt: e.startedAt, state: shellState, id: e.toolUseId, ...e.taskId ? { stoppable: true, taskId: e.taskId } : {}, ...lastActivityAt ? { lastActivityAt } : {} });
     }
     return out;
   }
+  function retiredShellViews(state) {
+    const out = [];
+    for (const r of state.retiredShells.values()) out.push({ id: r.toolUseId, taskId: r.taskId, label: r.label, status: r.status, finishedAt: r.finishedAt });
+    return out;
+  }
   function codexBgShellViews(state) {
     if (!deps.codexBackgroundExecs || state.foreign || state.paneDead) return [];
     const execs = deps.codexBackgroundExecs(state.slug, state.sessionId);
@@ -15373,7 +15648,7 @@ ${ask}`;
     const next = items.filter((item) => item.state !== "pending" && item.state !== "enqueued");
     return next.length === items.length ? items : next;
   }
-  function ledgerFold(row, nowMs) {
+  function ledgerFold(row, nowMs, state) {
     if (!row.delivery_ledger) {
       return { finish: () => ({ changed: false, value: null }) };
     }
@@ -15393,7 +15668,7 @@ ${ask}`;
       },
       finish: () => {
         items = retireDeliveriesLostWithTheDaemon(row, items);
-        items = ageDeliveries(items, nowMs);
+        items = ageDeliveries(items, nowMs, state.lastUserAt);
         if (items === before) return { changed: false, value: null };
         const value = serializeDeliveryLedger(items);
         deps.storage.setDeliveryLedger(row.slug, value);
@@ -15562,6 +15837,7 @@ ${ask}`;
   }
   function captureStall(state, row) {
     if (state.stallLogged) return;
+    if (row.exited && rowIsArchived(row)) return;
     state.stallLogged = true;
     let pane = "";
     try {
@@ -15571,11 +15847,11 @@ ${ask}`;
     }
     const authFailure = row.backend !== "codex" && isClaudeAuthErrorText(pane);
     if (authFailure) state.authFault = "authentication_rejected";
-    const evidence = isBrokerClaudeRow(row) && deps.project.stateDir ? `no tmux pane (broker runtime). Daemon diagnostics: ${claudeBrokerDiagnosticLogPath(deps.project.stateDir, row.session_id)}` : isHeadlessRow(row) ? `no tmux pane (headless ${row.backend === "codex" ? "codex app-server" : "claude broker"} runtime)` : "";
-    const detail = authFailure ? "(claude authentication failure \u2014 pane content redacted; sign in and retry)" : pane.trim() || evidence || "(pane empty / unavailable)";
+    const evidence = isBrokerClaudeRow(row) && deps.project.stateDir ? `no tmux pane (broker runtime). Daemon diagnostics: ${claudeBrokerDiagnosticLogPath(deps.project.stateDir, row.session_id)}` : isHeadlessRow(row) ? `no tmux pane (headless ${row.backend === "codex" ? "codex app-server" : "claude broker"} runtime)` : "no pane captured (this build runs no tmux)";
+    const detail = authFailure ? "(claude authentication failure \u2014 pane content redacted; sign in and retry)" : pane.trim() || evidence;
     log.error(
       "tailer",
-      `thread ${row.slug} (session ${row.session_id}): no transcript ${DISCOVERY_GRACE_MS / 1e3}s after dispatch \u2014 likely a boot failure. ${isHeadlessRow(row) && !pane.trim() && !authFailure ? "" : "Pane:\n"}${detail.slice(0, 4e3)}`
+      `thread ${row.slug} (session ${row.session_id}): no transcript ${DISCOVERY_GRACE_MS / 1e3}s after dispatch \u2014 likely a boot failure. ${pane.trim() && !authFailure ? "Pane:\n" : ""}${detail.slice(0, 4e3)}`
     );
     try {
       mkdirSync10(stallLogDir, { recursive: true });
@@ -15598,6 +15874,7 @@ ${detail}
     if (size > 0) {
       state.noTranscript = false;
       state.stallLogged = false;
+      state.discoverMisses = 0;
       return true;
     }
     const spawnedMs = Date.parse(row.spawned_at);
@@ -15612,6 +15889,7 @@ ${detail}
       state.primed = false;
       state.noTranscript = false;
       state.stallLogged = false;
+      state.discoverMisses = 0;
       return true;
     }
     const found = discoverTranscriptId(logDir, row.session_id, { nowMs, exclude: claimedIds(row.slug) });
@@ -15634,8 +15912,14 @@ ${detail}
       state.primed = false;
       state.noTranscript = false;
       state.stallLogged = false;
+      state.discoverMisses = 0;
       return true;
     }
+    state.discoverMisses++;
+    state.nextDiscoverMs = nowMs + Math.min(
+      DISCOVER_RETRY_MS * 2 ** (state.discoverMisses - 1),
+      DISCOVER_RETRY_MAX_MS
+    );
     state.noTranscript = true;
     captureStall(state, row);
     return true;
@@ -15647,6 +15931,15 @@ ${detail}
     const nowMs = now();
     adoptionBindings = /* @__PURE__ */ new Map();
     const rows = deps.storage.allSessions();
+    let coldVisibleRow = false;
+    for (const row of rows) {
+      if (rowIsArchived(row)) continue;
+      const known = states.get(row.slug);
+      if (!known || !known.primed) {
+        coldVisibleRow = true;
+        break;
+      }
+    }
     let primed = 0;
     let primedRows = 0;
     const tickStartedMs = performance.now();
@@ -15672,13 +15965,19 @@ ${detail}
       const prevNoTranscript = state.noTranscript;
       if (row.backend !== "codex" && !resolveTranscript(state, row, nowMs)) continue;
       if (!state.primed) {
-        if (primedRows >= MAX_PRIME_ROWS_PER_TICK || primedRows > 0 && performance.now() - tickStartedMs > PRIME_BUDGET_MS) {
+        if (
+          // Yield the slot to a still-cold visible row — but never at the cost of the forward-progress
+          // guarantee below. `primedRows > 0` keeps the archive advancing by at least one row per tick
+          // even if a visible row were somehow to stay cold indefinitely, so deferral can never become
+          // starvation. The visible row still primes on this same tick; it just is not necessarily first.
+          coldVisibleRow && primedRows > 0 && rowIsArchived(row) || primedRows >= MAX_PRIME_ROWS_PER_TICK || primedRows > 0 && performance.now() - tickStartedMs > PRIME_BUDGET_MS
+        ) {
           primeIncomplete = true;
           continue;
         }
         primedRows++;
         const primeOffset = state.offset;
-        const primeLedger = ledgerFold(row, nowMs);
+        const primeLedger = ledgerFold(row, nowMs, state);
         consume(state, backend, chainOnLine(primeLedger.onLine, codexSubAgentOnLine(row, state)));
         state.codexSubAgents?.poll(nowMs);
         const primedLedger = primeLedger.finish();
@@ -15734,7 +16033,7 @@ ${detail}
       const prevTurn = state.turn;
       const rowLedger = row.delivery_ledger ?? null;
       const ledgerDrifted = rowLedger !== (state.deliveryLedgerSeen ?? null);
-      const ledger = ledgerFold(row, nowMs);
+      const ledger = ledgerFold(row, nowMs, state);
       consume(state, backend, chainOnLine(ledger.onLine, codexSubAgentOnLine(row, state)));
       state.codexSubAgents?.poll(nowMs);
       const ledgerResult = ledger.finish();
@@ -15949,7 +16248,7 @@ ${detail}
       if (!s) return void 0;
       const pendingQuestion = s.turn === "idle" && s.lastAssistantHasQuestion;
       const nowMs = now();
-      return { turn: s.turn, permPrompt: s.permPrompt, permPolicy: s.permPolicy, permDenies: s.permDenies, nativeInputRequired: s.nativeInputRequired, model: s.model, effort: s.effort, profileAt: s.profileAt, profileRevision: s.profileRevision, permissionMode: s.permissionMode, permissionModeAt: s.permissionModeAt, permissionModeRevision: s.permissionModeRevision, lastActivityAt: s.lastActivityAt, lastAssistantAt: s.lastAssistantAt, lastAssistant: s.lastAssistant, aiTitle: s.aiTitle, customTitle: s.customTitle, customTitleRevision: s.customTitleRevision, subAgents: subAgentViews(s, nowMs), droppedReports: [...s.queuedReports.values()], bgShells: [...bgShellViews(s), ...codexBgShellViews(s)], pendingAsk: s.pendingAsk, pendingQuestion, lastAssistantAllDone: s.lastAssistantAllDone, lastUserAt: s.lastUserAt, lastUserText: s.lastUserText, lastFence: s.lastFence, noTranscript: s.noTranscript, authFault: s.authFault, limitFault: s.limitFault, contextTokens: s.contextTokens, contextWindow: s.contextWindow, lastCompactionAt: s.lastCompactionAt };
+      return { turn: s.turn, permPrompt: s.permPrompt, permPolicy: s.permPolicy, permDenies: s.permDenies, nativeInputRequired: s.nativeInputRequired, model: s.model, effort: s.effort, profileAt: s.profileAt, profileRevision: s.profileRevision, permissionMode: s.permissionMode, permissionModeAt: s.permissionModeAt, permissionModeRevision: s.permissionModeRevision, lastActivityAt: s.lastActivityAt, lastAssistantAt: s.lastAssistantAt, lastAssistant: s.lastAssistant, aiTitle: s.aiTitle, customTitle: s.customTitle, customTitleRevision: s.customTitleRevision, subAgents: subAgentViews(s, nowMs), droppedReports: [...s.queuedReports.values()], bgShells: [...bgShellViews(s), ...codexBgShellViews(s)], retiredShells: retiredShellViews(s), pendingAsk: s.pendingAsk, pendingQuestion, lastAssistantAllDone: s.lastAssistantAllDone, lastUserAt: s.lastUserAt, lastUserText: s.lastUserText, lastFence: s.lastFence, noTranscript: s.noTranscript, authFault: s.authFault, limitFault: s.limitFault, contextTokens: s.contextTokens, contextWindow: s.contextWindow, lastCompactionAt: s.lastCompactionAt };
     },
     // The CURRENT fresh foreign session ids (mtime within FOREIGN_FRESH_MS, capped), mtime-desc. Kept
     // as the last scan's result — recomputed at most every FOREIGN_SCAN_EVERY ticks.
@@ -16002,7 +16301,7 @@ function landsAfterRead(eventAt, lastReadAt) {
   if (!Number.isFinite(e) || !Number.isFinite(r)) return true;
   return e > r;
 }
-var IDLE_BACKSTOP_MS, RUNTIME_CHASE_MAX, POLL_MS2, MAX_PRIME_ROWS_PER_TICK, PRIME_BUDGET_MS, TRANSCRIPT_READ_WINDOW, EMPTY_BUFFER, MAX_POLL_MS, SUBAGENT_STALE_MS, FOREIGN_FRESH_MS, FOREIGN_MAX, FOREIGN_SCAN_EVERY, CACHE_FLUSH_MS, PRIME_PROGRESS_EVERY, DISCOVER_RETRY_MS, PERM_YES_OPTION, PERM_QUESTION, PERM_FOOTER, PERM_COMPOSER_FOOTER, PERM_MODAL_TAIL_ROWS, PERM_COMPOSER_TAIL_ROWS, BOOT_APIKEY_HEADLINE, BOOT_APIKEY_QUESTION, BOOT_TRUST_QUESTION, BOOT_TRUST_OPTION, BOOT_MODAL_TAIL_ROWS, RETAINED_SUBAGENTS_MAX, RETAINED_SHELLS_MAX, DESCENDANT_TERMINALS_MAX, PENDING_RESUMES_MAX, PENDING_SHELLS_MAX, RESUME_REPLAY_SLACK_MS, QUESTION_BLOCK_RE, SIGNAL_FENCE_RE, AWAITING_HINT_RE, FENCE_BODY_MAX, HINT_MAX, HINT_VALUE_MAX, LAUNCH_ACK_RE, AUTO_BACKGROUND_ACK_RE, DESCENDANT_SIDECAR_MAX, DESCENDANT_NOTIFY_GRACE_MS, MAX_OWNED_TOOL_USE_IDS, BROKER_LIVENESS_TTL_MS, UNRESTORED_TAIL_FIELDS;
+var IDLE_BACKSTOP_MS, RUNTIME_CHASE_MAX, POLL_MS2, MAX_PRIME_ROWS_PER_TICK, PRIME_BUDGET_MS, TRANSCRIPT_READ_WINDOW, EMPTY_BUFFER, MAX_POLL_MS, SUBAGENT_STALE_MS, BGSHELL_STALE_MS, FOREIGN_FRESH_MS, FOREIGN_MAX, FOREIGN_SCAN_EVERY, CACHE_FLUSH_MS, PRIME_PROGRESS_EVERY, DISCOVER_RETRY_MS, DISCOVER_RETRY_MAX_MS, PERM_YES_OPTION, PERM_QUESTION, PERM_FOOTER, PERM_COMPOSER_FOOTER, PERM_MODAL_TAIL_ROWS, PERM_COMPOSER_TAIL_ROWS, BOOT_APIKEY_HEADLINE, BOOT_APIKEY_QUESTION, BOOT_TRUST_QUESTION, BOOT_TRUST_OPTION, BOOT_MODAL_TAIL_ROWS, RETAINED_SUBAGENTS_MAX, RETAINED_SHELLS_MAX, DESCENDANT_TERMINALS_MAX, PENDING_RESUMES_MAX, PENDING_SHELLS_MAX, RESUME_REPLAY_SLACK_MS, QUESTION_BLOCK_RE, SIGNAL_FENCE_RE, AWAITING_HINT_RE, FENCE_BODY_MAX, HINT_MAX, HINT_VALUE_MAX, LAUNCH_ACK_RE, AUTO_BACKGROUND_ACK_RE, DESCENDANT_SIDECAR_MAX, DESCENDANT_NOTIFY_GRACE_MS, MAX_OWNED_TOOL_USE_IDS, BROKER_LIVENESS_TTL_MS, UNRESTORED_TAIL_FIELDS;
 var init_tailer = __esm({
   "packages/server/src/tailer.ts"() {
     "use strict";
@@ -16031,12 +16330,14 @@ var init_tailer = __esm({
     EMPTY_BUFFER = Buffer.alloc(0);
     MAX_POLL_MS = 1e4;
     SUBAGENT_STALE_MS = 15 * 6e4;
+    BGSHELL_STALE_MS = 12 * 60 * 6e4;
     FOREIGN_FRESH_MS = 24 * 60 * 6e4;
     FOREIGN_MAX = 20;
     FOREIGN_SCAN_EVERY = 5;
     CACHE_FLUSH_MS = 3e4;
     PRIME_PROGRESS_EVERY = 20;
     DISCOVER_RETRY_MS = 15e3;
+    DISCOVER_RETRY_MAX_MS = 15 * 6e4;
     PERM_YES_OPTION = /(^|\n)\s*(❯\s*)?1\.\s+Yes\b/;
     PERM_QUESTION = /\b(?:Do you want|Would you like)\b/;
     PERM_FOOTER = /\bEsc to (cancel|reject)\b/;
@@ -16056,7 +16357,7 @@ var init_tailer = __esm({
     RESUME_REPLAY_SLACK_MS = 6e4;
     QUESTION_BLOCK_RE = /^```question(?:[ \t]+[A-Za-z][^\r\n]*?)?[ \t]*\r?\n[\s\S]*?\r?\n```[ \t]*$/gm;
     SIGNAL_FENCE_RE = /^```(done|awaiting)[ \t]*\n([\s\S]*?)\n```[ \t]*$/gm;
-    AWAITING_HINT_RE = /^(pr-watch|human|timer|pr|ci|session):\s*(\S.*)$/i;
+    AWAITING_HINT_RE = /^(shell|agent|timer|pr|for|reason):\s*(\S.*)$/i;
     FENCE_BODY_MAX = 500;
     HINT_MAX = 8;
     HINT_VALUE_MAX = 200;
@@ -16089,6 +16390,7 @@ var init_tailer = __esm({
       "permDenies",
       "noTranscript",
       "nextDiscoverMs",
+      "discoverMisses",
       "stallLogged",
       "deliveryLedgerSeen",
       // The chase bookkeeping is compared against an IN-MEMORY, per-process counter — the ingest's `live`
@@ -16451,8 +16753,8 @@ function parseCodexSubAgentLine(line, toolNameFor) {
   if (pt === "function_call" && p.name === "spawn_agent") {
     const args = parseToolArguments(p.arguments);
     const a = args && typeof args === "object" && !Array.isArray(args) ? args : {};
-    const str = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
-    return { kind: "spawn", at, callId, taskName: str(a.task_name), model: str(a.model), effort: str(a.reasoning_effort), agentType: str(a.agent_type) };
+    const str2 = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+    return { kind: "spawn", at, callId, taskName: str2(a.task_name), model: str2(a.model), effort: str2(a.reasoning_effort), agentType: str2(a.agent_type) };
   }
   if (pt !== "function_call_output") return void 0;
   const name = toolNameFor(callId);
@@ -18602,7 +18904,7 @@ var require_sender = __commonJS({
        * @param {Function} [cb] Callback
        * @private
        */
-      getBlobData(blob, compress, options, cb) {
+      getBlobData(blob, compress2, options, cb) {
         this._bufferedBytes += options[kByteLength];
         this._state = GET_BLOB_DATA;
         blob.arrayBuffer().then((arrayBuffer) => {
@@ -18615,12 +18917,12 @@ var require_sender = __commonJS({
           }
           this._bufferedBytes -= options[kByteLength];
           const data = toBuffer(arrayBuffer);
-          if (!compress) {
+          if (!compress2) {
             this._state = DEFAULT;
             this.sendFrame(_Sender.frame(data, options), cb);
             this.dequeue();
           } else {
-            this.dispatch(data, compress, options, cb);
+            this.dispatch(data, compress2, options, cb);
           }
         }).catch((err) => {
           process.nextTick(onError, this, err, cb);
@@ -18649,8 +18951,8 @@ var require_sender = __commonJS({
        * @param {Function} [cb] Callback
        * @private
        */
-      dispatch(data, compress, options, cb) {
-        if (!compress) {
+      dispatch(data, compress2, options, cb) {
+        if (!compress2) {
           this.sendFrame(_Sender.frame(data, options), cb);
           return;
         }
@@ -24857,20 +25159,64 @@ function parsePrRef(value) {
   return { owner: m[1], repo: m[2].replace(/\.git$/, ""), number };
 }
 function isActionableAwaitingHint(hint) {
-  if (!hint) return false;
-  if (hint.kind === "timer") return isValidAwaitingTimer(hint.value);
-  if (hint.kind === "pr-watch") return parsePrRef(hint.value) !== void 0;
-  return false;
+  return hint !== void 0 && false;
+}
+function readAwaitingPark(hints) {
+  const items = [];
+  let forMs = null;
+  let reason = "";
+  for (const h of hints) {
+    const value = h.value.trim();
+    if (isAwaitingItemKind(h.kind)) {
+      if (value) items.push({ kind: h.kind, value });
+    } else if (h.kind === "for") {
+      forMs = parseAwaitingDuration(value);
+    } else if (h.kind === "reason" && !reason) {
+      reason = value;
+    }
+  }
+  return { items, forMs, reason };
+}
+function unaccountedItems(items, live) {
+  return items.filter((i) => !live[LIVE_SET[i.kind]].has(i.value));
+}
+function parkIsHonoured(park, live) {
+  if (park.items.length === 0) return false;
+  if (park.forMs === null) return false;
+  return unaccountedItems(park.items, live).length === 0;
+}
+function parkExpiresAt(park, fenceAtMs) {
+  if (park.forMs === null || !Number.isFinite(fenceAtMs)) return null;
+  return fenceAtMs + Math.min(park.forMs, AWAITING_FOR_MAX_MS);
 }
 function awaitingFenceIdentity(hint, fenceAt) {
   return createHash11("sha256").update(fenceAt).update("\0").update(hint.kind).update("\0").update(hint.value).digest("hex");
 }
-var PR_REF_RE;
+function readGithubStatusBook(raw2) {
+  if (!raw2 || typeof raw2 !== "object" || Array.isArray(raw2)) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(raw2)) {
+    const parsed = GithubWatchStatus.safeParse(value);
+    if (parsed.success) out[key] = parsed.data;
+  }
+  return out;
+}
+function githubStatusKey(ref) {
+  return `${ref.owner}/${ref.repo}#${ref.number}`;
+}
+var PR_REF_RE, LIVE_SET, GITHUB_STATUS_SETTING;
 var init_awaiting = __esm({
   "packages/server/src/awaiting.ts"() {
     "use strict";
     init_src();
     PR_REF_RE = /(?:https?:\/\/github\.com\/)?([A-Za-z0-9][\w.-]*)\/([A-Za-z0-9][\w.-]*?)(?:\/pull\/|\/pulls\/|#)(\d+)/;
+    LIVE_SET = {
+      shell: "shells",
+      agent: "agents",
+      timer: "timers",
+      pr: "prs"
+    };
+    GITHUB_STATUS_SETTING = "waker.github.status.v1";
   }
 });
 
@@ -24971,11 +25317,12 @@ triage: it says neither "answer me" nor "this is finished", so it sits in the qu
 Frizz corrects it, twice, and then stops: rest without a fence and you will be told to pick one, which
 costs you a turn each time.
 
-Pick \`question\` when you need the human, \`done\` when the work is genuinely finished, and REGISTER A
-WAIT (\`mcp__frizz__watch\`) when you are blocked on a PR, CI, or your own background shell \u2014 a
-registered wait is durable, survives compaction and restarts, and can be dropped when it stops
-mattering. You stay OUT of the queue only while you own a live sub-agent or a valid \`awaiting\` fence;
-a detached background process does NOT hold you out.
+Pick \`question\` when you need the human, \`done\` when the work is genuinely finished, and \`awaiting\`
+when you are WAITING \u2014 on a PR, or on your own background work \u2014 naming what you wait on, one line each.
+
+\`awaiting\` REGISTERS NOTHING. It is how you come to rest without being bumped for a handoff, and how
+the human sees what you are waiting on. Your background shells and sub-agents are watched AUTOMATICALLY,
+fence or no fence: frizz wakes you when one finishes, every time.
 
 **WRITE IT TO BE READ COLD.** The human reads your final message in a queue, hours later, with none of
 your context \u2014 and they have NOT seen anything since their own last message. Every prompt you received
@@ -24986,6 +25333,16 @@ you would do next \u2014 rather than only the last thing you touched. Do not ass
 Be concise, but do not omit. Use whatever markup makes it readable: headings, bullets, tables, code.
 The one place brevity is a RULE is a \`done\` body \u2014 see its entry below.
 
+**NAME THE PULL REQUEST, EVERY TIME YOU REST.** If your effort has a PR \u2014 one you opened, one you are
+reviewing, one you are fixing \u2014 write its number in EVERY resting message, not just the one where it
+first appeared. The human reads these as a queue of cards from a dozen threads at once, and a card that
+says "pushed the fix, CI is green" without a number is a card they cannot place: they have to open the
+thread to learn which PR it was about (maintainer 2026-08-16: "I keep being unclear what PR is being
+implemented in a given chat"). One \`#123\` in the first line or two costs you nothing and answers it.
+
+Several PRs in play \u21D2 name them all. No PR yet \u21D2 say what the work is against instead (a branch, an
+issue, a file) \u2014 the point is that the card identifies its own subject without being opened.
+
 Frizz turns \`#123\`, \`owner/repo#123\` and bare commit hashes into github.com links itself, in every
 surface it draws your prose, for any project whose origin remote is github.com. Write the bare form;
 wrapping one in a \`[link](url)\` yourself is redundant. Everything else you want clickable \u2014 a file, a
@@ -24995,8 +25352,14 @@ Use at most ONE fenced signal block, at the very END of the final message. The f
 state; the body is the card the human reads. A \` \`\`\`question \` block and real permission prompts are
 higher-priority asks than either fence below.
 
+**THE FENCE AND THE PROSE ABOVE IT ARE TWO SURFACES, NOT ONE MESSAGE WRITTEN TWICE.** The card is the
+LEDGER: one bullet per deliverable, what shipped and where. The prose is only what a ledger cannot hold
+\u2014 the reasoning, the caveat, the thing the human has to do. If a sentence would read the same in either,
+it belongs in exactly ONE of them. Writing the summary and then restating it as bullets costs the human
+a second read for nothing, and it is the commonest thing wrong with an otherwise good handoff.
+
 - \` \`\`\`done \` \u2014 you COMPLETED the effort's real work: code LANDED on the project's mainline, a plan or
-  doc written, or a commissioned research/audit report finished. Body: ONE TO THREE SENTENCES, then a
+  doc written, or a commissioned research/audit report finished INTO A FILE. Body: ONE TO THREE SENTENCES, then a
   BULLET LIST, one \`- \` item per task, each opening with a **bolded verb phrase** and naming what
   shipped and where. This is the ONE place the short shape is a rule \u2014 a dismissal card is scanned, not
   read, so it is a ledger. Everywhere else, say as much as the reader needs. The card renders inline markdown, so backtick every path,
@@ -25011,62 +25374,151 @@ higher-priority asks than either fence below.
   \`\`\`
 
   **\`done\` is a DISMISSAL, not a summary** \u2014 its card files the thread away where nobody looks again,
-  and anything living only in the conversation goes with it. If the thread points at future work AT ALL,
-  bare-rest instead; uncertain is not done. What blocks \`done\` is work you still OWE, not a process that
-  happens to still be RUNNING: a watcher, dev server, or poller you have already moved on from does not
-  hold it back \u2014 name it in the body and fence anyway. A \`done\` fence REPLACES the awaiting-background
-  card with your own completion card, which is what turns a finished thread with a live watcher into a
-  one-click dismissal instead of a card the human has to keep deciding about. Code written but not LANDED
-  is not done (a commit, a pushed branch, an open PR is work still ahead of the merge \u2014 where the project
-  uses PRs, \`done\` waits for the MERGE, so park the PR on \` \`\`\`awaiting \` with \`pr-watch:\`). An
-  investigation headed for a fix is NOT \`done\`; the fix is still owed. Two cases DO earn \`done\` on
-  something other than landed code: a commissioned research or audit EFFORT, whose finished report is the
-  deliverable, earns \`done\`; and so does a PLANNING session whose plan file is FULLY written and
-  PERSISTED (\`.frizz/plans/<topic>.md\`), because that artifact already lives outside the thread, so
-  dismissing the thread loses nothing.
-
-- \` \`\`\`awaiting \` \u2014 a durable wait frizz's scheduler manages. Lead the body with one or more
-  \`kind: value\` hint lines, then concise prose naming the exact wake condition. New waits use only:
-
-  - \`pr-watch: owner/repo#NUMBER\` \u2014 frizz polls the PR and resumes you on ANY new review, approval, or
-    comment, from a HUMAN OR A BOT alike. Your thread STAYS IN THE QUEUE as a visible "watching it"
-    handoff. This is the default for a PR you opened. ONE line watches ONE PR, and a fence may carry
-    SEVERAL \u2014 repeat the line per PR, across any mix of repos, and activity on ANY of them wakes you.
-    Never downgrade to a periodic \`timer:\` sweep just because you are tracking more than one PR. The
-    body keeps its first 8 hint lines and silently DROPS the rest, so past 8 watch the 8 that matter
-    and cover the tail with a \`timer:\`.
-
-    **READ THE PR BEFORE YOU PARK ON IT.** After your first park on a given PR the baseline is the
-    INSTANT YOU REST \u2014 only what arrives AFTER can wake you again. Frizz covers the first park by
-    replaying whatever was already sitting there, once, so review you never read cannot be lost; but
-    that replay costs you a whole turn to answer something you could have read before resting. Run
-    \`gh pr view N --comments\` first, deal with what is there, and only then write the fence.
-    "Waiting on review" is a claim that review has not arrived; go and check that it is true.
-  - \`human: <actor + exact review/approval>\` \u2014 a third party whose action cannot be supplied in this
-    frizz conversation. PARKS you in the dimmed Held band. A bot, CI gate, or merge queue is NOT a human
-    wait. Pair with \`pr-watch:\` when a GitHub PR exists, or \`timer:\` when none does.
-  - \`timer: <ISO-8601 instant>\` \u2014 the durable scheduler resumes you then, across restarts
-    (\`{{FRIZZ_RESUME_CMD}}\`).
+  and anything living only in the conversation goes with it. So the test is never "have I stopped
+  working": it is **WHAT IS LOST IF NOBODY EVER OPENS THIS THREAD AGAIN?** Name one thing and it is not
+  done. If the thread points at future work AT ALL, you are not done \u2014 see **When the work is finished
+  but the thread found more** for the ways out of that, none of which is stretching \`done\`. Uncertain
+  is not done.
+
+  **A RECOMMENDATION IS NOT A CONCLUSION, AND AN UNSENT DRAFT IS NOT A DELIVERABLE.** When the verdict
+  is that SOMEONE SHOULD NOW DO SOMETHING \u2014 merge it, decline it, post this comment, pick one of these
+  two designs, press the button you are not allowed to press \u2014 that someone is the human, so the effort
+  ends on a \` \`\`\`question \` carrying your recommendation as option A. Same for anything you WROTE but
+  did not SEND: a drafted comment, reply, issue body or release note you were right not to publish
+  unilaterally is one click short of delivered, and \`done\` files that draft away with the thread.
+
+  **A \`done\` MESSAGE SAYS WHAT HAPPENED. DELETE EVERY DANGLING "WORTH DOING LATER".** "One thing to
+  carry forward\u2026", "a follow-up could\u2026", "someone should add a changelog line before this ships" \u2014 a
+  forward-reference parked in a dismissal card is clutter: too weak for anyone to act on, too present to
+  ignore, and archived unread. Each one resolves four ways and there is no fifth \u2014 DO it, SPAWN it onto
+  its own card, ASK about it, or DROP it. Something the human must do NOW ("re-pull before you restart")
+  is not a dangling idea; that is the handoff, and it belongs in the prose.
+
+  What blocks \`done\` is work still OWED \u2014 by you, or by the human because of what you found \u2014 not a
+  BACKGROUND PROCESS that happens to still be running: a watcher, dev server, or poller you have already
+  moved on from does not hold it back \u2014 name it in the body and fence anyway. **Read that carve-out
+  narrowly: its subject is a running process, and nothing else.** Follow-up work you DISCOVERED blocks
+  \`done\` just as hard as work you were assigned, even when it is someone else's to do \u2014 "not mine" is
+  not "not owed", because the card takes the finding with it either way. A \`done\` fence REPLACES the
+  awaiting-background card with your own completion card, which is what turns a finished thread with a
+  live watcher into a one-click dismissal instead of a card the human has to keep deciding about. Code
+  written but not LANDED is not done (a commit, a pushed branch, an open PR is work still ahead of the
+  merge \u2014 where the project uses PRs, \`done\` waits for the MERGE, so park the PR on \` \`\`\`awaiting \`
+  with \`pr:\`). An investigation headed for a fix is NOT \`done\`; the fix is still owed. Two cases
+  DO earn \`done\` on something other than landed code, and BOTH earn it the same way \u2014 by passing the
+  test above, because the deliverable is a FILE the human opens without this thread: a commissioned
+  research or audit EFFORT, whose finished report is written to that file, earns \`done\`; and so does a
+  PLANNING session whose plan file is FULLY written and PERSISTED (\`.frizz/plans/<topic>.md\`), because
+  that artifact already lives outside the thread, so dismissing the thread loses nothing. Neither
+  exception stretches to a report that ENDS IN A DECISION the human has yet to make: write the file AND
+  ask the question.
+
+- \` \`\`\`awaiting \` \u2014 you have STOPPED, and you are waiting on work that is actually running. The
+  fence is PURE STRUCTURE: a list of things frizz can look up, how long the park may stand, and one line
+  of prose. Nothing else belongs in it.
 
   \`\`\`awaiting
-  pr-watch: acme/app#391
-  PR is open and CI is green. Watching for review \u2014 I'll address comments or merge on approval.
+  shell: bzvtnt3ig
+  agent: <the runtime agent id>
+  timer: tmr_a1b2c3d4e5f6
+  pr: acme/app#391
+  for: 2h
+  ---
+  Waiting on the three-platform run before porting the v2 drivers.
+
+  - the macOS leg is the one that has been flaky
+  - if it goes red I will bisect rather than re-run
   \`\`\`
 
-  \`pr:\` / \`ci:\` / \`session:\` remain parser compatibility for existing transcripts only; never emit
-  them. The operator's own answer or approval is a \` \`\`\`question \`, not \`awaiting\`.
+  **FRONTMATTER, THEN MARKDOWN.** The structural lines come first; a \`---\` line ends them and everything
+  after it is ORDINARY MARKDOWN \u2014 as much as you want, with paragraphs, lists and links. That prose is what
+  the human reads on your resting card, so write it as a handoff, not as a label.
+
+  Omit the \`---\` and the whole fence is structure. A single \`reason: <one line>\` line also still works, but
+  prefer the delimiter: a handoff is prose, and one line is not enough room for one.
+
 
-  **CI, releases, deploys and merge progression are automatable \u2014 never \`awaiting\` them.** They stay
-  ACTIVE: dispatch a sub-agent to own the wait (its liveness keeps you Active and its return re-invokes
-  you), or use a timer when the next check genuinely belongs at a later wall-clock time.
+  - \`shell:\` / \`agent:\` \u2014 the runtime id you were handed when you launched it ("Command running in
+    background with ID: bzvtnt3ig").
+
+  **LOST AN ID? \`mcp__frizz__activity\` PRINTS THEM ALL** \u2014 every shell, sub-agent, timer and PR you have
+  out, each with the exact line your fence needs. Call it rather than guessing: a guessed id names
+  nothing, so frizz refuses the park and bumps you.
+  - \`timer:\` \u2014 a timer id from \`mcp__frizz__timer\`. NOT an instant; the tool creates the timer.
+  - \`pr:\` \u2014 a pull request you REGISTERED with \`mcp__frizz__watch_pr\`, written \`owner/repo#N\`. Register
+    FIRST: this line states the wait, it does not create one. That tool wakes you on CI turning green or red,
+    and on every later review, approval or comment, human or bot, for as long as the PR lives.
+  - \`for:\` \u2014 **REQUIRED**, and a DURATION: \`30s\`, \`15m\`, \`2h\`, \`3d\`. Never an instant. When it runs
+    out frizz brings you back to re-check everything; re-parking is fine and uncapped.
+  - \`reason:\` \u2014 a one-line alternative to the \`---\` block above, kept for fences already written
+    that way. Prefer the delimiter.
+
+  **REGISTERING IS NOT PARKING, AND PARKING IS NOT REGISTERING.** Launching a shell, dispatching a
+  sub-agent, setting a timer, registering a PR watcher \u2014 those just happen, and frizz watches them
+  whether or not you ever write a fence. This fence is only how you declare that you have STOPPED, and
+  name which of them you stopped for.
+
+  **A FENCE THAT NAMES NOTHING IS NOT A PARK.** \`for:\` and \`reason:\` describe a wait; they are not one.
+  If you are waiting on CI, REGISTER the PR and name it \u2014 do not write "waiting on the checks" and a
+  duration, because nothing will wake you and your thread just sits in the queue. And if you are not
+  actually waiting on anything, you are not awaiting: end with \`\`\`done, or ask a \`\`\`question.
+
+  **FRIZZ CHECKS EVERY NAME THE MOMENT YOU REST.** All of them live \u21D2 your thread parks in the dimmed
+  Held band. Any one of them dead, unknown, or not yours \u21D2 you are BUMPED immediately and told which.
+  A fence naming nothing at all is not a park either \u2014 it is a claim to be waiting with no way to be
+  woken, which is the exact failure this grammar exists to make impossible.
+
+  **WAITING ON A PERSON IS A \` \`\`\`question \`.** There is no human gate and there is no prose park.
+  If you need a human, ask them something answerable.
+
+  **CI, RELEASES, DEPLOYS AND MERGE PROGRESSION ARE AUTOMATABLE \u2014 never \` \`\`\`awaiting \` them
+  BLINDLY.** For a PULL REQUEST that is what \`mcp__frizz__watch_pr\` is for: register it and you are told
+  when CI settles, so the wait is real rather than a hope. For anything else, stay ACTIVE \u2014 dispatch a
+  sub-agent to own the wait (its return re-invokes you), or set a timer and name it here.
+
+  **THE PARK SURVIVES A RESTART.** The registration and the fence are both durable, so frizz brings you
+  back (\`{{FRIZZ_RESUME_CMD}}\`) even if its own server or your daemon is replaced while you wait.
 
   **A follow-up clears the previous fence.** If the human says "back to awaiting", never answer that it
-  is already parked and never rely on the old fence: re-check the blocker, then re-emit a fresh
-  \` \`\`\`awaiting \` with a current \`human:\` / \`timer:\` / \`pr-watch:\` hint. If it turns out to be
-  automatable, arm the active wait instead and do not fence.
+  is already parked and never rely on the old fence: re-check what you are waiting on, confirm it is
+  still running, and emit a FRESH fence naming it. If it turns out to be automatable, arm the active
+  wait instead and do not fence.
 
 - \` \`\`\`question \` \u2014 you need the human's input; see **Questions for the human**.
 
+### When the work is finished but the thread found more
+
+Your mandate is complete and you turned up something else: a bug you were not sent for, a fix nobody
+landed, a follow-up the change implies. \`done\` is barred \u2014 the finding dies with the card. \`awaiting\`
+is barred \u2014 nothing is running. \`question\` looks barred \u2014 the human asked nothing. **That deadlock is
+not real, and stretching \`done\` is not how you break it.** Take the first exit that fits:
+
+1. **DO IT \u2014 the default, and it covers far more than "small".** Anything inside your change's own blast
+   radius is exit 1: the fix your change implies, the test it needs, the breakage it revealed, the caller
+   it left stale. **Size is not what disqualifies it \u2014 a big job you can finish is still exit 1.** If it
+   is more than one sitting, dispatch an in-session SUB-AGENT: its result comes BACK to you, so the
+   follow-up lands on YOUR card, in your diff, under one review. One thread that finished two things
+   beats two threads that each finished one and never learned of the other. Then \`done\` is honest with
+   nothing left over.
+2. **ASK** \u2014 the human should choose whether or how it happens. An ordinary \` \`\`\`question \`; "nothing
+   was pending" is not an objection. This is the exit for work you cannot bound, cannot verify, or that
+   is genuinely the human's call \u2014 and it is where a separable effort goes, as an OPTION they pick,
+   rather than a card you create for them.
+3. **HAND IT OFF TO ITS OWN CARD \u2014 the LAST resort, not the tidy one.** \`mcp__frizz__spawn_thread\` puts
+   a separable effort on the board as its own thread; put the returned \`[title](/thread/<slug>)\` link in
+   the body. **A spawned thread is FIRE-AND-FORGET: it reports to the HUMAN, never to you, so nothing it
+   learns can ever reach this effort or its siblings.** That is the whole cost, and it is not
+   theoretical \u2014 one thread here spawned four, three of those spawned more, and three separate
+   descendants independently rediscovered the SAME root-cause commit over twenty hours because none of
+   them could tell the others. Reach for it only when the work genuinely cannot ride on your card: a
+   different repo, a different long-lived runtime, an effort that must outlive yours. If a sub-agent
+   could do it, exit 1. If the human should choose, exit 2. Never spawn merely to clear your own \`done\`.
+4. **DROP IT** \u2014 it is not worth an effort, a card, or a question. Then it is not worth a SENTENCE
+   either: delete it. Do not park it in the handoff as "one thing to carry forward".
+
+A bare rest is the residual, not a plan \u2014 legitimate only when nothing above fits, and frizz will ask
+you twice for a fence before it gives up.
+
 A mid-conversation turn carries NO fence. Nor is a turn on a thread that still points at future work \u2014
 a live code-change discussion above all \u2014 ever \`done\`.`;
     AGENT_COMPLETION = `## Agent completion invariant
@@ -25165,6 +25617,23 @@ Three specific traps, each of which has ended a turn that should have continued:
 - **Pre-emptively worrying about context budget.** You do not get to stop early because the turn feels
   long. If context genuinely runs out, the harness summarizes and you continue.
 
+**AND THE INSTRUCTION IS ALSO THE CEILING.** Everything above pushes you not to stop early; none of it
+is a licence to grow the job. "Keep going" has no upper bound of its own \u2014 there is always more to do
+in any repository \u2014 so a worker that may not stop until nothing is left can only ever stop by widening
+what it was asked. Finish the mandate you were given, and nothing else.
+
+- **Work you notice on the way is a FINDING, not a task.** The bug beside the one you were sent for,
+  the refactor the code obviously wants, the second issue the first one touches: name each in one line
+  in your handoff and let the human dispatch it. Widening is not thoroughness \u2014 it buries the answer
+  they asked for under changes they now have to review, and it spends hours they did not agree to.
+- **If the deliverable is a DOCUMENT, the document is the ending.** A triage, a review, an
+  investigation, a recommendation, a plan \u2014 when that is what you were asked for, the finished
+  write-up IS the work. Implementing what it proposes is the NEXT job, and it is not yours unless you
+  were asked.
+- **An unanswered question is not permission to build the answer.** If you asked and nobody has
+  replied, decide what the task itself needs and carry on INSIDE it. Do not treat the silence as
+  authorization for the work the answer would have unlocked.
+
 **Your default is to DECIDE.** A reversible call costs minutes to redo; a round-trip to the human costs
 hours \u2014 they may not read your question for hours, and the whole effort sits idle until they do. If it
 is derivable from the code, the conventions, or ordinary engineering judgment, it is yours: make it,
@@ -25173,12 +25642,20 @@ say which way you went, and keep moving.
 **The test that catches almost every bad question: if you are about to mark one option
 \`(recommended)\`, you already know the answer \u2014 so implement it instead of asking.** Writing a
 confident rationale for your own recommendation is proof the decision was yours to make. The same goes
-for "want me to fix it?" on a bug you were dispatched to fix or noticed on the way, "should I also
+for "want me to fix it?" on a bug you were dispatched to fix, "should I also
 handle X?" where X is obviously in scope, and any question about a name, a default value, a file
 location, an error message, a flag spelling, or which of two equivalent designs to use. Those are
-granular implementation calls. Make them, note the notable ones in your handoff, and move on \u2014 a
+granular implementation calls. (A bug you merely NOTICED is not a question either \u2014 by the ceiling
+above it is a line in your handoff, not work to adopt and not permission to seek.) Make them, note the
+notable ones in your handoff, and move on \u2014 a
 decision the human can see and reverse in a line of code is not worth an hours-long stall.
 
+**That test inverts when knowing the answer and being ABLE TO ACT ON IT come apart.** Where the act is
+one you are not permitted or not able to perform \u2014 a read-only boundary, a comment that goes out under
+the human's name, a merge, a close, a publish, a spend \u2014 your recommendation is not a decision you take
+silently. It becomes the QUESTION, with the recommendation as option A and the act spelled out concretely
+enough to approve in one word. Never resolve that fork by fencing \` \`\`\`done \` on the investigation.
+
 Stop only when a wrong guess would be BOTH costly AND hard to undo:
 
 - destructive or irreversible actions (history rewrite, data loss, force-merge, a published release);
@@ -25471,8 +25948,9 @@ When delegation is explicitly authorized:
 Keep automatable waits inside the active turn through the selected persistent \`exec_command\` /
 \`write_stdin\` monitor session until it reaches a terminal condition. Then diagnose/fix/retry/merge as
 authorized. Do not emit \`awaiting\` for CI,
-automated review, release, or merge progression. Those tool sessions are process-bound; use a durable
-\`timer:\` awaiting fence only when the next check belongs at a named wall-clock instant. A partial
+automated review, release, or merge progression. Those tool sessions are process-bound; set a durable
+timer with \`mcp__frizz__timer\` and name it in your fence only when the next check belongs at a later
+wall-clock time. A partial
 \`gh pr checks\` rollup is not a CI-green verdict: inspect workflow runs for the exact PR head too, and
 treat \`ACTION_REQUIRED\` fork gates as pending. When no valid project monitor is declared, run the
 bundled \`ci-watch.mjs\` / \`review-watch.mjs\` named above instead of inventing a loop of your own.
@@ -25497,7 +25975,7 @@ So when a wait is longer than a single yield budget:
 3. Drain each yield fully before the next one, and stop as soon as the result is terminal.
 
 If you find yourself on the third identical poll with no new output, you are in this anti-pattern:
-switch to a blocking monitor, or emit a \`timer:\` awaiting fence for a genuinely distant check.
+switch to a blocking monitor, or set a timer with \`mcp__frizz__timer\` for a genuinely distant check.
 
 When you genuinely need to work alongside a disposable local process (a dev server or long gate), use
 the managed unified-exec handoff: create the \`tools.exec_command(...)\` promise, call
@@ -25512,8 +25990,9 @@ the cell can wake a rested turn.
 
 Never implement a recurring wake as a shell \`sleep\` loop. Shell output cannot create a new Codex turn,
 so an unattended loop is not a wake mechanism. When a later wall-clock check genuinely belongs after a
-rest, emit an \`awaiting\` fence with \`timer: <ISO-8601 instant>\`; Frizz's durable scheduler starts the
-new turn at that instant. The timer is one-shot; do not try to make it recur.
+rest, set one with \`mcp__frizz__timer\` and name the id it returns on a \`timer:\` line in your
+\`\`\`awaiting fence; Frizz's durable scheduler starts the new turn then. Each timer is one-shot \u2014 set
+several if you need several, and do not try to make one recur.
 
 ## Your model and reasoning effort
 
@@ -25538,7 +26017,15 @@ effort that deserves its own card and whose output you do not need.
 
 Give it a self-contained \`prompt\` and choose \`model\` + \`effort\` by the new task's complexity (both
 required). It returns a \`[title](/thread/<slug>)\` link \u2014 put that in your handoff so the human can open
-it.`;
+it.
+
+**It is the LAST resort among the exits, never the tidy one.** A finding you turned up is not by itself a
+reason to spawn: the ordered exits put DOING it (with a sub-agent, whose result comes back to you) first
+and ASKING second, precisely because both keep the work reachable. A spawned thread does not \u2014 it reports
+to the HUMAN and nothing it learns returns to you or to its siblings, so a chain of them re-derives the
+same facts in parallel and nobody notices. Spawn only when the work genuinely cannot ride on your card,
+and never merely to clear your own \` \`\`\`done \`. See **When the work is finished but the thread found
+more**.`;
     THREAD_EXECUTION = {
       claude: `## Thread types
 
@@ -26967,17 +27454,6 @@ function buildClaudeResumeCommand(opts) {
   if (opts.message) argv.push(opts.message);
   return argv;
 }
-function armDefaultGoal(storage, slug) {
-  try {
-    storage.setRecurringPromptBySlug(slug, {
-      prompt: DEFAULT_RECURRING_PROMPT,
-      ...DEFAULT_GOAL_TRIGGERS,
-      intervalMs: null,
-      armedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  } catch {
-  }
-}
 function createDispatcher(deps) {
   const readBoardSource = deps.readBoard ?? readBoard;
   const frizzDir = join23(deps.project.dir, ".frizz");
@@ -27063,7 +27539,6 @@ function createDispatcher(deps) {
             effort: effort ?? null,
             permission_mode: permissionMode
           });
-          armDefaultGoal(deps.storage, slug);
           deps.storage.setBackend(slug, "codex");
           deps.storage.setAgentSession(slug, spawned.binding.codexSessionId);
           deps.storage.setCodexRuntime(slug, "app-server");
@@ -27124,7 +27599,6 @@ function createDispatcher(deps) {
             effort: effort ?? null,
             permission_mode: permissionMode
           });
-          armDefaultGoal(deps.storage, slug);
           deps.storage.setBackend(slug, "claude");
           deps.storage.setClaudeRuntime(slug, "broker");
           void deps.board.rebuild().catch(() => {
@@ -27501,6 +27975,7 @@ var init_plan_files = __esm({
 import {
   watch as fsWatch
 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
 import { join as join25 } from "node:path";
 import watcher from "@parcel/watcher";
 function appServerTurnStalled(liveness, lastActivityAt, nowMs) {
@@ -27564,6 +28039,53 @@ function stampStoppableShells(shells, row) {
   if (isHeadlessRow(row)) return shells;
   return shells.map((shell) => shell.stoppable ? { ...shell, stoppable: false } : shell);
 }
+function declaredWaitIds(tele) {
+  if (tele?.lastFence?.kind !== "awaiting") return [];
+  return readAwaitingPark(tele.lastFence.hints).items.filter((i) => i.kind === "shell" || i.kind === "agent").map((i) => i.value);
+}
+function liveWaitHandles(tele) {
+  const handles = /* @__PURE__ */ new Set();
+  for (const shell of tele?.bgShells ?? []) {
+    if (shell.state !== "running") continue;
+    if (shell.id) handles.add(shell.id);
+    if (shell.taskId) handles.add(shell.taskId);
+    if (shell.label) handles.add(shell.label);
+  }
+  for (const agent of tele?.subAgents ?? []) {
+    if (!isDirectSubAgent(agent) || agent.state !== "running") continue;
+    handles.add(agent.id);
+    if (agent.label) handles.add(agent.label);
+  }
+  return handles;
+}
+function hasDeclaredBackgroundPark(tele, nowMs) {
+  const named = declaredWaitIds(tele);
+  if (named.length === 0) return false;
+  const live = liveWaitHandles(tele);
+  if (!named.every((id) => live.has(id))) return false;
+  const restedMs = Date.parse(tele?.lastAssistantAt ?? "");
+  if (Number.isFinite(restedMs) && nowMs - restedMs > DECLARED_PARK_MAX_MS) return false;
+  return true;
+}
+function hasDeclaredWait(tele, nowMs) {
+  if (hasDeclaredBackgroundPark(tele, nowMs)) return true;
+  if (tele?.lastFence?.kind === "awaiting" && hasParkedPrWatch(tele)) return true;
+  return (tele?.subAgents ?? []).some((a) => isDirectSubAgent(a) && a.state === "running");
+}
+function heldByRunningChecks(tele, github, registered) {
+  if (tele?.lastFence?.kind !== "awaiting") return false;
+  const refs = [];
+  for (const hint of tele.lastFence.hints) {
+    if (hint.kind !== "pr") continue;
+    const ref = parsePrRef(hint.value);
+    if (ref && registered.has(githubStatusKey(ref))) refs.push(githubStatusKey(ref));
+  }
+  if (refs.length === 0) return false;
+  return refs.every((key) => {
+    const status = github[key];
+    return status?.checks === "running" && status.state === "open";
+  });
+}
 function hasLiveOwnWork(tele) {
   return Boolean(
     tele?.subAgents?.some((agent) => isDirectSubAgent(agent) && agent.state === "running") || tele?.bgShells?.some((shell) => shell.state === "running") || // A PARKED PR WATCHER COUNTS (2026-08-13). It is the same shape of thing as a detached shell: the
@@ -27577,46 +28099,47 @@ function hasLiveOwnWork(tele) {
 }
 function hasParkedPrWatch(tele) {
   if (tele?.lastFence?.kind !== "awaiting") return false;
-  return tele.lastFence.hints.some((hint) => hint.kind === "pr-watch" && parsePrRef(hint.value) !== void 0);
+  return tele.lastFence.hints.some((hint) => hint.kind === "pr" && parsePrRef(hint.value) !== void 0);
 }
 function bgSnoozeArmed(row) {
   return row.bg_snooze_rested_at != null && row.rested_at != null && row.bg_snooze_rested_at === row.rested_at;
 }
-function hasParkedExternalWait(tele, nowMs) {
-  if (tele?.lastFence?.kind !== "awaiting") return false;
-  return tele.lastFence.hints.some(
-    (hint) => hint.kind === "human" || hint.kind === "timer" && isValidAwaitingTimer(hint.value) && Date.parse(hint.value) > nowMs
-  );
+function hasParkedExternalWait(tele, _nowMs) {
+  return false;
 }
-function githubWatchViews(slug, tele, fenceAt) {
-  if (tele?.lastFence?.kind !== "awaiting") return [];
+function fenceWatchViews(slug, tele, fenceAt, github = {}, registered = []) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
-  for (const hint of tele.lastFence.hints) {
-    if (hint.kind !== "pr-watch") continue;
-    const ref = parsePrRef(hint.value);
-    if (!ref) continue;
-    const target = `${ref.owner}/${ref.repo}#${ref.number}`;
-    if (seen.has(target)) continue;
-    seen.add(target);
+  for (const w of registered) {
+    if (seen.has(`github:${w.target}`)) continue;
+    seen.add(`github:${w.target}`);
     out.push({
-      id: `github:${slug}:${target}`,
+      id: `github:${slug}:${w.target}`,
       kind: "github",
-      target,
+      target: w.target,
       state: "armed",
-      // When the worker PARKED — which is what the strip's duration should count from, and what the
-      // watcher's own activity baseline is keyed on. Falls back to the thread's last activity when the
-      // fold has no instant for the fence.
-      createdAt: fenceAt ?? tele.lastAssistantAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      createdAt: w.createdAt,
+      // Absent until the poller's first successful read. The card says "checking…" then, rather than
+      // inventing a verdict — an unpolled PR and a PR with no CI are different facts.
+      ...github[w.target] ? { github: github[w.target] } : {}
     });
   }
+  if (tele?.lastFence?.kind !== "awaiting") return out;
+  const createdAt = fenceAt ?? tele.lastAssistantAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  for (const hint of tele.lastFence.hints) {
+    if (hint.kind !== "shell" && hint.kind !== "agent") continue;
+    const target = hint.value.trim();
+    if (!target || seen.has(`shell:${target}`) || !liveWaitHandles(tele).has(target)) continue;
+    seen.add(`shell:${target}`);
+    out.push({ id: `shell:${slug}:${target}`, kind: "shell", target, state: "armed", createdAt });
+  }
   return out;
 }
 function hasFreshDelivery(row, processGone) {
   if (processGone) return false;
   return parseDeliveryLedger(row.delivery_ledger).some((d) => d.state === "pending" || d.state === "enqueued");
 }
-function deriveNeedsYou(row, tele, runtime, hasActionableInteraction = false, nowMs = Date.now(), limitPause = void 0, excuseLiveOwnWork = true, deliveryProcessGone = false) {
+function deriveNeedsYou(row, tele, runtime, hasActionableInteraction = false, nowMs = Date.now(), limitPause = void 0, excuseLiveOwnWork = true, deliveryProcessGone = false, github = {}, registeredPrWatches = /* @__PURE__ */ new Set()) {
   if (futureSnooze(row, nowMs)) return false;
   if (hasActionableInteraction) return true;
   if (runtime === "perm-prompt") return true;
@@ -27630,15 +28153,17 @@ function deriveNeedsYou(row, tele, runtime, hasActionableInteraction = false, no
   if (hasParkedExternalWait(tele, nowMs)) return false;
   if (limitPause?.autoResume) return false;
   if (excuseLiveOwnWork && runtime !== "exited" && hasLiveBackgroundWork(tele) && !tele?.lastFence) return false;
+  if (excuseLiveOwnWork && runtime !== "exited" && hasDeclaredBackgroundPark(tele, nowMs)) return false;
+  if (excuseLiveOwnWork && runtime !== "exited" && heldByRunningChecks(tele, github, registeredPrWatches)) return false;
   if (runtime !== "exited" && hasLiveOwnWork(tele) && tele?.lastFence?.kind !== "done") return !bgSnoozeArmed(row);
   if (tele?.lastFence?.kind === "done") return true;
   return true;
 }
-function deriveAwaitingBackground(row, tele, runtime, hasActionableInteraction = false, nowMs = Date.now(), limitPause = void 0, deliveryProcessGone = false) {
-  if (runtime !== "turn-idle" || !hasLiveOwnWork(tele)) return false;
+function deriveAwaitingBackground(row, tele, runtime, hasActionableInteraction = false, nowMs = Date.now(), limitPause = void 0, deliveryProcessGone = false, github = {}, registeredPrWatches = /* @__PURE__ */ new Set()) {
+  if (runtime !== "turn-idle" || !hasDeclaredWait(tele, nowMs)) return false;
   if (hasActionableInteraction || tele?.pendingAsk || tele?.nativeInputRequired || tele?.pendingQuestion) return false;
   if (tele?.lastFence?.kind === "done") return false;
-  if (tele?.lastFence?.kind === "awaiting" && !hasParkedPrWatch(tele)) return false;
+  if (tele?.lastFence?.kind === "awaiting" && !hasParkedPrWatch(tele) && !hasDeclaredBackgroundPark(tele, nowMs)) return false;
   return deriveNeedsYou({ ...row, bg_snooze_rested_at: null }, tele, runtime, hasActionableInteraction, nowMs, limitPause, false, deliveryProcessGone);
 }
 function resolveSessionProfile(row, tele) {
@@ -27683,7 +28208,6 @@ function resolveRecurringPrompt(row) {
     stopHook: row.recurring_on_rest === 1,
     heartbeat: row.recurring_on_schedule === 1,
     postCompaction: row.recurring_on_compact === 1,
-    pauseOnQuestions: row.recurring_pause_on_questions === 1,
     // Carried whenever a cadence has ever been chosen, INCLUDING while the heartbeat is off — the
     // minutes field has to read back what switching it on again would use.
     intervalSeconds: row.recurring_interval_ms ? Math.round(row.recurring_interval_ms / 1e3) : void 0,
@@ -27717,7 +28241,12 @@ function resolveSessionTitle(row, tele) {
     aiTitle: locked ? void 0 : tele?.aiTitle ?? persisted
   };
 }
-function sessionThreadView(projectDir, storage, row, tele, registeredLegacyTerminal, interactionPresence, nowMs, codexTurnLiveness, claudeBrokerDaemonAlive) {
+function sessionThreadView(projectDir, storage, row, tele, registeredLegacyTerminal, interactionPresence, nowMs, codexTurnLiveness, claudeBrokerDaemonAlive, github = {}) {
+  const armedPrWatches = storage.listPrWatches(row.slug, { armedOnly: true }).map((w) => ({
+    target: `${w.owner}/${w.repo}#${w.number}`,
+    createdAt: new Date(w.created_at).toISOString()
+  }));
+  const registeredPrWatches = new Set(armedPrWatches.map((w) => w.target));
   const headlessStalled = row.codex_runtime === "app-server" ? appServerTurnStalled(codexTurnLiveness(row.slug, row.session_id), tele?.lastActivityAt, nowMs) : isBrokerClaudeRow(row) ? !claudeBrokerDaemonAlive(row.session_id) : false;
   const headlessLostWork = isBrokerClaudeRow(row) && headlessStalled && hasUnretiredOwnAgents(tele);
   const deliveryProcessGone = isBrokerClaudeRow(row) && headlessStalled;
@@ -27728,8 +28257,8 @@ function sessionThreadView(projectDir, storage, row, tele, registeredLegacyTermi
   const state = effectiveSessionState(row, registeredLegacyTerminal);
   const archived = state === "archived";
   const limitPause = resolveLimitPause(row, tele, nowMs);
-  const needsYou = archived ? false : deriveNeedsYou(row, tele, runtime, interactionPresence.needsUser, nowMs, limitPause, true, deliveryProcessGone);
-  const awaitingBackground = archived ? false : deriveAwaitingBackground(row, tele, runtime, interactionPresence.needsUser, nowMs, limitPause, deliveryProcessGone);
+  const needsYou = archived ? false : deriveNeedsYou(row, tele, runtime, interactionPresence.needsUser, nowMs, limitPause, true, deliveryProcessGone, github, registeredPrWatches);
+  const awaitingBackground = archived ? false : deriveAwaitingBackground(row, tele, runtime, interactionPresence.needsUser, nowMs, limitPause, deliveryProcessGone, github, registeredPrWatches);
   const crashed = runtime === "exited" && (tele?.turn === "in-flight" || hasLiveBackgroundWork(tele) || headlessLostWork);
   const snoozedUntil = futureSnooze(row, nowMs);
   const profile = resolveSessionProfile(row, tele);
@@ -27761,20 +28290,11 @@ function sessionThreadView(projectDir, storage, row, tele, registeredLegacyTermi
     lastAssistantAt: tele?.lastAssistantAt,
     subAgents: stampStoppable(tele?.subAgents ?? [], row),
     bgShells: stampStoppableShells(tele?.bgShells ?? [], row),
-    // TWO SOURCES, one list. A `shell` watch is a REGISTRATION the worker made by tool call, read from
-    // the registry — the whole point of moving that kind of wait out of the fence. A `github` watch has
-    // no row and never will (`f366e2d`); it is derived from the standing fence, so that the strip lists
-    // every wait the thread actually has out rather than only the ones with a table behind them.
-    watches: [
-      ...storage.listThreadWatches(row.slug, { armedOnly: true }).map((w) => ({
-        id: w.id,
-        kind: w.kind,
-        target: w.target,
-        state: w.state,
-        createdAt: new Date(w.created_at).toISOString()
-      })),
-      ...githubWatchViews(row.slug, tele, tele?.lastAssistantAt)
-    ],
+    // ONE SOURCE: the FENCE. Both kinds are derived from what the worker wrote — `pr-watch:` lines
+    // become the github rows, `watch:` lines the shell rows — so this strip lists exactly what will
+    // actually wake the thread, and the two cannot drift into claiming different things. There is no
+    // registry behind either any more (`thread_watch`, retired 2026-08-14).
+    watches: fenceWatchViews(row.slug, tele, tele?.lastAssistantAt, github, armedPrWatches),
     pendingAsk: tele?.pendingAsk ? { questions: tele.pendingAsk.questions } : void 0,
     nativeInputRequired: tele?.nativeInputRequired,
     pendingQuestion: tele?.pendingQuestion ?? false,
@@ -27795,6 +28315,10 @@ function sessionThreadView(projectDir, storage, row, tele, registeredLegacyTermi
     // Only meaningful while the snooze is still pending — a prompt without a live deadline is an
     // already-delivered (or superseded) bump the row has not been swept clean of yet.
     snoozePrompt: snoozedUntil ? row.snooze_prompt ?? void 0 : void 0,
+    // The event-snooze, as a fact the CHAT can read. `awaitingBackground` still ignores it — that flag
+    // states whether the thread is waiting, which the snooze does not change — so the suppression is a
+    // presentation rule the client applies, not a second opinion about the thread's state.
+    bgSnoozed: bgSnoozeArmed(row) || void 0,
     claudeRuntime: row.claude_runtime === "broker" ? "broker" : row.claude_runtime === "tmux" ? "tmux" : void 0,
     // The recurring prompt — the same projection the worker's own `action: "get"` reads back.
     recurringPrompt: resolveRecurringPrompt(row),
@@ -27881,6 +28405,7 @@ function createBoard(project, storage, bus, tailer, bootId, deps = {}) {
   let plansCache = [];
   function buildSessionThreads(nowMs) {
     const rows = storage.allSessions().filter((row) => ThreadSlug.safeParse(row.slug).success);
+    const github = readGithubStatusBook(storage.getSetting(GITHUB_STATUS_SETTING));
     const currentInteractionKeys = /* @__PURE__ */ new Set();
     const out = [];
     for (const row of rows) {
@@ -27916,7 +28441,8 @@ function createBoard(project, storage, bus, tailer, bootId, deps = {}) {
         interactionPresence,
         nowMs,
         codexTurnLiveness,
-        claudeBrokerDaemonAlive
+        claudeBrokerDaemonAlive,
+        github
       ));
     }
     for (const key of pendingInteractionCache.keys()) {
@@ -27932,7 +28458,9 @@ function createBoard(project, storage, bus, tailer, bootId, deps = {}) {
       projectName: project.name,
       projectLabel: project.label,
       ...project.githubRepo ? { githubRepo: project.githubRepo } : {},
-      projectSlug: findByPath(project.dir)?.slug
+      projectSlug: findByPath(project.dir)?.slug,
+      // So the client can expand a `~` a worker wrote in prose (see BoardSnapshot.homeDir).
+      homeDir: homedir12()
     };
     const sessionThreads = buildSessionThreads(assembledAtMs);
     armSnoozeWake(sessionThreads, assembledAtMs);
@@ -28113,7 +28641,7 @@ function createBoard(project, storage, bus, tailer, bootId, deps = {}) {
     }
   };
 }
-var DEBOUNCE_MS, RECONCILE_MS, STALL_GRACE_MS, LINE_CAP;
+var DEBOUNCE_MS, RECONCILE_MS, STALL_GRACE_MS, LINE_CAP, DECLARED_PARK_MAX_MS;
 var init_board = __esm({
   "packages/server/src/board.ts"() {
     "use strict";
@@ -28134,6 +28662,7 @@ var init_board = __esm({
     RECONCILE_MS = 15e3;
     STALL_GRACE_MS = 3e4;
     LINE_CAP = 240;
+    DECLARED_PARK_MAX_MS = 24 * 60 * 60 * 1e3;
   }
 });
 
@@ -28641,6 +29170,17 @@ var init_github_review = __esm({
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
 import { createHash as createHash14, randomUUID as randomUUID14 } from "node:crypto";
+function failureSignature(rollup) {
+  const ids = [];
+  for (const c of Array.isArray(rollup) ? rollup : []) {
+    if (!c || typeof c !== "object") continue;
+    if (!rollupEntryFailed(typeof c.conclusion === "string" ? c.conclusion : void 0, typeof c.state === "string" ? c.state : void 0)) continue;
+    const label = c.name ?? c.context ?? c.workflowName ?? "?";
+    ids.push(`${label}@${c.detailsUrl ?? c.targetUrl ?? c.completedAt ?? ""}`);
+  }
+  if (ids.length === 0) return "";
+  return createHash14("sha1").update(ids.sort().join("\n")).digest("hex").slice(0, 12);
+}
 function parsePrRef2(value) {
   const m = value.trim().match(PR_REF_RE2);
   if (!m) return void 0;
@@ -28652,7 +29192,7 @@ function refKey2(r) {
   return `${r.owner}/${r.repo}#${r.number}`;
 }
 function ghPrViewArgs(ref) {
-  return ["pr", "view", String(ref.number), "--repo", `${ref.owner}/${ref.repo}`, "--json", "state,mergedAt,statusCheckRollup,headRefOid"];
+  return ["pr", "view", String(ref.number), "--repo", `${ref.owner}/${ref.repo}`, "--json", "state,mergedAt,statusCheckRollup,headRefOid,mergeable,reviewDecision"];
 }
 function latestWorkflowRuns(runs) {
   const latest = /* @__PURE__ */ new Map();
@@ -28708,12 +29248,40 @@ function failedCheckNames(rollup, runs = [], cap = 8) {
   }
   return { names: names.slice(0, cap), omitted: Math.max(0, names.length - cap) };
 }
-function isPrWatchHint(kind) {
-  return kind === "pr-watch";
+function githubWatchStatus(pr, polledAt) {
+  const entries = Array.isArray(pr.rollup) ? pr.rollup.filter((c) => c && typeof c === "object") : [];
+  let running = 0;
+  let passed = 0;
+  let failed = 0;
+  for (const c of entries) {
+    const status = typeof c.status === "string" ? c.status : void 0;
+    const state2 = typeof c.state === "string" ? c.state : void 0;
+    const conclusion = typeof c.conclusion === "string" ? c.conclusion : void 0;
+    const terminal = status ? status === "COMPLETED" : state2 ? state2 !== "PENDING" && state2 !== "EXPECTED" : false;
+    if (!terminal) running++;
+    else if (rollupEntryFailed(conclusion, state2)) failed++;
+    else passed++;
+  }
+  const state = pr.state === "MERGED" ? "merged" : pr.state === "CLOSED" ? "closed" : "open";
+  const checks = entries.length === 0 ? "none" : failed > 0 ? "failing" : running > 0 ? "running" : "passing";
+  const merge = pr.mergeable === "CONFLICTING" ? "conflicting" : pr.mergeable !== "MERGEABLE" ? "unknown" : checks === "failing" || pr.reviewDecision === "CHANGES_REQUESTED" || pr.reviewDecision === "REVIEW_REQUIRED" ? "blocked" : "mergeable";
+  return {
+    checks,
+    running,
+    passed,
+    failed,
+    failing: failedCheckNames(entries, pr.workflowRuns ?? []).names,
+    merge,
+    state,
+    polledAt,
+    head: pr.head,
+    failureSig: failureSignature(entries)
+  };
+}
+function isPrWatchHint(_kind) {
+  return false;
 }
-function isActionable(hint) {
-  if (hint.kind === "timer") return isValidAwaitingTimer(hint.value);
-  if (isPrWatchHint(hint.kind) || hint.kind === "pr" || hint.kind === "ci") return parsePrRef2(hint.value) !== void 0;
+function isActionable(_hint) {
   return false;
 }
 function fenceIdentity(hints, fenceAt) {
@@ -28763,20 +29331,28 @@ function isHeartbeatFenceId(fenceId) {
 function saidDone(tele) {
   return tele.lastFence?.kind === "done" || tele.lastAssistantAllDone === true;
 }
-function restMessageIsSignedOff(tele) {
-  return tele.pendingQuestion === true || saidDone(tele) || parkedOnAWaitItCannotAdvance(tele);
+function armedTimerIdsOf(storage, slug) {
+  return new Set(storage.listThreadTimers(slug, { armedOnly: true }).map((t) => t.id));
 }
-function parkedOnAWaitItCannotAdvance(tele) {
-  const fence = tele.lastFence;
-  if (fence?.kind !== "awaiting") return false;
-  return fence.hints.some((h) => isActionable(h) || h.kind === "human");
+function restMessageIsSignedOff(tele, _registeredPrWatches = /* @__PURE__ */ new Set(), _armedTimerIds = /* @__PURE__ */ new Set()) {
+  if (tele.lastFence?.kind === "awaiting") return true;
+  return saidDone(tele);
 }
-function blockedOnHuman(tele) {
-  return tele.pendingQuestion === true || tele.pendingAsk !== void 0 || tele.permPrompt === true || tele.nativeInputRequired !== void 0;
+function liveActivityOf(tele, registeredPrWatches, armedTimerIds) {
+  const shells = /* @__PURE__ */ new Set();
+  for (const sh of tele.bgShells ?? []) {
+    if (sh.state !== "running") continue;
+    for (const h of [sh.taskId, sh.id, sh.label]) if (h) shells.add(h);
+  }
+  const agents = /* @__PURE__ */ new Set();
+  for (const a of tele.subAgents ?? []) {
+    if (a.state !== "running") continue;
+    for (const h of [a.id, a.label]) if (h) agents.add(h);
+  }
+  return { shells, agents, timers: armedTimerIds, prs: registeredPrWatches };
 }
-function heldByQuestion(row, tele) {
-  if (row.recurring_pause_on_questions !== 1) return false;
-  return tele !== void 0 && blockedOnHuman(tele);
+function registeredPrWatchesOf(storage, slug) {
+  return new Set(storage.listPrWatches(slug, { armedOnly: true }).map((w) => `${w.owner}/${w.repo}#${w.number}`));
 }
 function armedSchedule(row) {
   const prompt = row.recurring_prompt?.trim();
@@ -28814,20 +29390,36 @@ function armedCompact(row) {
   if (row.recurring_on_compact !== 1) return void 0;
   return { prompt, armedAt };
 }
+function shellFenceId(toolUseId) {
+  return `${SHELL_FENCE_PREFIX}:${toolUseId}`;
+}
+function isShellFenceId(fenceId) {
+  return fenceId.startsWith(`${SHELL_FENCE_PREFIX}:`);
+}
+function prWatchFenceId(watchId, report) {
+  return `${PR_WATCH_FENCE_PREFIX}:${watchId}:${report}`;
+}
+function prWatchExpiredFenceId(watchId) {
+  return `${PR_WATCH_EXPIRED_FENCE_PREFIX}:${watchId}`;
+}
+function isPrWatchFenceId(fenceId) {
+  return fenceId.startsWith(`${PR_WATCH_FENCE_PREFIX}:`) || fenceId.startsWith(`${PR_WATCH_EXPIRED_FENCE_PREFIX}:`);
+}
 function signoffFenceId(restedAt) {
   return `${SIGNOFF_FENCE_PREFIX}:${restedAt}`;
 }
 function isSignoffFenceId(fenceId) {
   return fenceId.startsWith(`${SIGNOFF_FENCE_PREFIX}:`);
 }
-function watchFenceId(watchId) {
-  return `${WATCH_FENCE_PREFIX}:${watchId}`;
+function parkFenceId(cause, spokeAt) {
+  return `${PARK_FENCE_PREFIX}:${cause}:${spokeAt}`;
 }
-function isWatchFenceId(fenceId) {
-  return fenceId.startsWith(`${WATCH_FENCE_PREFIX}:`);
+function isParkFenceId(fenceId) {
+  return fenceId.startsWith(`${PARK_FENCE_PREFIX}:`);
 }
-function watchIdOf(fenceId) {
-  return fenceId.slice(WATCH_FENCE_PREFIX.length + 1);
+function parkFenceRestOf(fenceId) {
+  const cut = fenceId.indexOf(":", PARK_FENCE_PREFIX.length + 1);
+  return cut < 0 ? "" : fenceId.slice(cut + 1);
 }
 function timerFenceId(timerId) {
   return `${TIMER_FENCE_PREFIX}:${timerId}`;
@@ -28839,12 +29431,6 @@ function timerIdOf(fenceId) {
   return fenceId.slice(TIMER_FENCE_PREFIX.length + 1);
 }
 function evalHint(hint, nowMs, prCache, fenceBody) {
-  if (hint.kind === "timer") {
-    const target = Date.parse(hint.value);
-    if (!isValidAwaitingTimer(hint.value) || !Number.isFinite(target)) return void 0;
-    const desc = fenceBody.trim().replace(/\s+/g, " ").slice(0, 200);
-    return { met: nowMs >= target, steer: `\u23F0 Your timer fired${desc ? `: ${desc}` : ""}. Continue.`, reason: `timer ${hint.value}` };
-  }
   if (isPrWatchHint(hint.kind)) return void 0;
   const ref = parsePrRef2(hint.value);
   if (!ref) return void 0;
@@ -28895,6 +29481,9 @@ async function defaultFetchPr(ref) {
       state: j.state,
       mergedAt: typeof j.mergedAt === "string" ? j.mergedAt : null,
       rollup: Array.isArray(j.statusCheckRollup) ? j.statusCheckRollup : [],
+      head: j.headRefOid,
+      mergeable: typeof j.mergeable === "string" ? j.mergeable : void 0,
+      reviewDecision: typeof j.reviewDecision === "string" ? j.reviewDecision : void 0,
       workflowRuns
     };
   } catch {
@@ -28937,6 +29526,14 @@ function createScheduler(deps) {
   let timer = null;
   let activeTick = null;
   let stopped = false;
+  function publishGithubStatus(key, pr, nowMs) {
+    const raw2 = deps.storage.getSetting(GITHUB_STATUS_SETTING);
+    const book = raw2 && typeof raw2 === "object" && !Array.isArray(raw2) ? { ...raw2 } : {};
+    book[key] = githubWatchStatus(pr, new Date(nowMs).toISOString());
+    const keys = Object.keys(book);
+    for (const stale of keys.slice(0, Math.max(0, keys.length - GITHUB_STATUS_CAP))) delete book[stale];
+    deps.storage.setSetting(GITHUB_STATUS_SETTING, book);
+  }
   function loadFired() {
     const raw2 = deps.storage.getSetting("waker.fired");
     return Array.isArray(raw2) ? raw2.filter((x) => typeof x === "string") : [];
@@ -29067,6 +29664,12 @@ function createScheduler(deps) {
       if (!fault || limitFenceId(fault) !== item.fenceId) return "superseded";
       return tele.turn === "idle" ? "current-idle" : "current-busy";
     }
+    if (isShellFenceId(item.fenceId)) {
+      return tele.turn === "idle" ? "current-idle" : "current-busy";
+    }
+    if (isPrWatchFenceId(item.fenceId)) {
+      return tele.turn === "idle" ? "current-idle" : "current-busy";
+    }
     if (isSnoozeFenceId(item.fenceId)) {
       if (armedSnooze(row)?.fenceId !== item.fenceId) return "superseded";
       return tele.turn === "idle" ? "current-idle" : "current-busy";
@@ -29079,7 +29682,7 @@ function createScheduler(deps) {
     if (isStopHookFenceId(item.fenceId)) {
       const armed = armedRest(row);
       if (!armed || item.fenceId !== stopHookFenceId(armed.armedAt, tele.lastAssistantAt ?? "")) return "superseded";
-      if (restMessageIsSignedOff(tele)) return "superseded";
+      if (restMessageIsSignedOff(tele, registeredPrWatchesOf(deps.storage, item.slug), armedTimerIdsOf(deps.storage, item.slug))) return "superseded";
       return tele.turn === "idle" ? "current-idle" : "current-busy";
     }
     if (isCompactFenceId(item.fenceId)) {
@@ -29096,15 +29699,19 @@ function createScheduler(deps) {
       if (tele.lastFence || tele.pendingQuestion) return "superseded";
       return tele.turn === "idle" ? "current-idle" : "current-busy";
     }
-    if (isWatchFenceId(item.fenceId)) {
-      if (deps.storage.getThreadWatch(watchIdOf(item.fenceId))?.state !== "armed") return "superseded";
-      return tele.turn === "idle" ? "current-idle" : "current-busy";
-    }
     if (isReportFenceId(item.fenceId)) {
       const stillMissing = tele.droppedReports?.some((r) => reportFenceId(r.taskId) === item.fenceId);
       if (!stillMissing) return "superseded";
       return tele.turn === "idle" ? "current-idle" : "current-busy";
     }
+    if (isParkFenceId(item.fenceId)) {
+      if (parkFenceRestOf(item.fenceId) !== (tele.lastAssistantAt ?? "")) return "superseded";
+      return tele.turn === "idle" ? "current-idle" : "current-busy";
+    }
+    if (!item.fenceId.includes("
")) {
+      log3(`waker: UNROUTED wake prefix ${item.fenceId.split(":")[0]} for ${item.slug} \u2014 no deliveryContext branch, superseding`);
+      return "superseded";
+    }
     const fence = tele.lastFence;
     if (!fence || fence.kind !== "awaiting" || !fence.hints.some(isActionable)) return "superseded";
     if (fenceIdentity(fence.hints, tele.lastActivityAt) !== item.fenceId) return "superseded";
@@ -29246,26 +29853,30 @@ function createScheduler(deps) {
     const deliveryId = wakeDeliveryId(slug, sessionId, fenceId);
     if (outbox.get(deliveryId)) st.fired = true;
     if (st.fired) return;
-    const needsPr = actionable.some((h) => h.kind === "pr" || h.kind === "ci");
+    const needsPr = false;
     const needsReview = actionable.some((h) => isPrWatchHint(h.kind));
     if ((needsPr || needsReview) && (st.lastPollAt === 0 || nowMs - st.lastPollAt >= pollMs)) {
       st.lastPollAt = nowMs;
       const refs = /* @__PURE__ */ new Map();
       const reviewRefs = /* @__PURE__ */ new Map();
+      const verdictRefs = /* @__PURE__ */ new Set();
       for (const h of actionable) {
         const ref = parsePrRef2(h.value);
         if (!ref) continue;
-        if (h.kind === "pr" || h.kind === "ci") refs.set(refKey2(ref), ref);
         if (isPrWatchHint(h.kind)) reviewRefs.set(refKey2(ref), ref);
       }
       await Promise.all([
         ...[...refs].map(async ([k, ref]) => {
           try {
             const s = await fetchPr(ref);
-            if (s) st.prCache.set(k, s);
-            else log3(`waker: gh check skipped for ${k} (${slug}) \u2014 gh unavailable / not authed / rate-limited`);
+            if (s) {
+              st.prCache.set(k, s);
+              publishGithubStatus(k, s, nowMs);
+            } else if (verdictRefs.has(k)) {
+              log3(`waker: gh check skipped for ${k} (${slug}) \u2014 gh unavailable / not authed / rate-limited`);
+            }
           } catch (err) {
-            log3(`waker: gh check errored for ${k} (${slug}): ${err instanceof Error ? err.message : String(err)}`);
+            if (verdictRefs.has(k)) log3(`waker: gh check errored for ${k} (${slug}): ${err instanceof Error ? err.message : String(err)}`);
           }
         }),
         ...[...reviewRefs].map(async ([k, ref]) => {
@@ -29451,7 +30062,19 @@ function createScheduler(deps) {
         sessionId: row.session_id,
         fenceId,
         hintKey: SIGNOFF_HINT_KEY,
-        message: SIGNOFF_NUDGE_MESSAGE,
+        // The reminder plus THIS THREAD's live ops and their ids, so the agent can write a correct
+        // `watch:` line without going looking for an id it cannot see. Shells are named by `taskId` —
+        // the handle the runtime actually showed the worker — because that is the string it will
+        // naturally reach for, and the one the fence's own integrity check matches on.
+        message: signoffNudgeMessage({
+          shells: (tele.bgShells ?? []).filter((sh) => sh.state === "running").map((sh) => ({ id: sh.taskId ?? sh.id, label: sh.label })),
+          subAgents: (tele.subAgents ?? []).filter((a) => a.state === "running").map((a) => ({ id: a.id, label: a.label })),
+          // The other two registries, so the nudge lists EVERY kind an awaiting fence can name rather
+          // than the two the fold happens to know about — a worker told about half its work writes half
+          // a fence, and the half it left out is not what gets it bumped.
+          timers: deps.storage.listThreadTimers(row.slug, { armedOnly: true }).map((t) => ({ id: t.id, label: t.prompt.trim().replace(/\s+/g, " ").slice(0, 80) })),
+          prs: deps.storage.listPrWatches(row.slug, { armedOnly: true }).map((w) => ({ id: `${w.owner}/${w.repo}#${w.number}`, label: `${w.owner}/${w.repo}#${w.number}` }))
+        }),
         reason: "rested without signing off"
       }, nowMs).delivery;
       log3(`waker: queued ${row.slug} \u2014 ${item.reason}`);
@@ -29462,27 +30085,99 @@ function createScheduler(deps) {
     if (!isSignoffFenceId(item.fenceId)) return;
     deps.storage.countSignoffNudge(item.slug, item.fenceId);
   }
-  function evalWatchers(nowMs) {
-    for (const watch of deps.storage.armedThreadWatches()) {
-      if (watch.kind !== "shell") continue;
-      const row = deps.storage.getSession(watch.thread_slug);
-      if (!row || row.state === "archived" || row.archived === 1) continue;
+  function evalParkIntegrity(nowMs) {
+    for (const row of deps.storage.allSessions()) {
+      if (row.state === "archived" || row.archived === 1) continue;
       const tele = deps.tailer.get(row.slug);
-      if (!tele) continue;
-      const live = tele.bgShells.some(
-        (sh) => sh.state === "running" && (sh.id === watch.target || sh.label === watch.target)
+      if (!tele || tele.turn !== "idle") continue;
+      if (tele.lastFence?.kind !== "awaiting") continue;
+      const spokeAt = tele.lastAssistantAt;
+      if (!spokeAt) continue;
+      if (tele.lastUserAt && Date.parse(tele.lastUserAt) >= Date.parse(spokeAt)) continue;
+      if (tele.authFault) continue;
+      const park = readAwaitingPark(tele.lastFence.hints);
+      const live = liveActivityOf(
+        tele,
+        registeredPrWatchesOf(deps.storage, row.slug),
+        armedTimerIdsOf(deps.storage, row.slug)
       );
-      if (live) {
-        if (watch.cursor !== SHELL_SEEN) deps.storage.setThreadWatchCursor(watch.id, SHELL_SEEN);
-        continue;
-      }
-      if (watch.cursor !== SHELL_SEEN) continue;
-      if (watch.foreground === 1) {
-        deps.storage.markThreadWatchFired(watch.id, nowMs);
-        log3(`waker: settled ${row.slug} \u2014 foreground watcher ${watch.id} resolved (shell ${watch.target})`);
-        continue;
-      }
-      const fenceId = watchFenceId(watch.id);
+      const dead = unaccountedItems(park.items, live);
+      const expiresAt = parkExpiresAt(park, Date.parse(spokeAt));
+      const expired = expiresAt !== null && nowMs >= expiresAt;
+      const nameless = park.items.length === 0;
+      if (parkIsHonoured(park, live) && (row.park_bumps ?? 0) > 0) deps.storage.resetParkBumps(row.slug);
+      if (dead.length === 0 && !expired && !nameless) continue;
+      if (park.forMs === null && !nameless) continue;
+      const status = park.items.map((i) => {
+        const gone = dead.some((d) => d.kind === i.kind && d.value === i.value);
+        return `- \`${i.kind}: ${i.value}\` \u2014 ${gone ? "NOT RUNNING" : "still running"}`;
+      });
+      const retired = retiredAwaitingKindsIn(tele.lastFence.body ?? "");
+      const head = retired.length > 0 ? [
+        `\u26D4 Your \`\`\`awaiting fence uses ${retired.length === 1 ? "a line kind" : "line kinds"} that no longer exist, so frizz ignored ${retired.length === 1 ? "it" : "them"} \u2014 the`,
+        "fence named nothing and your thread stayed in the queue.",
+        "",
+        ...retired.map((k) => `- \`${k}:\` is GONE \u2192 ${RETIRED_AWAITING_REPLACEMENT[k]}`),
+        "",
+        "THE ONLY LINE KINDS NOW SUPPORTED, and every one is checked against something frizz can see:",
+        "",
+        "  shell: <runtime task id>    a background shell you launched",
+        "  agent: <runtime agent id>   a sub-agent you dispatched",
+        "  timer: tmr_\u2026                a timer from `mcp__frizz__timer`",
+        "  pr:    owner/repo#123       a PR registered with `mcp__frizz__watch_pr`",
+        "  for:   2h                   REQUIRED \u2014 a DURATION, never an instant",
+        "  reason: one line            the only prose",
+        "",
+        "`mcp__frizz__activity` lists everything you have running with the exact id each line needs.",
+        "If you are not waiting on anything, you are not awaiting \u2014 end with ```done, or ask a ```question."
+      ].join("\n") : nameless ? [
+        "\u26A0\uFE0F Your ```awaiting fence names nothing to wait on, so it is not a park \u2014 your thread is still",
+        "in the queue, and nothing will wake you.",
+        "",
+        "A wait has to be something frizz can SEE. Register one, then name it:",
+        "",
+        "- a pull request \u2192 `mcp__frizz__watch_pr` (it wakes you on CI going green or red, and on every",
+        "  later review and comment) \u2192 `pr: owner/repo#123`",
+        "- a wall-clock check \u2192 `mcp__frizz__timer` \u2192 `timer: tmr_\u2026`",
+        "- work you already launched \u2192 `shell: <the id your runtime gave you>` or `agent: <id>`",
+        "",
+        "Use `mcp__frizz__activity` to read back everything you have running, with the exact id each",
+        "line needs.",
+        "",
+        "AND IF YOU ARE NOT WAITING ON ANYTHING, you are not awaiting \u2014 you are done. End with ```done,",
+        "or ask a ```question if you need the human."
+      ].join("\n") : expired ? [
+        "\u23F0 Your wait expired, nothing resolved. Check back in on everything.",
+        "",
+        ...status,
+        "",
+        "Re-park if they are genuinely still going \u2014 there is no limit on that, and a long job is not a",
+        "failure. If something is finished, read its result. If nothing is left, end in ```done or ask a",
+        "```question."
+      ].join("\n") : [
+        `\u26A0\uFE0F Your \`\`\`awaiting fence names ${dead.length === 1 ? "something that is" : "things that are"} not running, so it is not a park and your thread stayed in the queue.`,
+        "",
+        ...status,
+        "",
+        "Use `mcp__frizz__activity` to read back what you actually have out, with the exact id each line",
+        "needs, then re-fence naming only those \u2014 or end in ```done or a ```question if there is nothing",
+        "left to wait for."
+      ].join("\n");
+      const cause = retired.length > 0 ? "retired" : nameless ? "nameless" : expired ? "expired" : "dead";
+      const ops = cause === "expired" ? [] : liveOpsLines({
+        shells: (tele.bgShells ?? []).filter((sh) => sh.state === "running").map((sh) => ({ id: sh.taskId ?? sh.id, label: sh.label })),
+        subAgents: (tele.subAgents ?? []).filter((a) => a.state === "running").map((a) => ({ id: a.id, label: a.label })),
+        timers: deps.storage.listThreadTimers(row.slug, { armedOnly: true }).map((t) => ({ id: t.id, label: t.prompt.trim().replace(/\s+/g, " ").slice(0, 80) })),
+        prs: deps.storage.listPrWatches(row.slug, { armedOnly: true }).map((w) => ({ id: `${w.owner}/${w.repo}#${w.number}`, label: `${w.owner}/${w.repo}#${w.number}` }))
+      });
+      const message = ops.length > 0 ? `${head}
+${ops.join("\n")}` : cause === "expired" ? head : `${head}
+
+You have NOTHING running right now \u2014 no shell, no sub-agent, no timer, no registered
+pull request. There is nothing that could wake you, so this thread is not awaiting: finish in
+\`\`\`done, or ask a \`\`\`question.`;
+      if (cause !== "expired" && (row.park_bumps ?? 0) >= PARK_BUMP_MAX) continue;
+      const fenceId = parkFenceId(cause, spokeAt);
       const deliveryId = wakeDeliveryId(row.slug, row.session_id, fenceId);
       if (outbox.get(deliveryId)) continue;
       const item = outbox.enqueue({
@@ -29490,17 +30185,199 @@ function createScheduler(deps) {
         slug: row.slug,
         sessionId: row.session_id,
         fenceId,
-        hintKey: `${WATCH_HINT_PREFIX}${watch.id}`,
-        message: watchWakeMessage("shell", watch.target, "The background shell you were waiting on has finished"),
-        reason: `watcher ${watch.id} resolved (shell ${watch.target})`
+        hintKey: fenceId,
+        message,
+        reason: retired.length > 0 ? `awaiting fence uses retired kind(s): ${retired.join(", ")}` : nameless ? "awaiting park names nothing" : expired ? "awaiting park expired" : `awaiting park named ${dead.length} dead item(s)`
       }, nowMs).delivery;
+      if (cause !== "expired") deps.storage.countParkBump(row.slug, fenceId);
       log3(`waker: queued ${row.slug} \u2014 ${item.reason}`);
       checkpoint("after-enqueue", item);
     }
   }
-  function settleWatcher(item) {
-    if (!isWatchFenceId(item.fenceId)) return;
-    deps.storage.markThreadWatchFired(watchIdOf(item.fenceId), now());
+  const prWatchPolledAt = /* @__PURE__ */ new Map();
+  function readPrWatchCursor(raw2) {
+    try {
+      const parsed = raw2 ? JSON.parse(raw2) : null;
+      if (!parsed || typeof parsed !== "object") return { seen: [] };
+      const seen = Array.isArray(parsed.seen) ? parsed.seen.filter((x) => typeof x === "string") : [];
+      return { seen, checks: typeof parsed.checks === "string" ? parsed.checks : void 0, report: Number(parsed.report) || 0 };
+    } catch {
+      return { seen: [] };
+    }
+  }
+  async function evalPrWatches(nowMs) {
+    for (const w of deps.storage.expiredPrWatches(nowMs)) {
+      const row = deps.storage.getSession(w.thread_slug);
+      deps.storage.settlePrWatch(w.id, nowMs);
+      const ref = `${w.owner}/${w.repo}#${w.number}`;
+      log3(`waker: settled ${w.thread_slug} \u2014 pr watcher ${w.id} expired (${ref})`);
+      if (!row || row.state === "archived" || row.archived === 1) continue;
+      const fenceId = prWatchExpiredFenceId(w.id);
+      const deliveryId = wakeDeliveryId(row.slug, row.session_id, fenceId);
+      if (outbox.get(deliveryId)) continue;
+      const item = outbox.enqueue({
+        id: deliveryId,
+        slug: row.slug,
+        sessionId: row.session_id,
+        fenceId,
+        hintKey: fenceId,
+        message: `\u23F0 Your watcher on ${ref} has expired and is no longer armed \u2014 nothing on that PR will wake you now.
+
+If you still care about it, register it again with \`mcp__frizz__watch_pr\` and a fresh \`for:\`. If you do not, and it was the only thing you were waiting on, end in a proper terminal state instead of parking on it again.`,
+        reason: `pr watcher ${w.id} expired (${ref})`
+      }, nowMs).delivery;
+      log3(`waker: queued ${row.slug} \u2014 ${item.reason}`);
+      checkpoint("after-enqueue", item);
+    }
+    const armed = deps.storage.armedPrWatches();
+    if (armed.length === 0) return;
+    const refs = /* @__PURE__ */ new Map();
+    for (const w of armed) {
+      const key = `${w.owner}/${w.repo}#${w.number}`;
+      const last = prWatchPolledAt.get(key) ?? 0;
+      if (nowMs - last < PR_WATCH_POLL_MS) continue;
+      refs.set(key, { owner: w.owner, repo: w.repo, number: w.number });
+    }
+    const status = /* @__PURE__ */ new Map();
+    const activity = /* @__PURE__ */ new Map();
+    await Promise.all([...refs].map(async ([key, ref]) => {
+      prWatchPolledAt.set(key, nowMs);
+      try {
+        const pr = await fetchPr(ref);
+        if (pr) {
+          status.set(key, githubWatchStatus(pr, new Date(nowMs).toISOString()));
+          publishGithubStatus(key, pr, nowMs);
+        }
+      } catch (err) {
+        log3(`waker: pr-watch status fetch failed for ${key}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      try {
+        const result = normalizeReviewResult(await fetchGithubReview(ref));
+        if (result.status === "ok") {
+          activity.set(key, result.activity);
+          recordReviewSuccess(key, "pr-watch registry");
+        } else if (result.status === "error") recordReviewFailure(key, "pr-watch registry", result, nowMs);
+      } catch (err) {
+        recordReviewFailure(key, "pr-watch registry", {
+          status: "error",
+          failure: { kind: "network", message: err instanceof Error ? err.message : String(err) }
+        }, nowMs);
+      }
+    }));
+    for (const w of armed) {
+      const row = deps.storage.getSession(w.thread_slug);
+      if (!row || row.state === "archived" || row.archived === 1) continue;
+      const key = `${w.owner}/${w.repo}#${w.number}`;
+      const st = status.get(key);
+      const acts = activity.get(key);
+      if (!st && !acts) continue;
+      const cursor = readPrWatchCursor(w.cursor);
+      if (st && st.state !== "open") {
+        deps.storage.settlePrWatch(w.id, nowMs);
+        enqueuePrWatchWake(row, w.id, nextReport(cursor), prWatchWakeMessage({
+          target: key,
+          merged: st.state === "merged",
+          closed: st.state === "closed"
+        }), `pr-watch ${key} ${st.state}`, nowMs);
+        continue;
+      }
+      const terminal = st && (st.checks === "passing" || st.checks === "failing") ? st.checks : void 0;
+      const stamp = terminal !== void 0 ? `${st?.head ?? "?"}:${terminal}:${st?.failureSig ?? ""}` : void 0;
+      const checksChanged = stamp !== void 0 && cursor.checks !== stamp;
+      const seen = new Set(cursor.seen);
+      const firstPoll = w.cursor === null;
+      const newestFirst = [...acts ?? []].sort((a, b) => {
+        const at = Date.parse(b.at ?? "") - Date.parse(a.at ?? "");
+        return Number.isFinite(at) && at !== 0 ? at : b.id.localeCompare(a.id);
+      });
+      const fresh = newestFirst.filter((a) => {
+        if (seen.has(a.id)) return false;
+        if (!firstPoll) return true;
+        const landed = Date.parse(a.at ?? "");
+        return Number.isFinite(landed) && landed > w.created_at;
+      });
+      const named = fresh.slice(0, REVIEW_STEER_CAP);
+      const reviewSteer = fresh.length > 0 ? formatGithubWakeSteer({
+        ref: key,
+        omitted: fresh.length - named.length,
+        items: [...named].reverse().map((a) => ({
+          label: activityLabel(a),
+          actor: a.actor,
+          bot: isBotGithubActor(a),
+          ...a.at ? { at: a.at } : {},
+          ...a.url ? { url: a.url } : {}
+        }))
+      }) : void 0;
+      const nextCursor = {
+        seen: acts ? [.../* @__PURE__ */ new Set([...cursor.seen, ...acts.map((a) => a.id)])].slice(-REVIEW_SEEN_CAP) : cursor.seen,
+        // The STAMP, so the next poll compares against the commit as well as the colour.
+        checks: stamp ?? cursor.checks,
+        report: cursor.report ?? 0
+      };
+      if (!checksChanged && !reviewSteer) {
+        if (JSON.stringify(nextCursor) !== JSON.stringify(cursor)) {
+          deps.storage.setPrWatchCursor(w.id, JSON.stringify(nextCursor));
+        }
+        continue;
+      }
+      deps.storage.setSnoozedUntil(row.slug, null);
+      const report = nextReport(cursor);
+      enqueuePrWatchWake(row, w.id, report, prWatchWakeMessage({
+        target: key,
+        ...checksChanged && terminal ? { checks: { verdict: terminal, passed: st.passed, failed: st.failed, failing: st.failing } } : {},
+        ...reviewSteer ? { review: reviewSteer } : {}
+      }), `pr-watch ${key}${checksChanged ? ` CI ${terminal}` : ""}${reviewSteer ? " review" : ""}`, nowMs);
+      deps.storage.setPrWatchCursor(w.id, JSON.stringify({ ...nextCursor, report }));
+    }
+  }
+  function nextReport(cursor) {
+    return (cursor.report ?? 0) + 1;
+  }
+  function enqueuePrWatchWake(row, watchId, report, message, reason, nowMs) {
+    const fenceId = prWatchFenceId(watchId, report);
+    const deliveryId = wakeDeliveryId(row.slug, row.session_id, fenceId);
+    if (outbox.get(deliveryId)) return;
+    const item = outbox.enqueue({
+      id: deliveryId,
+      slug: row.slug,
+      sessionId: row.session_id,
+      fenceId,
+      hintKey: `${PR_WATCH_FENCE_PREFIX}:${watchId}`,
+      message,
+      reason
+    }, nowMs).delivery;
+    log3(`waker: queued ${row.slug} \u2014 ${item.reason}`);
+    checkpoint("after-enqueue", item);
+  }
+  function evalShellCompletions(nowMs) {
+    for (const row of deps.storage.allSessions()) {
+      if (row.state === "archived" || row.archived === 1) continue;
+      const tele = deps.tailer.get(row.slug);
+      if (!tele) continue;
+      if (tele.turn !== "idle") continue;
+      if (tele.authFault) continue;
+      const restedAt = Date.parse(tele.lastAssistantAt ?? "");
+      if (!Number.isFinite(restedAt)) continue;
+      for (const shell of tele.retiredShells ?? []) {
+        const finishedAt = Date.parse(shell.finishedAt ?? "");
+        if (!Number.isFinite(finishedAt) || finishedAt <= restedAt) continue;
+        const fenceId = shellFenceId(shell.id);
+        const deliveryId = wakeDeliveryId(row.slug, row.session_id, fenceId);
+        if (outbox.get(deliveryId)) continue;
+        const item = outbox.enqueue({
+          id: deliveryId,
+          slug: row.slug,
+          sessionId: row.session_id,
+          fenceId,
+          hintKey: `${SHELL_FENCE_PREFIX}:${shell.id}`,
+          message: shellDoneMessage(shell),
+          reason: `background shell finished (${shell.taskId ?? shell.label})`
+        }, nowMs).delivery;
+        log3(`waker: queued ${row.slug} \u2014 ${item.reason}`);
+        checkpoint("after-enqueue", item);
+        return;
+      }
+    }
   }
   function evalTimers(nowMs) {
     for (const timer2 of deps.storage.dueThreadTimers(nowMs)) {
@@ -29534,7 +30411,6 @@ function createScheduler(deps) {
       if (!armed || armed.dueAtMs > nowMs) continue;
       const beatTele = deps.tailer.get(row.slug);
       if (beatTele && saidDone(beatTele)) continue;
-      if (heldByQuestion(row, beatTele)) continue;
       if (openSchedulePrompt(row.slug, row.session_id)) continue;
       const beat = beatIndex(row.recurring_schedule_fired_at ?? null, armed);
       const fenceId = heartbeatFenceId(armed.armedAt, beat);
@@ -29583,8 +30459,7 @@ function createScheduler(deps) {
       if (!restedAt) continue;
       if (tele.lastUserAt && Date.parse(tele.lastUserAt) >= Date.parse(restedAt)) continue;
       if (tele.authFault) continue;
-      if (restMessageIsSignedOff(tele)) continue;
-      if (heldByQuestion(row, tele)) continue;
+      if (restMessageIsSignedOff(tele, registeredPrWatchesOf(deps.storage, row.slug), armedTimerIdsOf(deps.storage, row.slug))) continue;
       const fenceId = stopHookFenceId(armed.armedAt, restedAt);
       const deliveryId = wakeDeliveryId(row.slug, row.session_id, fenceId);
       if (outbox.get(deliveryId)) continue;
@@ -29594,7 +30469,7 @@ function createScheduler(deps) {
         sessionId: row.session_id,
         fenceId,
         hintKey: STOP_HOOK_HINT_KEY,
-        message: restPromptMessage(armed.prompt),
+        message: restPromptMessage(armed.prompt, { overQuestion: tele.pendingQuestion === true }),
         reason: "recurring prompt at rest"
       }, nowMs).delivery;
       log3(`waker: queued ${row.slug} \u2014 ${item.reason}`);
@@ -29609,7 +30484,6 @@ function createScheduler(deps) {
       const tele = deps.tailer.get(row.slug);
       if (!tele?.lastCompactionAt) continue;
       if (tele.lastCompactionAt <= armed.armedAt) continue;
-      if (heldByQuestion(row, tele)) continue;
       const fenceId = compactFenceId(armed.armedAt, tele.lastCompactionAt);
       const deliveryId = wakeDeliveryId(row.slug, row.session_id, fenceId);
       if (outbox.get(deliveryId)) continue;
@@ -29659,7 +30533,6 @@ function createScheduler(deps) {
         settleRestPrompt(item);
         settleCompactPrompt(item);
         settleTimer(item);
-        settleWatcher(item);
         continue;
       }
       if (context === "superseded") {
@@ -29679,7 +30552,6 @@ function createScheduler(deps) {
       if (recovered?.state === "exhausted") {
         settleSnooze(item);
         settleTimer(item);
-        settleWatcher(item);
         log3(`waker: delivery EXHAUSTED for ${item.slug} after ${recovered.attempts} attempts \u2014 ${recovered.lastError ?? "unknown error"}`);
       }
     }
@@ -29698,7 +30570,6 @@ function createScheduler(deps) {
         settleRestPrompt(item);
         settleCompactPrompt(item);
         settleTimer(item);
-        settleWatcher(item);
         continue;
       }
       if (context === "superseded") {
@@ -29726,7 +30597,6 @@ function createScheduler(deps) {
           outbox.supersede(item.id, failedAt, message);
           settleSnooze(item);
           settleTimer(item);
-          settleWatcher(item);
           log3(`waker: delivery ABANDONED for ${item.slug} (terminal, no retry): ${message}`);
           continue;
         }
@@ -29752,7 +30622,6 @@ function createScheduler(deps) {
       settleRestPrompt(item);
       settleCompactPrompt(item);
       settleTimer(item);
-      settleWatcher(item);
       settleSignoffNudge(item);
       const acknowledged = outbox.get(item.id);
       if (acknowledged) checkpoint("after-ack", acknowledged);
@@ -29821,15 +30690,22 @@ function createScheduler(deps) {
     }
     try {
       evalSignoffNudges(now());
+      evalParkIntegrity(now());
     } catch (err) {
       if (err instanceof InjectedSchedulerCrash) throw err;
       log3(`waker: sign-off nudge pass failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     try {
-      evalWatchers(now());
+      await evalPrWatches(now());
+    } catch (err) {
+      if (err instanceof InjectedSchedulerCrash) throw err;
+      log3(`waker: pr-watch registry pass failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    try {
+      evalShellCompletions(now());
     } catch (err) {
       if (err instanceof InjectedSchedulerCrash) throw err;
-      log3(`waker: watcher pass failed: ${err instanceof Error ? err.message : String(err)}`);
+      log3(`waker: shell-completion pass failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     try {
       evalTimers(now());
@@ -29881,11 +30757,12 @@ function createScheduler(deps) {
     tick
   };
 }
-var execFileAsync4, PR_REF_RE2, LIMIT_FENCE_PREFIX, LIMIT_HINT_PREFIX, LIMIT_RESUME_GRACE_MS, LIMIT_RESUME_HEADROOM_PERCENT, LIMIT_HEADROOM_MIN_FAULT_AGE_MS, REPORT_FENCE_PREFIX, REPORT_HINT_PREFIX, SNOOZE_FENCE_PREFIX, SNOOZE_HINT_PREFIX, HEARTBEAT_FENCE_PREFIX, HEARTBEAT_HINT_PREFIX, STOP_HOOK_FENCE_PREFIX, STOP_HOOK_HINT_KEY, COMPACT_FENCE_PREFIX, COMPACT_HINT_KEY, TIMER_FENCE_PREFIX, TIMER_HINT_PREFIX, SIGNOFF_FENCE_PREFIX, SIGNOFF_HINT_KEY, SIGNOFF_NUDGE_MAX, SIGNOFF_NUDGE_SETTING, WATCH_FENCE_PREFIX, WATCH_HINT_PREFIX, SHELL_SEEN, FIRED_CAP, REGISTRATION_CAP, REVIEW_SEEN_CAP, INTRODUCED_CAP, REVIEW_STEER_CAP;
+var execFileAsync4, PR_REF_RE2, LIMIT_FENCE_PREFIX, LIMIT_HINT_PREFIX, LIMIT_RESUME_GRACE_MS, LIMIT_RESUME_HEADROOM_PERCENT, LIMIT_HEADROOM_MIN_FAULT_AGE_MS, REPORT_FENCE_PREFIX, REPORT_HINT_PREFIX, SNOOZE_FENCE_PREFIX, SNOOZE_HINT_PREFIX, HEARTBEAT_FENCE_PREFIX, HEARTBEAT_HINT_PREFIX, STOP_HOOK_FENCE_PREFIX, STOP_HOOK_HINT_KEY, COMPACT_FENCE_PREFIX, COMPACT_HINT_KEY, TIMER_FENCE_PREFIX, TIMER_HINT_PREFIX, SHELL_FENCE_PREFIX, PR_WATCH_FENCE_PREFIX, PR_WATCH_EXPIRED_FENCE_PREFIX, PR_WATCH_POLL_MS, SIGNOFF_FENCE_PREFIX, SIGNOFF_HINT_KEY, SIGNOFF_NUDGE_MAX, PARK_BUMP_MAX, SIGNOFF_NUDGE_SETTING, PARK_FENCE_PREFIX, FIRED_CAP, GITHUB_STATUS_CAP, REGISTRATION_CAP, REVIEW_SEEN_CAP, INTRODUCED_CAP, REVIEW_STEER_CAP;
 var init_scheduler = __esm({
   "packages/server/src/scheduler.ts"() {
     "use strict";
     init_src();
+    init_awaiting();
     init_usage_limit();
     init_wake_store();
     init_shutdown();
@@ -29912,14 +30789,18 @@ var init_scheduler = __esm({
     COMPACT_HINT_KEY = "recurring:compaction";
     TIMER_FENCE_PREFIX = "timer";
     TIMER_HINT_PREFIX = "timer:";
+    SHELL_FENCE_PREFIX = "shell";
+    PR_WATCH_FENCE_PREFIX = "prwatch";
+    PR_WATCH_EXPIRED_FENCE_PREFIX = "prwatch-expired";
+    PR_WATCH_POLL_MS = 6e4;
     SIGNOFF_FENCE_PREFIX = "signoff";
     SIGNOFF_HINT_KEY = "signoff:rest";
     SIGNOFF_NUDGE_MAX = 2;
+    PARK_BUMP_MAX = 3;
     SIGNOFF_NUDGE_SETTING = "signoffNudge";
-    WATCH_FENCE_PREFIX = "watch";
-    WATCH_HINT_PREFIX = "watch:";
-    SHELL_SEEN = "seen";
+    PARK_FENCE_PREFIX = "park";
     FIRED_CAP = 500;
+    GITHUB_STATUS_CAP = 200;
     REGISTRATION_CAP = 500;
     REVIEW_SEEN_CAP = 300;
     INTRODUCED_CAP = 500;
@@ -30628,7 +31509,7 @@ var init_orphan_reaper = __esm({
 // packages/server/src/context.ts
 import { join as join29 } from "node:path";
 import { randomUUID as randomUUID15 } from "node:crypto";
-import { homedir as homedir12 } from "node:os";
+import { homedir as homedir13 } from "node:os";
 function reconcileSessions(storage) {
   for (const row of storage.allSessions()) {
     if (isHeadlessRow(row)) continue;
@@ -30782,7 +31663,7 @@ async function createContext(opts = {}) {
   }
 }
 function createContextUnchecked(opts, resources) {
-  const home = opts.home ?? homedir12();
+  const home = opts.home ?? homedir13();
   const project = opts.project ?? resolveProject();
   const dbPath = join29(project.stateDir, "ui.db");
   const storage = createStorage(dbPath);
@@ -31356,11 +32237,11 @@ var init_url = __esm({
       }
       return null;
     };
-    tryDecode = (str, decoder) => {
+    tryDecode = (str2, decoder) => {
       try {
-        return decoder(str);
+        return decoder(str2);
       } catch {
-        return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match2) => {
+        return str2.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match2) => {
           try {
             return decoder(match2);
           } catch {
@@ -31369,7 +32250,7 @@ var init_url = __esm({
         });
       }
     };
-    tryDecodeURI = (str) => tryDecode(str, decodeURI);
+    tryDecodeURI = (str2) => tryDecode(str2, decodeURI);
     getPath = (request) => {
       const url = request.url;
       const start = url.indexOf("/", url.indexOf(":") + 4);
@@ -31517,7 +32398,7 @@ var init_request = __esm({
     init_constants();
     init_body();
     init_url();
-    tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
+    tryDecodeURIComponent = (str2) => tryDecode(str2, decodeURIComponent_);
     HonoRequest = class {
       /**
        * `.raw` can get the raw Request object.
@@ -31816,27 +32697,27 @@ var init_html = __esm({
       escapedString.callbacks = callbacks;
       return escapedString;
     };
-    resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
-      if (typeof str === "object" && !(str instanceof String)) {
-        if (!(str instanceof Promise)) {
-          str = str.toString();
+    resolveCallback = async (str2, phase, preserveCallbacks, context, buffer) => {
+      if (typeof str2 === "object" && !(str2 instanceof String)) {
+        if (!(str2 instanceof Promise)) {
+          str2 = str2.toString();
         }
-        if (str instanceof Promise) {
-          str = await str;
+        if (str2 instanceof Promise) {
+          str2 = await str2;
         }
       }
-      const callbacks = str.callbacks;
+      const callbacks = str2.callbacks;
       if (!callbacks?.length) {
-        return Promise.resolve(str);
+        return Promise.resolve(str2);
       }
       if (buffer) {
-        buffer[0] += str;
+        buffer[0] += str2;
       } else {
-        buffer = [str];
+        buffer = [str2];
       }
       const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
         (res) => Promise.all(
-          res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
+          res.filter(Boolean).map((str22) => resolveCallback(str22, phase, false, context, buffer))
         ).then(() => buffer[0])
       );
       if (preserveCallbacks) {
@@ -34006,11 +34887,14 @@ import { closeSync as closeSync13, existsSync as existsSync11, fstatSync as fsta
 import { createHash as createHash15 } from "node:crypto";
 import { StringDecoder as StringDecoder4 } from "node:string_decoder";
 import { join as join30 } from "node:path";
-import { homedir as homedir13 } from "node:os";
+import { homedir as homedir14 } from "node:os";
 function isInjectedNoise(text) {
   const t = text.trimStart();
   return NOISE_PREFIXES.some((p) => t.startsWith(p));
 }
+function isInterruptMarker(text) {
+  return INTERRUPT_MARKERS.includes(text.trim());
+}
 function formatTokens(n) {
   if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
   if (n >= 1e3) return `${Math.round(n / 1e3)}k`;
@@ -34141,6 +35025,7 @@ function createTranscriptFold(identityPrefix = "claude") {
   const pendingTools = /* @__PURE__ */ new Map();
   const agentDispatches = /* @__PURE__ */ new Map();
   const backgroundShells = /* @__PURE__ */ new Map();
+  const consumedShells = /* @__PURE__ */ new Map();
   const backgroundTaskIds = /* @__PURE__ */ new Map();
   const relayedWakesDrawn = /* @__PURE__ */ new Set();
   const childDispatchIds = /* @__PURE__ */ new Map();
@@ -34148,9 +35033,11 @@ function createTranscriptFold(identityPrefix = "claude") {
   const queuedPending = [];
   let deliveredDedupe = null;
   let pendingRest = null;
+  const restEpoch = { n: 0 };
   function flushRest() {
     if (!pendingRest) return;
     out.push(restMessage(pendingRest.sourceId, pendingRest.at));
+    restEpoch.n++;
     pendingRest = null;
     lastAssistantId = null;
   }
@@ -34194,7 +35081,7 @@ function createTranscriptFold(identityPrefix = "claude") {
     if (pendingRest && !(rec.type === "assistant" && typeof rec.message?.id === "string" && rec.message.id === pendingRest.msgId)) {
       flushRest();
     }
-    const evs = completionEvents(rec, agentDispatches, backgroundShells, backgroundTaskIds, relayedWakesDrawn);
+    const evs = completionEvents(rec, agentDispatches, backgroundShells, backgroundTaskIds, relayedWakesDrawn, consumedShells, restEpoch);
     let drewEvents = false;
     if (evs.length > 0) {
       attachToolResults(rec, pendingTools, backgroundShells, backgroundTaskIds, childDispatchIds);
@@ -34246,8 +35133,8 @@ function createTranscriptFold(identityPrefix = "claude") {
       }
       const peerOrigin = att.origin?.kind === "peer" ? att.origin : void 0;
       if (peerOrigin && att.commandMode === "prompt") {
-        const str = (v) => typeof v === "string" ? v.trim() : "";
-        const senderTaskId = str(peerOrigin.senderTaskId);
+        const str2 = (v) => typeof v === "string" ? v.trim() : "";
+        const senderTaskId = str2(peerOrigin.senderTaskId);
         const dispatchId = senderTaskId ? childDispatchIds.get(senderTaskId) : void 0;
         const entry = prompt.trim() ? findQueued(prompt) : void 0;
         if (entry) {
@@ -34263,7 +35150,7 @@ function createTranscriptFold(identityPrefix = "claude") {
         } else {
           const parsed = prompt.trim() ? parseAgentMessage(prompt) : void 0;
           const describedHere = dispatchId ? dispatchLabels.get(dispatchId) : void 0;
-          const from = describedHere || str(peerOrigin.from) || str(peerOrigin.name) || parsed?.from || "";
+          const from = describedHere || str2(peerOrigin.from) || str2(peerOrigin.name) || parsed?.from || "";
           const body = parsed?.body ?? (typeof peerOrigin.body === "string" ? peerOrigin.body : "");
           if (from && body.trim()) {
             out.push({
@@ -34307,6 +35194,7 @@ function createTranscriptFold(identityPrefix = "claude") {
       }
       let text = userText(rec);
       if (text && isAllInjectedNoise(text)) return;
+      if (text && isInterruptMarker(text)) return;
       if (text) {
         const queued = findQueued(text)?.message;
         if (queued) {
@@ -34442,9 +35330,14 @@ ${block.text}` : block.text;
   return {
     ingest,
     finalize,
+    // The SAME window the paged reader returns (latestWindowStart), because this is the OTHER producer:
+    // the /ws push renders from here while the RPC page renders from there, and a push whose head sat
+    // further forward than the page's would splice the human's ask straight back out of a card that had
+    // just anchored on it (reconcileLiveMessages replaces the window wholesale).
     messages: () => {
       const all = projected();
-      return all.length > MAX_MESSAGES ? all.slice(-MAX_MESSAGES) : all;
+      const start = latestWindowStart(all);
+      return start === 0 ? all : all.slice(start);
     },
     allMessages: projected,
     consumedBytes: () => offset + Buffer.byteLength(buffer)
@@ -34874,7 +35767,7 @@ function notificationCarrierText(rec) {
   }
   return void 0;
 }
-function completionEvents(rec, dispatches, backgroundShells, backgroundTaskIds, relayedWakesDrawn) {
+function completionEvents(rec, dispatches, backgroundShells, backgroundTaskIds, relayedWakesDrawn, consumedShells = /* @__PURE__ */ new Map(), restEpoch = { n: 0 }) {
   const carrier = notificationCarrierText(rec);
   const raw2 = carrier === void 0 ? void 0 : splitWakeDeliveries(carrier).map((s) => relayNotificationBlock(s) ?? s).join("\n");
   if (!raw2 || !raw2.includes("<task-notification>")) return [];
@@ -34908,10 +35801,17 @@ function completionEvents(rec, dispatches, backgroundShells, backgroundTaskIds,
       if (!d) {
         const shell = backgroundShells.get(id);
         if (!shell) {
+          const drawn = consumedShells.get(id);
+          if (drawn && restEpoch.n > drawn.epoch) {
+            consumedShells.set(id, { epoch: restEpoch.n, call: drawn.call });
+            out.push({ role: "assistant", kind: "event", boundary: "wake", text: backgroundWakeLabel(drawn.call, status, block), tools: [], parts: [], at });
+            continue;
+          }
           relayedFallback();
           continue;
         }
         backgroundShells.delete(id);
+        consumedShells.set(id, { epoch: restEpoch.n, call: shell.call });
         const elapsedMs2 = elapsedBetween(shell.at, rec.timestamp);
         shell.call.status = status === "completed" ? "completed" : status === "killed" ? "cancelled" : "failed";
         if (elapsedMs2 !== void 0) shell.call.durationMs = elapsedMs2;
@@ -35015,7 +35915,7 @@ function verifyIncrementalParse(path, identityPrefix, incremental) {
   }
 }
 function logDirOf(project) {
-  return join30(homedir13(), ".claude", "projects", project.cwdSlug);
+  return join30(homedir14(), ".claude", "projects", project.cwdSlug);
 }
 function resolveTranscriptPath(project, sessionId) {
   const path = join30(logDirOf(project), `${sessionId}.jsonl`);
@@ -35267,8 +36167,30 @@ function parseCodexTranscript(raw2, identityPrefix = "codex") {
   const out = projectCodexTranscript(raw2, identityPrefix);
   return latestTranscriptWindow(out);
 }
+function latestWindowStart(messages) {
+  const tail = Math.max(0, messages.length - MAX_MESSAGES);
+  if (tail === 0) return 0;
+  let boundary = -1;
+  for (let i = tail - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m.role === "user" && !m.wake && !m.queued) {
+      boundary = i;
+      break;
+    }
+  }
+  if (boundary < 0) return tail;
+  let start = tail;
+  let bytes = 0;
+  while (start > boundary && tail - start < LATEST_WINDOW_ASK_REACH_ITEMS) {
+    const nextBytes = messageBytes(messages[start - 1]);
+    if (bytes + nextBytes > LATEST_WINDOW_ASK_REACH_BYTES) break;
+    start--;
+    bytes += nextBytes;
+  }
+  return start === boundary ? start : tail;
+}
 function latestTranscriptWindow(messages) {
-  const start = Math.max(0, messages.length - MAX_MESSAGES);
+  const start = latestWindowStart(messages);
   if (start === 0) return [...messages];
   const pinned = [];
   for (let i = 0; i < start; i++) {
@@ -36161,7 +37083,7 @@ function readLatestThreadTranscriptPage(project, storage, slug, backendFor) {
     }
   }
   const latest = latestTranscriptWindow(projected);
-  const canonicalStart = Math.max(0, projected.length - MAX_MESSAGES);
+  const canonicalStart = latestWindowStart(projected);
   const row = storage.getSession(slug);
   const pageMessages = row ? projectDeliveryLedger(latest, parseDeliveryLedger(row.delivery_ledger)) : latest;
   return {
@@ -36302,7 +37224,7 @@ function readTranscriptFile(absPath) {
     return [];
   }
 }
-var MAX_MESSAGES, NOISE_PREFIXES, REST_LABEL, LEGACY_TASK_MARKER, LEGACY_BANNER_PREAMBLE, COMMAND_NAME_RE, COMMAND_ARGS_RE, PEER_SESSION_PREAMBLE, QUEUED_STALE_MS, EDIT_CAP, TRUNC_MARKER, ENCRYPTED_PAYLOAD, AGENT_PROMPT_CAP, SEND_BODY_CAP, COMMAND_CAP, TOOL_INPUT_CAP, READ_LINE_CAP, READ_BYTE_CAP, IMAGE_MEDIA_EXT, SCREENSHOT_CACHE_DIR, SCREENSHOT_CACHE_MAX, SCREENSHOT_MAX_BASE64, screenshotTmpSeq, SENT_IMAGE_MAX_BYTES, SENT_FILES_MAX, TODO_ROWS_MAX, TODO_TEXT_CAP, TRANSCRIPT_CACHE_CAP, transcriptCache, PARSE_VERIFY_SAMPLE, TRANSCRIPT_DECODE_WINDOW, FOREIGN_SESSION_ID_RE, MAX_PINNED_BACKGROUND_OPERATIONS, CAPTION_MAX, _defaultCodexBackend, TRANSCRIPT_EARLIER_MAX_ITEMS, TRANSCRIPT_EARLIER_MAX_BYTES, fullDigestCache, FULL_DIGEST_CACHE_CAP, EMPTY_RETIRED_OPS;
+var MAX_MESSAGES, LATEST_WINDOW_ASK_REACH_ITEMS, LATEST_WINDOW_ASK_REACH_BYTES, NOISE_PREFIXES, INTERRUPT_MARKERS, REST_LABEL, LEGACY_TASK_MARKER, LEGACY_BANNER_PREAMBLE, COMMAND_NAME_RE, COMMAND_ARGS_RE, PEER_SESSION_PREAMBLE, QUEUED_STALE_MS, EDIT_CAP, TRUNC_MARKER, ENCRYPTED_PAYLOAD, AGENT_PROMPT_CAP, SEND_BODY_CAP, COMMAND_CAP, TOOL_INPUT_CAP, READ_LINE_CAP, READ_BYTE_CAP, IMAGE_MEDIA_EXT, SCREENSHOT_CACHE_DIR, SCREENSHOT_CACHE_MAX, SCREENSHOT_MAX_BASE64, screenshotTmpSeq, SENT_IMAGE_MAX_BYTES, SENT_FILES_MAX, TODO_ROWS_MAX, TODO_TEXT_CAP, TRANSCRIPT_CACHE_CAP, transcriptCache, PARSE_VERIFY_SAMPLE, TRANSCRIPT_DECODE_WINDOW, FOREIGN_SESSION_ID_RE, MAX_PINNED_BACKGROUND_OPERATIONS, CAPTION_MAX, _defaultCodexBackend, TRANSCRIPT_EARLIER_MAX_ITEMS, TRANSCRIPT_EARLIER_MAX_BYTES, fullDigestCache, FULL_DIGEST_CACHE_CAP, EMPTY_RETIRED_OPS;
 var init_transcript = __esm({
   "packages/server/src/transcript.ts"() {
     "use strict";
@@ -36317,7 +37239,10 @@ var init_transcript = __esm({
     init_bash_background();
     init_frizz_paths();
     MAX_MESSAGES = 300;
+    LATEST_WINDOW_ASK_REACH_ITEMS = 100;
+    LATEST_WINDOW_ASK_REACH_BYTES = 512 * 1024;
     NOISE_PREFIXES = ["<task-notification>", "[SYSTEM NOTIFICATION", "<system-reminder>", "<frizz-", "[frizz]"];
+    INTERRUPT_MARKERS = ["[Request interrupted by user]", "[Request interrupted by user for tool use]"];
     REST_LABEL = "Agent rested";
     LEGACY_TASK_MARKER = "\nTASK:\n";
     LEGACY_BANNER_PREAMBLE = "Everything ABOVE this line is frizz system orientation. Everything BELOW the `TASK:` marker is the human operator's own prompt, verbatim.";
@@ -36394,7 +37319,7 @@ var init_open_external = __esm({
 // packages/server/src/local-file.ts
 import { spawn as spawn6 } from "node:child_process";
 import { readFileSync as readFileSync20, realpathSync as realpathSync8, statSync as statSync15 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
+import { homedir as homedir15 } from "node:os";
 import { isAbsolute as isAbsolute3, join as join31, resolve as resolve7, sep } from "node:path";
 function isUnder(real, root) {
   let rootReal;
@@ -36422,7 +37347,7 @@ function resolveLocalFile(rawPath, roots) {
   }
   return real;
 }
-function resolveOpenableFile(raw2, projectDir, roots, home = homedir14()) {
+function resolveOpenableFile(raw2, projectDir, roots, home = homedir15()) {
   const trimmed = raw2.trim().replace(/:\d+(?::\d+)?$/, "");
   if (!trimmed) return null;
   const abs = trimmed === "~" ? home : trimmed.startsWith("~/") ? join31(home, trimmed.slice(2)) : isAbsolute3(trimmed) ? trimmed : resolve7(projectDir, trimmed);
@@ -36462,6 +37387,286 @@ var init_local_file = __esm({
   }
 });
 
+// packages/server/src/github-hovercard.ts
+function parseRef(ref) {
+  const match2 = REF_PATTERN.exec(ref);
+  if (!match2) return null;
+  const [, owner, name, number, sha] = match2;
+  if (number) {
+    const n = Number(number);
+    if (!Number.isSafeInteger(n) || n <= 0 || n > 2147483647) return null;
+    return { key: ref, owner, name, number: n };
+  }
+  return { key: ref, owner, name, sha };
+}
+function isImmutableRef(ref) {
+  return ref.sha !== void 0;
+}
+function buildRefQuery(refs) {
+  const variables = {};
+  const declarations = [];
+  const selections = [];
+  refs.forEach((ref, index) => {
+    declarations.push(`$owner${index}: String!`, `$name${index}: String!`);
+    variables[`owner${index}`] = ref.owner;
+    variables[`name${index}`] = ref.name;
+    if (ref.number !== void 0) {
+      declarations.push(`$number${index}: Int!`);
+      variables[`number${index}`] = ref.number;
+      selections.push(`  a${index}: repository(owner: $owner${index}, name: $name${index}) {
+    target: issueOrPullRequest(number: $number${index}) {${ISSUE_FIELDS}
+    }
+  }`);
+    } else {
+      declarations.push(`$rev${index}: String!`);
+      variables[`rev${index}`] = ref.sha;
+      selections.push(`  a${index}: repository(owner: $owner${index}, name: $name${index}) {
+    target: object(expression: $rev${index}) {${COMMIT_FIELDS}
+    }
+  }`);
+    }
+  });
+  return { query: `query(${declarations.join(", ")}) {
+${selections.join("\n")}
+}`, variables };
+}
+function str(v) {
+  return typeof v === "string" && v ? v : void 0;
+}
+function int(v) {
+  return typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.trunc(v) : void 0;
+}
+function excerptBody(body) {
+  if (!body) return "";
+  const cleaned = body.replace(/<!--[\s\S]*?-->/g, "").trim();
+  if (cleaned.length <= BODY_BUDGET) return cleaned;
+  return `${cleaned.slice(0, BODY_BUDGET).trimEnd()}\u2026`;
+}
+function labelsOf(v) {
+  const nodes = v?.nodes;
+  if (!Array.isArray(nodes)) return [];
+  const out = [];
+  for (const node of nodes) {
+    const name = str(node?.name);
+    if (name) out.push({ name, color: str(node?.color) ?? "" });
+  }
+  return out;
+}
+function cardFromNode(ref, node, fetchedAt) {
+  if (!node || typeof node !== "object") return null;
+  const n = node;
+  const repo = `${ref.owner}/${ref.name}`;
+  const typename = str(n.__typename);
+  if (typename === "Commit") {
+    const headline = str(n.messageHeadline) ?? "";
+    if (!headline) return null;
+    const author2 = n.author ?? {};
+    const user = author2.user ?? {};
+    return {
+      ref: ref.key,
+      kind: "commit",
+      repo,
+      url: str(n.url) ?? `https://github.com/${repo}/commit/${str(n.oid) ?? ref.sha}`,
+      title: headline,
+      body: excerptBody(str(n.messageBody)),
+      state: "",
+      at: str(n.committedDate),
+      ...str(user.login) ? { authorLogin: str(user.login) } : {},
+      ...str(author2.name) ? { authorName: str(author2.name) } : {},
+      // The LINKED ACCOUNT's avatar first. A commit's `GitActor.avatarUrl` is derived from the
+      // committer email, so for an author with no matching account it is a Gravatar behind GitHub's
+      // camo image proxy — a different host, and a generic silhouette rather than the person.
+      ...str(user.avatarUrl) || str(author2.avatarUrl) ? { authorAvatar: str(user.avatarUrl) ?? str(author2.avatarUrl) } : {},
+      labels: [],
+      ...int(n.additions) !== void 0 ? { additions: int(n.additions) } : {},
+      ...int(n.deletions) !== void 0 ? { deletions: int(n.deletions) } : {},
+      ...int(n.changedFilesIfAvailable) !== void 0 ? { changedFiles: int(n.changedFilesIfAvailable) } : {},
+      fetchedAt
+    };
+  }
+  if (typename !== "Issue" && typename !== "PullRequest") return null;
+  const title = str(n.title);
+  if (!title) return null;
+  const author = n.author ?? {};
+  const state = n.isDraft === true && str(n.state)?.toUpperCase() === "OPEN" ? "DRAFT" : str(n.state)?.toUpperCase() ?? "";
+  return {
+    ref: ref.key,
+    kind: typename === "Issue" ? "issue" : "pr",
+    repo,
+    url: str(n.url) ?? `https://github.com/${repo}/issues/${ref.number}`,
+    title,
+    body: excerptBody(str(n.body)),
+    state,
+    ...str(n.stateReason) ? { stateReason: str(n.stateReason).toUpperCase() } : {},
+    at: str(n.createdAt),
+    ...str(author.login) ? { authorLogin: str(author.login) } : {},
+    ...str(author.avatarUrl) ? { authorAvatar: str(author.avatarUrl) } : {},
+    labels: labelsOf(n.labels),
+    ...int(n.additions) !== void 0 ? { additions: int(n.additions) } : {},
+    ...int(n.deletions) !== void 0 ? { deletions: int(n.deletions) } : {},
+    ...int(n.changedFiles) !== void 0 ? { changedFiles: int(n.changedFiles) } : {},
+    ...int(n.comments?.totalCount) !== void 0 ? { comments: int(n.comments.totalCount) } : {},
+    fetchedAt
+  };
+}
+function parseRefResponse(raw2, refs, fetchedAt) {
+  const data = raw2?.data;
+  const cards = [];
+  const missing = [];
+  refs.forEach((ref, index) => {
+    const alias = data?.[`a${index}`] ?? null;
+    const card = cardFromNode(ref, alias?.target, fetchedAt);
+    if (card) cards.push(card);
+    else missing.push(ref.key);
+  });
+  return { cards, missing };
+}
+function conciseError2(error) {
+  const raw2 = error instanceof Error ? error.message : String(error);
+  return raw2.trim().split(/\r?\n/, 1)[0]?.slice(0, 300) || "unknown error";
+}
+function createGithubHovercardService(deps = {}) {
+  const getToken = deps.getToken ?? defaultGetToken;
+  const request = deps.request ?? globalThis.fetch;
+  const now = deps.now ?? Date.now;
+  const cache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  let tokenPromise;
+  const token = async () => {
+    if (!tokenPromise) {
+      tokenPromise = getToken();
+      tokenPromise.catch(() => {
+        tokenPromise = void 0;
+      });
+    }
+    return tokenPromise;
+  };
+  const isFresh = (ref, entry, refresh) => {
+    if (isImmutableRef(ref) && entry.card) return true;
+    if (refresh) return false;
+    return now() - entry.at < MUTABLE_TTL_MS;
+  };
+  const fetchChunk = async (refs) => {
+    const authToken = await token();
+    const { query: query2, variables } = buildRefQuery(refs);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS2);
+    timeout.unref?.();
+    try {
+      const response = await request("https://api.github.com/graphql", {
+        method: "POST",
+        headers: {
+          accept: "application/vnd.github+json",
+          authorization: `Bearer ${authToken}`,
+          "content-type": "application/json",
+          "user-agent": "frizz-hovercard",
+          "x-github-api-version": "2022-11-28"
+        },
+        body: JSON.stringify({ query: query2, variables }),
+        signal: controller.signal
+      });
+      const text = await response.text();
+      if (!response.ok) {
+        if (response.status === 401 || response.status === 403) tokenPromise = void 0;
+        throw new Error(`GitHub GraphQL returned HTTP ${response.status}`);
+      }
+      let body;
+      try {
+        body = JSON.parse(text);
+      } catch {
+        throw new Error("GitHub GraphQL returned malformed JSON");
+      }
+      const at = now();
+      const { cards, missing } = parseRefResponse(body, refs, at);
+      for (const card of cards) cache.set(card.ref, { card, at });
+      for (const key of missing) cache.set(key, { missing: true, at });
+    } finally {
+      clearTimeout(timeout);
+    }
+  };
+  return {
+    size: () => cache.size,
+    async preview(refs, opts = {}) {
+      const refresh = opts.refresh === true;
+      const parsed = /* @__PURE__ */ new Map();
+      const missing = [];
+      for (const raw2 of refs) {
+        if (parsed.has(raw2)) continue;
+        const ref = parseRef(raw2);
+        if (ref) parsed.set(raw2, ref);
+        else missing.push(raw2);
+      }
+      const wanted = [];
+      const joins = [];
+      for (const ref of parsed.values()) {
+        const entry = cache.get(ref.key);
+        if (entry && isFresh(ref, entry, refresh)) continue;
+        const pending = inflight.get(ref.key);
+        if (pending && !refresh) joins.push(pending);
+        else wanted.push(ref);
+      }
+      let error;
+      if (wanted.length > 0) {
+        const chunks = [];
+        for (let i = 0; i < wanted.length; i += MAX_REFS_PER_QUERY) chunks.push(wanted.slice(i, i + MAX_REFS_PER_QUERY));
+        const runs = chunks.map((chunk) => {
+          const run3 = fetchChunk(chunk);
+          for (const ref of chunk) inflight.set(ref.key, run3);
+          return run3.finally(() => {
+            for (const ref of chunk) if (inflight.get(ref.key) === run3) inflight.delete(ref.key);
+          });
+        });
+        const settled = await Promise.allSettled([...runs, ...joins]);
+        const failure = settled.find((r) => r.status === "rejected");
+        if (failure && failure.status === "rejected") error = conciseError2(failure.reason);
+      } else if (joins.length > 0) {
+        const settled = await Promise.allSettled(joins);
+        const failure = settled.find((r) => r.status === "rejected");
+        if (failure && failure.status === "rejected") error = conciseError2(failure.reason);
+      }
+      const cards = [];
+      for (const ref of parsed.values()) {
+        const entry = cache.get(ref.key);
+        if (entry?.card) cards.push(entry.card);
+        else if (entry?.missing) missing.push(ref.key);
+      }
+      return { cards, missing, ...error ? { error } : {} };
+    }
+  };
+}
+var REQUEST_TIMEOUT_MS2, MAX_REFS_PER_QUERY, BODY_BUDGET, MUTABLE_TTL_MS, REF_SEG, REF_PATTERN, ISSUE_FIELDS, COMMIT_FIELDS;
+var init_github_hovercard = __esm({
+  "packages/server/src/github-hovercard.ts"() {
+    "use strict";
+    init_github_review();
+    REQUEST_TIMEOUT_MS2 = 15e3;
+    MAX_REFS_PER_QUERY = 25;
+    BODY_BUDGET = 400;
+    MUTABLE_TTL_MS = 5 * 6e4;
+    REF_SEG = "[A-Za-z0-9][A-Za-z0-9._-]*";
+    REF_PATTERN = new RegExp(`^(${REF_SEG})/(${REF_SEG})(?:#([1-9]\\d{0,9})|@([0-9a-f]{7,40}))$`);
+    ISSUE_FIELDS = `
+  ... on Issue {
+    __typename number title body state stateReason url createdAt
+    author { login avatarUrl }
+    labels(first: 6) { nodes { name color } }
+    comments { totalCount }
+  }
+  ... on PullRequest {
+    __typename number title body state isDraft url createdAt additions deletions changedFiles
+    author { login avatarUrl }
+    labels(first: 6) { nodes { name color } }
+    comments { totalCount }
+  }`;
+    COMMIT_FIELDS = `
+  ... on Commit {
+    __typename oid abbreviatedOid url messageHeadline messageBody committedDate
+    additions deletions changedFilesIfAvailable
+    author { name avatarUrl user { login avatarUrl } }
+  }`;
+  }
+});
+
 // packages/server/src/backend/account-actions.ts
 import { execFile as execFile8 } from "node:child_process";
 import { promisify as promisify7 } from "node:util";
@@ -36897,7 +38102,7 @@ import { join as join32, resolve as resolve8 } from "node:path";
 import { randomUUID as randomUUID16 } from "node:crypto";
 import { basename as basename10, dirname as dirname14 } from "node:path";
 import { existsSync as existsSync12, mkdirSync as mkdirSync16, rmSync as rmSync9, writeFileSync as writeFileSync12 } from "node:fs";
-import { homedir as homedir15 } from "node:os";
+import { homedir as homedir16 } from "node:os";
 function validateGithubDispatchProfile(input) {
   validateThreadProfile(input.backend, input.model, input.effort);
 }
@@ -37056,7 +38261,7 @@ function projectCard(entry, stale) {
 function addProjectAtPath(input) {
   const typed = input.trim();
   if (!typed) throw new Error("Enter a folder path.");
-  const expanded = typed === "~" || typed.startsWith("~/") ? join32(homedir15(), typed.slice(1)) : typed;
+  const expanded = typed === "~" || typed.startsWith("~/") ? join32(homedir16(), typed.slice(1)) : typed;
   const absolute = resolve8(expanded);
   let stats;
   try {
@@ -37066,7 +38271,7 @@ function addProjectAtPath(input) {
   }
   if (!stats.isDirectory()) throw new Error(`That is a file, not a folder: ${absolute}`);
   const root = discoverProjectRoot(absolute);
-  const id = ensureProjectIdFile(root, homedir15(), existingProjectId(root));
+  const id = ensureProjectIdFile(root, homedir16(), existingProjectId(root));
   const remoteOwner = resolveProjectLabel(root)?.split("/")[0];
   let registered = registerProject({ dir: root, id, remoteOwner });
   if (registered.action === "duplicate") {
@@ -37139,14 +38344,18 @@ function createRouter(ctx) {
     if (input.prompt === null || input.intervalSeconds === void 0) return null;
     return input.intervalSeconds * 1e3;
   }
-  function armedWatchViews(slug) {
-    return ctx.storage.listThreadWatches(slug, { armedOnly: true }).map((w) => ({
-      id: w.id,
-      kind: w.kind,
-      target: w.target,
-      state: w.state,
-      createdAt: new Date(w.created_at).toISOString()
-    }));
+  function armedPrWatchViews(slug) {
+    const github = readGithubStatusBook(ctx.storage.getSetting(GITHUB_STATUS_SETTING));
+    return ctx.storage.listPrWatches(slug, { armedOnly: true }).map((w) => {
+      const target = `${w.owner}/${w.repo}#${w.number}`;
+      return {
+        id: w.id,
+        target,
+        state: w.state,
+        createdAt: new Date(w.created_at).toISOString(),
+        ...github[target] ? { github: github[target] } : {}
+      };
+    });
   }
   function armedTimerViews(slug) {
     return ctx.storage.listThreadTimers(slug, { armedOnly: true }).map((t) => ({
@@ -37162,16 +38371,14 @@ function createRouter(ctx) {
     if (!row) throw new Error(`thread ${slug} is not registered`);
     const otherOn = trigger === "rest" ? row.recurring_on_schedule === 1 : row.recurring_on_rest === 1;
     const compactOn = row.recurring_on_compact === 1;
-    const holdOn = row.recurring_pause_on_questions === 1;
     const storedSeconds = row.recurring_interval_ms ? Math.round(row.recurring_interval_ms / 1e3) : void 0;
     const on = write.enabled && write.prompt !== null;
     const prompt = on ? write.prompt : otherOn || compactOn ? row.recurring_prompt ?? null : null;
-    const next = prompt === null ? { prompt: null, stopHook: false, heartbeat: false, postCompaction: false, pauseOnQuestions: false } : {
+    const next = prompt === null ? { prompt: null, stopHook: false, heartbeat: false, postCompaction: false } : {
       prompt,
       stopHook: trigger === "rest" ? on : otherOn,
       heartbeat: trigger === "schedule" ? on : otherOn,
       postCompaction: compactOn,
-      pauseOnQuestions: holdOn,
       intervalSeconds: trigger === "schedule" && on ? write.intervalSeconds : storedSeconds
     };
     assertRecurringPromptArmable(next, row);
@@ -37180,7 +38387,6 @@ function createRouter(ctx) {
       stopHook: next.stopHook,
       heartbeat: next.heartbeat,
       postCompaction: next.postCompaction,
-      pauseOnQuestions: next.pauseOnQuestions,
       intervalMs: recurringIntervalMs(next),
       armedAt: (/* @__PURE__ */ new Date()).toISOString()
     })) {
@@ -38004,7 +39210,6 @@ function createRouter(ctx) {
           stopHook: input.stopHook,
           heartbeat: input.heartbeat,
           postCompaction: input.postCompaction,
-          pauseOnQuestions: input.pauseOnQuestions,
           intervalMs: recurringIntervalMs(input),
           armedAt: (/* @__PURE__ */ new Date()).toISOString()
         })) {
@@ -38034,7 +39239,6 @@ function createRouter(ctx) {
           stopHook: input.stopHook,
           heartbeat: input.heartbeat,
           postCompaction: input.postCompaction,
-          pauseOnQuestions: input.pauseOnQuestions,
           intervalMs: recurringIntervalMs(input),
           armedAt: (/* @__PURE__ */ new Date()).toISOString()
         })) {
@@ -38111,56 +39315,106 @@ function createRouter(ctx) {
       output: OwnThreadTimersResult,
       handler: async ({ input }) => ({ timers: armedTimerViews(input.slug) })
     }),
-    // ---- THE WATCHER REGISTRY (add / drop / list) ------------------------------------------------
-    // The worker's own waits, from `mcp__frizz__watch`. Same caller and therefore the same rules as the
-    // timers above: slug-only (the MCP server outlives the session ids underneath it), and no thread
-    // parameter a model could aim elsewhere.
-    addOwnThreadWatch: mutation({
-      input: AddOwnThreadWatchInput,
-      output: AddOwnThreadWatchResult,
+    // EVERY kind of background work this thread has out, with the id its awaiting fence names it by.
+    //
+    // The fence is structural — it references live things by id — so a worker that no longer has those
+    // ids to hand cannot write a correct fence at all, and the failure is silent: it names something
+    // wrong, frizz refuses the park, and the thread queues. That is the exact stall the grammar exists
+    // to prevent, so the ids have to be RETRIEVABLE rather than remembered. Same list the sign-off nudge
+    // prints, from the same source, so the two can never tell a worker different things.
+    //
+    // A shell is keyed by its RUNTIME task id ("Command running in background with ID: bzvtnt3ig"),
+    // never its launch tool_use id: that is the string the worker was actually shown and the one it will
+    // reach for. Falls back to the launch id only when the ack has not landed yet.
+    listOwnThreadActivity: mutation({
+      input: ListOwnThreadActivityInput,
+      output: OwnThreadActivityResult,
+      handler: async ({ input }) => {
+        const tele = ctx.tailer.get(input.slug);
+        const activity = [];
+        for (const sh of tele?.bgShells ?? []) {
+          if (sh.state !== "running") continue;
+          const id = sh.taskId ?? sh.id;
+          if (id) activity.push({ kind: "shell", id, label: sh.label, since: sh.startedAt });
+        }
+        for (const a of tele?.subAgents ?? []) {
+          if (a.state !== "running") continue;
+          if (a.id) activity.push({ kind: "agent", id: a.id, label: a.label, since: a.startedAt });
+        }
+        for (const t of ctx.storage.listThreadTimers(input.slug, { armedOnly: true })) {
+          activity.push({
+            kind: "timer",
+            id: t.id,
+            label: t.prompt.trim().replace(/\s+/g, " ").slice(0, 120),
+            since: new Date(t.created_at).toISOString(),
+            until: new Date(t.fire_at).toISOString()
+          });
+        }
+        for (const w of ctx.storage.listPrWatches(input.slug, { armedOnly: true })) {
+          activity.push({
+            kind: "pr",
+            id: `${w.owner}/${w.repo}#${w.number}`,
+            label: `${w.owner}/${w.repo}#${w.number}`,
+            since: new Date(w.created_at).toISOString()
+          });
+        }
+        return { activity };
+      }
+    }),
+    // THE WATCHER REGISTRY IS GONE (2026-08-14). `mcp__frizz__watch` and its four procedures are
+    // deleted rather than shimmed: a wait is now a `watch:` line in the worker's own ```awaiting fence,
+    // which is BOTH the park and the wake (scheduler `watchVerdict`), so there is nothing to register and
+    // nothing an alias could usefully do. A session dispatched before the change still holds the old MCP
+    // binary and will get a 404 from it — which is the honest answer, and the tool it should not be
+    // calling is the only casualty.
+    // ---- REGISTERED PR WATCHERS (add / drop / list) ---------------------------------------------
+    // The worker's own PR watchers, from `mcp__frizz__watch_pr`. Same caller and therefore the same rules
+    // as the timers above: slug-only (the MCP server outlives the session ids underneath it), and no
+    // thread parameter a model could aim elsewhere.
+    addOwnPrWatch: mutation({
+      input: AddOwnPrWatchInput,
+      output: AddOwnPrWatchResult,
       handler: async ({ input }) => {
         const row = ctx.storage.getSession(input.slug);
         if (!row) throw new Error(`thread ${input.slug} is not registered`);
         if (row.state === "archived" || row.archived === 1) {
           throw new Error("Reopen this thread before registering a watcher on it");
         }
-        const armed = ctx.storage.listThreadWatches(input.slug, { armedOnly: true });
-        const existing = armed.find((w) => w.kind === input.kind && w.target === input.target);
-        if (existing) return { id: existing.id, alreadyArmed: true, watches: armedWatchViews(input.slug) };
-        if (armed.length >= WATCH_MAX_ARMED) {
-          throw new Error(`this thread already has ${armed.length} armed watchers (the limit is ${WATCH_MAX_ARMED}) \u2014 drop one first`);
+        const ref = parsePrRef(input.target);
+        if (!ref) {
+          throw new Error(`\`${input.target}\` is not a pull request I can watch \u2014 give owner/repo#123 or a PR URL`);
+        }
+        const armed = ctx.storage.listPrWatches(input.slug, { armedOnly: true });
+        const existing = armed.find((w) => w.owner === ref.owner && w.repo === ref.repo && w.number === ref.number);
+        const target = `${ref.owner}/${ref.repo}#${ref.number}`;
+        if (existing) return { id: existing.id, target, alreadyArmed: true, watches: armedPrWatchViews(input.slug) };
+        if (armed.length >= PR_WATCH_MAX_ARMED) {
+          throw new Error(`this thread already watches ${armed.length} pull requests (the limit is ${PR_WATCH_MAX_ARMED}) \u2014 drop one first`);
+        }
+        const forMs = input.for === void 0 ? PR_WATCH_DEFAULT_FOR_MS : parseAwaitingDuration(input.for);
+        if (forMs === null) {
+          throw new Error(`\`for: ${input.for}\` is not a duration \u2014 give one like \`30m\`, \`2h\` or \`3d\` (max 24h)`);
         }
-        const id = `wch_${randomUUID16().replace(/-/g, "").slice(0, 12)}`;
-        ctx.storage.armThreadWatch({ id, slug: input.slug, kind: input.kind, target: input.target, createdAtMs: Date.now(), foreground: input.foreground });
+        const now = Date.now();
+        const id = `prw_${randomUUID16().replace(/-/g, "").slice(0, 12)}`;
+        ctx.storage.armPrWatch({ id, slug: input.slug, owner: ref.owner, repo: ref.repo, number: ref.number, createdAtMs: now, expiresAtMs: now + forMs });
         ctx.board.refresh();
-        return { id, alreadyArmed: false, watches: armedWatchViews(input.slug) };
+        return { id, target, alreadyArmed: false, watches: armedPrWatchViews(input.slug) };
       }
     }),
-    dropOwnThreadWatch: mutation({
-      input: DropOwnThreadWatchInput,
-      output: DropOwnThreadWatchResult,
+    dropOwnPrWatch: mutation({
+      input: DropOwnPrWatchInput,
+      output: DropOwnPrWatchResult,
       handler: async ({ input }) => {
-        const dropped = ctx.storage.dropThreadWatch(input.slug, input.id, Date.now());
+        const dropped = ctx.storage.dropPrWatch(input.slug, input.id, Date.now());
         if (dropped) ctx.board.refresh();
-        return { dropped, watches: armedWatchViews(input.slug) };
+        return { dropped, watches: armedPrWatchViews(input.slug) };
       }
     }),
-    // Hand a foreground watch back to the scheduler. Called by the blocking tool call when its timeout
-    // expires, so a wait the worker started degrades into a durable one rather than being lost — which
-    // is the property that makes choosing the blocking mode safe.
-    promoteOwnThreadWatch: mutation({
-      input: PromoteOwnThreadWatchInput,
-      output: PromoteOwnThreadWatchResult,
-      handler: async ({ input }) => {
-        const promoted = ctx.storage.promoteThreadWatch(input.slug, input.id);
-        if (promoted) ctx.board.refresh();
-        return { promoted, watches: armedWatchViews(input.slug) };
-      }
-    }),
-    listOwnThreadWatches: mutation({
-      input: ListOwnThreadWatchesInput,
-      output: OwnThreadWatchesResult,
-      handler: async ({ input }) => ({ watches: armedWatchViews(input.slug) })
+    listOwnPrWatches: mutation({
+      input: ListOwnPrWatchesInput,
+      output: OwnPrWatchesResult,
+      handler: async ({ input }) => ({ watches: armedPrWatchViews(input.slug) })
     }),
     // The SUPERSEDED worker procedures, aliased onto the row above — see SetOwnThreadStopHookInput for
     // why they cannot simply be deleted. A worker's MCP server outlives every server restart, so these
@@ -38238,10 +39492,7 @@ function createRouter(ctx) {
         if (!fenceAt || !Number.isFinite(Date.parse(fenceAt)) || fenceAt !== input.fenceAt) {
           throw new Error("This awaiting proposal changed before it could be confirmed");
         }
-        const snoozedUntil = hint.kind === "timer" ? canonicalSnoozeInstant(hint.value) : null;
-        if (hint.kind === "timer" && !snoozedUntil) {
-          throw new Error("This awaiting proposal changed before it could be confirmed");
-        }
+        const snoozedUntil = null;
         if (snoozedUntil && Date.parse(snoozedUntil) <= Date.now()) {
           throw new Error("This scheduled time has already passed");
         }
@@ -38738,12 +39989,12 @@ function createRouter(ctx) {
       output: DispatchPreferences,
       handler: async ({ input }) => setDispatchPreference(ctx.storage, ctx.getSettings(), input, readCodexModels())
     }),
-    // The shipped GitHub batch-dispatch prompt templates (single source of truth: server/github.ts).
-    // The Settings UI reads these to prefill the editors for editing and to power "reset to default";
-    // an empty/unset githubIssuePrompt/githubPrPrompt setting means the server uses exactly these.
+    // The shipped GitHub batch-dispatch prompt template (single source of truth: server/github.ts).
+    // The Settings UI reads it to prefill the editor and to power "reset to default"; an empty/unset
+    // githubPrompt setting means the server uses exactly this. One template serves issues AND PRs.
     githubPromptDefaults: query({
-      output: external_exports.object({ issue: external_exports.string(), pr: external_exports.string() }),
-      handler: async () => ({ issue: DEFAULT_ISSUE_PROMPT, pr: DEFAULT_PR_PROMPT })
+      output: external_exports.object({ prompt: external_exports.string() }),
+      handler: async () => ({ prompt: DEFAULT_GITHUB_PROMPT })
     }),
     // ---- GitHub-first batch dispatch ----
     // gh availability: installed (cache-warmed resolveInstalled) + inRepo/nameWithOwner (cache-warmed
@@ -38775,6 +40026,18 @@ function createRouter(ctx) {
         return await listItems(repo, input.kind, input.sort, input.page, input.perPage);
       }
     }),
+    // Hovercard data for every GitHub reference the client autolinked into the prose on screen —
+    // ONE request for a whole page of refs, answered from a process-lifetime cache (see
+    // github-hovercard.ts). The client asks as the prose renders, so the hover itself never waits on
+    // the network; `refresh` is its revalidation of the handful it is actually pointing at.
+    //
+    // Never throws: a missing gh, an unauthenticated one, a rate limit and a network stall all come
+    // back as `error` with whatever cards the cache already holds, and the anchor stays a plain link.
+    githubRefPreview: query({
+      input: GithubRefPreviewInput,
+      output: GithubRefPreviewResult,
+      handler: async ({ input }) => await githubHovercards.preview(input.refs, { refresh: input.refresh })
+    }),
     // Spin up one frizz thread per checked item: hydrate each fresh from gh, template a server-side
     // prompt (single source of truth, unit-tested), then REUSE ctx.dispatcher.dispatch (no new spawn
     // logic). SEQUENTIAL — a burst of 20 concurrent tmux spawns would hammer the box (risk 5). A
@@ -38786,14 +40049,13 @@ function createRouter(ctx) {
         validateGithubDispatchProfile(input);
         const repo = await resolveRepo();
         if (!repo) throw new Error("not a GitHub repo");
-        const settings = ctx.getSettings();
+        const template = effectiveTemplate(ctx.getSettings().githubPrompt);
         const dispatched = [];
         const failed = [];
         for (const it of input.items) {
           try {
             const title = `${it.kind === "issue" ? "Investigate" : "Review"} ${repo}#${it.number}`;
             const slug = resolveSlug(frizzDir, slugify(title), (s) => ctx.storage.getSession(s) !== void 0);
-            const template = effectiveTemplate(it.kind, it.kind === "issue" ? settings.githubIssuePrompt : settings.githubPrPrompt);
             const hydrated = it.kind === "issue" ? await hydrateIssue(repo, it.number) : await hydratePr(repo, it.number);
             const prompt = renderGithubPrompt(template, repo, hydrated, slug, it.kind);
             const request = githubDispatcherRequest(input, { prompt, title, slug });
@@ -38808,7 +40070,7 @@ function createRouter(ctx) {
     })
   };
 }
-var SlugInput, cachedLivenessTerminator, HOLD_OPS_MAX, HOLD_LABEL_MAX;
+var SlugInput, cachedLivenessTerminator, HOLD_OPS_MAX, HOLD_LABEL_MAX, githubHovercards;
 var init_router5 = __esm({
   "packages/server/src/router.ts"() {
     "use strict";
@@ -38826,6 +40088,7 @@ var init_router5 = __esm({
     init_local_file();
     init_project();
     init_github();
+    init_github_hovercard();
     init_dispatch();
     init_codex_models();
     init_codex();
@@ -38860,6 +40123,7 @@ var init_router5 = __esm({
     };
     HOLD_OPS_MAX = 8;
     HOLD_LABEL_MAX = 100;
+    githubHovercards = createGithubHovercardService();
   }
 });
 
@@ -38999,6 +40263,52 @@ var init_local_origin = __esm({
   }
 });
 
+// packages/server/src/compression.ts
+import { brotliCompressSync, gzipSync, constants as constants3 } from "node:zlib";
+function negotiateEncoding(acceptEncoding) {
+  if (!acceptEncoding) return null;
+  const offers = /* @__PURE__ */ new Map();
+  for (const part of acceptEncoding.split(",")) {
+    const [name, ...params] = part.trim().split(";");
+    if (!name) continue;
+    const q = params.map((p) => /^\s*q=([0-9.]+)\s*$/i.exec(p)).find(Boolean);
+    offers.set(name.trim().toLowerCase(), q ? Number(q[1]) : 1);
+  }
+  const wildcard = offers.get("*");
+  const accepted = (name) => {
+    const explicit = offers.get(name);
+    if (explicit !== void 0) return explicit > 0;
+    return wildcard !== void 0 && wildcard > 0;
+  };
+  if (accepted("br")) return "br";
+  if (accepted("gzip")) return "gzip";
+  return null;
+}
+function compress(body, encoding) {
+  const out = encoding === "br" ? brotliCompressSync(body, {
+    params: {
+      [constants3.BROTLI_PARAM_QUALITY]: 4,
+      // Telling brotli the input size lets it size its window instead of guessing.
+      [constants3.BROTLI_PARAM_SIZE_HINT]: body.byteLength
+    }
+  }) : gzipSync(body, { level: 6 });
+  return Uint8Array.from(out);
+}
+function shouldCompress(headers, byteLength2) {
+  if (byteLength2 < MIN_COMPRESS_BYTES) return false;
+  if (headers.has("content-encoding")) return false;
+  const type = headers.get("content-type") ?? "";
+  if (type.includes("text/event-stream")) return false;
+  return /json|text\/|javascript|xml|svg/i.test(type);
+}
+var MIN_COMPRESS_BYTES;
+var init_compression = __esm({
+  "packages/server/src/compression.ts"() {
+    "use strict";
+    MIN_COMPRESS_BYTES = 1024;
+  }
+});
+
 // packages/server/src/local-image.ts
 import { readFileSync as readFileSync22, realpathSync as realpathSync9, statSync as statSync18 } from "node:fs";
 import { extname as extname2, isAbsolute as isAbsolute4 } from "node:path";
@@ -39035,7 +40345,7 @@ var init_local_image = __esm({
 
 // packages/server/src/project-icon.ts
 import { readFileSync as readFileSync23, readdirSync as readdirSync11, realpathSync as realpathSync10, statSync as statSync19 } from "node:fs";
-import { homedir as homedir16 } from "node:os";
+import { homedir as homedir17 } from "node:os";
 import { basename as basename11, dirname as dirname15, extname as extname3, join as join33, relative, sep as sep2 } from "node:path";
 function normalizeStem(stem) {
   const sized = stem.toLowerCase().replace(/[@-]\d+(\.\d+)?x(\d+)?$/u, "").replace(/[-_]\d{2,4}$/u, "");
@@ -39174,7 +40484,7 @@ function iconMediaType(path) {
 }
 function resolveProjectIconResponse(id, options = {}) {
   if (!id) return { status: 400 };
-  const home = options.home ?? homedir16();
+  const home = options.home ?? homedir17();
   const entry = readRegistry(home).projects.find((project) => project.id === id);
   if (!entry) return { status: 404 };
   const path = resolveProjectIcon(id, (root) => detectProjectIcon(root)?.path, { home });
@@ -39502,6 +40812,21 @@ function createApp(ctx, options = {}) {
     c.header("x-frizz-boot", ctx.bootId);
     await next();
   });
+  app.use(`${frizzRoute("/rpc")}/*`, async (c, next) => {
+    await next();
+    const encoding = negotiateEncoding(c.req.header("accept-encoding"));
+    if (!encoding || !c.res.body) return;
+    const body = new Uint8Array(await c.res.arrayBuffer());
+    if (!shouldCompress(c.res.headers, body.byteLength)) {
+      c.res = new Response(body, { status: c.res.status, headers: c.res.headers });
+      return;
+    }
+    const headers = new Headers(c.res.headers);
+    headers.set("content-encoding", encoding);
+    headers.set("vary", "Accept-Encoding");
+    headers.delete("content-length");
+    c.res = new Response(compress(body, encoding), { status: c.res.status, headers });
+  });
   app.get(frizzRoute("/health"), (c) => c.json({
     ok: true,
     projectId: ctx.project.id,
@@ -39608,6 +40933,7 @@ var init_app = __esm({
     init_src();
     init_router5();
     init_local_origin();
+    init_compression();
     init_local_image();
     init_project_icon();
     init_local_visualization();
@@ -40071,6 +41397,11 @@ function createAppSocketServer(deps) {
   const bufferedAmount = deps.bufferedAmount ?? ((ws) => ws.bufferedAmount);
   const now = deps.now ?? Date.now;
   const serializeMessage = deps.serializeMessage ?? JSON.stringify;
+  const scheduleSubscriptionFlush = deps.scheduleSubscriptionFlush ?? ((flush) => {
+    const immediate = setImmediate(flush);
+    immediate.unref?.();
+    return () => clearImmediate(immediate);
+  });
   const terminationTimers = /* @__PURE__ */ new WeakMap();
   const keyframes = /* @__PURE__ */ new Set();
   let closing = false;
@@ -40307,7 +41638,33 @@ function createAppSocketServer(deps) {
     scheduleTranscriptFlush(BACKPRESSURE_RETRY_MS);
   }
   const pendingSubscriptionPushes = /* @__PURE__ */ new Map();
-  let subscriptionFlushImmediate = null;
+  let subscriptionFlushArmed = false;
+  let cancelSubscriptionFlush = null;
+  function flushSubscriptionPushes() {
+    subscriptionFlushArmed = false;
+    cancelSubscriptionFlush = null;
+    if (closing) {
+      pendingSubscriptionPushes.clear();
+      return;
+    }
+    const batch = [...pendingSubscriptionPushes];
+    pendingSubscriptionPushes.clear();
+    const batchResults = /* @__PURE__ */ new Map();
+    for (const [candidate, candidateSlugs] of batch) {
+      if (candidate.readyState !== candidate.OPEN) continue;
+      for (const candidateSlug of candidateSlugs) {
+        if (!registry.isSubscribed(candidate, candidateSlug)) continue;
+        let result = batchResults.get(candidateSlug);
+        if (!result || result.kind === "limited" && result.scope === "origin") {
+          result = snapshotFor(candidateSlug, socketOrigins.get(candidate));
+          if (!(result.kind === "limited" && result.scope === "origin")) {
+            batchResults.set(candidateSlug, result);
+          }
+        }
+        pushSnapshotResult(candidate, candidateSlug, result);
+      }
+    }
+  }
   function enqueueSubscriptionPush(ws, slug) {
     deleteTranscriptSnapshot(slug);
     let slugs = pendingSubscriptionPushes.get(ws);
@@ -40316,32 +41673,10 @@ function createAppSocketServer(deps) {
       pendingSubscriptionPushes.set(ws, slugs);
     }
     slugs.add(slug);
-    if (subscriptionFlushImmediate) return;
-    subscriptionFlushImmediate = setImmediate(() => {
-      subscriptionFlushImmediate = null;
-      if (closing) {
-        pendingSubscriptionPushes.clear();
-        return;
-      }
-      const batch = [...pendingSubscriptionPushes];
-      pendingSubscriptionPushes.clear();
-      const batchResults = /* @__PURE__ */ new Map();
-      for (const [candidate, candidateSlugs] of batch) {
-        if (candidate.readyState !== candidate.OPEN) continue;
-        for (const candidateSlug of candidateSlugs) {
-          if (!registry.isSubscribed(candidate, candidateSlug)) continue;
-          let result = batchResults.get(candidateSlug);
-          if (!result || result.kind === "limited" && result.scope === "origin") {
-            result = snapshotFor(candidateSlug, socketOrigins.get(candidate));
-            if (!(result.kind === "limited" && result.scope === "origin")) {
-              batchResults.set(candidateSlug, result);
-            }
-          }
-          pushSnapshotResult(candidate, candidateSlug, result);
-        }
-      }
-    });
-    subscriptionFlushImmediate.unref?.();
+    if (subscriptionFlushArmed) return;
+    subscriptionFlushArmed = true;
+    const cancel = scheduleSubscriptionFlush(flushSubscriptionPushes);
+    if (subscriptionFlushArmed) cancelSubscriptionFlush = cancel ?? null;
   }
   function cancelPendingSubscriptionPush(ws, slug) {
     if (slug === void 0) {
@@ -40643,8 +41978,12 @@ function createAppSocketServer(deps) {
         offTranscript();
       } catch {
       }
-      if (subscriptionFlushImmediate) clearImmediate(subscriptionFlushImmediate);
-      subscriptionFlushImmediate = null;
+      try {
+        cancelSubscriptionFlush?.();
+      } catch {
+      }
+      cancelSubscriptionFlush = null;
+      subscriptionFlushArmed = false;
       pendingSubscriptionPushes.clear();
       if (transcriptRefreshTimer) clearTimeout(transcriptRefreshTimer);
       transcriptRefreshTimer = null;