@joshuafolkken/kit 1.1455.0 → 1.1514.0

package/dist/hooks/stop-guard.js

@@ -1,60 +1,105 @@
 #!/usr/bin/env tsx
 import {
+  IN_PROGRESS_LABEL,
+  PROCESS_ALIVE,
+  PROCESS_NONE,
+  PROCESS_UNKNOWN,
   RUN_LANE_LABEL,
   RUN_SOLO_LABEL,
+  bounded_pool,
   filing_cap,
   gh_spawn,
   git_gh_command,
+  git_gh_issue_read,
+  git_gh_repo,
   has_label_name,
-  issue_citation,
+  issue_state,
+  label_name_of,
   lane_background,
   lane_handoff,
   lane_park,
+  pre_gate_cut,
   repo_party,
   run_cut,
-  run_hold
-} from "./chunk-7WQBPLUN.js";
+  run_cut_handoff,
+  run_liveness,
+  tail_commands
+} from "./chunk-SYOTDYCI.js";
+import {
+  LEDGER_FILE_EXTENSION,
+  LEGACY_LEDGER_FILE,
+  LEGACY_OBSERVATION_LEDGER_DIRECTORY,
+  LEGACY_OBSERVATION_LEDGER_PATHS,
+  MIGRATION_CLAIM_SUFFIX,
+  OBSERVATION_LEDGER_DIRECTORY,
+  observation_ledger
+} from "./chunk-4KKD2UTK.js";
 import {
   agent_headless,
-  agent_role_profile,
+  git_gh_api_path,
+  git_gh_exec,
+  git_worktree,
+  has_stderr_field,
+  issue_citation,
   issue_cite,
+  lane_child_invocation,
+  lane_reap,
   lane_registry,
+  parse_json_object_or_undefined,
+  process_tools,
+  repository_lock,
   run_event_stream,
   run_event_stream_emit,
   run_headless,
+  run_hold,
+  run_preflight,
+  session_cite,
   session_language
-} from "./chunk-Z4XI7CZS.js";
+} from "./chunk-WK6SMBIC.js";
 import {
   timed_fetch
 } from "./chunk-723HKZO5.js";
-import "./chunk-CDY4NFQG.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  agent_role_profile
+} from "./chunk-UPUZF3AN.js";
 import {
   hook_decision
-} from "./chunk-GPLGZ6IC.js";
+} from "./chunk-6TS2JD6D.js";
 import {
   time_density_hook,
   time_hook_transcript,
   time_reported_failure
-} from "./chunk-LIAFCXL7.js";
+} from "./chunk-TNUMY6NL.js";
 import {
+  josh_environment_file,
   lane_child_marker
-} from "./chunk-OLMO72ON.js";
+} from "./chunk-LAOV7NLM.js";
 import {
   backlog_budget,
+  cli_flags,
+  file_reader,
+  git_command,
+  git_spawn,
+  issue_label_schema,
   issue_number_shape,
   json_value,
+  lane_paths,
   process_identity,
   process_owner_schema,
   run_carry,
   run_invocation
-} from "./chunk-3C4XRYG6.js";
+} from "./chunk-APUO6U4J.js";
 import {
+  PROBE_TIMEOUT_MS,
   stamp_file
 } from "./chunk-DGT54IH5.js";
 
 // scripts/hooks/stop-guard.ts
 import { text } from "node:stream/consumers";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // scripts/josh/josh-run.ts
 import { execa } from "execa";
@@ -83,8 +128,8 @@ async function carry_target() {
   return repository === void 0 ? void 0 : run_carry.carry_path(repository);
 }
 function live_carry(target) {
-  const read = run_carry.read_carry(target);
-  return read.kind === "carried" ? read.carry : void 0;
+  const read2 = run_carry.read_carry(target);
+  return read2.kind === "carried" ? read2.carry : void 0;
 }
 async function read_override() {
   const target = await carry_target();
@@ -152,8 +197,10 @@ async function lane_limit(environment = process.env, read_override2 = lane_limit
 function seated_limit(limit) {
   return Math.min(limit, lane_seed_policy.LAST_LANE_SEAT);
 }
-function free_lanes(limit, occupied) {
-  return Math.max(NO_LANES, seated_limit(limit) - occupied);
+function free_lanes(limit, occupied, seated = occupied) {
+  const by_limit = seated_limit(limit) - occupied;
+  const by_seats = lane_seed_policy.LAST_LANE_SEAT - seated;
+  return Math.max(NO_LANES, Math.min(by_limit, by_seats));
 }
 var lane_capacity = {
   LANE_LIMIT_KEY,
@@ -163,6 +210,304 @@ var lane_capacity = {
   seated_limit
 };
 
+// scripts/backlog/backlog-drive-restore.ts
+var ISSUE_IN_EVENT = /#([1-9]\d*)\b/u;
+var SETTLED_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.MERGE,
+  run_event_stream.EVENT_KIND.PARK,
+  run_event_stream.EVENT_KIND.SPLIT,
+  run_event_stream.EVENT_KIND.WITHDRAW,
+  run_event_stream.EVENT_KIND.OUTAGE
+]);
+var DONE_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.MERGE,
+  run_event_stream.EVENT_KIND.PARK,
+  run_event_stream.EVENT_KIND.SPLIT,
+  run_event_stream.EVENT_KIND.WITHDRAW
+]);
+function issue_of(event) {
+  return ISSUE_IN_EVENT.exec(event.text)?.[1];
+}
+function update_active(active, event) {
+  const issue = issue_of(event);
+  if (issue === void 0) return;
+  if (event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH) active.add(issue);
+  if (SETTLED_KINDS.has(event.kind)) active.delete(issue);
+}
+function active_issues(events) {
+  const active = /* @__PURE__ */ new Set();
+  for (const event of events) update_active(active, event);
+  return active;
+}
+function settled_issues(events) {
+  const settled = events.filter((event) => DONE_KINDS.has(event.kind));
+  return new Set(
+    settled.map((event) => issue_of(event)).filter((issue) => issue !== void 0).map(Number)
+  );
+}
+function parked_issues(events) {
+  return new Set(
+    events.filter((event) => event.kind === run_event_stream.EVENT_KIND.PARK).map((event) => issue_of(event)).filter((issue) => issue !== void 0).map(Number)
+  );
+}
+function mentioned_issues(events) {
+  const tracked = events.filter(
+    (event) => event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH || SETTLED_KINDS.has(event.kind)
+  );
+  return new Set(tracked.map((event) => issue_of(event)).filter((issue) => issue !== void 0));
+}
+function restore(lanes, events, merged_issues, dispatched = []) {
+  const active = active_issues(events);
+  const mentioned = mentioned_issues(events);
+  const carried2 = new Set(dispatched.filter((issue) => !mentioned.has(issue)));
+  return lanes.filter(
+    (issue) => (active.has(issue) || carried2.has(issue)) && !merged_issues.includes(Number(issue))
+  );
+}
+var backlog_drive_restore = {
+  active_issues,
+  mentioned_issues,
+  restore,
+  settled_issues,
+  parked_issues
+};
+
+// scripts/lane/lane-await.ts
+import { spawnSync } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+import { parseArgs } from "node:util";
+var RECONFIRM_MS = 15e3;
+var DEFAULT_POLL_MS = 5e3;
+var NEVER_APPEARED_TIMEOUT_MS = 6e5;
+var MS_PER_SECOND = 1e3;
+var PROCESS_FOUND = 0;
+var PROCESS_NOT_FOUND = 1;
+var PGREP_COMMAND = "pgrep";
+function process_trace_default(issue) {
+  const pattern = lane_child_invocation.process_pattern(issue);
+  const result = spawnSync(PGREP_COMMAND, ["-f", pattern], {
+    encoding: "utf8",
+    timeout: PROBE_TIMEOUT_MS
+  });
+  process_tools.throw_if_missing(PGREP_COMMAND, result.error);
+  if (result.status === PROCESS_FOUND || lane_handoff.is_ship_running(issue, process.cwd())) {
+    return PROCESS_ALIVE;
+  }
+  return result.status === PROCESS_NOT_FOUND ? PROCESS_NONE : PROCESS_UNKNOWN;
+}
+function is_process_running_default(issue) {
+  return process_trace_default(issue) === PROCESS_ALIVE;
+}
+async function is_settled_default(issue) {
+  return await run_liveness.read_child_settled(issue) === true;
+}
+function read_await_args(rest) {
+  try {
+    return parseArgs({
+      args: [...rest],
+      allowPositionals: true,
+      strict: true,
+      options: { owner: { type: "string" } }
+    });
+  } catch {
+    return void 0;
+  }
+}
+function is_valid(raw) {
+  const { owner } = raw.values;
+  const numbers = owner === void 0 ? raw.positionals : [...raw.positionals, owner];
+  return raw.positionals.length > 0 && numbers.every((value) => issue_number_shape.is_issue_number(value));
+}
+function parse_arguments(rest) {
+  const raw = read_await_args(rest);
+  if (raw === void 0 || !is_valid(raw)) return void 0;
+  const { owner } = raw.values;
+  return { issues: raw.positionals, owner: owner === void 0 ? void 0 : Number(owner) };
+}
+function make_initial_state(is_settled) {
+  return { appeared: false, disappeared_at: void 0, first_polled_at: void 0, is_settled };
+}
+async function make_states(issues, is_settled) {
+  const settled = await Promise.all(issues.map(async (issue) => await is_settled(issue)));
+  return new Map(issues.map((issue, index) => [issue, make_initial_state(settled[index] === true)]));
+}
+function resolve_timing(options) {
+  return {
+    poll_ms: options.poll_ms ?? DEFAULT_POLL_MS,
+    reconfirm_ms: options.reconfirm_ms ?? RECONFIRM_MS,
+    never_appeared_timeout_ms: options.never_appeared_timeout_ms ?? NEVER_APPEARED_TIMEOUT_MS
+  };
+}
+function resolve_options(options) {
+  return {
+    is_running: options.is_running ?? is_process_running_default,
+    is_settled: options.is_settled ?? is_settled_default,
+    now: options.now ?? Date.now,
+    sleep: options.sleep ?? sleep,
+    ...resolve_timing(options)
+  };
+}
+function update_liveness(state, is_live) {
+  if (!is_live) return;
+  state.appeared = true;
+  state.disappeared_at = void 0;
+}
+function check_not_appeared(issue, state, now_ms, timeout_ms) {
+  if (state.is_settled === true) return issue;
+  state.first_polled_at ??= now_ms;
+  const elapsed_ms = now_ms - state.first_polled_at;
+  if (elapsed_ms >= timeout_ms) {
+    throw new Error(
+      `lane child ${issue} never appeared within ${String(timeout_ms / MS_PER_SECOND)}s`
+    );
+  }
+  return void 0;
+}
+function check_issue(issue, state, now_ms, config) {
+  const is_live = config.is_running(issue);
+  update_liveness(state, is_live);
+  if (is_live) return void 0;
+  if (!state.appeared) {
+    return check_not_appeared(issue, state, now_ms, config.never_appeared_timeout_ms);
+  }
+  if (state.disappeared_at === void 0) {
+    state.disappeared_at = now_ms;
+    return void 0;
+  }
+  return now_ms - state.disappeared_at >= config.reconfirm_ms ? issue : void 0;
+}
+function check_any(states, now_ms, config) {
+  for (const [issue, state] of states) {
+    const result = check_issue(issue, state, now_ms, config);
+    if (result !== void 0) return result;
+  }
+  return void 0;
+}
+async function wait_for_any(issues, options = {}) {
+  const config = resolve_options(options);
+  const states = await make_states(issues, config.is_settled);
+  for (; ; ) {
+    const completed = check_any(states, config.now(), config);
+    if (completed !== void 0) return completed;
+    await config.sleep(config.poll_ms);
+  }
+}
+var lane_await = {
+  NEVER_APPEARED_TIMEOUT_MS,
+  RECONFIRM_MS,
+  check_issue,
+  is_process_running_default,
+  parse_arguments,
+  process_trace_default,
+  wait_for_any
+};
+
+// scripts/lane/lane-spent.ts
+var STATE_FIELD = "state";
+var CLOSED_STATE = "CLOSED";
+async function read_issue_state(issue) {
+  const json = await git_gh_issue_read.issue_view_json(issue, STATE_FIELD);
+  return json === void 0 ? void 0 : issue_state.parse_issue_state(json)?.state;
+}
+async function read_unpushed_commits(branch) {
+  try {
+    return await git_command.commit_count_unpushed(branch);
+  } catch {
+    return void 0;
+  }
+}
+async function read_in_flight() {
+  return backlog_drive_restore.active_issues(await run_event_stream_emit.current_events());
+}
+var LIVE_PROBES = {
+  process_trace: lane_await.process_trace_default,
+  issue_state: read_issue_state,
+  in_flight: read_in_flight,
+  is_tree_dirty: run_hold.is_tree_dirty,
+  unpushed_commits: read_unpushed_commits
+};
+function trace_of(lane, probes) {
+  return lane.is_stranded ? PROCESS_NONE : probes.process_trace(lane.issue);
+}
+async function child_reason(lane, probes) {
+  const trace = probes.process_trace(lane.issue);
+  if (trace === PROCESS_NONE) return void 0;
+  return trace === PROCESS_ALIVE ? "a child is still working in it" : "whether a child is working in it could not be read";
+}
+async function issue_reason(lane, probes) {
+  const state = await probes.issue_state(lane.issue);
+  if (state === CLOSED_STATE) return void 0;
+  return state === void 0 ? "its issue could not be read" : "its issue is still open";
+}
+async function run_reason(lane, probes) {
+  const in_flight = await probes.in_flight();
+  return in_flight.has(lane.issue) ? "the running backlogrun has not collected it yet (`pnpm josh run:merge` does)" : void 0;
+}
+async function tree_reason(lane, probes) {
+  return await probes.is_tree_dirty(lane.directory) ? "it has uncommitted changes" : void 0;
+}
+async function commit_reason(lane, probes) {
+  const count = await probes.unpushed_commits(lane.branch);
+  if (count === 0) return void 0;
+  return count === void 0 ? "its commits could not be counted" : `it has ${String(count)} commit(s) that are on no remote`;
+}
+var CHECKS = [
+  child_reason,
+  issue_reason,
+  run_reason,
+  tree_reason,
+  commit_reason
+];
+async function kept_reason(lane, probes = LIVE_PROBES) {
+  const reasons = await Promise.all(CHECKS.map(async (check) => await check(lane, probes)));
+  return reasons.find((reason) => reason !== void 0);
+}
+async function sort_lanes(lanes, probes = LIVE_PROBES) {
+  const live = lanes.filter((lane) => !lane.is_stranded);
+  const reasons = await Promise.all(live.map(async (lane) => await kept_reason(lane, probes)));
+  const sorted = { spent: [], kept: [] };
+  for (const [index, lane] of live.entries()) {
+    const reason = reasons[index];
+    if (reason === void 0) sorted.spent.push(lane);
+    else sorted.kept.push({ issue: lane.issue, reason });
+  }
+  return sorted;
+}
+function issues_traced(traced, trace) {
+  return traced.filter(([, answer2]) => answer2 === trace).map(([issue]) => issue);
+}
+function traced_of(lanes, probes) {
+  return lanes.map((lane) => [lane.issue, trace_of(lane, probes)]);
+}
+async function lanes_in_use(probes = LIVE_PROBES) {
+  const traced = traced_of(await lane_registry.list_lanes(), probes);
+  return {
+    working: issues_traced(traced, PROCESS_ALIVE),
+    unread: issues_traced(traced, PROCESS_UNKNOWN)
+  };
+}
+function idle_lanes(lanes, probes = LIVE_PROBES) {
+  return issues_traced(traced_of(lanes, probes), PROCESS_NONE);
+}
+var lane_spent = { idle_lanes, kept_reason, lanes_in_use, sort_lanes };
+
+// scripts/backlog/backlog-occupied.ts
+function owned_issues(read2) {
+  const { invocation, events } = read2;
+  const is_only = invocation !== void 0 && run_invocation.has_only(invocation);
+  if (!is_only || events === void 0) return void 0;
+  const named = (run_invocation.issue_numbers(invocation) ?? []).map(String);
+  return /* @__PURE__ */ new Set([...named, ...backlog_drive_restore.mentioned_issues(events)]);
+}
+function occupied_lanes(lanes, read2) {
+  const live = lanes.filter((lane) => !lane.is_stranded);
+  const owned = owned_issues(read2);
+  if (owned === void 0) return live;
+  const idle = new Set(read2.idle(live));
+  return live.filter((lane) => owned.has(lane.issue) || !idle.has(lane.issue));
+}
+var backlog_occupied = { occupied_lanes };
+
 // scripts/epic/epic-triage.ts
 var TRIAGE_VERDICT = "triage";
 function has_triage_label(labels) {
@@ -240,16 +585,36 @@ var backlog_stalled = {
 // scripts/backlog/backlog-ready.ts
 var NO_FREE = 0;
 var NONE2 = 0;
-async function live_lane_count() {
-  return lane_registry.live_count(await lane_registry.list_lanes());
+async function occupied_read() {
+  const carry = await run_headless.current_carry();
+  return {
+    invocation: carry?.invocation,
+    events: carry === void 0 ? [] : await run_event_stream_emit.scoped_current_events(),
+    idle: lane_spent.idle_lanes
+  };
+}
+async function occupied_lanes2(lanes) {
+  const open = lanes ?? await lane_registry.list_lanes();
+  return backlog_occupied.occupied_lanes(open, await occupied_read());
+}
+async function lane_use(lanes) {
+  const open = lanes ?? await lane_registry.list_lanes();
+  const occupied = await occupied_lanes2(open);
+  return { occupied: occupied.length, seated: open.filter((lane) => !lane.is_stranded).length };
+}
+function free_of(limit, use) {
+  return lane_capacity.free_lanes(limit, use.occupied, use.seated);
+}
+async function free_lanes_beside(lanes) {
+  const limit = await lane_capacity.lane_limit();
+  if (limit.kind !== "limit") return void 0;
+  return free_of(limit.limit, await lane_use(lanes));
 }
 async function free_under(limit) {
-  return lane_capacity.free_lanes(limit, await live_lane_count());
+  return free_of(limit, await lane_use());
 }
 async function free_lane_count() {
-  const limit = await lane_capacity.lane_limit();
-  if (limit.kind !== "limit") return NO_FREE;
-  return await free_under(limit.limit);
+  return await free_lanes_beside(await lane_registry.list_lanes()) ?? NO_FREE;
 }
 async function drive_free_lane_count() {
   const limit = await lane_capacity.lane_limit();
@@ -275,8 +640,8 @@ async function read_ready(ports = DEFAULT_PORTS) {
 }
 function ready_line(reading, slug) {
   if (reading.issues.length === NONE2 || reading.free_lanes <= NO_FREE) return void 0;
-  const cite = issue_cite.citer(slug, /* @__PURE__ */ new Map());
-  const issues = reading.issues.map((issue) => cite(issue)).join(" ");
+  const cite3 = issue_cite.citer(slug, /* @__PURE__ */ new Map());
+  const issues = reading.issues.map((issue) => cite3(issue)).join(" ");
   return `ready ${issues} \xB7 free lanes ${String(reading.free_lanes)}`;
 }
 async function parent_ready_line(ports, is_parent, read_repo) {
@@ -306,7 +671,9 @@ var backlog_ready = {
   read_backlog_next,
   print_offer_hint,
   free_lane_count,
-  live_lane_count,
+  free_lanes_beside,
+  lane_use,
+  occupied_lanes: occupied_lanes2,
   drive_free_lane_count,
   drains_pool,
   print_ready_line,
@@ -659,46 +1026,400 @@ async function run_stall_check(ready = backlog_ready.DEFAULT_PORTS) {
 }
 var backlog_stalled_detect = { detect_and_report, run_stall_check };
 
-// scripts/rules/last-prompt.ts
+// scripts/issue/issue-cite-cli.ts
+import { fileURLToPath } from "node:url";
 import { z as z2 } from "zod";
-var WORKFLOW_KEYWORDS = /* @__PURE__ */ new Set([
-  "kickoff",
-  "fullrun",
-  "halfrun",
-  "prrun",
-  "backlogrun"
-]);
-var NO_PROMPT = "";
-var HUMAN_ORIGIN = "human";
-var KEYWORD_BEFORE_ARGUMENT = -2;
-var PROMPT_LINE_SCHEMA = z2.object({
-  isMeta: z2.boolean().nullish(),
-  origin: z2.object({ kind: z2.string().nullish() }).nullish(),
-  message: z2.object({ content: z2.unknown() })
-});
-function is_person(line) {
-  if (line.isMeta === true) return false;
-  return line.origin === null || line.origin === void 0 || line.origin.kind === HUMAN_ORIGIN;
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var ARGV_OFFSET = 2;
+var READ_CONCURRENCY = 8;
+var TITLE_FIELD = "title";
+var LINE_SEPARATOR = "\n";
+var USAGE = "Usage: josh issue:cite <issue-number|owner/repo#N> [ ... ] [--repo <owner/repo>]";
+var OPTIONS = { repo: { type: "string" } };
+var title_schema = z2.looseObject({ title: z2.string() });
+function parse_title(json) {
+  const title = json_value.parse_with(json, title_schema)?.title.trim();
+  return title === "" ? void 0 : title;
+}
+function to_line(target, slug, read2) {
+  if (read2.kind === "missing") return { kind: "fail", line: issue_cite.missing_line(target) };
+  if (read2.kind !== "read") return { kind: "fail", line: issue_cite.unreadable_line(target) };
+  const title = parse_title(read2.json);
+  if (title === void 0) return { kind: "fail", line: issue_cite.unreadable_line(target) };
+  return { kind: "ok", line: issue_cite.citation_line(slug, target.number, title) };
+}
+async function cite_target(target, local_slug) {
+  const slug = target.repo ?? local_slug;
+  if (slug === void 0) return { kind: "fail", line: issue_cite.no_repo_line(target) };
+  const read2 = await git_gh_command.issue_view_json_classified(
+    target.number,
+    TITLE_FIELD,
+    target.repo
+  );
+  return to_line(target, slug, read2);
+}
+function parse_targets(positionals, default_repo) {
+  const targets = [];
+  for (const token of positionals) {
+    const target = issue_cite.parse_target(token, default_repo);
+    if (target === void 0) return void 0;
+    targets.push(target);
+  }
+  return targets.length === 0 ? void 0 : targets;
 }
-function person_text(line) {
-  const parsed = PROMPT_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
-  if (!parsed.success || !is_person(parsed.data)) return void 0;
-  return time_reported_failure.result_text(parsed.data.message.content);
+async function local_slug_for(targets) {
+  const has_bare_target = targets.some((target) => target.repo === void 0);
+  return has_bare_target ? await git_gh_command.repo_get_name_with_owner() : void 0;
 }
-function is_invocation(prompt) {
-  const words = prompt.trim().split(/\s+/u);
-  return [words.at(0), words.at(KEYWORD_BEFORE_ARGUMENT)].some(
-    (word) => WORKFLOW_KEYWORDS.has(word ?? NO_PROMPT)
+function split_results(results) {
+  return {
+    lines: results.filter((result) => result.kind === "ok").map((result) => result.line),
+    failures: results.filter((result) => result.kind === "fail").map((result) => result.line)
+  };
+}
+function report2(cited) {
+  if (cited.lines.length > 0) console.info(cited.lines.join(LINE_SEPARATOR));
+  for (const failure of cited.failures) console.error(failure);
+  return cited.failures.length === 0 ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+function read_targets(args) {
+  const parsed = cli_flags.arguments_of(args, OPTIONS);
+  if (parsed === void 0) return void 0;
+  return parse_targets(parsed.positionals, parsed.values.repo);
+}
+async function cite(args) {
+  const targets = read_targets(args);
+  if (targets === void 0) return void 0;
+  const local_slug = await local_slug_for(targets);
+  const results = await bounded_pool.bounded_map(
+    targets,
+    READ_CONCURRENCY,
+    async (target) => await cite_target(target, local_slug)
   );
+  return split_results(results);
 }
-function prompt_line_text(line) {
-  return filing_cap.is_prompt_line(line) ? person_text(line) : void 0;
+async function run(args) {
+  const cited = await cite(args);
+  if (cited === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  return report2(cited);
 }
-function prompt_text(tail) {
-  const text2 = tail.split("\n").map((line) => prompt_line_text(line)).findLast((one) => one !== void 0);
-  return text2 === void 0 || is_invocation(text2) ? NO_PROMPT : text2;
+async function main(args) {
+  process.exitCode = await run(args);
+}
+var issue_cite_cli = {
+  USAGE,
+  cite,
+  parse_targets,
+  run
+};
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET));
+
+// scripts/notify/telegram-test.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// scripts/gh/github-issue-url.ts
+var NAME_WITH_OWNER_SEPARATOR = "/";
+var GITHUB_URL_PREFIX = "https://github.com/";
+var GITHUB_URL_PREFIX_SOURCE = GITHUB_URL_PREFIX.replaceAll(".", String.raw`\.`);
+var REPOSITORY_SOURCE = `^${GITHUB_URL_PREFIX_SOURCE}([^/]+)/([^/]+)`;
+var ISSUE_URL_PATTERN = new RegExp(String.raw`${REPOSITORY_SOURCE}/issues/(\d+)\b`, "u");
+var PULL_URL_PATTERN = new RegExp(String.raw`${REPOSITORY_SOURCE}/pull/(\d+)\b`, "u");
+function build_target(match) {
+  const [, owner = "", repo = "", number = ""] = match;
+  const name_with_owner = `${owner}${NAME_WITH_OWNER_SEPARATOR}${repo}`;
+  return {
+    target: {
+      owner,
+      repo,
+      name_with_owner,
+      base_url: `${GITHUB_URL_PREFIX}${name_with_owner}`
+    },
+    number
+  };
+}
+function parse_with(pattern, url = "") {
+  const match = pattern.exec(url);
+  if (match === null) return void 0;
+  return build_target(match);
+}
+function parse(issue_url) {
+  const parsed = parse_with(ISSUE_URL_PATTERN, issue_url);
+  if (parsed === void 0) return void 0;
+  return { ...parsed.target, issue_number: parsed.number };
+}
+function parse_pull(pull_url) {
+  const parsed = parse_with(PULL_URL_PATTERN, pull_url);
+  if (parsed === void 0) return void 0;
+  return { ...parsed.target, pull_number: parsed.number };
+}
+var github_issue_url = { parse, parse_pull };
+
+// scripts/git/git-error.ts
+function get_stderr_from_error(cause) {
+  if (!has_stderr_field(cause)) return void 0;
+  const stderr = cause.stderr.trim();
+  return stderr.length > 0 ? stderr : void 0;
+}
+function get_error_message_from_cause(cause) {
+  const message3 = cause.message.trim();
+  if (message3.length > 0) return message3;
+  return get_stderr_from_error(cause);
+}
+function get_cause_message(cause) {
+  if (cause instanceof Error) return get_error_message_from_cause(cause);
+  if (typeof cause === "string") return cause.trim();
+  return void 0;
+}
+function display_error_details(cause) {
+  const cause_message = get_cause_message(cause);
+  if (cause_message === void 0 || cause_message.length === 0) return;
+  console.error("");
+  console.error("\u{1F4A1} Details:", cause_message);
+}
+var FAILURE_EXIT_CODE2 = 1;
+var OPERATION_CANCELLED_MESSAGE = "\u{1F4A1} Operation cancelled.";
+var BranchMismatchError = class extends Error {
+  current_branch;
+  target_branch_name;
+  constructor(mismatch, options) {
+    super(
+      `Branch mismatch: on ${mismatch.current_branch}, expected ${mismatch.target_branch_name}`,
+      options
+    );
+    this.name = "BranchMismatchError";
+    this.current_branch = mismatch.current_branch;
+    this.target_branch_name = mismatch.target_branch_name;
+  }
+};
+var OperationCancelledError = class extends Error {
+  constructor() {
+    super("Operation cancelled");
+    this.name = "OperationCancelledError";
+  }
+};
+function display_failure(error) {
+  const error_message = error_text.message_of(error);
+  console.error("");
+  console.error("\u274C Error:", error_message);
+  if (error instanceof Error && error.cause !== void 0) {
+    display_error_details(error.cause);
+  }
+  console.error("");
+}
+function display_branch_mismatch(error) {
+  console.error("");
+  console.error("\u274C Branch mismatch detected");
+  console.error("");
+  console.error(`Current branch: ${error.current_branch}`);
+  console.error(`Expected branch: ${error.target_branch_name}`);
+  console.error("");
+  console.error("\u{1F4A1} Please update main branch to the latest and try again.");
+}
+function display_cancelled() {
+  console.info(OPERATION_CANCELLED_MESSAGE);
+  console.info("");
+}
+function display(error) {
+  if (error instanceof BranchMismatchError) {
+    display_branch_mismatch(error);
+    return;
+  }
+  if (error instanceof OperationCancelledError) {
+    display_cancelled();
+    return;
+  }
+  display_failure(error);
+}
+function handle(error) {
+  display(error);
+  process.exitCode = FAILURE_EXIT_CODE2;
+}
+var git_error = {
+  handle
+};
+
+// scripts/josh/cli-body.ts
+import { readFileSync, statSync } from "node:fs";
+import path from "node:path";
+var STDIN_PATH = "-";
+var STDIN_FD = 0;
+var ESCAPED_NEWLINE = String.raw`\n`;
+function read_body_file(raw_path) {
+  const resolved = path.resolve(raw_path);
+  const stats = statSync(resolved, { throwIfNoEntry: false });
+  if (stats === void 0 || stats.isDirectory()) {
+    throw new Error(`Not a readable file: ${resolved}`);
+  }
+  return readFileSync(resolved, "utf8");
+}
+function read_file_or_stdin(raw_path) {
+  return raw_path === STDIN_PATH ? readFileSync(STDIN_FD, "utf8") : read_body_file(raw_path);
+}
+function expand_escaped_newlines(raw) {
+  return raw.replaceAll(ESCAPED_NEWLINE, "\n");
+}
+function has_value(raw) {
+  return raw !== void 0 && raw.length > 0;
+}
+function resolve_inline(inline) {
+  return inline === void 0 ? void 0 : expand_escaped_newlines(inline.trim());
+}
+function resolve(input) {
+  const { inline, file_path: file_path2 } = input;
+  if (file_path2 === void 0 || file_path2.length === 0) return resolve_inline(inline);
+  if (has_value(inline)) {
+    throw new Error(`Pass ${input.inline_flag} or ${input.file_flag}, not both.`);
+  }
+  return read_file_or_stdin(file_path2);
+}
+var cli_body = { read_file_or_stdin, has_value, resolve };
+
+// scripts/notify/telegram-test-logic.ts
+var VALID_TASK_TYPES = [
+  "planning",
+  "completion",
+  "failure",
+  "warning",
+  "kickoff_retry",
+  "confirmation",
+  "stalled"
+];
+var DEFAULT_TASK_TYPE = "planning";
+function parse_task_type(raw) {
+  if (raw === void 0) return DEFAULT_TASK_TYPE;
+  const matched = VALID_TASK_TYPES.find((candidate) => candidate === raw);
+  if (matched === void 0) {
+    throw new Error(`Invalid --task-type: ${raw}. Expected one of ${VALID_TASK_TYPES.join(", ")}.`);
+  }
+  return matched;
+}
+var has_flag_value = cli_body.has_value;
+function coalesce(primary, fallback) {
+  if (has_flag_value(primary)) return primary;
+  return fallback;
+}
+function normalize_body(values) {
+  return cli_body.resolve({
+    inline: values.body,
+    file_path: values["body-file"],
+    inline_flag: "--body",
+    file_flag: "--body-file"
+  });
 }
-var last_prompt = { prompt_text };
+function require_recommended(values) {
+  const recommended = values.recommended?.trim() ?? "";
+  if (recommended.length === 0) {
+    throw new Error('--task-type confirmation needs --recommended "<the recommended choice>".');
+  }
+  return recommended;
+}
+function given_alternatives(values) {
+  return (values.alternative ?? []).filter((alternative) => alternative.trim().length > 0);
+}
+function build_choices(values, task_type) {
+  if (task_type !== "confirmation") return void 0;
+  return confirmation_options.block({
+    recommended: require_recommended(values),
+    alternatives: given_alternatives(values)
+  });
+}
+function build_input(input) {
+  const task_type = parse_task_type(input.values["task-type"]);
+  return {
+    task_type,
+    repo_name: coalesce(input.values["repo-name"], input.context.repo_name),
+    issue_title: coalesce(input.values["issue-title"], input.context.issue_title),
+    body: normalize_body(input.values),
+    choices: build_choices(input.values, task_type),
+    issue_url: input.values["issue-url"],
+    pr_url: input.values["pr-url"]
+  };
+}
+var telegram_test_logic = {
+  build_input,
+  parse_task_type,
+  has_flag_value
+};
+
+// scripts/notify/telegram-test.ts
+var REPO_NAME_SEPARATOR = "/";
+var ARGV_OFFSET2 = 2;
+var FAILURE_EXIT_CODE3 = 1;
+var USAGE2 = "Usage: josh notify [--task-type <type>] [--body <text> | --body-file <path>] [--issue-url <url>] [--pr-url <url>] [--issue-title <text>] [--repo-name <name>] [--recommended <text>] [--alternative <text>]...";
+var FREE_TEXT_FLAGS = ["--body", "--issue-title", "--recommended", "--alternative"];
+var OPTIONS2 = {
+  "task-type": { type: "string" },
+  "repo-name": { type: "string" },
+  "issue-title": { type: "string" },
+  body: { type: "string" },
+  "body-file": { type: "string" },
+  "issue-url": { type: "string" },
+  "pr-url": { type: "string" },
+  recommended: { type: "string" },
+  alternative: { type: "string", multiple: true }
+};
+function parse_cli_arguments() {
+  return cli_flags.values_of(
+    cli_flags.attach_values(process.argv.slice(ARGV_OFFSET2), FREE_TEXT_FLAGS),
+    OPTIONS2
+  );
+}
+function refuse_usage() {
+  console.error(USAGE2);
+  process.exitCode = FAILURE_EXIT_CODE3;
+}
+async function fetch_repo_name() {
+  const name_with_owner = await git_gh_repo.repo_get_name_with_owner();
+  if (name_with_owner === void 0) return void 0;
+  return name_with_owner.split(REPO_NAME_SEPARATOR).at(-1);
+}
+async function fetch_issue_title(target) {
+  if (target === void 0) return void 0;
+  const title = await git_gh_issue_read.issue_get_title(target.issue_number, target.name_with_owner);
+  if (title === void 0) {
+    console.warn(
+      `\u26A0\uFE0F  Could not read ${session_cite.issue(target.issue_number, void 0, target.name_with_owner)}.`
+    );
+  }
+  return title;
+}
+async function resolve_issue_title(values, target) {
+  if (telegram_test_logic.has_flag_value(values["issue-title"])) return void 0;
+  return await fetch_issue_title(target);
+}
+async function resolve_context(values) {
+  const target = github_issue_url.parse(values["issue-url"]);
+  const pull_target = github_issue_url.parse_pull(values["pr-url"]);
+  const repo_name = target?.repo ?? pull_target?.repo ?? await fetch_repo_name();
+  const issue_title = await resolve_issue_title(values, target);
+  return { repo_name, issue_title };
+}
+async function send_values(values) {
+  const context = await resolve_context(values);
+  await telegram_notify.send(telegram_test_logic.build_input({ values, context }));
+}
+async function main2() {
+  josh_environment_file.load_environment_file();
+  const values = parse_cli_arguments();
+  if (values === void 0) {
+    refuse_usage();
+    return;
+  }
+  await send_values(values);
+}
+async function run_cli() {
+  try {
+    await main2();
+  } catch (error) {
+    git_error.handle(error);
+  }
+}
+if (process.argv[1] === fileURLToPath2(import.meta.url)) await run_cli();
+var telegram_test = { fetch_repo_name, fetch_issue_title, resolve_context, run_cli, send_values };
 
 // scripts/rules/stop-rules.ts
 import { z as z3 } from "zod";
@@ -717,21 +1438,21 @@ var OWNER_SEPARATOR = "/";
 function is_offer_line(line) {
   return OFFER_PATTERNS.some((pattern) => pattern.test(line));
 }
-function offers_filing(message2) {
-  return issue_citation.prose_lines(message2).some((line) => is_offer_line(line));
+function offers_filing(message3) {
+  return issue_citation.prose_lines(message3).some((line) => is_offer_line(line));
 }
-function url_owners(message2) {
-  return [...message2.matchAll(GITHUB_URL_OWNER)].map((match) => match[1] ?? "");
+function url_owners(message3) {
+  return [...message3.matchAll(GITHUB_URL_OWNER)].map((match) => match[1] ?? "");
 }
-function qualified_owners(message2) {
-  return issue_citation.bare_references(message2).filter((reference) => reference.includes(OWNER_SEPARATOR)).map((reference) => reference.split(OWNER_SEPARATOR)[0] ?? "");
+function qualified_owners(message3) {
+  return issue_citation.bare_references(message3).filter((reference) => reference.includes(OWNER_SEPARATOR)).map((reference) => reference.split(OWNER_SEPARATOR)[0] ?? "");
 }
-function mentioned_owners(message2) {
-  return [...url_owners(message2), ...qualified_owners(message2)];
+function mentioned_owners(message3) {
+  return [...url_owners(message3), ...qualified_owners(message3)];
 }
-function is_first_party_target(message2, session_owner) {
+function is_first_party_target(message3, session_owner) {
   if (session_owner === void 0) return false;
-  return mentioned_owners(message2).every(
+  return mentioned_owners(message3).every(
     (owner) => repo_party.classify(session_owner, owner) === repo_party.FIRST_PARTY
   );
 }
@@ -773,10 +1494,10 @@ function letter_pattern(script) {
     return void 0;
   }
 }
-function prose_of(message2) {
-  let text2 = message2;
+function prose_of(message3) {
+  let text2 = message3;
   for (const pattern of CODE_PATTERNS) text2 = text2.replaceAll(pattern, " ");
-  return text2.replaceAll(ASCII_RUN_PATTERN, (run) => run.includes("/") ? " " : run);
+  return text2.replaceAll(ASCII_RUN_PATTERN, (run3) => run3.includes("/") ? " " : run3);
 }
 function letter_count(text2) {
   return text2.match(LETTER_PATTERN)?.length ?? 0;
@@ -795,17 +1516,46 @@ function matches_share(prose, script, pattern) {
   const matched = lines.filter((line) => is_line_in_script(line, script, pattern));
   return matched.length / lines.length;
 }
-function is_mismatch(message2, lang) {
+function is_mismatch(message3, lang) {
   const script = script_of(lang);
   if (script === void 0) return false;
   const pattern = letter_pattern(script);
   if (pattern === void 0) return false;
-  const prose = prose_of(message2);
+  const prose = prose_of(message3);
   if (letter_count(prose) < MIN_PROSE_LETTERS) return false;
   return matches_share(prose, script, pattern) < MATCH_SHARE_FLOOR;
 }
 var reply_language = { is_mismatch, script_of };
 
+// scripts/rules/stop-decision.ts
+var RECOMMENDED_LABEL = /^recommended[*_]*:/iu;
+var ALTERNATIVE_LABEL = /^alternative[*_]*:/iu;
+var LEADING_EMPHASIS = /^[*_]+/u;
+var TRAILING_EMPHASIS = /(?<![*_])[*_]+$/u;
+var BULLET = /^[-*]\s+/u;
+var QUESTION_ENDING = /(?:[?？]|か|かな|かね)[\s。.]*$/u;
+function unwrapped(text2) {
+  return text2.trim().replace(LEADING_EMPHASIS, "").replace(TRAILING_EMPHASIS, "").trim();
+}
+function bare_line(line) {
+  return unwrapped(line.trim().replace(BULLET, ""));
+}
+function choice_of(message3, label) {
+  const line = message3.split("\n").map((one) => bare_line(one)).find((one) => label.test(one));
+  const choice = line === void 0 ? void 0 : unwrapped(line.replace(label, ""));
+  return choice === "" ? void 0 : choice;
+}
+function decision_of(message3) {
+  const recommended = choice_of(message3, RECOMMENDED_LABEL);
+  if (recommended === void 0) return void 0;
+  return { recommended, alternative: choice_of(message3, ALTERNATIVE_LABEL) };
+}
+function is_question(prompt) {
+  return QUESTION_ENDING.test(prompt.trim());
+}
+var DECISION_REASON = "\u26D4 stop decision: this working tree is held by your run and your reply names no decision. If the run waits on a person, end the reply with a `Recommended: <choice>` line and, where there is one, an `Alternative: <choice>` line \u2014 the hook sends the `confirmation` Telegram from them. If it waits on nobody, continue the run, or say in one line that nothing is awaited. Do not repeat your previous reply.";
+var stop_decision = { DECISION_REASON, decision_of, is_question };
+
 // scripts/rules/stop-rules.ts
 var SWITCH_ENV_KEY = "JOSH_STOP_GUARD";
 var BLOCK_DECISION = "block";
@@ -814,26 +1564,26 @@ var stop_payload_schema = z3.object({
   stop_hook_active: z3.boolean().nullish(),
   last_assistant_message: z3.string().nullish()
 });
-var NO_OUTCOME = { reason: void 0 };
-var STOP_NOTIFY_REASON = '\u26D4 mid-workflow stop notification: this working tree is still held by a run and no `confirmation` Telegram was sent this turn, so a person is being left to wait off-screen without knowing the run paused. `CLAUDE.md` \u2192 "Mid-workflow stop notification" requires `pnpm josh notify --task-type confirmation --issue-url "<url>" --body=$\'<reason>\' --recommended "<choice>" --alternative "<choice>"` before any mid-workflow pause. Send it, then end with a one-line confirmation that it was sent \u2014 do not repeat your previous reply. This fires only while the hold is held and no notify is on the transcript, and `stop_hook_active` lets a second stop through so a run is never wedged.';
-var HOLD_RELEASE_REASON = "\u26D4 working-tree hold not released: this working tree is clean but its `run:hold` record is still in place, so the next run here runs `pnpm josh ms` believing the tree is free while you hold it. The workflow-commands skill \u2192 `working-tree-hold.md`: a stop that leaves the tree clean releases the hold with `pnpm josh run:release <N>` (bare for a `new` entry). A `halfrun` pre-commit stop and a `needs-human-review` stop keep the hold because their tree is dirty, and a `prrun` stop keeps it by its stop mark \u2014 this row is silent there. Release it, then end with a one-line confirmation that it was released \u2014 do not repeat your previous reply.";
+var NO_OUTCOME = { reason: void 0, actions: [], blocks_on_failure: false };
+var STOP_NOTIFY_REASON = '\u26D4 mid-workflow stop notification: this working tree is still held by a run and no `confirmation` Telegram was sent this turn. Send `pnpm josh notify --task-type confirmation --issue-url "<url>" --body=$\'<reason>\' --recommended "<choice>" --alternative "<choice>"` (`CLAUDE.md` \u2192 "Mid-workflow stop notification"), then confirm in one line that it was sent \u2014 do not repeat your previous reply.';
+var HOLD_RELEASE_REASON = "\u26D4 working-tree hold not released: this working tree is clean but its `run:hold` record is still in place. Release it with `pnpm josh run:release <N>` (bare for a `new` entry; `working-tree-hold.md`), then confirm in one line that it was released \u2014 do not repeat your previous reply.";
 var ISSUE_CITATION_REASON = "Session-facing output cites an Issue as a number-link so the reader can click through and see which repository it is (`CLAUDE.md`, `prompts/collaboration-workflow/issue-citation.md`).";
 function build_citation_reason(references) {
   const numbers = references.join(", ");
   const command = `pnpm josh issue:cite ${issue_citation.cite_arguments(references).join(" ")}`;
   return `\u26D4 issue citation: your reply names an Issue as a bare \`#N\` (${numbers}). Run \`${command}\` to print the paste-ready citation lines, then print the corrected citation lines alone \u2014 do not repeat your previous reply. ${ISSUE_CITATION_REASON}`;
 }
-var FILING_OFFER_REASON = '\u26D4 filing offer: your reply offers to file an Issue instead of filing it, and this run is unattended \u2014 nobody is there to answer. Filing into a first-party repository there is Tier A \u2014 the trigger is the judgement that it is worth filing, not the run\'s progress (the workflow-commands skill \u2192 `observation-filing.md`). Run `pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2>` \u2014 it scouts, lints, labels and runs `epic:bundle` itself \u2014 then end with the one-line citation of what was filed; do not repeat your previous reply. If it is not worth filing after all, say so in one line instead.';
+var FILING_OFFER_REASON = '\u26D4 filing offer: your reply offers to file an Issue instead of filing it, and this run is unattended \u2014 nobody is there to answer. Run `pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2>` (Tier A, `observation-filing.md`), then end with the one-line citation of what was filed; do not repeat your previous reply. If it is not worth filing after all, say so in one line instead.';
 var HEADLESS_WAIT_MARKER = "\u26D4 headless parent:";
 var HEADLESS_REFUSAL_CAP = 3;
 var HEADLESS_WAIT_CALLS = ['"command":"pnpm josh lane:await'];
-var HEADLESS_WAIT_BODY = ' this is a `claude -p` `backlogrun` parent (`JOSH_RUN_HEADLESS`) with lanes still in flight, and ending this turn ends the process \u2014 its background waits are killed with it and the lanes are left without a parent. Do not watch them yourself: the `run:wake` supervisor\'s driver watches the lanes and wakes a session only for a branch that needs judging. Hand the loop back with `pnpm josh run:carry --cut --owner "$PPID"` (or `--end` when the run is over), then end the turn (`backlogrun-progress.md` \u2192 "Picking the lanes up in the fresh session").';
+var HEADLESS_WAIT_BODY = ' this is a `claude -p` `backlogrun` parent with lanes in flight, and ending this turn kills the process and its background waits. Hand the loop back with `pnpm josh run:carry --cut --owner "$PPID"` (or `--end` when the run is over), then end the turn (`backlogrun-progress.md`).';
 var HEADLESS_WAIT_REASON = `${HEADLESS_WAIT_MARKER}${HEADLESS_WAIT_BODY}`;
 var INDEX_COMMAND_PATTERN = /git (?:add|stage|rm --cached|restore --staged|restore -S)\b/u;
 var PERMISSION_PATTERN = /許可|承認|permission|approve|approval|authorization/iu;
-var LANE_INDEX_REASON = '\u26D4 lane index permission: this is a dispatched lane child (`JOSH_LANE_CHILD`) and your reply asks a person for permission to change the git index. A lane is a per-run work tree with no person\'s staging to protect, and the sanctioned commit flow is already authorized: remove any conflict markers, then run `pnpm josh git -y`, which stages and commits them \u2014 a conflicted merge included. This is Tier A (`.claude/skills/workflow-commands/chain-rule.md` \u2192 "origin/main is merged in before the gate"). Do it and continue the run \u2014 do not repeat your previous reply.';
-function asks_index_permission(message2) {
-  return INDEX_COMMAND_PATTERN.test(message2) && PERMISSION_PATTERN.test(message2);
+var LANE_INDEX_REASON = "\u26D4 lane index permission: this is a dispatched lane child (`JOSH_LANE_CHILD`) and your reply asks a person for permission to change the git index. That is Tier A here (`chain-rule.md`): remove any conflict markers, run `pnpm josh git -y` (it stages and commits, a conflicted merge included) and continue the run \u2014 do not repeat your previous reply.";
+function asks_index_permission(message3) {
+  return INDEX_COMMAND_PATTERN.test(message3) && PERMISSION_PATTERN.test(message3);
 }
 function needs_index_route(context) {
   return context.lane_child && asks_index_permission(context.message);
@@ -856,26 +1606,29 @@ function needs_filing(context) {
   return filing_offer.offers_filing(context.message) && filing_offer.is_first_party_target(context.message, context.session_owner);
 }
 function is_held_idle(context) {
-  return context.hold_present && !context.agent_pending && !context.handed_off;
+  if (context.hold_issue === void 0 || !context.hold_owned) return false;
+  return !context.agent_pending && !context.handed_off;
 }
 function needs_notify(context) {
-  return is_held_idle(context) && !context.notified;
+  return is_held_idle(context) && !context.notified && !context.answers_question;
+}
+function needs_decision(context) {
+  return needs_notify(context) && stop_decision.decision_of(context.message) === void 0;
 }
 function needs_release(context) {
   return is_held_idle(context) && context.tree_clean && !context.prrun_stopped;
 }
-function citation_reason(context) {
-  const references = issue_citation.unquoted_references(context.message, context.prompt);
-  if (references.length === 0) return void 0;
-  return build_citation_reason(references);
-}
-function wording_reason(context) {
-  if (context.headless_agent) return void 0;
-  return citation_reason(context) ?? language_reason(context);
+function bare_references(context) {
+  if (context.headless_agent) return [];
+  return issue_citation.unquoted_references(context.message, context.prompt);
 }
 function reply_reason(context) {
   if (needs_filing(context)) return FILING_OFFER_REASON;
-  return wording_reason(context);
+  if (context.headless_agent) return void 0;
+  return language_reason(context);
+}
+function decision_reason(context) {
+  return needs_decision(context) ? stop_decision.DECISION_REASON : void 0;
 }
 function is_headless_held(context) {
   if (!context.headless_waiting) return false;
@@ -888,23 +1641,61 @@ function count_headless_refusals(tail) {
 function needs_background_wait(context) {
   return context.lane_child && context.background_pending;
 }
-function hold_reason(context) {
+function lane_reason(context) {
   if (needs_index_route(context)) return LANE_INDEX_REASON;
   if (needs_background_wait(context)) return lane_background.LANE_BACKGROUND_STOP_REASON;
-  if (needs_notify(context)) return STOP_NOTIFY_REASON;
-  if (needs_release(context)) return HOLD_RELEASE_REASON;
   return void 0;
 }
+function model_reason(context) {
+  const lane = lane_reason(context);
+  if (lane !== void 0) return lane;
+  const reasons = [reply_reason(context), decision_reason(context)].filter(
+    (reason) => reason !== void 0
+  );
+  return reasons.length === 0 ? void 0 : reasons.join("\n\n");
+}
+function notify_actions(context, issue) {
+  const decision = stop_decision.decision_of(context.message);
+  if (decision === void 0 || !needs_notify(context)) return [];
+  return [{ kind: "notify", issue, message: context.message, decision }];
+}
+function hold_actions(context) {
+  const issue = context.hold_issue;
+  if (issue === void 0) return [];
+  const notify2 = notify_actions(context, issue);
+  return needs_release(context) ? [...notify2, { kind: "release", issue }] : notify2;
+}
+function stop_actions(context) {
+  const references = bare_references(context);
+  const cite3 = references.length > 0 ? [{ kind: "cite", references }] : [];
+  return [...hold_actions(context), ...cite3];
+}
 function block_reason(context) {
   if (is_headless_held(context)) return HEADLESS_WAIT_REASON;
   if (context.stop_hook_active || context.cut_pending) return void 0;
-  return hold_reason(context) ?? reply_reason(context);
+  return model_reason(context);
+}
+function runs_actions(context, reason) {
+  return reason === void 0 && !context.cut_pending && lane_reason(context) === void 0;
 }
 function stop_outcome(context) {
-  return { reason: block_reason(context) };
+  const reason = block_reason(context);
+  if (!runs_actions(context, reason)) return { ...NO_OUTCOME, reason };
+  const actions = stop_actions(context);
+  if (actions.length === 0) return NO_OUTCOME;
+  return { reason, actions, blocks_on_failure: !context.stop_hook_active };
 }
-function block_envelope(reason, lang) {
-  return JSON.stringify({ decision: BLOCK_DECISION, reason: `${reason} ${language_note(lang)}` });
+function fallback_reason(action) {
+  if (action.kind === "notify") return STOP_NOTIFY_REASON;
+  if (action.kind === "release") return HOLD_RELEASE_REASON;
+  return build_citation_reason(action.references);
+}
+function block_envelope(reason, lang, notice) {
+  const refusal = { decision: BLOCK_DECISION, reason: `${reason} ${language_note(lang)}` };
+  return JSON.stringify(notice === void 0 ? refusal : { ...refusal, systemMessage: notice });
+}
+function notice_envelope(notice) {
+  return JSON.stringify({ systemMessage: notice });
 }
 function parse_stop_payload(raw_payload) {
   const parsed = stop_payload_schema.safeParse(JSON.parse(raw_payload));
@@ -926,32 +1717,51 @@ var stop_rules = {
   block_envelope,
   build_language_reason,
   count_headless_refusals,
+  fallback_reason,
   is_enabled,
+  notice_envelope,
   parse_stop_payload,
   stop_outcome
 };
 
+// scripts/run/hold/run-hold-cli.ts
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+
+// scripts/run/run-cli-fault.ts
+async function directory_of(where, read2) {
+  try {
+    return await read2();
+  } catch (error) {
+    error_text.trace_swallowed(where, error);
+    return void 0;
+  }
+}
+function message2(command, error) {
+  return `${command} failed and established nothing: ${error_text.message_of(error)}`;
+}
+var run_cli_fault = { directory_of, message: message2 };
+
 // scripts/run/run-halfrun-resume.ts
 var MARKED = "marked";
 var FOREIGN = "foreign";
 var UNREADABLE2 = "unreadable";
-function hold_of(read) {
-  return read.kind === "held" || read.kind === "stale" ? read.hold : void 0;
+function hold_of(read2) {
+  return read2.kind === "held" || read2.kind === "stale" ? read2.hold : void 0;
 }
-function is_halfrun_stop(read, issue, is_dirty) {
-  const hold = hold_of(read);
+function is_halfrun_stop(read2, issue, is_dirty) {
+  const hold = hold_of(read2);
   return is_dirty && hold?.issue === issue && hold.is_halfrun_stop === true;
 }
-function is_own_record(read, issue) {
-  const hold = hold_of(read);
+function is_own_record(read2, issue) {
+  const hold = hold_of(read2);
   return hold === void 0 || hold.issue === issue || hold.issue === run_hold.UNNUMBERED_ISSUE;
 }
-function mark_stop_at(target, issue, mark = run_hold.HALFRUN_STOP_FIELDS) {
-  const read = run_hold.read_hold(target);
-  if (read.kind === "unreadable") return UNREADABLE2;
-  if (!is_own_record(read, issue)) return FOREIGN;
+function mark_stop_at(target, issue, mark2 = run_hold.HALFRUN_STOP_FIELDS) {
+  const read2 = run_hold.read_hold(target);
+  if (read2.kind === "unreadable") return UNREADABLE2;
+  if (!is_own_record(read2, issue)) return FOREIGN;
   run_hold.release_hold(target);
-  return run_hold.create_stop_hold(target, issue, mark) ? MARKED : FOREIGN;
+  return run_hold.create_stop_hold(target, issue, mark2) ? MARKED : FOREIGN;
 }
 function take_over(target, issue) {
   run_hold.release_hold(target);
@@ -992,59 +1802,1632 @@ var run_halfrun_resume = {
   take_over
 };
 
-// scripts/run/carry/run-carry-ended.ts
-import path from "node:path";
+// scripts/followup/git-followup-label.ts
 import { z as z4 } from "zod";
-var ENDED_PREFIX = "josh-run-ended-";
-var TRANSCRIPT_SUFFIX = ".jsonl";
-var ended_run_schema = z4.object({
-  invocation: z4.string(),
-  started_at: z4.string(),
-  ended_at: z4.string(),
-  stopped: z4.string().optional(),
-  session: z4.string().optional()
-});
-function ended_path(git_directory) {
-  return stamp_file.stamp_path(ENDED_PREFIX, git_directory);
-}
-function session_of(transcript) {
-  return transcript === void 0 ? void 0 : path.basename(transcript, TRANSCRIPT_SUFFIX);
+var labels_read_schema = z4.object({ labels: z4.array(issue_label_schema).optional() });
+function unreadable_error(issue_number) {
+  return new Error(
+    `gh api answered no readable labels for issue ${session_cite.issue(issue_number)}`
+  );
 }
-function stop_of(transcript, stopped) {
-  return stopped === void 0 ? {} : { stopped, session: session_of(transcript) };
+async function read_label_names(issue_number) {
+  const raw = await git_gh_command.issue_get_labels_and_body(issue_number);
+  if (raw === void 0) throw unreadable_error(issue_number);
+  const parsed = parse_json_object_or_undefined(raw, labels_read_schema);
+  if (parsed === void 0) throw unreadable_error(issue_number);
+  return (parsed.labels ?? []).map((label) => label.name);
+}
+async function strip_in_progress(issue_number) {
+  if (issue_number === void 0) return;
+  const stored = label_name_of(await read_label_names(issue_number), IN_PROGRESS_LABEL);
+  if (stored === void 0) return;
+  await git_gh_command.issue_remove_label(issue_number, stored);
+}
+var git_followup_label = {
+  strip_in_progress
+};
+
+// scripts/run/run-label.ts
+var MARK_RECOVERY = "gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=in-progress'";
+var UNMARK_RECOVERY = "gh api -X DELETE repos/{owner}/{repo}/issues/<N>/labels/in-progress";
+function warn2(action, issue, recovery) {
+  console.warn(
+    `\u26A0 could not ${action} \`in-progress\` on ${session_cite.issue(issue)} \u2014 run by hand: ${recovery}`
+  );
 }
-function record_ended(target, read, now = /* @__PURE__ */ new Date(), stopped) {
-  if (read.kind !== "carried") return;
-  const { invocation, started_at, owner_transcript } = read.carry;
-  const ended_at = now.toISOString();
-  stamp_file.replace_stamp(target, {
-    invocation,
-    started_at,
-    ended_at,
-    ...stop_of(owner_transcript, stopped)
-  });
+async function mark(issue) {
+  const is_marked = await git_gh_command.issue_add_label(issue, IN_PROGRESS_LABEL);
+  if (!is_marked) warn2("apply", issue, MARK_RECOVERY);
+  return is_marked;
 }
-function parse_ended(raw) {
-  return json_value.parse_with(raw, ended_run_schema);
+async function unmark(issue) {
+  try {
+    await git_followup_label.strip_in_progress(issue);
+    return true;
+  } catch {
+    warn2("remove", issue, UNMARK_RECOVERY);
+    return false;
+  }
 }
-function read_ended(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  return raw === void 0 ? void 0 : parse_ended(raw);
+var run_label = {
+  mark,
+  unmark
+};
+
+// scripts/lib/git-animation.ts
+import ora from "ora";
+var SUCCESS_ICON = "\u2705";
+function create_stop_function(spinner, message3) {
+  return (result, icon) => {
+    if (result === void 0) {
+      spinner.stop();
+      return;
+    }
+    const symbol = (icon ?? SUCCESS_ICON).trimEnd();
+    spinner.stopAndPersist({ symbol, text: `${message3} ${result}` });
+  };
 }
-function has_ended(target, started_at) {
-  const ended = read_ended(target);
-  return ended !== void 0 && ended.started_at === started_at;
+function create_animation(message3) {
+  const spinner = ora({ text: message3 }).start();
+  return {
+    stop: create_stop_function(spinner, message3),
+    pause: () => {
+      spinner.stop();
+    }
+  };
 }
-var run_carry_ended = { ended_path, has_ended, read_ended, record_ended };
+var git_animation = {
+  create_animation
+};
 
-// scripts/run/wake/run-wake.ts
-import { z as z5 } from "zod";
-var WAKE_PREFIX = "josh-run-wake-";
-var WAKE_LOG_PREFIX = "josh-run-wake-log-";
-var WAKE_LOG_SUFFIX = ".log";
-var WAKE_GRACE_MS = 6e5;
-var MAX_WAKE_ATTEMPTS = 3;
-var IDLE_CEILING_MS = backlog_budget.DEFAULT_IDLE_MS;
+// scripts/lib/animation-helpers.ts
+function get_error_message(error_message = "Operation failed") {
+  return error_message;
+}
+function get_display_result(result, formatter) {
+  return formatter?.(result) ?? String(result);
+}
+function handle_animation_success(animation, result, options) {
+  const icon = options?.icon_selector?.(result);
+  const display_result = get_display_result(result, options?.result_formatter);
+  animation.stop(display_result, icon);
+}
+function handle_animation_error(animation, error, error_message) {
+  animation.stop();
+  if (error_message === void 0 || error_message.length === 0) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(String(error), { cause: error });
+  }
+  throw new Error(get_error_message(error_message), { cause: error });
+}
+async function execute_with_animation(message3, command_executor, options) {
+  const animation = git_animation.create_animation(message3);
+  try {
+    const result = await command_executor(() => {
+      animation.pause();
+    });
+    handle_animation_success(animation, result, options);
+    return result;
+  } catch (error) {
+    return handle_animation_error(animation, error, options?.error_message);
+  }
+}
+function create_git_operation_config(error_message) {
+  return {
+    error_message,
+    icon_selector: () => "\u2705",
+    result_formatter: (message3) => message3
+  };
+}
+var animation_helpers = {
+  execute_with_animation
+};
+
+// scripts/git/git-branch.ts
+async function current() {
+  const config = {
+    error_message: "Failed to get current branch"
+  };
+  return await animation_helpers.execute_with_animation(
+    "Getting current branch...",
+    git_command.branch,
+    config
+  );
+}
+async function create(branch_name) {
+  const config = create_git_operation_config("Failed to create branch");
+  await animation_helpers.execute_with_animation(
+    `Creating branch: ${branch_name}...`,
+    async () => {
+      await git_command.checkout_b(branch_name);
+      return `Branch created: ${branch_name}`;
+    },
+    config
+  );
+}
+async function switch_to(branch_name) {
+  const config = create_git_operation_config("Failed to switch branch");
+  await animation_helpers.execute_with_animation(
+    `Switching to branch: ${branch_name}...`,
+    async () => {
+      await git_command.checkout(branch_name);
+      return `Switched to branch: ${branch_name}`;
+    },
+    config
+  );
+}
+async function exists(branch_name) {
+  const config = {
+    error_message: "Failed to check branch existence",
+    result_formatter: (is_exists) => is_exists ? "Exists" : "Not found"
+  };
+  return await animation_helpers.execute_with_animation(
+    "Checking if branch exists...",
+    async () => {
+      return await git_command.branch_exists(branch_name);
+    },
+    config
+  );
+}
+async function pull_latest() {
+  const config = create_git_operation_config("Failed to pull latest from remote");
+  await animation_helpers.execute_with_animation(
+    "Pulling latest from remote...",
+    async () => {
+      await git_command.pull_fast_forward();
+      return "Pulled latest from remote";
+    },
+    config
+  );
+}
+var ISSUE_PREFIX_PATTERN = /^(\d+)-/u;
+function has_same_issue_prefix(branch_a, branch_b) {
+  const prefix_a = ISSUE_PREFIX_PATTERN.exec(branch_a)?.[0];
+  const prefix_b = ISSUE_PREFIX_PATTERN.exec(branch_b)?.[0];
+  return prefix_a !== void 0 && prefix_a === prefix_b;
+}
+function issue_from_branch(branch) {
+  const digits = ISSUE_PREFIX_PATTERN.exec(branch)?.[1];
+  return digits === void 0 ? void 0 : Number(digits);
+}
+function is_mismatch2(current_branch2, target_branch_name, default_branch) {
+  if (current_branch2 === default_branch || current_branch2 === target_branch_name) return false;
+  return !has_same_issue_prefix(current_branch2, target_branch_name);
+}
+async function handle_default_branch(target_branch_name) {
+  await pull_latest();
+  const is_branch_exists = await exists(target_branch_name);
+  await (is_branch_exists ? switch_to : create)(target_branch_name);
+}
+async function check_and_create_branch(current_branch2, target_branch_name) {
+  const default_branch = await git_command.get_default_branch();
+  if (current_branch2 === default_branch) {
+    await handle_default_branch(target_branch_name);
+    return target_branch_name;
+  }
+  if (is_mismatch2(current_branch2, target_branch_name, default_branch)) {
+    throw new BranchMismatchError({ current_branch: current_branch2, target_branch_name });
+  }
+  return current_branch2;
+}
+var git_branch = {
+  current,
+  check_and_create_branch,
+  is_mismatch: is_mismatch2,
+  // Exported so a lane's branch name can be checked against the real matcher rather than against a
+  // second copy of the pattern. A copy is what let `lane/<N>` ship: nothing
+  // asserted that the name `lane:open` writes is one this function accepts.
+  has_same_issue_prefix,
+  issue_from_branch
+};
+
+// scripts/run/run-prrun-resume.ts
+var PRRUN_MERGED = "prrun-merged";
+var PRRUN_MERGE = "prrun-merge";
+var PRRUN_GATE = "prrun-gate";
+function is_untouched(facts) {
+  return facts.head === facts.stop_head && facts.pr_head === facts.stop_head && !facts.is_dirty;
+}
+function decide(facts) {
+  if (facts.is_merged) return PRRUN_MERGED;
+  return is_untouched(facts) ? PRRUN_MERGE : PRRUN_GATE;
+}
+function stop_head_of(read2, issue) {
+  const hold = run_halfrun_resume.hold_of(read2);
+  return hold?.issue === issue ? hold.prrun_stop_head : void 0;
+}
+async function read_merge_state() {
+  return await git_gh_command.pr_get_merge_state(await git_branch.current());
+}
+async function read_facts(stop_head) {
+  const [state, head, is_dirty] = await Promise.all([
+    read_merge_state(),
+    git_command.head_commit(),
+    run_hold.is_tree_dirty()
+  ]);
+  return {
+    is_merged: state?.is_merged === true,
+    stop_head,
+    head,
+    pr_head: state?.head_sha,
+    is_dirty
+  };
+}
+async function resume_token(issue) {
+  const target = await run_halfrun_resume.hold_target();
+  if (target === void 0) return void 0;
+  const stop_head = stop_head_of(run_hold.read_hold(target), issue);
+  return stop_head === void 0 ? void 0 : decide(await read_facts(stop_head));
+}
+async function adopt2(issue) {
+  const target = await run_halfrun_resume.hold_target();
+  if (target === void 0 || stop_head_of(run_hold.read_hold(target), issue) === void 0) {
+    return false;
+  }
+  return run_halfrun_resume.take_over(target, issue);
+}
+async function mark_stop_at2(target, issue) {
+  const head = await git_command.head_commit();
+  return run_halfrun_resume.mark_stop_at(target, issue, { prrun_stop_head: head });
+}
+var run_prrun_resume = {
+  PRRUN_GATE,
+  PRRUN_MERGE,
+  PRRUN_MERGED,
+  adopt: adopt2,
+  decide,
+  mark_stop_at: mark_stop_at2,
+  resume_token,
+  stop_head_of
+};
+
+// scripts/run/tidy/run-tidy-cli.ts
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
+// scripts/issue/issue-merged.ts
+var CLOSED_EVENT = "closed";
+var REOPENED_EVENT = "reopened";
+var MERGED_REFERENCE = "merged-reference";
+var COMPLETED_REASONS = /* @__PURE__ */ new Set(["", "completed"]);
+var FIELD_SEPARATOR = "	";
+var LINE_SEPARATOR2 = "\n";
+var TIMELINE_FILTER = [
+  ".[]",
+  '| if .event == "cross-referenced" and .source.issue.pull_request.merged_at != null',
+  String.raw`then "${MERGED_REFERENCE}\t"`,
+  `elif .event == "${CLOSED_EVENT}" or .event == "${REOPENED_EVENT}"`,
+  String.raw`then "\(.event)\t\(.state_reason // "")"`,
+  "else empty end"
+].join(" ");
+function parse_rows(raw) {
+  return raw.split(LINE_SEPARATOR2).filter((line) => line !== "").map((line) => {
+    const [event = "", reason = ""] = line.split(FIELD_SEPARATOR);
+    return { event, reason };
+  });
+}
+function is_merged_close(rows) {
+  const last = rows.findLast((row) => row.event === CLOSED_EVENT || row.event === REOPENED_EVENT);
+  if (last?.event !== CLOSED_EVENT || !COMPLETED_REASONS.has(last.reason)) return false;
+  return rows.some((row) => row.event === MERGED_REFERENCE);
+}
+async function read_merge_state2(issue) {
+  try {
+    const raw = await git_gh_exec.exec_gh_api({
+      path: `${git_gh_api_path.issue_api_path(issue)}/timeline?per_page=100`,
+      should_paginate: true,
+      jq_filter: TIMELINE_FILTER
+    });
+    return is_merged_close(parse_rows(raw));
+  } catch {
+    return void 0;
+  }
+}
+async function read_merged(issue) {
+  return await read_merge_state2(issue) ?? false;
+}
+var issue_merged = { is_merged_close, parse_rows, read_merge_state: read_merge_state2, read_merged };
+
+// scripts/observations/observation-ledger-line.ts
+var KEY_PREFIX = "- k:";
+var FIELD_SEPARATOR2 = " | ";
+var FIELD_COUNT = 5;
+var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var DEPTH_PATTERN = /^d[1-9]\d*$/u;
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
+var SLUG_REASON = "the slug must be lowercase words joined by `-`";
+var DEPTH_REASON = "the depth must be `d1` or higher (never `d0`)";
+var DATE_REASON = "the date must be `YYYY-MM-DD`";
+var WHERE_REASON = "the `where` field is empty";
+var WHAT_REASON = "the `what` field is empty";
+function is_ledger_entry_line(line) {
+  return line.trimStart().startsWith(KEY_PREFIX);
+}
+function slug_of(first_field) {
+  return first_field.trimStart().slice(KEY_PREFIX.length);
+}
+function is_present(field = "") {
+  return field.trim().length > 0;
+}
+function matches(pattern, field = "") {
+  return pattern.test(field);
+}
+function slug_ok(key_field = "") {
+  return SLUG_PATTERN.test(slug_of(key_field));
+}
+function field_reason(fields) {
+  const [key_field, depth, date, where, what] = fields;
+  const checks = [
+    [slug_ok(key_field), SLUG_REASON],
+    [matches(DEPTH_PATTERN, depth), DEPTH_REASON],
+    [matches(DATE_PATTERN, date), DATE_REASON],
+    [is_present(where), WHERE_REASON],
+    [is_present(what), WHAT_REASON]
+  ];
+  return checks.find(([is_valid2]) => !is_valid2)?.[1];
+}
+function line_reason(line) {
+  const fields = line.split(FIELD_SEPARATOR2);
+  if (fields.length !== FIELD_COUNT) {
+    return `expected ${String(FIELD_COUNT)} fields separated by " | " (a \`|\` in the last field is not allowed)`;
+  }
+  return field_reason(fields);
+}
+function broken_ledger_lines(content) {
+  return content.split("\n").filter((line) => is_ledger_entry_line(line)).map((line) => ({ line, reason: line_reason(line) })).filter((entry) => entry.reason !== void 0);
+}
+function missing_lines(candidates, ledger) {
+  const present = new Set(ledger.split("\n"));
+  return candidates.filter((line) => !present.has(line));
+}
+var observation_ledger_line = {
+  broken_ledger_lines,
+  is_ledger_entry_line,
+  line_reason,
+  missing_lines
+};
+
+// scripts/run/tidy/run-tidy.ts
+var LINE_SEPARATOR3 = "\n";
+var CLEANED_HEADER = "run:tidy \u2014 cleaned:";
+var KEPT_HEADER = "run:tidy \u2014 kept:";
+var CHANGES_REASON = "uncommitted changes";
+var UNPUSHED_REASON = "commits no remote has";
+var RUNNING_REASON = "held by a live run";
+var CLEAN = { kind: "clean" };
+function keep(reason) {
+  return { kind: "keep", reason };
+}
+function lane_verdict(facts) {
+  if (!facts.is_merged) return void 0;
+  if (facts.has_changes) return keep(CHANGES_REASON);
+  if (facts.has_unpushed) return keep(UNPUSHED_REASON);
+  return facts.is_running ? keep(RUNNING_REASON) : CLEAN;
+}
+function unmerged_reason(unmerged) {
+  const named = unmerged.map((issue) => session_cite.issue(issue)).join(", ");
+  return `${named} not merged`;
+}
+function stash_verdict(facts, merged) {
+  const unmerged = facts.issues.filter((issue) => !merged.has(issue));
+  if (unmerged.length === facts.issues.length) return void 0;
+  return unmerged.length === 0 ? CLEAN : keep(unmerged_reason(unmerged));
+}
+function ledger_carry(added, ledger) {
+  const entries = added.filter((line) => observation_ledger_line.is_ledger_entry_line(line));
+  return observation_ledger_line.missing_lines([...new Set(entries)], ledger);
+}
+function format_outcome(outcome) {
+  const suffix = outcome.verdict.kind === "keep" ? ` \u2014 ${outcome.verdict.reason}` : "";
+  return `  ${outcome.target}${suffix}`;
+}
+function section(header, outcomes) {
+  return outcomes.length === 0 ? [] : [header, ...outcomes.map((item) => format_outcome(item))];
+}
+function format_report(outcomes) {
+  const cleaned = outcomes.filter((outcome) => outcome.verdict.kind === "clean");
+  const kept = outcomes.filter((outcome) => outcome.verdict.kind === "keep");
+  const lines = [...section(CLEANED_HEADER, cleaned), ...section(KEPT_HEADER, kept)];
+  return lines.length === 0 ? void 0 : lines.join(LINE_SEPARATOR3);
+}
+var run_tidy = { CLEAN, format_report, keep, lane_verdict, ledger_carry, stash_verdict };
+
+// scripts/git/stash/git-stash.ts
+var ENTRY_SEPARATOR = "\n";
+var FIELD_SEPARATOR3 = "\0";
+var LIST_FORMAT = "--format=%gd%x00%gs";
+var SUBJECT_MESSAGE_SEPARATOR = ": ";
+var HASH_FORMAT = "--format=%H%x00%gs";
+var HASH_POSITION_FORMAT = "--format=%H%x00%gd";
+var NAME_ONLY_FLAG = "--name-only";
+var ADDED_PREFIX = "+";
+var FILE_HEADER_PREFIX = "+++";
+function to_entry(line) {
+  const [selector, subject] = line.split(FIELD_SEPARATOR3);
+  if (selector === void 0 || subject === void 0) return void 0;
+  return { selector, subject };
+}
+function parse_entries(raw) {
+  if (raw === "") return [];
+  return raw.split(ENTRY_SEPARATOR).map((line) => to_entry(line)).filter((entry) => entry !== void 0);
+}
+function matches2(subject, message3) {
+  return subject === message3 || subject.endsWith(`${SUBJECT_MESSAGE_SEPARATOR}${message3}`);
+}
+function select(entries, message3) {
+  const found = entries.filter((entry) => matches2(entry.subject, message3));
+  const [first] = found;
+  if (first === void 0) return { kind: "none" };
+  if (found.length > 1) {
+    return { kind: "ambiguous", selectors: found.map((entry) => entry.selector) };
+  }
+  return { kind: "match", selector: first.selector };
+}
+function git_args(directory, args) {
+  return directory === void 0 ? args : ["-C", directory, ...args];
+}
+async function list(directory) {
+  return parse_entries(await git_spawn.read(git_args(directory, ["stash", "list", LIST_FORMAT])));
+}
+async function pop(selector, directory) {
+  await git_spawn.read(git_args(directory, ["stash", "pop", selector]));
+}
+async function has_conflict(directory) {
+  const unmerged = await git_spawn.read(
+    git_args(directory, ["diff", NAME_ONLY_FLAG, "--diff-filter=U"])
+  );
+  return unmerged !== "";
+}
+async function has_changes(directory) {
+  return await git_spawn.read(git_args(directory, ["status", "--porcelain"])) !== "";
+}
+async function push(message3, directory) {
+  await git_spawn.read(git_args(directory, ["stash", "push", "-u", "-m", message3]));
+}
+async function list_by_hash(directory) {
+  return parse_entries(await git_spawn.read(git_args(directory, ["stash", "list", HASH_FORMAT])));
+}
+async function changed_paths(hash, directory) {
+  const raw = await git_spawn.read(
+    git_args(directory, ["stash", "show", "--include-untracked", NAME_ONLY_FLAG, hash])
+  );
+  return raw === "" ? [] : raw.split(ENTRY_SEPARATOR);
+}
+async function untracked_lines(hash, file, directory) {
+  try {
+    const raw = await git_spawn.read(git_args(directory, ["show", `${hash}^3:${file}`]));
+    return raw === "" ? [] : raw.split(ENTRY_SEPARATOR);
+  } catch {
+    return [];
+  }
+}
+async function added_lines(hash, file, directory) {
+  const diff = await git_spawn.read(git_args(directory, ["diff", `${hash}^1`, hash, "--", file]));
+  if (diff === "") return await untracked_lines(hash, file, directory);
+  return diff.split(ENTRY_SEPARATOR).filter((line) => line.startsWith(ADDED_PREFIX) && !line.startsWith(FILE_HEADER_PREFIX)).map((line) => line.slice(ADDED_PREFIX.length));
+}
+async function drop_by_hash(hash, directory) {
+  const raw = await git_spawn.read(git_args(directory, ["stash", "list", HASH_POSITION_FORMAT]));
+  const entry = parse_entries(raw).find((candidate) => candidate.selector === hash);
+  if (entry === void 0) return false;
+  await git_spawn.read(git_args(directory, ["stash", "drop", entry.subject]));
+  return true;
+}
+function work_message(issue, occasion) {
+  return `${issue}: uncommitted work at ${occasion}`;
+}
+var git_stash = {
+  added_lines,
+  changed_paths,
+  drop_by_hash,
+  has_changes,
+  has_conflict,
+  list,
+  list_by_hash,
+  matches: matches2,
+  parse_entries,
+  pop,
+  push,
+  select,
+  work_message
+};
+
+// scripts/lane/lane-close.ts
+import { existsSync, rmSync } from "node:fs";
+async function ignore_failure(action) {
+  try {
+    await action();
+  } catch {
+  }
+}
+function lane_targets(root, issue, lane) {
+  return {
+    directory: lane?.directory ?? lane_paths.lane_directory(root, issue),
+    branch: lane?.branch ?? lane_paths.lane_branch(issue)
+  };
+}
+function remove_directory(directory) {
+  try {
+    rmSync(directory, { force: true, recursive: true });
+  } catch {
+  }
+}
+async function remove_lane(targets) {
+  await ignore_failure(async () => await git_worktree.worktree_remove(targets.directory));
+  remove_directory(targets.directory);
+  await ignore_failure(async () => await git_worktree.worktree_prune());
+  await ignore_failure(async () => await git_worktree.branch_delete(targets.branch));
+}
+async function residue(targets) {
+  const left = [];
+  if (existsSync(targets.directory)) left.push(targets.directory);
+  if (await git_command.branch_exists(targets.branch)) left.push(targets.branch);
+  return left;
+}
+function close_kind(did_exist, left_behind) {
+  if (left_behind.length > 0) return "incomplete";
+  return did_exist ? "closed" : "none";
+}
+async function lane_root_directory() {
+  return lane_paths.lane_root(await lane_registry.main_repository_root());
+}
+async function resolve_lane(issue) {
+  const root = await lane_root_directory();
+  const existing = lane_registry.find_lane(await lane_registry.list_lanes(), issue);
+  return { existing, targets: lane_targets(root, issue, existing) };
+}
+async function close_lane(issue) {
+  const { existing, targets } = await resolve_lane(issue);
+  const did_exist = existing !== void 0 || existsSync(targets.directory);
+  const reaped = lane_reap.reap_child(issue);
+  await remove_lane(targets);
+  const left_behind = await residue(targets);
+  return { issue, kind: close_kind(did_exist, left_behind), left_behind, reaped };
+}
+async function try_close(issue) {
+  try {
+    const outcome = await close_lane(issue);
+    return outcome.kind !== "incomplete";
+  } catch (error) {
+    error_text.trace_swallowed("lane_close.try_close", error);
+    return false;
+  }
+}
+async function close_each(issues) {
+  const sweep2 = { closed: [], failed: [] };
+  for (const issue of issues) {
+    const bucket = await try_close(issue) ? sweep2.closed : sweep2.failed;
+    bucket.push(issue);
+  }
+  return sweep2;
+}
+async function prune_lanes() {
+  const lanes = await lane_registry.list_lanes();
+  const { spent, kept } = await lane_spent.sort_lanes(lanes);
+  const doomed = lanes.filter((lane) => lane.is_stranded || spent.includes(lane));
+  const sweep2 = await close_each(doomed.map((lane) => lane.issue));
+  return { ...sweep2, kept };
+}
+async function close_all_lanes() {
+  const lanes = await lane_registry.list_lanes();
+  return await close_each(lanes.map((lane) => lane.issue));
+}
+var lane_close = {
+  close_all_lanes,
+  close_lane,
+  prune_lanes,
+  resolve_lane
+};
+
+// scripts/run/tidy/run-tidy-lanes.ts
+var CLOSED_KIND = "closed";
+var INCOMPLETE_REASON = "the close left files behind";
+var NOT_MERGED_REASON = "not merged";
+async function has_unpushed(directory) {
+  try {
+    const count = await git_spawn.read([
+      "-C",
+      directory,
+      "rev-list",
+      "--count",
+      "HEAD",
+      "--not",
+      "--remotes"
+    ]);
+    return count !== "0";
+  } catch (error) {
+    error_text.trace_swallowed("run_tidy_lanes.has_unpushed", error);
+    return true;
+  }
+}
+async function hold_path_of(directory) {
+  const git_directory = await git_spawn.read(["-C", directory, "rev-parse", "--absolute-git-dir"]);
+  return run_hold.hold_path(git_directory);
+}
+function is_running(hold_path) {
+  const read2 = run_hold.read_hold(hold_path);
+  return read2.kind === "held" || read2.kind === "unreadable";
+}
+async function lane_verdict2(lane, hold_path) {
+  const verdict = run_tidy.lane_verdict({
+    issue: lane.issue,
+    is_merged: true,
+    has_changes: await git_stash.has_changes(lane.directory),
+    has_unpushed: await has_unpushed(lane.directory),
+    is_running: is_running(hold_path)
+  });
+  return verdict ?? run_tidy.keep(NOT_MERGED_REASON);
+}
+async function close(issue, hold_path) {
+  const outcome = await lane_close.close_lane(issue);
+  if (outcome.kind !== CLOSED_KIND) return run_tidy.keep(INCOMPLETE_REASON);
+  run_hold.release_hold(hold_path);
+  return run_tidy.CLEAN;
+}
+async function settle(lane) {
+  try {
+    const hold_path = await hold_path_of(lane.directory);
+    const verdict = await lane_verdict2(lane, hold_path);
+    return verdict.kind === "clean" ? await close(lane.issue, hold_path) : verdict;
+  } catch (error) {
+    return run_tidy.keep(String(error));
+  }
+}
+async function tidy_lane(lane, is_merged, in_flight) {
+  if (in_flight.has(lane.issue) || lane.is_stranded || !await is_merged(lane.issue)) {
+    return void 0;
+  }
+  return { target: `lane ${session_cite.issue(lane.issue)}`, verdict: await settle(lane) };
+}
+async function tidy_lanes(is_merged, in_flight = /* @__PURE__ */ new Set()) {
+  const outcomes = [];
+  const lanes = await lane_registry.list_lanes();
+  for (const lane of lanes) {
+    const outcome = await tidy_lane(lane, is_merged, in_flight);
+    if (outcome !== void 0) outcomes.push(outcome);
+  }
+  return outcomes;
+}
+var run_tidy_lanes = { has_unpushed, tidy_lanes };
+
+// scripts/git/stash/stash-orphans.ts
+var HASH_PATTERN = /#(?<issue>\d+)\b/u;
+var LEADING_PATTERN = /(?:^|: )(?<issue>\d+): /u;
+var MESSAGE_PATTERNS = [HASH_PATTERN, LEADING_PATTERN];
+var ALL_ISSUE_PATTERN = new RegExp(HASH_PATTERN.source, "gu");
+var BRANCH_PATTERN = /^(?:WIP on|On) (?<issue>\d+)-lane: /u;
+var WIP_PREFIX = "WIP on ";
+var NO_PATTERNS = [];
+var HEADER = "Stashes whose issue is closed, or whose owner cannot be read \u2014 decide for each whether to revive or discard it (none is dropped automatically):";
+var FOOTER = 'Revive: `pnpm josh stash:pop "<message>"` \xB7 Discard: `git stash drop <selector>` \u2014 re-read the selector first, the stack is shared by every lane.';
+var UNKNOWN_OWNER = "owner unknown";
+var COLUMN_SEPARATOR = "  ";
+var LINE_SEPARATOR4 = "\n";
+function patterns_for(subject) {
+  if (subject.includes(run_preflight.STASH_LABEL_PREFIX)) return NO_PATTERNS;
+  return subject.startsWith(WIP_PREFIX) ? [BRANCH_PATTERN] : [...MESSAGE_PATTERNS, BRANCH_PATTERN];
+}
+function issue_of2(subject) {
+  for (const pattern of patterns_for(subject)) {
+    const issue = pattern.exec(subject)?.groups?.["issue"];
+    if (issue !== void 0) return issue;
+  }
+  return void 0;
+}
+function issues_of(entries) {
+  const issues = entries.map((entry) => issue_of2(entry.subject));
+  return [...new Set(issues.filter((issue) => issue !== void 0))];
+}
+function message_issues(subject) {
+  const hashed = [...subject.matchAll(ALL_ISSUE_PATTERN)].map((match) => match.groups?.["issue"]);
+  return [...hashed, LEADING_PATTERN.exec(subject)?.groups?.["issue"]];
+}
+function issues_named(subject) {
+  const branch = BRANCH_PATTERN.exec(subject)?.groups?.["issue"];
+  const named = subject.startsWith(WIP_PREFIX) ? [] : message_issues(subject);
+  const found = [...named, branch].filter((issue) => issue !== void 0);
+  return [...new Set(found)];
+}
+function orphans(entries, closed) {
+  return entries.map((entry) => ({ ...entry, issue: issue_of2(entry.subject) })).filter((entry) => entry.issue === void 0 || closed.has(entry.issue));
+}
+function format_line(orphan) {
+  const owner = orphan.issue === void 0 ? UNKNOWN_OWNER : `${session_cite.issue(orphan.issue)} closed`;
+  return `  ${[orphan.selector, owner, orphan.subject].join(COLUMN_SEPARATOR)}`;
+}
+function format_report2(found) {
+  if (found.length === 0) return void 0;
+  return [HEADER, ...found.map((orphan) => format_line(orphan)), FOOTER].join(LINE_SEPARATOR4);
+}
+var stash_orphans = { format_report: format_report2, issue_of: issue_of2, issues_named, issues_of, orphans };
+
+// scripts/git/stash/stash-sweep-lock.ts
+var LOCK_PREFIX = "josh-stash-sweep-lock-";
+var MAX_WAIT_MS = 3e4;
+function lock_path(cwd) {
+  return repository_lock.lock_path(LOCK_PREFIX, cwd);
+}
+async function with_lock(work, target = lock_path(), max_wait_ms = MAX_WAIT_MS) {
+  return await repository_lock.with_lock(work, target, max_wait_ms);
+}
+var stash_sweep_lock = { clear_stale: repository_lock.clear_stale, with_lock };
+
+// scripts/observations/observation-ledger-home.ts
+import { appendFile, mkdir, readdir, readFile } from "node:fs/promises";
+import path3 from "node:path";
+
+// scripts/observations/observation-ledger-migrate.ts
+import {
+  appendFileSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmdirSync,
+  rmSync as rmSync2
+} from "node:fs";
+import path2 from "node:path";
+var NEWLINE = "\n";
+function claim_path(legacy) {
+  return `${legacy}.${String(process.pid)}${MIGRATION_CLAIM_SUFFIX}`;
+}
+function claim(from, to) {
+  try {
+    renameSync(from, to);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function is_stale_claim(name, legacy_name) {
+  const prefix = `${legacy_name}.`;
+  if (!name.startsWith(prefix) || !name.endsWith(MIGRATION_CLAIM_SUFFIX)) return false;
+  const pid = Number(name.slice(prefix.length, -MIGRATION_CLAIM_SUFFIX.length));
+  return Number.isSafeInteger(pid) && !process_identity.is_present_pid(pid);
+}
+function stale_claims(legacy) {
+  const directory = path2.dirname(legacy);
+  try {
+    return readdirSync(directory).filter((name) => is_stale_claim(name, path2.basename(legacy))).map((name) => path2.join(directory, name));
+  } catch {
+    return [];
+  }
+}
+function terminated(content) {
+  return content.length === 0 || content.endsWith(NEWLINE) ? content : `${content}${NEWLINE}`;
+}
+function carried(content, ledger) {
+  if (ledger === void 0) return terminated(content);
+  const lines = content.split(NEWLINE).filter((line) => line.length > 0);
+  const missing = observation_ledger_line.missing_lines(lines, ledger);
+  return missing.length === 0 ? "" : `${missing.join(NEWLINE)}${NEWLINE}`;
+}
+function absorb(claimed, target) {
+  mkdirSync(path2.dirname(target), { recursive: true });
+  appendFileSync(
+    target,
+    carried(readFileSync2(claimed, "utf8"), file_reader.read_if_readable(target)),
+    "utf8"
+  );
+  rmSync2(claimed);
+}
+function absorb_stale(legacy, target) {
+  let count = 0;
+  for (const stale of stale_claims(legacy)) {
+    const claimed = claim_path(legacy);
+    if (!claim(stale, claimed)) continue;
+    absorb(claimed, target);
+    count += 1;
+  }
+  return count;
+}
+function migrate_one(legacy, target) {
+  const recovered = absorb_stale(legacy, target);
+  const claimed = claim_path(legacy);
+  if (!claim(legacy, claimed)) return recovered > 0;
+  absorb(claimed, target);
+  return true;
+}
+function source_name(name) {
+  const end = name.indexOf(LEDGER_FILE_EXTENSION);
+  return end === -1 ? void 0 : name.slice(0, end + LEDGER_FILE_EXTENSION.length);
+}
+function legacy_directory_names(directory) {
+  try {
+    const names = readdirSync(directory).map((name) => source_name(name));
+    return [...new Set(names.filter((name) => name !== void 0))];
+  } catch {
+    return [];
+  }
+}
+function migrate_directory(root) {
+  const legacy_directory = path2.join(root, LEGACY_OBSERVATION_LEDGER_DIRECTORY);
+  const did_move = legacy_directory_names(legacy_directory).map(
+    (name) => migrate_one(
+      path2.join(legacy_directory, name),
+      path2.join(root, OBSERVATION_LEDGER_DIRECTORY, name)
+    )
+  ).some(Boolean);
+  try {
+    rmdirSync(legacy_directory);
+  } catch {
+  }
+  return did_move;
+}
+function migrate(root) {
+  const target = path2.join(root, OBSERVATION_LEDGER_DIRECTORY, LEGACY_LEDGER_FILE);
+  const moved_files = LEGACY_OBSERVATION_LEDGER_PATHS.map(
+    (legacy) => migrate_one(path2.join(root, legacy), target)
+  );
+  return [...moved_files, migrate_directory(root)].some(Boolean);
+}
+var observation_ledger_migrate = { migrate };
+
+// scripts/observations/observation-ledger-home.ts
+var DATE_END = 10;
+function ledger_root(cwd = process.cwd()) {
+  return cwd;
+}
+function ledger_directory(cwd = process.cwd()) {
+  const root = ledger_root(cwd);
+  observation_ledger_migrate.migrate(root);
+  return path3.join(root, OBSERVATION_LEDGER_DIRECTORY);
+}
+function file_path(name, cwd) {
+  ledger_directory(cwd);
+  return path3.join(ledger_root(cwd), observation_ledger.ledger_file(name));
+}
+function issue_path(issue, cwd = process.cwd()) {
+  return file_path(issue, cwd);
+}
+async function current_branch(cwd) {
+  try {
+    return await git_spawn.read(["-C", cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
+  } catch {
+    return "";
+  }
+}
+function ledger_date(now) {
+  return now.toISOString().slice(0, DATE_END);
+}
+async function writer_path(now, cwd = process.cwd()) {
+  const issue = git_branch.issue_from_branch(await current_branch(cwd));
+  return file_path(issue ?? ledger_date(now), cwd);
+}
+async function read_file(target) {
+  try {
+    const content = await readFile(target, "utf8");
+    return content.length === 0 || content.endsWith("\n") ? content : `${content}
+`;
+  } catch {
+    return "";
+  }
+}
+async function ledger_files(directory) {
+  try {
+    const names = await readdir(directory);
+    return names.filter((name) => observation_ledger.is_ledger_file_name(name)).toSorted((left, right) => left.localeCompare(right));
+  } catch {
+    return void 0;
+  }
+}
+async function read(cwd = process.cwd()) {
+  const directory = ledger_directory(cwd);
+  const files = await ledger_files(directory);
+  if (files === void 0) return void 0;
+  const contents = await Promise.all(
+    files.map(async (name) => await read_file(path3.join(directory, name)))
+  );
+  return contents.join("");
+}
+async function append(target, lines) {
+  if (lines.length === 0) return;
+  await mkdir(path3.dirname(target), { recursive: true });
+  await appendFile(target, `${lines.join("\n")}
+`, "utf8");
+}
+var observation_ledger_home = {
+  append,
+  file_path,
+  issue_path,
+  ledger_date,
+  ledger_root,
+  read,
+  writer_path
+};
+
+// scripts/run/tidy/run-tidy-stashes.ts
+var READ_CONCURRENCY2 = 8;
+var GONE_REASON = "already dropped by another run";
+var BUSY_REASON = "another run held the stash sweep lock";
+async function added_ledger_lines(hash, ledger_paths) {
+  const added = await bounded_pool.bounded_map(
+    ledger_paths,
+    READ_CONCURRENCY2,
+    async (ledger_path) => await git_stash.added_lines(hash, ledger_path)
+  );
+  return added.flat();
+}
+async function carry_ledger(hash) {
+  const changed = await git_stash.changed_paths(hash);
+  const ledger_paths = changed.filter((file_path2) => observation_ledger.is_ledger_path(file_path2));
+  if (ledger_paths.length === 0) return 0;
+  const ledger_path = await observation_ledger_home.writer_path(/* @__PURE__ */ new Date());
+  const added = await added_ledger_lines(hash, ledger_paths);
+  const carried2 = run_tidy.ledger_carry(added, await observation_ledger_home.read() ?? "");
+  await observation_ledger_home.append(ledger_path, carried2);
+  return carried2.length;
+}
+function carried_note(count) {
+  return count === 0 ? "" : ` (${String(count)} observation line(s) carried to the ledger)`;
+}
+async function drop(entry) {
+  const carried2 = await carry_ledger(entry.selector);
+  const target = `stash "${entry.subject}"${carried_note(carried2)}`;
+  const is_dropped = await git_stash.drop_by_hash(entry.selector);
+  return { target, verdict: is_dropped ? run_tidy.CLEAN : run_tidy.keep(GONE_REASON) };
+}
+async function merged_set(issues, is_merged) {
+  const answers = await bounded_pool.bounded_map(
+    issues,
+    READ_CONCURRENCY2,
+    async (issue) => await is_merged(issue)
+  );
+  return new Set(issues.filter((_issue, index) => answers[index] === true));
+}
+function entry_verdict(entry, merged) {
+  const issues = stash_orphans.issues_named(entry.subject);
+  return run_tidy.stash_verdict({ subject: entry.subject, issues }, merged);
+}
+async function tidy_entry(entry, merged) {
+  const verdict = entry_verdict(entry, merged);
+  if (verdict === void 0) return void 0;
+  if (verdict.kind === "keep") return { target: `stash "${entry.subject}"`, verdict };
+  try {
+    return await drop(entry);
+  } catch (error) {
+    return { target: `stash "${entry.subject}"`, verdict: run_tidy.keep(String(error)) };
+  }
+}
+async function tidy_entries(entries, merged) {
+  const outcomes = [];
+  for (const entry of entries) {
+    const outcome = await tidy_entry(entry, merged);
+    if (outcome !== void 0) outcomes.push(outcome);
+  }
+  return outcomes;
+}
+function busy_outcome(entry, merged) {
+  const verdict = entry_verdict(entry, merged);
+  if (verdict === void 0) return void 0;
+  return {
+    target: `stash "${entry.subject}"`,
+    verdict: verdict.kind === "keep" ? verdict : run_tidy.keep(BUSY_REASON)
+  };
+}
+function busy_outcomes(entries, merged) {
+  return entries.map((entry) => busy_outcome(entry, merged)).filter((outcome) => outcome !== void 0);
+}
+async function tidy_stashes(is_merged) {
+  const entries = await git_stash.list_by_hash();
+  const issues = [...new Set(entries.flatMap((entry) => stash_orphans.issues_named(entry.subject)))];
+  const merged = await merged_set(issues, is_merged);
+  const outcomes = await stash_sweep_lock.with_lock(async () => await tidy_entries(entries, merged));
+  return outcomes ?? busy_outcomes(entries, merged);
+}
+var run_tidy_stashes = { tidy_stashes };
+
+// scripts/run/tidy/run-tidy-cli.ts
+var FAILURE_NOTE = "run:tidy could not finish; merged lanes and stashes may remain:";
+function memoized(read2) {
+  const answers = /* @__PURE__ */ new Map();
+  return async function read_once(issue) {
+    const cached = answers.get(issue) ?? read2(issue);
+    answers.set(issue, cached);
+    return await cached;
+  };
+}
+async function sweep() {
+  try {
+    const is_merged = memoized(issue_merged.read_merged);
+    const in_flight = backlog_drive_restore.active_issues(
+      await run_event_stream_emit.current_events()
+    );
+    const lanes = await run_tidy_lanes.tidy_lanes(is_merged, in_flight);
+    const stashes = await run_tidy_stashes.tidy_stashes(is_merged);
+    const report6 = run_tidy.format_report([...lanes, ...stashes]);
+    if (report6 !== void 0) console.error(report6);
+  } catch (error) {
+    console.error(FAILURE_NOTE, error);
+  }
+}
+var run_tidy_cli = { sweep };
+if (process.argv[1] === fileURLToPath3(import.meta.url)) await sweep();
+
+// scripts/run/hold/run-hold-cli.ts
+var SUCCESS_EXIT_CODE2 = 0;
+var FAILURE_EXIT_CODE4 = 1;
+var ARGV_OFFSET3 = 2;
+var RELEASE_FLAG = "--release";
+var FORCE_FLAG = "--force";
+var FULLRUN_FLAG = "--fullrun";
+var HALFRUN_STOP_FLAG = "--halfrun-stop";
+var PRRUN_STOP_FLAG = "--prrun-stop";
+var MAX_CLAIM_ARGUMENTS = 2;
+var USAGE3 = "Usage: josh run:hold [<issue-number> [--fullrun | --halfrun-stop | --prrun-stop]] | josh run:release [<issue-number> | --force]";
+var COMMAND = "run:hold";
+var HOLD_VERDICT = "hold";
+var BUSY_VERDICT = "busy";
+var UNKNOWN_VERDICT = "unknown";
+var RELEASED_VERDICT = "released";
+var NONE_VERDICT = "none";
+var HELD_VERDICT = "held";
+var FORCE_RELEASE_KIND = "force-release";
+var HALFRUN_STOP_KIND = "halfrun-stop";
+var PRRUN_STOP_KIND = "prrun-stop";
+function is_stop_request(request) {
+  return request.kind === HALFRUN_STOP_KIND || request.kind === PRRUN_STOP_KIND;
+}
+var FORCE_RELEASE_REQUEST = { kind: FORCE_RELEASE_KIND };
+function release_request(claimant) {
+  return { kind: "release", claimant };
+}
+var STOP_KIND_BY_FLAG = /* @__PURE__ */ new Map([
+  [HALFRUN_STOP_FLAG, HALFRUN_STOP_KIND],
+  [PRRUN_STOP_FLAG, PRRUN_STOP_KIND]
+]);
+function numbered_claim(issue, flag) {
+  if (flag === void 0) return { kind: "claim", issue };
+  const stop_kind = STOP_KIND_BY_FLAG.get(flag);
+  if (stop_kind !== void 0) return { kind: stop_kind, issue };
+  return flag === FULLRUN_FLAG ? { kind: "claim", issue, is_fullrun: true } : void 0;
+}
+function parse_claim(argv) {
+  const [first, flag] = argv;
+  if (first === void 0) return { kind: "claim", issue: run_hold.UNNUMBERED_ISSUE };
+  if (argv.length > MAX_CLAIM_ARGUMENTS || !issue_number_shape.ISSUE_NUMBER_PATTERN.test(first)) {
+    return void 0;
+  }
+  return numbered_claim(first, flag);
+}
+function parse_release_argument(first) {
+  if (first === FORCE_FLAG) return FORCE_RELEASE_REQUEST;
+  return issue_number_shape.ISSUE_NUMBER_PATTERN.test(first) ? release_request(first) : void 0;
+}
+function parse_release(argv) {
+  const [first] = argv;
+  if (first === void 0) return release_request(run_hold.UNNUMBERED_ISSUE);
+  return argv.length > 1 ? void 0 : parse_release_argument(first);
+}
+function parse_request(argv) {
+  if (argv[0] === RELEASE_FLAG) return parse_release(argv.slice(1));
+  return parse_claim(argv);
+}
+function report3(message3, verdict, code) {
+  console.error(message3);
+  console.info(verdict);
+  return code;
+}
+function report_busy(message3) {
+  return report3(message3, BUSY_VERDICT, SUCCESS_EXIT_CODE2);
+}
+function report_hold() {
+  console.info(HOLD_VERDICT);
+  return SUCCESS_EXIT_CODE2;
+}
+function held_block(hold, issue) {
+  return run_hold.is_reentry(hold, issue) ? void 0 : run_hold.held_message(hold);
+}
+function is_own_unstopped(hold, issue) {
+  return run_hold.is_reentry(hold, issue) && !run_hold.is_stop_marked(hold);
+}
+async function stale_block(hold, issue) {
+  if (is_own_unstopped(hold, issue)) return void 0;
+  return await run_hold.is_tree_dirty() ? run_hold.uncommitted_message(hold) : void 0;
+}
+async function blocking_message(read2, issue) {
+  if (read2.kind === "held") return held_block(read2.hold, issue);
+  if (read2.kind === "unreadable") return run_hold.unreadable_message();
+  return read2.kind === "stale" ? await stale_block(read2.hold, issue) : void 0;
+}
+function take_free_tree(target, request) {
+  const is_taken = run_hold.create_hold(target, request.issue, /* @__PURE__ */ new Date(), request.is_fullrun);
+  if (is_taken) return report_hold();
+  return report_busy(run_hold.race_message(run_hold.read_hold(target), target));
+}
+function replace_stale(target, request, hold) {
+  console.error(run_hold.stale_message(hold));
+  run_hold.release_hold(target);
+  return take_free_tree(target, request);
+}
+function take_tree(target, request, read2) {
+  if (read2.kind === "held") return report_hold();
+  return read2.kind === "stale" ? replace_stale(target, request, read2.hold) : take_free_tree(target, request);
+}
+function report_preflight(decision) {
+  console.error(`${decision.reason}
+${decision.advice}`);
+  console.info(decision.verdict);
+  return SUCCESS_EXIT_CODE2;
+}
+async function preflight_gate(issue, is_linked) {
+  if (is_linked || issue === run_hold.UNNUMBERED_ISSUE) return void 0;
+  const decision = await run_preflight.check(issue);
+  if (decision.verdict === run_preflight.CLEAN_VERDICT) return void 0;
+  return report_preflight(decision);
+}
+async function claim2(target, request, is_linked) {
+  const gate = await preflight_gate(request.issue, is_linked);
+  if (gate !== void 0) return gate;
+  const read2 = run_hold.read_hold(target);
+  const blocked = await blocking_message(read2, request.issue);
+  if (blocked !== void 0) return report_busy(blocked);
+  const code = take_tree(target, request, read2);
+  if (code === SUCCESS_EXIT_CODE2) await run_tidy_cli.sweep();
+  return code;
+}
+function remove_record(target, was_present) {
+  run_hold.release_hold(target);
+  console.info(was_present ? RELEASED_VERDICT : NONE_VERDICT);
+  return SUCCESS_EXIT_CODE2;
+}
+function report_held(hold) {
+  return report3(run_hold.foreign_release_message(hold), HELD_VERDICT, FAILURE_EXIT_CODE4);
+}
+function report_unreadable_record() {
+  return report3(run_hold.unreadable_message(), UNKNOWN_VERDICT, FAILURE_EXIT_CODE4);
+}
+function release_record(target, claimant) {
+  const read2 = run_hold.read_hold(target);
+  if (read2.kind === "free") return remove_record(target, false);
+  if (read2.kind === "unreadable") return report_unreadable_record();
+  if (!run_hold.is_own_hold(read2.hold, claimant)) return report_held(read2.hold);
+  return remove_record(target, true);
+}
+async function release(target, claimant) {
+  const code = release_record(target, claimant);
+  const is_own_end = code === SUCCESS_EXIT_CODE2 && claimant !== run_hold.UNNUMBERED_ISSUE;
+  if (is_own_end) await run_label.unmark(claimant);
+  return code;
+}
+function force_release(target) {
+  const read2 = run_hold.read_hold(target);
+  if (read2.kind === "held" || read2.kind === "stale") {
+    console.error(run_hold.forced_release_message(read2.hold));
+  }
+  return remove_record(target, read2.kind !== "free");
+}
+function report_unknown() {
+  return report3(run_hold.unknown_message(), UNKNOWN_VERDICT, FAILURE_EXIT_CODE4);
+}
+function report_usage() {
+  console.error(USAGE3);
+  return FAILURE_EXIT_CODE4;
+}
+async function mark_stop(target, request) {
+  const mark2 = request.kind === PRRUN_STOP_KIND ? await run_prrun_resume.mark_stop_at(target, request.issue) : run_halfrun_resume.mark_stop_at(target, request.issue);
+  if (mark2 === run_halfrun_resume.MARKED) return report_hold();
+  if (mark2 === run_halfrun_resume.UNREADABLE) return report_unreadable_record();
+  return report_busy(run_hold.race_message(run_hold.read_hold(target), target));
+}
+async function dispatch(request, target, is_linked) {
+  if (request.kind === "claim") return await claim2(target, request, is_linked);
+  if (is_stop_request(request)) return await mark_stop(target, request);
+  if (request.kind === FORCE_RELEASE_KIND) return force_release(target);
+  return await release(target, request.claimant);
+}
+async function answer(request) {
+  const directory = await run_cli_fault.directory_of(COMMAND, run_hold.worktree_directory);
+  if (directory === void 0) return report_unknown();
+  const is_linked = await run_hold.is_linked_worktree();
+  return await dispatch(request, run_hold.hold_path(directory), is_linked);
+}
+async function run2(argv) {
+  const request = parse_request(argv);
+  if (request === void 0) return report_usage();
+  try {
+    return await answer(request);
+  } catch (error) {
+    return report3(run_cli_fault.message(COMMAND, error), UNKNOWN_VERDICT, FAILURE_EXIT_CODE4);
+  }
+}
+async function main3(argv) {
+  process.exitCode = await run2(argv);
+}
+var run_hold_cli = {
+  BUSY_VERDICT,
+  HELD_VERDICT,
+  HOLD_VERDICT,
+  NONE_VERDICT,
+  RELEASED_VERDICT,
+  UNKNOWN_VERDICT,
+  USAGE: USAGE3,
+  parse_request,
+  run: run2
+};
+if (process.argv[1] === fileURLToPath4(import.meta.url)) await main3(process.argv.slice(ARGV_OFFSET3));
+
+// scripts/run/hold/run-hold-session.ts
+function is_same_start(recorded, own) {
+  return recorded === void 0 || own === void 0 || recorded === own;
+}
+function is_session_hold(hold, owner = run_hold.session_owner()) {
+  if (hold.owner_pid === void 0 || owner.owner_pid === void 0) return true;
+  return hold.owner_pid === owner.owner_pid && is_same_start(hold.owner_start, owner.owner_start);
+}
+function is_notified_since(hold, pause_start2) {
+  if (pause_start2 === void 0 || hold.notified_at === void 0) return false;
+  return Date.parse(hold.notified_at) >= Date.parse(pause_start2);
+}
+function mark_notified(target, now = /* @__PURE__ */ new Date()) {
+  const hold = run_halfrun_resume.hold_of(run_hold.read_hold(target, now));
+  if (hold === void 0) return;
+  stamp_file.write_stamp(target, { ...hold, notified_at: now.toISOString() });
+}
+var run_hold_session = { is_notified_since, is_session_hold, mark_notified };
+
+// scripts/hooks/stop-actions.ts
+var SUCCESS_EXIT_CODE3 = 0;
+var NOTICE_SEPARATOR = "\n";
+var SUMMARY_CHARS = 600;
+var TOKEN_CHAR = /^[!-~]$/u;
+var EMPTY_SUMMARY = "The run stopped and is waiting for you.";
+var SEQUENTIAL = 1;
+function token_start(text2) {
+  let index = text2.length;
+  while (index > 0 && TOKEN_CHAR.test(text2.charAt(index - 1))) index -= 1;
+  return index;
+}
+function summary_of(message3) {
+  const trimmed = message3.trim();
+  if (trimmed === "") return EMPTY_SUMMARY;
+  if (trimmed.length <= SUMMARY_CHARS) return trimmed;
+  const overshoot = trimmed.slice(0, SUMMARY_CHARS + 1);
+  const cut = overshoot.slice(0, Math.min(token_start(overshoot), SUMMARY_CHARS));
+  return cut === "" ? trimmed.slice(0, SUMMARY_CHARS) : cut;
+}
+async function issue_url_of(issue) {
+  if (issue === run_hold.UNNUMBERED_ISSUE) return void 0;
+  const slug = await git_gh_repo.repo_get_name_with_owner();
+  return slug === void 0 ? void 0 : issue_cite.issue_url(slug, issue);
+}
+function notify_values(issue_url, action) {
+  const { recommended, alternative } = action.decision;
+  const values = {
+    "task-type": "confirmation",
+    body: session_cite.text(summary_of(action.message)),
+    recommended,
+    ...alternative !== void 0 && { alternative: [alternative] }
+  };
+  return issue_url === void 0 ? values : { ...values, "issue-url": issue_url };
+}
+async function mark_notified2() {
+  try {
+    const directory = await run_hold.worktree_directory();
+    if (directory !== void 0) run_hold_session.mark_notified(run_hold.hold_path(directory));
+  } catch (error) {
+    console.warn(`stop:guard could not stamp the notify on the hold: ${String(error)}`);
+  }
+}
+async function notify(action) {
+  const issue_url = await issue_url_of(action.issue);
+  await telegram_test.send_values(notify_values(issue_url, action));
+  await mark_notified2();
+  return `\u{1F4F1} stop:guard sent the confirmation notify (${issue_url ?? action.issue}).`;
+}
+async function release2(issue) {
+  const argv = issue === run_hold.UNNUMBERED_ISSUE ? ["--release"] : ["--release", issue];
+  const code = await run_hold_cli.run(argv);
+  return code === SUCCESS_EXIT_CODE3 ? "\u{1F513} stop:guard released the run:hold record." : void 0;
+}
+async function cite2(references) {
+  const cited = await issue_cite_cli.cite(issue_citation.cite_arguments(references));
+  if (cited === void 0 || cited.failures.length > 0) return void 0;
+  return ["Issue citations:", ...cited.lines].join(NOTICE_SEPARATOR);
+}
+async function run_action(action) {
+  if (action.kind === "notify") return await notify(action);
+  if (action.kind === "release") return await release2(action.issue);
+  return await cite2(action.references);
+}
+function set_stdout_write(stream_write) {
+  process.stdout.write = stream_write;
+}
+async function on_stderr(work) {
+  const saved = { write: process.stdout.write.bind(process.stdout) };
+  set_stdout_write(process.stderr.write.bind(process.stderr));
+  try {
+    return await work();
+  } finally {
+    set_stdout_write(saved.write);
+  }
+}
+async function attempt(action) {
+  try {
+    return await run_action(action);
+  } catch {
+    return void 0;
+  }
+}
+function is_notice(notice) {
+  return notice !== void 0;
+}
+async function settle2(actions) {
+  const notices = await on_stderr(
+    async () => await bounded_pool.bounded_map(actions, SEQUENTIAL, attempt)
+  );
+  const failed = actions.find((_action, index) => notices[index] === void 0);
+  return {
+    notices: notices.filter((notice) => is_notice(notice)),
+    failure: failed === void 0 ? void 0 : stop_rules.fallback_reason(failed)
+  };
+}
+function joined(notices) {
+  return notices.length === 0 ? void 0 : notices.join(NOTICE_SEPARATOR);
+}
+function settled_envelope(settled, is_blocking, lang) {
+  const notice = joined(settled.notices);
+  if (is_blocking && settled.failure !== void 0) {
+    return stop_rules.block_envelope(settled.failure, lang, notice);
+  }
+  return notice === void 0 ? void 0 : stop_rules.notice_envelope(notice);
+}
+async function envelope_of(outcome, lang) {
+  if (outcome.reason !== void 0) return stop_rules.block_envelope(outcome.reason, lang);
+  const settled = await settle2(outcome.actions);
+  return settled_envelope(settled, outcome.blocks_on_failure, lang);
+}
+var stop_actions2 = { envelope_of, summary_of };
+
+// scripts/rules/last-prompt.ts
+import { z as z5 } from "zod";
+var WORKFLOW_KEYWORDS = /* @__PURE__ */ new Set([
+  "kickoff",
+  "fullrun",
+  "halfrun",
+  "prrun",
+  "backlogrun"
+]);
+var NO_PROMPT = "";
+var HUMAN_ORIGIN = "human";
+var KEYWORD_BEFORE_ARGUMENT = -2;
+var PROMPT_LINE_SCHEMA = z5.object({
+  isMeta: z5.boolean().nullish(),
+  timestamp: z5.string().nullish(),
+  origin: z5.object({ kind: z5.string().nullish() }).nullish(),
+  message: z5.object({ content: z5.unknown() })
+});
+var TIMED_LINE_SCHEMA = z5.object({ timestamp: z5.string() });
+function is_person(line) {
+  if (line.isMeta === true) return false;
+  return line.origin === null || line.origin === void 0 || line.origin.kind === HUMAN_ORIGIN;
+}
+function person_line(line) {
+  const parsed = PROMPT_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line));
+  return parsed.success && is_person(parsed.data) ? parsed.data : void 0;
+}
+function person_text(line) {
+  const person = person_line(line);
+  if (person === void 0) return void 0;
+  return time_reported_failure.result_text(person.message.content);
+}
+function is_invocation(prompt) {
+  const words = prompt.trim().split(/\s+/u);
+  return [words.at(0), words.at(KEYWORD_BEFORE_ARGUMENT)].some(
+    (word) => WORKFLOW_KEYWORDS.has(word ?? NO_PROMPT)
+  );
+}
+function prompt_line_text(line) {
+  return filing_cap.is_prompt_line(line) ? person_text(line) : void 0;
+}
+function prompt_text(tail) {
+  const text2 = tail.split("\n").map((line) => prompt_line_text(line)).findLast((one) => one !== void 0);
+  return text2 === void 0 || is_invocation(text2) ? NO_PROMPT : text2;
+}
+function turn_prompt(tail) {
+  const opener = tail.split("\n").findLast((line) => filing_cap.is_prompt_line(line));
+  if (opener === void 0) return NO_PROMPT;
+  return person_text(opener) ?? NO_PROMPT;
+}
+function prompt_time(tail) {
+  return tail.split("\n").filter((line) => filing_cap.is_prompt_line(line)).map((line) => person_line(line)?.timestamp ?? void 0).findLast((time) => time !== void 0);
+}
+function tail_time(tail) {
+  return tail.split("\n").map((line) => TIMED_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line)).data?.timestamp).find((time) => time !== void 0);
+}
+function pause_start(tail) {
+  return prompt_time(tail) ?? tail_time(tail);
+}
+var last_prompt = { pause_start, prompt_text, turn_prompt };
+
+// scripts/run/cut/run-cut-report.ts
+var SUCCESS_EXIT_CODE4 = 0;
+var FAILURE_EXIT_CODE5 = 1;
+var CUT_VERDICT = "cut";
+var RESUME_VERDICT = "resume";
+var RESUME_IMPL_VERDICT = "resume-impl";
+var FRESH_VERDICT = "fresh";
+var UNDER_THRESHOLD_VERDICT = "under-threshold";
+var STALE_VERDICT = "stale";
+var INCOMPLETE_VERDICT = "incomplete";
+var BAD_HANDOFF_VERDICT = "bad-handoff";
+var HANDED_OFF_VERDICT = "handed-off";
+var BUSY_VERDICT2 = "busy";
+var NOT_A_LANE_VERDICT = "not-a-lane";
+var UNREADY_VERDICT = "unready";
+var FAILED_VERDICT = "failed";
+var ENDED_VERDICT = "ended";
+var UNREADABLE_VERDICT = "unreadable";
+var UNKNOWN_VERDICT2 = "unknown";
+var OVER_VERDICT = "over";
+function report4(verdict, code) {
+  console.info(verdict);
+  return code;
+}
+function report_stale(cut_record) {
+  console.error(run_cut.stale_message(cut_record));
+  return report4(STALE_VERDICT, FAILURE_EXIT_CODE5);
+}
+function report_busy2(cut_record) {
+  console.error(run_cut.busy_message(cut_record));
+  return report4(BUSY_VERDICT2, FAILURE_EXIT_CODE5);
+}
+function report_incomplete(cut_record) {
+  console.error(run_cut.incomplete_message(cut_record));
+  return report4(INCOMPLETE_VERDICT, FAILURE_EXIT_CODE5);
+}
+var HANDOFF_OVERFLOW_NOTE = "--handoff <path> would grow the cut record past its byte bound";
+var HANDOFF_MISSING_NOTE = "this cut resumes into implementation and needs --handoff <path>";
+function report_bad_handoff(note) {
+  console.error(
+    `${note}. Nothing was cut; write the handoff file at ${run_cut_handoff.HANDOFF_PATH} and reissue.`
+  );
+  return report4(BAD_HANDOFF_VERDICT, FAILURE_EXIT_CODE5);
+}
+function report_handed_off(cut_record) {
+  console.error(run_cut.handed_off_message(cut_record));
+  return report4(HANDED_OFF_VERDICT, SUCCESS_EXIT_CODE4);
+}
+function report_unreadable() {
+  console.error(run_cut.unreadable_message());
+  return report4(UNREADABLE_VERDICT, FAILURE_EXIT_CODE5);
+}
+function report_fault(message3) {
+  console.error(message3);
+  return report4(UNKNOWN_VERDICT2, FAILURE_EXIT_CODE5);
+}
+function report_unknown2() {
+  return report_fault(run_cut.unknown_message());
+}
+function refuse_unready(state) {
+  console.error(
+    `Not ready to cut on ${state.branch} (dirty: ${String(state.is_dirty)}); a cut needs an uncommitted lane branch. Nothing was cut.`
+  );
+  return report4(UNREADY_VERDICT, FAILURE_EXIT_CODE5);
+}
+function report_under_threshold() {
+  console.error(
+    "The current context is under the shared cut threshold, so nothing was cut; a resume would cost more than the accumulation it would drop. Continue to the gate."
+  );
+  return report4(UNDER_THRESHOLD_VERDICT, SUCCESS_EXIT_CODE4);
+}
+function report_reviewer() {
+  console.error(
+    "This session is a ship reviewer, which its supervisor is waiting on, so nothing was cut and nothing was relaunched. Write the findings file and finish the review in this process."
+  );
+  return report4(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE4);
+}
+function report_held_cut(issue) {
+  console.error(
+    `The cut is recorded for ${session_cite.issue(issue)} outside a lane, so nothing was relaunched. Keep the hold, send a \`confirmation\` Telegram whose body names the resume command \`fullrun ${issue_cite.plain(issue)}\`, and end the turn; the fresh session's \`pnpm josh run:cut --resume ${issue}\` answers \`resume-impl\` with the handoff.`
+  );
+  return report4(CUT_VERDICT, SUCCESS_EXIT_CODE4);
+}
+var RELAUNCHED_CUT_MARKER = "cut-relaunched";
+function report_relaunched_cut() {
+  console.error(RELAUNCHED_CUT_MARKER);
+  return report4(CUT_VERDICT, SUCCESS_EXIT_CODE4);
+}
+function report_over() {
+  console.error(
+    "This session is over the shared context-cut threshold (`pnpm josh cost --cut` answers `over`), so the implementation cut was not resumed here and its record is kept. End this conversation and type the invocation again in a fresh session."
+  );
+  return report4(OVER_VERDICT, FAILURE_EXIT_CODE5);
+}
+var run_cut_report = {
+  BAD_HANDOFF_VERDICT,
+  BUSY_VERDICT: BUSY_VERDICT2,
+  CUT_VERDICT,
+  ENDED_VERDICT,
+  FAILED_VERDICT,
+  FAILURE_EXIT_CODE: FAILURE_EXIT_CODE5,
+  FRESH_VERDICT,
+  HANDED_OFF_VERDICT,
+  HANDOFF_MISSING_NOTE,
+  HANDOFF_OVERFLOW_NOTE,
+  INCOMPLETE_VERDICT,
+  NOT_A_LANE_VERDICT,
+  OVER_VERDICT,
+  RELAUNCHED_CUT_MARKER,
+  RESUME_IMPL_VERDICT,
+  RESUME_VERDICT,
+  STALE_VERDICT,
+  SUCCESS_EXIT_CODE: SUCCESS_EXIT_CODE4,
+  UNDER_THRESHOLD_VERDICT,
+  UNKNOWN_VERDICT: UNKNOWN_VERDICT2,
+  UNREADABLE_VERDICT,
+  UNREADY_VERDICT,
+  refuse_unready,
+  report: report4,
+  report_bad_handoff,
+  report_busy: report_busy2,
+  report_fault,
+  report_handed_off,
+  report_held_cut,
+  report_incomplete,
+  report_over,
+  report_relaunched_cut,
+  report_reviewer,
+  report_stale,
+  report_under_threshold,
+  report_unknown: report_unknown2,
+  report_unreadable
+};
+
+// scripts/run/carry/run-carry-ended.ts
+import path4 from "node:path";
+import { z as z6 } from "zod";
+var ENDED_PREFIX = "josh-run-ended-";
+var TRANSCRIPT_SUFFIX = ".jsonl";
+var ended_run_schema = z6.object({
+  invocation: z6.string(),
+  started_at: z6.string(),
+  ended_at: z6.string(),
+  stopped: z6.string().optional(),
+  session: z6.string().optional()
+});
+function ended_path(git_directory) {
+  return stamp_file.stamp_path(ENDED_PREFIX, git_directory);
+}
+function session_of(transcript) {
+  return transcript === void 0 ? void 0 : path4.basename(transcript, TRANSCRIPT_SUFFIX);
+}
+function stop_of(transcript, stopped) {
+  return stopped === void 0 ? {} : { stopped, session: session_of(transcript) };
+}
+function record_ended(target, read2, now = /* @__PURE__ */ new Date(), stopped) {
+  if (read2.kind !== "carried") return;
+  const { invocation, started_at, owner_transcript } = read2.carry;
+  const ended_at = now.toISOString();
+  stamp_file.replace_stamp(target, {
+    invocation,
+    started_at,
+    ended_at,
+    ...stop_of(owner_transcript, stopped)
+  });
+}
+function parse_ended(raw) {
+  return json_value.parse_with(raw, ended_run_schema);
+}
+function read_ended(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? void 0 : parse_ended(raw);
+}
+function has_ended(target, started_at) {
+  const ended = read_ended(target);
+  return ended !== void 0 && ended.started_at === started_at;
+}
+var run_carry_ended = { ended_path, has_ended, read_ended, record_ended };
+
+// scripts/run/wake/run-wake.ts
+import { z as z7 } from "zod";
+var WAKE_PREFIX = "josh-run-wake-";
+var WAKE_LOG_PREFIX = "josh-run-wake-log-";
+var WAKE_LOG_SUFFIX = ".log";
+var WAKE_GRACE_MS = 6e5;
+var MAX_WAKE_ATTEMPTS = 3;
+var IDLE_CEILING_MS = backlog_budget.DEFAULT_IDLE_MS;
 var NO_WAKES = 0;
 var ONE_WAKE = 1;
 var WAKE_DECISION = { kind: "wake" };
@@ -1057,15 +3440,15 @@ var STOP_REASONS = {
   unreadable: "unreadable"
 };
 var run_wake_schema = process_owner_schema.extend({
-  invocation: z5.string(),
-  started_at: z5.string(),
-  woke: z5.number(),
-  woke_at: z5.string().optional(),
+  invocation: z7.string(),
+  started_at: z7.string(),
+  woke: z7.number(),
+  woke_at: z7.string().optional(),
   // Every optional `RunWake` field must be listed: `z.object` strips undeclared ones on the round trip.
-  attempts: z5.number().optional(),
-  woke_pid: z5.number().optional(),
-  spawned: z5.array(z5.string()).optional(),
-  idle_since: z5.string().optional(),
+  attempts: z7.number().optional(),
+  woke_pid: z7.number().optional(),
+  spawned: z7.array(z7.string()).optional(),
+  idle_since: z7.string().optional(),
   profile: agent_role_profile.PROFILE_SCHEMA.optional()
 });
 function is_overdue(marked_at, now, limit_ms = WAKE_GRACE_MS) {
@@ -1087,7 +3470,7 @@ function decide_not_handed_off(input) {
   if (input.is_owner_live) return WAIT_DECISION;
   return decide_launch(input);
 }
-function decide(input) {
+function decide2(input) {
   if (input.read.kind !== "carried") return { kind: "stop", reason: STOP_REASONS[input.read.kind] };
   if (input.read.carry.is_handed_off !== true) return decide_not_handed_off(input);
   return decide_launch(input);
@@ -1143,7 +3526,7 @@ function reclaim(target, wake) {
   remove_wake(target);
   return stamp_file.create_stamp(target, wake) ? wake : void 0;
 }
-function claim(target, invocation, now, profile) {
+function claim3(target, invocation, now, profile) {
   const existing = read_wake(target);
   if (is_held_by_live_supervisor(existing)) return void 0;
   const wake = { ...fresh_wake(invocation, now, profile), ...carried_state(existing, invocation) };
@@ -1198,10 +3581,10 @@ var run_wake = {
   IDLE_CEILING_MS,
   MAX_WAKE_ATTEMPTS,
   WAKE_GRACE_MS,
-  claim,
+  claim: claim3,
   count_claim,
   count_wake,
-  decide,
+  decide: decide2,
   fresh_wake,
   is_supervisor_live,
   mark_idle,
@@ -1283,11 +3666,11 @@ var DEFAULT_PORTS3 = {
   notify_stranded: real_notify_stranded
 };
 function input_at(ports, targets) {
-  const read = ports.read_carry(targets.carry);
-  if (read.kind !== "carried") return void 0;
+  const read2 = ports.read_carry(targets.carry);
+  if (read2.kind !== "carried") return void 0;
   return {
-    read,
-    is_owner_live: ports.is_owner_live(read.carry),
+    read: read2,
+    is_owner_live: ports.is_owner_live(read2.carry),
     supervisor: ports.supervisor_liveness(ports.read_wake(targets.wake))
   };
 }
@@ -1295,7 +3678,7 @@ async function gather2(ports) {
   const targets = await ports.resolve_targets();
   return targets === void 0 ? void 0 : input_at(ports, targets);
 }
-async function report2(ports, input) {
+async function report5(ports, input) {
   if (input.read.kind !== "carried") return;
   const text2 = run_stranded.describe(input.read.carry);
   if (await ports.emit_stranded(text2)) await ports.notify_stranded(text2);
@@ -1304,7 +3687,7 @@ async function detect_and_report2(ports = DEFAULT_PORTS3) {
   const input = await gather2(ports);
   if (input === void 0) return run_stranded.OK;
   const is_run_stranded = run_stranded.is_stranded(input);
-  if (is_run_stranded) await report2(ports, input);
+  if (is_run_stranded) await report5(ports, input);
   return run_stranded.verdict_of(is_run_stranded);
 }
 async function run_stranded_check() {
@@ -1317,12 +3700,12 @@ function is_stranded_at(directory, ports = DEFAULT_PORTS3) {
   const input = input_at(ports, targets_of(directory));
   return input !== void 0 && run_stranded.is_stranded(input);
 }
-function is_left_stranded(run, ports = DEFAULT_PORTS3) {
-  const read = ports.read_carry(run.carry_target);
-  if (read.kind !== "carried") return !ports.has_ended(run.ended_target, run.started_at);
+function is_left_stranded(run3, ports = DEFAULT_PORTS3) {
+  const read2 = ports.read_carry(run3.carry_target);
+  if (read2.kind !== "carried") return !ports.has_ended(run3.ended_target, run3.started_at);
   return run_stranded.is_stranded({
-    read,
-    is_owner_live: run_carry.is_held_by_another(read.carry, ports.is_owner_live),
+    read: read2,
+    is_owner_live: run_carry.is_held_by_another(read2.carry, ports.is_owner_live),
     supervisor: run_stranded.GONE
   });
 }
@@ -1334,10 +3717,23 @@ var run_stranded_detect = {
 };
 
 // scripts/hooks/stop-guard.ts
-async function hold_facts() {
+async function held_record() {
   const directory = await run_hold.worktree_directory();
-  const hold = directory === void 0 ? void 0 : run_halfrun_resume.hold_of(run_hold.read_hold(run_hold.hold_path(directory)));
-  return { hold_present: hold !== void 0, prrun_stopped: hold?.prrun_stop_head !== void 0 };
+  if (directory === void 0) return void 0;
+  return run_halfrun_resume.hold_of(run_hold.read_hold(run_hold.hold_path(directory)));
+}
+function was_notified(hold, tail) {
+  if (lane_park.mentions_confirmation_notify(tail)) return true;
+  return hold !== void 0 && run_hold_session.is_notified_since(hold, last_prompt.pause_start(tail));
+}
+async function hold_facts(tail) {
+  const hold = await held_record();
+  return {
+    hold_issue: hold?.issue,
+    hold_owned: hold === void 0 || run_hold_session.is_session_hold(hold),
+    notified: was_notified(hold, tail),
+    prrun_stopped: hold?.prrun_stop_head !== void 0
+  };
 }
 function transcript_tail(transcript_path) {
   const transcript = time_hook_transcript.transcript_of(transcript_path, void 0);
@@ -1346,6 +3742,14 @@ function transcript_tail(transcript_path) {
 function was_filed(tail) {
   return filing_cap.turn_filing_count(tail) > 0;
 }
+function is_cut_stop(tail) {
+  if (run_cut.carried_cut_sync() !== void 0) return true;
+  return tail_commands.answered(
+    filing_cap.current_turn(tail),
+    pre_gate_cut.takes_the_cut,
+    run_cut_report.RELAUNCHED_CUT_MARKER
+  );
+}
 function session_lang() {
   return session_language.resolve_session_lang().lang;
 }
@@ -1360,13 +3764,13 @@ async function session_role_facts() {
 async function build_context(transcript_path, payload_tail) {
   const tail = transcript_tail(transcript_path);
   return {
-    ...await hold_facts(),
+    ...await hold_facts(tail),
     tree_clean: !await run_hold.is_tree_dirty(),
-    notified: lane_park.mentions_confirmation_notify(tail),
     message: payload_tail.message,
     prompt: last_prompt.prompt_text(tail),
+    answers_question: stop_decision.is_question(last_prompt.turn_prompt(tail)),
     stop_hook_active: payload_tail.stop_hook_active,
-    cut_pending: run_cut.carried_cut_sync() !== void 0,
+    cut_pending: is_cut_stop(tail),
     filed: was_filed(tail),
     session_owner: repo_party.current_owner(),
     ...await session_role_facts(),
@@ -1397,8 +3801,8 @@ async function carried_owner_live() {
   try {
     const directory = await run_carry.repository_directory();
     if (directory === void 0) return void 0;
-    const read = run_carry.read_carry(run_carry.carry_path(directory));
-    return read.kind === "carried" ? run_carry.is_owner_live(read.carry) : void 0;
+    const read2 = run_carry.read_carry(run_carry.carry_path(directory));
+    return read2.kind === "carried" ? run_carry.is_owner_live(read2.carry) : void 0;
   } catch {
     return void 0;
   }
@@ -1412,13 +3816,13 @@ async function run_report_checks() {
 async function write_stop_decision(raw_payload) {
   hook_decision.load_environment_file();
   await run_report_checks();
-  const { reason } = await outcome_of(raw_payload);
-  if (reason === void 0) return;
-  process.stdout.write(`${stop_rules.block_envelope(reason, session_lang())}
+  const envelope = await stop_actions2.envelope_of(await outcome_of(raw_payload), session_lang());
+  if (envelope === void 0) return;
+  process.stdout.write(`${envelope}
 `);
 }
 var stop_guard = { outcome_of, stop_outcome_for_payload };
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
+if (process.argv[1] === fileURLToPath5(import.meta.url)) {
   if (process.stdin.isTTY) hook_decision.report_no_payload("stop:guard");
   else await write_stop_decision(await text(process.stdin));
 }