@joshuafolkken/kit 1.3000.0 → 1.3044.0

package/dist/commands/{chunk-UTBVTCQN.js → chunk-24OATKOF.js}

@@ -1,23 +1,22 @@
 import {
   run_board_quota_read
-} from "./chunk-7IT23HIR.js";
+} from "./chunk-GY4DMCKS.js";
 import {
   lane_held_stats
-} from "./chunk-KQWSENCT.js";
+} from "./chunk-F6IQHZYY.js";
 import {
   run_event_step
-} from "./chunk-IG22Y5MA.js";
+} from "./chunk-7KKUFLH5.js";
 import {
   lane_investigation_switch,
   run_event_overrun
-} from "./chunk-ORSI7Y55.js";
+} from "./chunk-XXN2EZBY.js";
 import {
-  git_gh_issue_alias_graphql,
   run_board_closed
-} from "./chunk-RPDWFUQO.js";
+} from "./chunk-RKIAX4DZ.js";
 import {
   lane_withdraw
-} from "./chunk-GDUK5YPO.js";
+} from "./chunk-4NRSFLG7.js";
 import {
   process_directories
 } from "./chunk-MXC4IBZ7.js";
@@ -27,31 +26,37 @@ import {
   issue_human_stops,
   run_board_labels,
   run_board_machine
-} from "./chunk-H4LYG37R.js";
+} from "./chunk-4DN4XVPL.js";
 import {
   gh_core_rate_limit,
   run_merge_usage_limit
-} from "./chunk-PZ6VWHOO.js";
+} from "./chunk-FHFWNNUC.js";
 import {
   run_park_body
-} from "./chunk-FGZQSSGH.js";
+} from "./chunk-UREXZJDB.js";
 import {
   backlog_plan,
   backlog_plan_read,
   backlog_waves
-} from "./chunk-QDFDB4CF.js";
-import {
-  run_stalled
-} from "./chunk-B33BTNB4.js";
+} from "./chunk-4Q64PG46.js";
 import {
   run_event_filed
 } from "./chunk-PYOK73QE.js";
+import {
+  issue_outcome
+} from "./chunk-5CG3XU3O.js";
 import {
   ts_entry_loader
 } from "./chunk-VHRNXWVP.js";
+import {
+  git_gh_issue_alias_graphql
+} from "./chunk-HWEZRNPL.js";
+import {
+  home_tilde
+} from "./chunk-D5OHVIPM.js";
 import {
   run_stranded_detect
-} from "./chunk-VJLZ3IQQ.js";
+} from "./chunk-G5KSL2Q2.js";
 import {
   run_wake
 } from "./chunk-6Q3XUCLM.js";
@@ -61,35 +66,35 @@ import {
 import {
   backlog_hold_text,
   backlog_ready
-} from "./chunk-5WIZR5SC.js";
+} from "./chunk-M4UV3BEV.js";
 import {
   backlog_next_shared
-} from "./chunk-ILQZFUDC.js";
+} from "./chunk-ELY76WAR.js";
 import {
   epic_classify,
   epic_solo
-} from "./chunk-PWYXY46Y.js";
+} from "./chunk-TYNH2R66.js";
 import {
   epic_triage
-} from "./chunk-AM44D7NF.js";
+} from "./chunk-VQRT32JB.js";
 import {
   auto_ok_cli
-} from "./chunk-F2J6DGDM.js";
+} from "./chunk-FMZWRDKH.js";
 import {
   issue_not_before
-} from "./chunk-M42SLJCD.js";
+} from "./chunk-FKZ5E4JD.js";
 import {
   issue_sample_gate
-} from "./chunk-YGDNUTTI.js";
+} from "./chunk-CQUZ6TNQ.js";
 import {
   epic_issue
-} from "./chunk-LC7SBONO.js";
+} from "./chunk-IAD4WLLI.js";
 import {
   git_closes_keyword
 } from "./chunk-J3TKZLHA.js";
 import {
   lane_stage_budget
-} from "./chunk-RQRLW4XK.js";
+} from "./chunk-AXXEMVRJ.js";
 import {
   telegram_notify
 } from "./chunk-WJ4NEDNI.js";
@@ -101,19 +106,19 @@ import {
 } from "./chunk-3RIQ36LH.js";
 import {
   run_event_retry
-} from "./chunk-LUMCYDGE.js";
+} from "./chunk-TFLHYC2F.js";
 import {
   lane_yield
-} from "./chunk-EH3LVYOX.js";
+} from "./chunk-EGIHAEMT.js";
 import {
   lane_stage_stats
-} from "./chunk-HOSZITJM.js";
+} from "./chunk-IBAYXCMU.js";
 import {
   usage_state_path
 } from "./chunk-K2WVYHCP.js";
 import {
   run_progress_read
-} from "./chunk-HPVLI26Z.js";
+} from "./chunk-4WR2LEZL.js";
 import {
   issue_run_hold
 } from "./chunk-QX2R6UJG.js";
@@ -122,40 +127,43 @@ import {
 } from "./chunk-23GH6B3D.js";
 import {
   backlog_overlap
-} from "./chunk-4Z5723GA.js";
+} from "./chunk-B7ZNIEDV.js";
 import {
   issue_read
-} from "./chunk-HBNB3TLG.js";
+} from "./chunk-2BB5ZR2F.js";
 import {
   run_progress
 } from "./chunk-RGDFWJPZ.js";
-import {
-  run_event_checks
-} from "./chunk-E2ZCUKHT.js";
 import {
   markdown_section
-} from "./chunk-CRNPPKP2.js";
+} from "./chunk-JZK33TA5.js";
+import {
+  backlogrun_launch
+} from "./chunk-2EZTYLO4.js";
 import {
   lane_stats
-} from "./chunk-QS5USD4T.js";
+} from "./chunk-XXC32PVL.js";
 import {
   lane_await
-} from "./chunk-WWC5L3AO.js";
+} from "./chunk-IB5TT73I.js";
 import {
   lane_ledger
-} from "./chunk-XYAK53TK.js";
-import {
-  backlogrun_launch
-} from "./chunk-TVJE67O2.js";
+} from "./chunk-ZNR75OXP.js";
 import {
   run_event_setup
-} from "./chunk-BNXE3NVB.js";
+} from "./chunk-I2KCGKJI.js";
 import {
   run_board_usage_rusage
 } from "./chunk-FCINBCKB.js";
+import {
+  run_stalled
+} from "./chunk-S4M6UWR2.js";
+import {
+  run_event_checks
+} from "./chunk-OJ65BZBV.js";
 import {
   transcript_tail
-} from "./chunk-UCQJDYE3.js";
+} from "./chunk-EMTZAGT5.js";
 import {
   core_budget
 } from "./chunk-TCBUX52E.js";
@@ -165,13 +173,10 @@ import {
 import {
   lane_process_table,
   lane_registry
-} from "./chunk-LRS2OS5J.js";
+} from "./chunk-452HWOJ7.js";
 import {
   run_liveness
-} from "./chunk-7S6VRZOH.js";
-import {
-  run_hold
-} from "./chunk-P4CWLRT2.js";
+} from "./chunk-3AEDZZNL.js";
 import {
   COMMENTS,
   ISSUE_FIELDS,
@@ -180,10 +185,13 @@ import {
   git_gh_issue_read,
   git_gh_issue_rest,
   issue_fields_schema
-} from "./chunk-LRA3PXHS.js";
+} from "./chunk-ENKFCOVY.js";
 import {
   git_gh_transport
 } from "./chunk-TVZXG4Y4.js";
+import {
+  run_hold
+} from "./chunk-X3TNPALI.js";
 import {
   git_gh_etag_read
 } from "./chunk-EWVR5AEX.js";
@@ -196,14 +204,14 @@ import {
 import {
   run_board_lane_time,
   run_event_scope
-} from "./chunk-34LAULSC.js";
-import {
-  figure_format,
-  lane_state
-} from "./chunk-5Y7QQYTU.js";
+} from "./chunk-OKZWEVR4.js";
 import {
   run_event_stream
 } from "./chunk-NSAVEXVR.js";
+import {
+  figure_format,
+  lane_state
+} from "./chunk-ZZXO6TFH.js";
 import {
   ALREADY_DONE_LABEL,
   BREAKING_CHANGE_LABEL,
@@ -323,6 +331,7 @@ var SNAPSHOT_PREFIX = "josh-run-board-snapshot-";
 var NO_KNOWN = { titles: /* @__PURE__ */ new Map(), labels: /* @__PURE__ */ new Map() };
 var label_names_schema = z.array(z.string());
 var closed_issue_schema = z.object({
+  outcome: z.object({ summary: issue_outcome.summary_schema, url: issue_outcome.url_schema }).optional(),
   title: z.string(),
   labels: label_names_schema,
   closed_ms: z.number().optional(),
@@ -439,6 +448,55 @@ function newest_of(events) {
 }
 var run_board_checks = { newest_of };
 
+// scripts/run/board/run-board-pause.ts
+import { z as z2 } from "zod";
+var record_schema = z2.object({
+  summary: issue_outcome.summary_schema,
+  url: z2.string().regex(/^https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/\d+(?:#issuecomment-\d+)?$(?![\s\S])/u).optional(),
+  at_ms: z2.number()
+});
+var FALLBACK = "Reason unavailable: inspect issue";
+function is_stop(comment) {
+  return comment.is_trusted === true && run_park_body.summary_of(comment.body) !== void 0;
+}
+function outcome_for(comments, latest) {
+  if (latest === void 0) return void 0;
+  const candidates = comments.filter((comment) => {
+    const outcome = issue_outcome.from_comments(comments, [comment]);
+    return comment === latest || outcome?.url === latest.html_url;
+  });
+  return issue_outcome.from_comments(comments, candidates);
+}
+function at_of(comment) {
+  const at_ms = Date.parse(comment?.created_at ?? "");
+  return Number.isFinite(at_ms) ? at_ms : 0;
+}
+function from_comments(comments, issue_url2) {
+  const latest = comments.findLast((comment) => is_stop(comment));
+  const url = issue_outcome.url_schema.safeParse(latest?.html_url).data;
+  const outcome = outcome_for(comments, latest);
+  return { summary: FALLBACK, url: url ?? issue_url2, ...outcome, at_ms: at_of(latest) };
+}
+function launch_of(status) {
+  return status?.launched_ms ?? status?.started_ms ?? 0;
+}
+function is_unread(record) {
+  return record?.at_ms === 0 && record.url === void 0;
+}
+function record_of(number, read5, status) {
+  const record = read5.pause_reasons?.get(number);
+  return status === void 0 && is_unread(record) ? void 0 : record;
+}
+function reason_of(number, read5, status) {
+  const record = record_of(number, read5, status);
+  if (record === void 0) return void 0;
+  if (record.at_ms < launch_of(status)) {
+    return { tail: FALLBACK, evidence_url: record.url?.split("#", 1)[0] };
+  }
+  return { tail: record.summary, evidence_url: record.url };
+}
+var run_board_pause = { FALLBACK, from_comments, reason_of, record_schema };
+
 // scripts/run/board/run-board-fit.ts
 import { stripVTControlCharacters } from "node:util";
 import string_width from "string-width";
@@ -546,11 +604,11 @@ function compose(parts, cut2) {
     ...cut2.footer ? [] : parts.footer
   ];
 }
-function at_of(entry) {
+function at_of2(entry) {
   return entry.line.row?.at_ms ?? -Infinity;
 }
 function oldest_first(left, right2) {
-  const [left_at, right_at] = [at_of(left), at_of(right2)];
+  const [left_at, right_at] = [at_of2(left), at_of2(right2)];
   if (left_at === right_at) return right2.index - left.index;
   return left_at < right_at ? -1 : 1;
 }
@@ -627,7 +685,11 @@ var TITLE_FLOOR = 8;
 var ELLIPSIS = "\u2026";
 var WHOLE = { title_limit: TITLE_LIMIT, reason_cut: 0 };
 var WHOLE_TAIL_STATES = /* @__PURE__ */ new Set(["stopped", "parked", "human"]);
+function has_short_reason(reason) {
+  return reason?.evidence_url !== void 0 || reason?.tail === run_board_pause.FALLBACK;
+}
 function keeps_tail(row) {
+  if (has_short_reason(row.reason)) return false;
   return WHOLE_TAIL_STATES.has(row.state) || row.reason?.icon === run_board_labels.STATE_ICONS.human;
 }
 function title_of(title = "", limit = TITLE_LIMIT) {
@@ -724,12 +786,12 @@ function park_row_reason(issue, reason, is_backlog_live2, waits = []) {
     is_backlog_live2
   );
 }
-function reason_of(event) {
+function reason_of2(event) {
   if (event.kind === KIND.PARK) return park_reason(event) || void 0;
   return event.kind === KIND.WITHDRAW ? withdraw_reason(event) || void 0 : void 0;
 }
 function recorded_of(event) {
-  const reason = reason_of(event);
+  const reason = reason_of2(event);
   const { elapsed_ms: elapsed_ms2 } = event;
   return {
     ...reason !== void 0 && { reason },
@@ -745,14 +807,14 @@ function is_stalled(status, labels = []) {
   return STALLED_STATES.has(status.state) && has_label_name(labels, RUN_STALLED_LABEL);
 }
 var FINISHED_ENDINGS = {
-  done: { word: "done", fallback: "closed without a PR to merge" },
-  withdrawn: { word: "withdrawn", fallback: "run withdrawn" },
-  already_done: { word: "already done", fallback: "closed with verified evidence" }
+  done: "Closed without a merged PR",
+  withdrawn: "Run withdrawn",
+  already_done: "Closed with verified evidence"
 };
 function tail_of(status) {
   const ending = FINISHED_ENDINGS[status.state];
   if (ending === void 0) return status.reason;
-  return `nothing to do \xB7 ${ending.word}: ${status.reason ?? ending.fallback}`;
+  return status.outcome?.summary ?? ending;
 }
 function stop_reason_of(status) {
   if (status.stop_reason === void 0) return void 0;
@@ -763,19 +825,25 @@ function stop_row_reason(status) {
   const reason = stop_reason_of(status);
   return reason === void 0 ? {} : { reason };
 }
-function row_reason(number, status, read5) {
+function ending_row_reason(number, status, read5) {
   const reason = tail_of(status);
   const waits = read5.waits?.get(number);
   if (reason !== void 0) {
     const tail = park_row_reason(number, reason, read5.is_backlog_live === true, waits);
-    return { reason: { tail } };
+    return {
+      reason: { tail, ...status.outcome !== void 0 && { evidence_url: status.outcome.url } }
+    };
   }
   return is_stalled(status, read5.labels.get(number)) ? { reason: stalled_reason(number, read5, waits) } : stop_row_reason(status);
 }
+function row_reason(number, status, read5) {
+  const pause = status.state === "parked" ? run_board_pause.reason_of(number, read5, status) : void 0;
+  return pause === void 0 ? ending_row_reason(number, status, read5) : { reason: pause };
+}
 var run_board_ending_reason = {
   park_reason,
   park_row_reason,
-  reason_of,
+  reason_of: reason_of2,
   recorded_of,
   row_reason,
   stalled_reason
@@ -965,9 +1033,18 @@ function kept_of(previous) {
   };
 }
 function settled_as(previous, state) {
-  return { state, started_ms: previous?.started_ms, ...kept_of(previous) };
+  return {
+    state,
+    started_ms: previous?.started_ms,
+    ...kept_of(previous),
+    ...previous?.outcome !== void 0 && { outcome: previous.outcome }
+  };
+}
+var OUTCOME_STATES = /* @__PURE__ */ new Set(["done", "already_done", "withdrawn"]);
+function with_outcome(status, outcome) {
+  return outcome === void 0 || !OUTCOME_STATES.has(status.state) ? status : { ...status, outcome };
 }
-var run_board_settle = { relaunch_of, settled_as };
+var run_board_settle = { relaunch_of, settled_as, with_outcome };
 
 // scripts/run/board/run-board-lane-stop.ts
 var RELEASE_REASON = "run:release";
@@ -1016,14 +1093,15 @@ var run_board_lane_stop = { RELEASE_REASON, label_settled, label_stop, lane_stat
 var KIND5 = run_event_stream.EVENT_KIND;
 var { STAGE: STAGE2 } = run_event_setup;
 var NO_SETUP = { setup: void 0, setup_ms: void 0 };
-var SESSION_STAGES = /* @__PURE__ */ new Set([
-  STAGE2.JUDGING,
-  STAGE2.SESSION,
-  STAGE2.RETROSPECTIVE
-]);
+var SESSION_STAGES = /* @__PURE__ */ new Set([STAGE2.JUDGING, STAGE2.SESSION]);
+var RETAINED_STAGES = /* @__PURE__ */ new Set([...SESSION_STAGES, STAGE2.RETROSPECTIVE]);
 function is_setup(event) {
   return event.kind === KIND5.SETUP;
 }
+function is_working2(setup, is_session_active) {
+  if (setup === void 0) return false;
+  return !SESSION_STAGES.has(setup) || is_session_active !== false;
+}
 function is_refusal(event) {
   return is_setup(event) && event.text.startsWith(STAGE2.NO_CHILD);
 }
@@ -1039,7 +1117,7 @@ function is_opening(events, stage) {
   return position === void 0 || position.pos < stage.pos;
 }
 function is_standing(events, stage) {
-  if (!has_started(events) || SESSION_STAGES.has(stage.text)) return true;
+  if (!has_started(events) || RETAINED_STAGES.has(stage.text)) return true;
   return is_opening(events, stage);
 }
 function read(events) {
@@ -1065,7 +1143,7 @@ function lane_stage(events, issue) {
   if (step === void 0 || !is_lane_stage(step, issue)) return void 0;
   return { text: step.text, at_ms: Date.parse(step.at) };
 }
-var run_board_setup = { is_refusal, lane_stage, read };
+var run_board_setup = { is_refusal, is_working: is_working2, lane_stage, read };
 
 // scripts/run/board/run-board-status.ts
 var KIND6 = run_event_stream.EVENT_KIND;
@@ -1208,7 +1286,13 @@ function settled(issue, status, read5) {
   return UNSETTLED_STATES.has(status.state) ? unsettled(issue, status, read5) : status;
 }
 function settle_closed(statuses, read5) {
-  return new Map([...statuses].map(([issue, status]) => [issue, settled(issue, status, read5)]));
+  return new Map(
+    [...statuses].map(([issue, status]) => {
+      const closed = read5.closed.get(issue);
+      const outcome = closed === void 0 || is_closed_before_launch(status, closed) ? void 0 : closed.outcome;
+      return [issue, run_board_settle.with_outcome(settled(issue, status, read5), outcome)];
+    })
+  );
 }
 function is_run_stop(event) {
   return event?.kind === KIND6.STOP && run_event_scope.issue_named(event) === void 0;
@@ -1314,10 +1398,14 @@ function is_unlisted(issue, read5) {
   const open = read5.open_numbers;
   return open !== void 0 && !open.has(issue);
 }
+function is_closed_cached(issue, read5) {
+  const closed = read5.closed.get(issue);
+  return closed?.is_merged === true || closed?.outcome !== void 0;
+}
 function is_closed_candidate(issue, status, read5, is_plan_failed) {
   if (ALWAYS_ASKED_STATES.has(status.state)) return true;
   if (status.state === RUNNING_STATE) return is_plan_failed || is_unlisted(issue, read5);
-  return is_unlisted(issue, read5) && !read5.closed.has(issue);
+  return is_unlisted(issue, read5) && !is_closed_cached(issue, read5);
 }
 function has_asked_since_end(state, local) {
   const { closed_answered_ms } = state;
@@ -1526,21 +1614,23 @@ function comment_question(bodies) {
 function read_question(number, read5) {
   return read5.decision_questions?.get(number) ?? read5.titles.get(number) ?? "";
 }
-function reason_of2(number, reason, read5) {
+function reason_of3(number, reason, read5, status) {
+  const pause = run_board_pause.reason_of(number, read5, status);
+  if (pause !== void 0) return pause;
   const parts = parts_of(reason);
   const question = question_of(parts.question) ?? read_question(number, read5);
   if (question === "") return void 0;
   return { tail: `\u2192 decide: ${question}${note_of(parts.note)}` };
 }
 function plan_reason(number, plan) {
-  return reason_of2(number, void 0, { ...plan, titles: plan.context.titles });
+  return reason_of3(number, void 0, { ...plan, titles: plan.context.titles });
 }
 function waiting_tail(reference, title, body = "") {
   const detail = HUMAN_DETAIL.exec(body)?.[1];
   const suffix = detail === void 0 ? "" : ` (${detail})`;
   return `\u2192 decide ${reference}: ${title}${suffix}`;
 }
-var run_board_decision = { comment_question, plan_reason, reason_of: reason_of2, waiting_tail };
+var run_board_decision = { comment_question, plan_reason, reason_of: reason_of3, waiting_tail };
 
 // scripts/run/board/run-board-kind.ts
 var RELEASE_KINDS = [
@@ -1663,7 +1753,7 @@ function pr_reason(issue, prs) {
     pr
   };
 }
-function reason_of3(child, plan) {
+function reason_of4(child, plan) {
   if (child.state !== "OPEN" || !is_waiting(plan, child.number)) return void 0;
   return pr_reason(child.number, plan.human_merge_prs);
 }
@@ -1696,7 +1786,7 @@ function overlay_of(plan, statuses) {
     statuses: new Map([...statuses].filter(([issue]) => !numbers.has(issue)))
   };
 }
-var run_board_human_merge = { overlay_of, read_prs, reason_of: reason_of3, with_prs };
+var run_board_human_merge = { overlay_of, read_prs, reason_of: reason_of4, with_prs };
 
 // scripts/run/board/run-board-standing-waits.ts
 function is_waiting_on(edge, source) {
@@ -1781,7 +1871,7 @@ function touched_row(number, status, read5) {
   const is_asked = status.state === "parked" && run_board_human.is_decision(status.reason);
   const labels = read5.labels.get(number);
   return {
-    ...is_asked ? { reason: run_board_decision.reason_of(number, status.reason, read5) } : run_board_ending_reason.row_reason(number, status, read5),
+    ...is_asked ? { reason: run_board_decision.reason_of(number, status.reason, read5, status) } : run_board_ending_reason.row_reason(number, status, read5),
     ...solo_flag(labels),
     number,
     title: read5.titles.get(number),
@@ -1836,10 +1926,10 @@ function waiting_children2(overlay) {
     (child) => is_untouched(child, overlay) && plan_state(child) === "waiting"
   );
 }
-function layout_of(input_plan, input_statuses, reason_of6, earlier = run_board_earlier.NO_EARLIER) {
+function layout_of(input_plan, input_statuses, reason_of7, earlier = run_board_earlier.NO_EARLIER) {
   const current2 = run_board_human_merge.overlay_of(input_plan, input_statuses);
   const { plan, statuses } = current2;
-  const overlay = { plan, statuses, reason_of: reason_of6 };
+  const overlay = { plan, statuses, reason_of: reason_of7 };
   const queue = plan.waves.waves.flat().filter((child) => is_untouched(child, overlay));
   const read5 = {
     ...plan,
@@ -2000,7 +2090,7 @@ function padded(text, width, emphasized) {
 var run_board_fresh = { aged, padded, paint, since, stage_of };
 
 // scripts/run/board/run-board-issue-count.ts
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 var ICON2 = "\u{1F4EE}";
 var LOCALE = "en-US";
 var COUNT_QUERY = `query($owner: String!, $name: String!) {
@@ -2009,10 +2099,10 @@ var COUNT_QUERY = `query($owner: String!, $name: String!) {
 		closed: issues(states: CLOSED) { totalCount }
 	}
 }`;
-var total_schema = z2.object({ totalCount: z2.number() });
-var search_schema = z2.object({ total_count: z2.number() });
-var answer_schema = z2.object({
-  data: z2.object({ repository: z2.object({ open: total_schema, closed: total_schema }) })
+var total_schema = z3.object({ totalCount: z3.number() });
+var search_schema = z3.object({ total_count: z3.number() });
+var answer_schema = z3.object({
+  data: z3.object({ repository: z3.object({ open: total_schema, closed: total_schema }) })
 }).transform(({ data }) => ({
   open: data.repository.open.totalCount,
   closed: data.repository.closed.totalCount
@@ -2055,24 +2145,24 @@ var run_board_issue_count = { count_of, part_of: part_of2, read_issue_count };
 
 // scripts/run/board/run-board-operation.ts
 import path from "node:path";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // scripts/run/board/run-board-operation-codex.ts
-import { z as z3 } from "zod";
-var CHANGES_SCHEMA = z3.array(z3.object({ path: z3.string() }));
-var ITEM_SCHEMA = z3.object({
-  type: z3.enum(["item.started", "item.updated", "item.completed"]),
-  timestamp: z3.string(),
-  item: z3.object({
-    type: z3.enum(["command_execution", "file_change"]),
-    command: z3.string().optional(),
+import { z as z4 } from "zod";
+var CHANGES_SCHEMA = z4.array(z4.object({ path: z4.string() }));
+var ITEM_SCHEMA = z4.object({
+  type: z4.enum(["item.started", "item.updated", "item.completed"]),
+  timestamp: z4.string(),
+  item: z4.object({
+    type: z4.enum(["command_execution", "file_change"]),
+    command: z4.string().optional(),
     changes: CHANGES_SCHEMA.optional()
   })
 });
 function input_of(item) {
   return item.type === "command_execution" ? { command: item.command } : { file_path: item.changes?.at(-1)?.path };
 }
-function record_of(value) {
+function record_of2(value) {
   const record = ITEM_SCHEMA.safeParse(value).data;
   if (record === void 0) return void 0;
   const { item, timestamp } = record;
@@ -2083,7 +2173,7 @@ function record_of(value) {
     message: { content: [{ type: "tool_use", name: is_command ? "Bash" : "Edit", input }] }
   };
 }
-var run_board_operation_codex = { record_of };
+var run_board_operation_codex = { record_of: record_of2 };
 
 // scripts/run/board/run-board-operation.ts
 var TARGET_LIMIT = 40;
@@ -2098,7 +2188,7 @@ var ASSIGNMENT = new RegExp(String.raw`^\w+=${VALUE}(?:\s*(?:&&|;)\s*|\s+|$)`, "
 var UNREAD_ASSIGNMENT = /^\w+=/u;
 var SPACES = /\s+/gu;
 var ASCII_HEAD = /^[ -~]*/u;
-var INPUT_SCHEMA = z4.looseObject({ command: z4.string().optional(), file_path: z4.string().optional() }).catch({});
+var INPUT_SCHEMA = z5.looseObject({ command: z5.string().optional(), file_path: z5.string().optional() }).catch({});
 function ascii_head(text) {
   return (ASCII_HEAD.exec(text)?.[0] ?? "").trim();
 }
@@ -2112,7 +2202,8 @@ function without_assignments(command) {
 function command_target(command) {
   const [first = ""] = without_assignments(command.trim()).split(NEWLINE);
   if (UNREAD_ASSIGNMENT.test(first)) return "";
-  return cut(ascii_head(token_shape.redact(first).replaceAll(SPACES, " ")));
+  const masked = home_tilde.mask(token_shape.redact(first));
+  return cut(ascii_head(masked.replaceAll(SPACES, " ")));
 }
 function path_target(file_path, root) {
   const relative = root === void 0 ? void 0 : path.relative(root, path.resolve(root, file_path));
@@ -2167,12 +2258,12 @@ function pool_reason(waiting, people) {
 function running_of(running) {
   return `${String(running)} ${WORDS3.in_progress}`;
 }
-function reason_of4(read5) {
+function reason_of5(read5) {
   if (read5.running > 0) return running_of(read5.running);
   return read5.waiting === void 0 ? void 0 : pool_reason(read5.waiting, read5.people);
 }
 function with_reason(line, read5) {
-  const reason = reason_of4(read5);
+  const reason = reason_of5(read5);
   return reason === void 0 ? line : `${line}${REASON_SEPARATOR}${reason}`;
 }
 function latest_line(read5) {
@@ -2300,7 +2391,6 @@ var { padded: padded2 } = run_board_fresh;
 var aged_fresh = run_board_fresh.aged;
 var UNKNOWN = "-";
 var BLANK2 = " ";
-var REPO_SEPARATOR = "/";
 var { GAP, PERCENT_WIDTH } = run_board_machine;
 var STALE_MINUTES = 15;
 var STALE_MS = STALE_MINUTES * MS_PER_MINUTE;
@@ -2326,8 +2416,8 @@ function counts_of(layout) {
 }
 var WORKING_MARKS = /* @__PURE__ */ new Set(["running", "setup"]);
 function quiet_mark(header) {
-  const { layout } = header;
-  if (header.activity.setup !== void 0) return "setup";
+  const { activity, layout } = header;
+  if (run_board_setup.is_working(activity.setup, activity.is_setup_working)) return "setup";
   return layout?.queued.length === 0 && run_board_layout.people_of(layout).length > 0 ? "human" : "idle";
 }
 function mark_of(header, running) {
@@ -2339,7 +2429,7 @@ function run_part(mark, name = RUN_NAME) {
   return styleText2(color, `${glyph} ${name}`);
 }
 function repo_part(header, mark) {
-  const name = header.repo?.split(REPO_SEPARATOR).at(-1) ?? "";
+  const name = header.repo?.split("/").at(-1) ?? "";
   const indent = run_board_fit.width_of(RUN_MARKS[mark].glyph) + BLANK2.length;
   return `${BLANK2.repeat(indent)}${header.repo_link(name, "home")}`;
 }
@@ -2541,6 +2631,7 @@ function repo_linker(repo, link) {
 }
 function links_of(repo, link) {
   return {
+    comment_link: link,
     link: linker(repo, link),
     pull_link: pull_linker(repo, link),
     repo_link: repo_linker(repo, link)
@@ -2771,7 +2862,7 @@ function wait_of(child, waits, read5, pool) {
 function reader(read5) {
   const current2 = { ...read5, ...run_board_human_merge.overlay_of(read5.plan, read5.statuses) };
   const pool = pool_of(current2);
-  return function reason_of6(child, waits) {
+  return function reason_of7(child, waits) {
     return run_board_human_merge.reason_of(child, current2.plan) ?? stage_of2(child, current2) ?? planned_of(child, pool) ?? wait_of(child, waits, current2, pool);
   };
 }
@@ -3001,8 +3092,13 @@ function value_of(reason, header) {
   if (since_ms !== void 0) return run_board_labels.span_of(header.now_ms - since_ms);
   return pr_linked(reason.value ?? "", reason.pr, header);
 }
+function evidence_linked(text, url, header) {
+  return header.comment_link?.(text, url) ?? text;
+}
 function tail_of2(row, cut2, header) {
-  return pr_linked(run_board_render_title.reason_text(row, cut2) ?? "", row.reason?.pr, header);
+  const text = run_board_render_title.reason_text(row, cut2) ?? "";
+  const url = row.reason?.evidence_url;
+  return url === void 0 ? pr_linked(text, row.reason?.pr, header) : evidence_linked(text, url, header);
 }
 function ended_of(row, header) {
   const ended_ms = row.status?.ended_ms;
@@ -4823,7 +4919,7 @@ async function spin_to_second(spots, ports) {
 var run_board_spin = { REDRAW_MS, SPOT, spin_bytes, spin_to_second, spun };
 
 // scripts/run/board/run-board-thanks-read.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 
 // scripts/run/board/run-board-thanks-csv.ts
 import { parse } from "csv-parse/sync";
@@ -4868,11 +4964,11 @@ var ROSTER_URL = "https://docs.google.com/spreadsheets/d/e/2PACX-1vR8Ia38Wiw6Kfy
 var RECORD_PREFIX = "josh-run-board-thanks-";
 var TTL_MINUTES = 5;
 var TTL_MS = TTL_MINUTES * MS_PER_MINUTE;
-var thanker_schema = z5.object({ name: z5.string(), url: z5.string().optional() });
-var record_schema = z5.object({ checked_ms: z5.number(), thanks: z5.array(thanker_schema) });
+var thanker_schema = z6.object({ name: z6.string(), url: z6.string().optional() });
+var record_schema2 = z6.object({ checked_ms: z6.number(), thanks: z6.array(thanker_schema) });
 function read_record(record_path) {
   const raw = stamp_file.read_stamp_text(record_path);
-  const parsed2 = raw === void 0 ? void 0 : json_value.parse_with(raw, record_schema);
+  const parsed2 = raw === void 0 ? void 0 : json_value.parse_with(raw, record_schema2);
   if (parsed2 === void 0) return void 0;
   return {
     checked_ms: parsed2.checked_ms,
@@ -4972,10 +5068,14 @@ function titles_of2(state) {
   return closed_under(known_of2(state), state.closed).titles;
 }
 function activity_here(local) {
-  return run_board_status.activity_of(
+  const activity = run_board_status.activity_of(
     local.events,
     local.ended_ms !== void 0 || local.is_stranded
   );
+  return {
+    ...activity,
+    is_setup_working: run_board_setup.is_working(activity.setup, local.is_session_active)
+  };
 }
 function is_backlog_live(local) {
   const roots = local.roots ?? {};
@@ -5021,7 +5121,7 @@ function earlier_here(local) {
 function planned_layout(state, input_plan, local, now_ms) {
   const plan = plan_here(input_plan, state, local);
   const statuses = planned_statuses(state, plan, local);
-  const reason_of6 = run_board_reason.reader({
+  const reason_of7 = run_board_reason.reader({
     plan,
     statuses,
     events: local.events,
@@ -5030,7 +5130,7 @@ function planned_layout(state, input_plan, local, now_ms) {
     is_stopped: activity_here(local).is_stopped,
     now_ms
   });
-  return run_board_layout.layout_of(plan, statuses, reason_of6, earlier_here(local));
+  return run_board_layout.layout_of(plan, statuses, reason_of7, earlier_here(local));
 }
 function layout_for(state, local, now_ms) {
   if (state.plan !== void 0) return planned_layout(state, state.plan, local, now_ms);
@@ -5515,11 +5615,11 @@ function held_reader(ports) {
 var run_board_held = { held_reader };
 
 // scripts/run/board/run-board-quota-spent.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var MS_PER_MINUTE3 = 6e4;
 var HALF = 2;
-var CLAUDE_END = z6.looseObject({ type: z6.literal("result") });
-var CODEX_END = z6.looseObject({ payload: z6.looseObject({ type: z6.literal("task_complete") }) });
+var CLAUDE_END = z7.looseObject({ type: z7.literal("result") });
+var CODEX_END = z7.looseObject({ payload: z7.looseObject({ type: z7.literal("task_complete") }) });
 function last_line(text) {
   const trimmed = text.trimEnd();
   return trimmed.slice(trimmed.lastIndexOf("\n") + 1);
@@ -5592,17 +5692,17 @@ var run_board_quota_spent = { claude_done, codex_done, per_lane_of, per_task_of,
 
 // scripts/run/board/run-board-quota-status.ts
 import { readFile } from "node:fs/promises";
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var MS_PER_SECOND2 = 1e3;
 var MAX_PERCENTAGE = 100;
-var WINDOW = z7.object({
-  used_percentage: z7.number().min(0).max(MAX_PERCENTAGE),
-  resets_at: z7.number().nonnegative()
+var WINDOW = z8.object({
+  used_percentage: z8.number().min(0).max(MAX_PERCENTAGE),
+  resets_at: z8.number().nonnegative()
 });
-var RECORD = z7.object({
+var RECORD = z8.object({
   five_hour: WINDOW.nullable(),
   seven_day: WINDOW.nullable(),
-  at: z7.string()
+  at: z8.string()
 });
 function window_of(minutes, window) {
   if (window === null) return [];
@@ -6057,12 +6157,24 @@ function parent_of(read5, is_same) {
 function roots_of(repository, read5, is_same = process_identity.is_same_process) {
   return { supervisor: supervisor_of(repository, is_same), parent: parent_of(read5, is_same) };
 }
+function is_session_owner(read5) {
+  return read5.kind === "carried" && read5.carry.is_handed_off !== true;
+}
+function live_session_pid(pid, start2, wake, is_same) {
+  return pid !== void 0 && pid !== wake?.pid && is_same(pid, start2) !== false;
+}
+function session_is_active(repository, read5, is_same) {
+  if (read5.kind !== "carried" || !is_session_owner(read5)) return false;
+  const wake = run_wake.read_wake(run_wake.wake_path(repository));
+  const pid = read5.carry.owner_pid ?? wake?.woke_pid;
+  return live_session_pid(pid, read5.carry.owner_start, wake, is_same);
+}
 async function same_in(table) {
   const rows = table === void 0 ? void 0 : await table();
   const read5 = lane_process_table.start_reader(rows ?? []);
   return (pid, start2) => process_identity.is_same_process(pid, start2, read5);
 }
-var run_board_roots = { roots_of, same_in };
+var run_board_roots = { roots_of, same_in, session_is_active };
 
 // scripts/run/board/run-board-single.ts
 var FULLRUN = "fullrun";
@@ -6333,7 +6445,8 @@ var NO_SPAN = {
   transcript: void 0,
   roots: {},
   carry: void 0,
-  is_stranded: false
+  is_stranded: false,
+  is_session_active: false
 };
 var main_roots = stamped_memo.create();
 async function main_root() {
@@ -6360,6 +6473,7 @@ async function recorded_span_here(repository, table, read5) {
     resume: run_board_span.resume_of(read5, ended2, launch2),
     transcript: read5.kind === "carried" ? read5.carry.owner_transcript : void 0,
     roots: run_board_roots.roots_of(repository, read5, same_process),
+    is_session_active: run_board_roots.session_is_active(repository, read5, same_process),
     carry: read5.kind === "carried" ? read5.carry : void 0,
     is_stranded: run_stranded_detect.is_stranded_at(repository, stranded_ports)
   };
@@ -6456,7 +6570,7 @@ function span_fields(span) {
 }
 async function read_local(table) {
   const repository = await run_carry.repository_directory();
-  const { span, resume, transcript, roots, carry, is_stranded } = repository === void 0 ? NO_SPAN : await span_here2(repository, table);
+  const { span, resume, transcript, roots, carry, is_stranded, is_session_active } = repository === void 0 ? NO_SPAN : await span_here2(repository, table);
   if (repository === void 0 || span === void 0) return void 0;
   const events = run_event_tail.read_events(run_event_stream.target_of(repository));
   const lanes = await lane_registry.list_lanes(await main_root());
@@ -6472,6 +6586,7 @@ async function read_local(table) {
     roots,
     carry,
     is_stranded,
+    is_session_active,
     operations: run_board_operation_read.read(sources_of2(repository, lanes, transcript)),
     ...await lane_room_of(lanes, lane_read.lane_states, table),
     ...ledger_here(repository)
@@ -6734,12 +6849,12 @@ function post_of(before, after) {
 function is_post(value) {
   return typeof value === "object" && value !== null && "read" in value;
 }
-function reason_of5(error) {
+function reason_of6(error) {
   const message = error instanceof Error ? error.message : String(error);
   return message.split("\n", 1)[0] ?? "";
 }
 function failed_of(error) {
-  return { failed: reason_of5(error) };
+  return { failed: reason_of6(error) };
 }
 async function gather_round(state, ports, post) {
   try {
@@ -6782,7 +6897,7 @@ function listen(thread, worker, now) {
     else if (is_failed(value)) said_failed(thread, value.failed, now);
   });
   worker.on("error", (error) => {
-    fail(thread, worker, reason_of5(error), now);
+    fail(thread, worker, reason_of6(error), now);
   });
   worker.on("exit", (code) => {
     fail(thread, worker, `exit ${String(code)}`, now);
@@ -6855,7 +6970,7 @@ function read_keys(input) {
 var run_board_keys = { CTRL_C, read_keys };
 
 // scripts/run/board/run-board-plan-shared.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // scripts/run/board/run-board-decision-graphql.ts
 var NODE_FIELDS = "number,title,body,state,labels,blockedBy";
@@ -6983,25 +7098,42 @@ async function blocker_of(reference, read5, seen) {
   );
   return blockers.find((blocker) => blocker !== void 0) ?? terminal_of(node);
 }
-async function question_of2(number, repo, answered) {
+async function read_comments2(number, repo, answered) {
   const json = answered.get(number) ?? await git_gh_issue_read.issue_list_comments(
     String(number),
     void 0,
     repo,
     git_gh_issue_read.read_comments_conditionally
   );
-  const comments = await issue_read.parse_comments(json, repo);
-  const question = run_board_decision.comment_question(issue_read.trusted_bodies(comments ?? []));
-  return question === void 0 ? void 0 : [number, question];
+  return await issue_read.parse_comments(json, repo) ?? [];
+}
+async function comments_of(number, repo, answered) {
+  try {
+    return await read_comments2(number, repo, answered);
+  } catch {
+    return [];
+  }
+}
+async function question_of2(number, repo, answered) {
+  const comments = await comments_of(number, repo, answered);
+  const question = run_board_decision.comment_question(issue_read.trusted_bodies(comments));
+  const issue_url2 = `https://github.com/${repo}/issues/${String(number)}`;
+  return [number, { question, pause: run_board_pause.from_comments(comments, issue_url2) }];
+}
+function question_pair([number, value]) {
+  return value.question === void 0 ? [] : [[number, value.question]];
 }
 async function questions_of(plan) {
   const { repo } = plan.context;
-  const numbers = [...plan.labels].filter(([, labels]) => has_label_name(labels, NEEDS_DECISION_LABEL)).map(([number]) => number);
+  const numbers = [...plan.labels].filter(([, labels]) => has_parked_label(labels)).map(([number]) => number);
   const answered = await run_board_decision_graphql.read_comments(numbers, repo);
   const pairs = await Promise.all(
     numbers.map(async (number) => await question_of2(number, repo, answered))
   );
-  return new Map(pairs.filter((pair) => pair !== void 0));
+  return {
+    decision_questions: new Map(pairs.flatMap((pair) => question_pair(pair))),
+    pause_reasons: new Map(pairs.map(([number, value]) => [number, value.pause]))
+  };
 }
 async function wait_of2(child, read5) {
   if (read5.plan.withheld?.has(child.number) !== true) return void 0;
@@ -7030,13 +7162,13 @@ async function with_decisions(plan) {
     ...plan.waves.running ?? []
   ];
   const read5 = read_of3(plan, children2);
-  const [decision_questions, waits] = await Promise.all([
+  const [questions, waits] = await Promise.all([
     questions_of(plan),
     Promise.all(children2.map(async (child) => await wait_of2(child, read5)))
   ]);
   return {
     ...plan,
-    decision_questions,
+    ...questions,
     decision_waits: new Map(waits.filter((pair) => pair !== void 0))
   };
 }
@@ -7138,57 +7270,58 @@ var PLAN_CACHE = {
   ttl_ms: backlog_next_shared.NEXT_CACHE.ttl_ms
 };
 function map_of(value) {
-  const entries = z8.array(z8.tuple([z8.number(), value]));
-  const map = z8.map(z8.number(), z8.custom()).readonly();
-  return z8.codec(entries, map, {
+  const entries = z9.array(z9.tuple([z9.number(), value]));
+  const map = z9.map(z9.number(), z9.custom()).readonly();
+  return z9.codec(entries, map, {
     decode: (pairs) => new Map(pairs),
     encode: (pairs) => [...pairs]
   });
 }
-var number_set = z8.codec(z8.array(z8.number()), z8.set(z8.number()).readonly(), {
+var number_set = z9.codec(z9.array(z9.number()), z9.set(z9.number()).readonly(), {
   decode: (numbers) => new Set(numbers),
   encode: (numbers) => [...numbers]
 });
-var optional_numbers = z8.array(z8.number()).optional();
-var unknown_or_set = z8.codec(
-  z8.object({ numbers: optional_numbers }),
-  z8.custom(),
+var optional_numbers = z9.array(z9.number()).optional();
+var unknown_or_set = z9.codec(
+  z9.object({ numbers: optional_numbers }),
+  z9.custom(),
   {
     decode: ({ numbers }) => numbers === void 0 ? void 0 : new Set(numbers),
     encode: (numbers) => numbers === void 0 ? {} : { numbers: [...numbers] }
   }
 );
-var string_set = z8.codec(z8.array(z8.string()), z8.set(z8.string()).readonly(), {
+var string_set = z9.codec(z9.array(z9.string()), z9.set(z9.string()).readonly(), {
   decode: (values) => new Set(values),
   encode: (values) => [...values]
 });
-var names2 = z8.array(z8.string()).readonly();
-var reference_schema = z8.object({ repo: z8.string(), number: z8.number() });
-var child_schema = z8.object({
-  number: z8.number(),
-  repo: z8.string(),
-  state: z8.enum(["OPEN", "CLOSED"]),
+var names2 = z9.array(z9.string()).readonly();
+var reference_schema = z9.object({ repo: z9.string(), number: z9.number() });
+var child_schema = z9.object({
+  number: z9.number(),
+  repo: z9.string(),
+  state: z9.enum(["OPEN", "CLOSED"]),
   labels: names2,
-  blocked_by: z8.array(reference_schema).readonly(),
-  body: z8.string().optional()
+  blocked_by: z9.array(reference_schema).readonly(),
+  body: z9.string().optional()
 });
-var children = z8.array(child_schema).readonly();
-var waves_schema = z8.object({
-  waves: z8.array(children).readonly(),
+var children = z9.array(child_schema).readonly();
+var waves_schema = z9.object({
+  waves: z9.array(children).readonly(),
   unreached: children,
   running: children.exactOptional()
 });
-var context_schema = z8.object({
-  repo: z8.string(),
-  titles: map_of(z8.string()),
+var context_schema = z9.object({
+  repo: z9.string(),
+  titles: map_of(z9.string()),
   open_numbers: unknown_or_set
 });
-var board_plan_schema = z8.object({
-  decision_questions: map_of(z8.string()).optional(),
-  decision_waits: map_of(z8.string()).optional(),
-  human_merge_prs: map_of(z8.number()).optional(),
+var board_plan_schema = z9.object({
+  pause_reasons: map_of(run_board_pause.record_schema).optional(),
+  decision_questions: map_of(z9.string()).optional(),
+  decision_waits: map_of(z9.string()).optional(),
+  human_merge_prs: map_of(z9.number()).optional(),
   waves: waves_schema,
-  tracked: map_of(z8.number()),
+  tracked: map_of(z9.number()),
   context: context_schema,
   labels: map_of(names2),
   declared: map_of(string_set).optional(),