@joshuafolkken/kit 1.1035.0 → 1.1094.0

package/dist/hooks/stop-guard.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env tsx
 import {
+  FETCH_TIMEOUT_MS,
   RUN_LANE_LABEL,
   RUN_SOLO_LABEL,
   agent_role_profile,
@@ -8,25 +9,29 @@ import {
   git_gh_api_path,
   git_gh_exec,
   has_label_name,
+  issue_cite,
   lane_background,
-  lane_child_invocation,
+  lane_handoff,
   lane_park,
   lane_registry,
   process_identity,
+  process_owner_schema,
   repo_party,
   run_carry,
   run_cut,
+  run_event_stream,
+  run_event_stream_emit,
+  run_headless,
   run_hold,
-  run_invocation,
-  run_watcher_guard
-} from "./chunk-EIFCAJRB.js";
+  run_invocation
+} from "./chunk-UD24EAIL.js";
 import {
   session_language
 } from "./chunk-6V5OPIUU.js";
 import {
   hook_decision,
   lane_child_marker
-} from "./chunk-HOYJU5RM.js";
+} from "./chunk-E54KGFEQ.js";
 import {
   PROJECT_ROOT,
   json_value,
@@ -34,7 +39,7 @@ import {
   time_density_hook,
   time_hook_transcript,
   time_reported_failure
-} from "./chunk-GLBDBJOK.js";
+} from "./chunk-NKOG3XAV.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 
@@ -62,6 +67,23 @@ async function josh_run(args, should_forward_stderr = false, timeout_ms) {
 }
 var josh_command = { josh_run };
 
+// scripts/lane/lane-seed.ts
+var FIRST_LANE_SEAT = 1;
+var LAST_LANE_SEAT = 9;
+function free_seats(used) {
+  const taken = new Set(used);
+  const free = [];
+  for (let seat = FIRST_LANE_SEAT; seat <= LAST_LANE_SEAT; seat += 1) {
+    if (!taken.has(seat)) free.push(seat);
+  }
+  return free;
+}
+var lane_seed_policy = {
+  FIRST_LANE_SEAT,
+  LAST_LANE_SEAT,
+  free_seats
+};
+
 // scripts/lane/lane-capacity.ts
 var DEFAULT_LANE_LIMIT = 6;
 var LANE_LIMIT_KEY = "JOSH_LANE_LIMIT";
@@ -78,219 +100,47 @@ function read_limit(raw) {
   }
   return { kind: "limit", limit: Number(trimmed) };
 }
-function lane_limit(environment2 = process.env) {
-  return read_limit(environment2[LANE_LIMIT_KEY]);
+function lane_limit(environment = process.env) {
+  return read_limit(environment[LANE_LIMIT_KEY]);
 }
 function free_lanes(limit, occupied) {
-  return Math.max(NO_LANES, limit - occupied);
+  return Math.max(NO_LANES, Math.min(limit, lane_seed_policy.LAST_LANE_SEAT) - occupied);
 }
 var lane_capacity = {
-  DEFAULT_LANE_LIMIT,
   LANE_LIMIT_KEY,
-  read_limit,
   lane_limit,
   free_lanes
 };
 
-// scripts/lane/lane-reap.ts
-import { execFileSync } from "node:child_process";
-var PGREP_COMMAND = "pgrep";
-var MATCH_FULL_COMMAND_LINE = "-f";
-var CHILDREN_OF_FLAG = "-P";
-var PS_COMMAND = "/bin/ps";
-var PARENT_FORMAT = ["-o", "ppid=", "-p"];
-var TERMINATE_SIGNAL = "SIGTERM";
-var PROBE_TIMEOUT_MS = 2e3;
-var LOWEST_CHILD_PID = 2;
-function parse_pids(printed) {
-  return printed.split("\n").map((line) => Number(line.trim())).filter((pid) => Number.isSafeInteger(pid) && pid >= LOWEST_CHILD_PID);
-}
-function run_probe(command, args) {
-  try {
-    return execFileSync(command, [...args], {
-      encoding: "utf8",
-      timeout: PROBE_TIMEOUT_MS,
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-  } catch {
-    return "";
-  }
-}
-function parent_of(pid) {
-  return parse_pids(run_probe(PS_COMMAND, [...PARENT_FORMAT, String(pid)]))[0];
-}
-function terminate(pid) {
-  try {
-    process.kill(pid, TERMINATE_SIGNAL);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var SYSTEM_PROBES = {
-  matching: (pattern) => parse_pids(run_probe(PGREP_COMMAND, [MATCH_FULL_COMMAND_LINE, pattern])),
-  children_of: (pid) => parse_pids(run_probe(PGREP_COMMAND, [CHILDREN_OF_FLAG, String(pid)])),
-  parent_of,
-  terminate
-};
-function ancestry_of(pid, probes) {
-  const ancestry = /* @__PURE__ */ new Set([pid]);
-  let current = probes.parent_of(pid);
-  while (current !== void 0 && !ancestry.has(current)) {
-    ancestry.add(current);
-    current = probes.parent_of(current);
-  }
-  return ancestry;
-}
-function own_ancestry(probes = SYSTEM_PROBES) {
-  return ancestry_of(process.pid, probes);
-}
-function tree_of(roots, probes) {
-  const tree = [];
-  const pending = [...roots];
-  let next = pending.shift();
-  while (next !== void 0) {
-    if (!tree.includes(next)) {
-      tree.push(next);
-      pending.push(...probes.children_of(next));
-    }
-    next = pending.shift();
-  }
-  return tree;
-}
-function reap_child(issue, probes = SYSTEM_PROBES) {
-  const own = own_ancestry(probes);
-  const pattern = lane_child_invocation.process_pattern(issue);
-  const roots = probes.matching(pattern).filter((pid) => !own.has(pid));
-  const doomed = tree_of(roots, probes).filter((pid) => !own.has(pid));
-  return doomed.filter((pid) => probes.terminate(pid));
-}
-var lane_reap = {
-  own_ancestry,
-  parse_pids,
-  reap_child
-};
-
-// scripts/run/run-headless.ts
-var HEADLESS_ENV_KEY = "JOSH_RUN_HEADLESS";
-var HEADLESS_VALUE = "1";
-function environment() {
-  return { [HEADLESS_ENV_KEY]: HEADLESS_VALUE };
-}
-function is_headless(source = process.env) {
-  return source[HEADLESS_ENV_KEY] === HEADLESS_VALUE;
-}
-function is_driving(read) {
-  return read?.kind === "carried" && read.carry.is_handed_off !== true;
-}
-async function read_carry_here() {
-  const repository = await run_carry.repository_directory();
-  return repository === void 0 ? void 0 : run_carry.read_carry(run_carry.carry_path(repository));
-}
-async function must_keep_waiting(source = process.env) {
-  const is_candidate = is_headless(source) && lane_child_marker.marked_issue(source) === void 0;
-  if (!is_candidate || !await run_watcher_guard.has_lanes_in_flight()) return false;
-  return is_driving(await read_carry_here());
-}
-async function current_carry() {
-  const read = await read_carry_here();
-  return read?.kind === "carried" ? read.carry : void 0;
-}
-function is_owned_here(carry, ancestry) {
-  return carry.owner_pid !== void 0 && ancestry().has(carry.owner_pid);
-}
-function is_driven_here(read, ancestry) {
-  if (read?.kind !== "carried" || !is_driving(read)) return false;
-  return is_owned_here(read.carry, ancestry);
-}
-async function is_backlog_parent(source = process.env, ancestry = lane_reap.own_ancestry) {
-  if (lane_child_marker.marked_issue(source) !== void 0) return false;
-  return is_driven_here(await read_carry_here(), ancestry);
-}
-var run_headless = {
-  HEADLESS_ENV_KEY,
-  current_carry,
-  environment,
-  is_backlog_parent,
-  is_headless,
-  is_owned_here,
-  must_keep_waiting
-};
-
-// scripts/issue/issue-cite.ts
-var GITHUB_URL_PREFIX = "https://github.com/";
-var ISSUE_PATH = "/issues/";
-var SUMMARY_SEPARATOR = " \u2014 ";
-var REPO_QUALIFIED = /^([^\s/#]+\/[^\s/#]+)#(\d+)$/u;
-var BARE_NUMBER = /^#?(\d+)$/u;
-function issue_url(slug, number) {
-  return `${GITHUB_URL_PREFIX}${slug}${ISSUE_PATH}${number}`;
-}
-function citation_line(slug, number, summary) {
-  return `[#${number}](${issue_url(slug, number)})${SUMMARY_SEPARATOR}${summary}`;
-}
-function qualified_target(token) {
-  const match = REPO_QUALIFIED.exec(token);
-  if (match === null) return void 0;
-  const [, repo = "", number = ""] = match;
-  return { number, repo };
-}
-function bare_target(token, default_repo) {
-  const match = BARE_NUMBER.exec(token);
-  if (match === null) return void 0;
-  const [, number = ""] = match;
-  return { number, repo: default_repo };
-}
-function parse_target(token, default_repo) {
-  return qualified_target(token) ?? bare_target(token, default_repo);
-}
-function label(target) {
-  return target.repo === void 0 ? `#${target.number}` : `${target.repo}#${target.number}`;
-}
-function missing_line(target) {
-  return `\u2716 ${label(target)}: issue does not resolve \u2014 check the number and the repository`;
-}
-function unreadable_line(target) {
-  return `\u2716 ${label(target)}: could not be read \u2014 a rate limit, expired auth, or a dropped connection`;
-}
-function no_repo_line(target) {
-  return `\u2716 ${label(target)}: could not read this repository \u2014 check gh auth and the origin remote`;
-}
-var issue_cite = {
-  SUMMARY_SEPARATOR,
-  citation_line,
-  issue_url,
-  label,
-  missing_line,
-  no_repo_line,
-  parse_target,
-  unreadable_line
-};
-
 // scripts/rules/issue-citation.ts
 var ISSUE_NUMBER = /#\d+/gu;
 var REFERENCE_BOUNDARY = /[\s#()[\]<>|]/u;
 var OWNER_REPO = /^[^\s/#]+\/[^\s/#]+$/u;
-var MARKDOWN_LINK = /\[([^[\]]*)\]\([^()]*\)/gu;
+var MARKDOWN_LINK = /\[[^[\]]*\]\([^()]*\)/gu;
+var NUMBER_CONTINUATION = /^(?:\w|-[a-z])/iu;
+var CONTINUATION_WIDTH = 2;
+var GLUED_LEAD = /[&./]/u;
 var FENCE_MARKER = /^\s*(?:`{3,}|~{3,})/u;
 var QUOTE_LINE = /^\s*>/u;
 var PR_PREFIX = /\b(?:pr|pull request)\s*$/iu;
 var BACKTICK_PAIR = 2;
-function text_span_covers(link, index) {
-  const start = (link.index ?? 0) + 1;
-  const end = start + (link[1] ?? "").length;
-  return index >= start && index < end;
+function link_covers(link, index) {
+  const start = link.index ?? 0;
+  return index >= start && index < start + link[0].length;
 }
 function is_linked_at(line, index) {
   for (const link of line.matchAll(MARKDOWN_LINK)) {
-    if (text_span_covers(link, index)) return true;
+    if (link_covers(link, index)) return true;
   }
   return false;
 }
-function repo_prefix(message2, hash_index) {
+function lead_token(message2, hash_index) {
   let start = hash_index;
   while (start > 0 && !REFERENCE_BOUNDARY.test(message2.charAt(start - 1))) start -= 1;
-  const token = message2.slice(start, hash_index);
+  return message2.slice(start, hash_index);
+}
+function repo_prefix(message2, hash_index) {
+  const token = lead_token(message2, hash_index);
   return OWNER_REPO.test(token) ? token : "";
 }
 function is_inline_code_at(line, index) {
@@ -301,13 +151,16 @@ function is_bare_at(line, index) {
   if (is_linked_at(line, index) || is_inline_code_at(line, index)) return false;
   return !PR_PREFIX.test(line.slice(0, index));
 }
+function is_glued(line, reference) {
+  const end = reference.index + reference.text.length;
+  if (NUMBER_CONTINUATION.test(line.slice(end, end + CONTINUATION_WIDTH))) return true;
+  return reference.prefix === "" && GLUED_LEAD.test(lead_token(line, reference.index));
+}
 function line_references(line) {
   const references = [];
   for (const match of line.matchAll(ISSUE_NUMBER)) {
-    const { index } = match;
-    if (is_bare_at(line, index)) {
-      references.push({ index, prefix: repo_prefix(line, index), text: match[0] });
-    }
+    const reference = { index: match.index, prefix: repo_prefix(line, match.index), text: match[0] };
+    if (!is_glued(line, reference) && is_bare_at(line, match.index)) references.push(reference);
   }
   return references;
 }
@@ -406,144 +259,6 @@ function message(children, repo) {
 }
 var epic_triage = { TRIAGE_VERDICT, is_triaged, message, untriaged };
 
-// scripts/run/run-event-stream.ts
-import { z } from "zod";
-var EVENT_PREFIX = "josh-run-events-";
-var EVENT_SUFFIX = ".jsonl";
-var EVENT_CAP = 500;
-var FIRST_POSITION = 0;
-var POSITION_INCREMENT = 1;
-var LINE_SEPARATOR = "\n";
-var EVENT_KIND = {
-  PLAN: "plan",
-  CHILD_LAUNCH: "child-launch",
-  MERGE: "merge",
-  PARK: "park",
-  SPLIT: "split",
-  OUTAGE: "outage",
-  CUT: "cut",
-  // The backlog emptied while nothing of the run's own was in flight — the drain
-  // (joshuafolkken/kit#2335). It marks the position at which the end-of-run retrospective is owed,
-  // *before* the idle watch opens, so `run:step` fires the retrospective at the drain rather than after
-  // the watch runs its course. It is not itself a stop: the run watches on once the retrospective has
-  // run, and the real `STOP` follows when the watch expires.
-  DRAIN: "drain",
-  STOP: "stop",
-  PR_OPENED: "pr-opened",
-  REVIEW_ROUND: "review-round",
-  // The end-of-run retrospective's result, recorded when the run marks the retrospective done
-  // (joshuafolkken/kit#2342). A retrospective that files zero improvements and one that never ran look
-  // the same from outside — no new Issue either way — so the result is put on the stream the report is
-  // generated from: the issues filed (or that none were), and the candidates dropped with why. It is
-  // emitted from the `run:carry --retrospective` close, so marking the retrospective done and recording
-  // what it found are one action rather than two the run could do only one of.
-  RETROSPECTIVE: "retrospective",
-  // Ready backlog work is sitting undispatched while a lane is free and nothing has dispatched for a
-  // while (joshuafolkken/kit#2359). Emitted once per stall episode by the stop-time detector, it is
-  // both the dedup marker — `emit_once_since` refuses a second until a `CHILD_LAUNCH` intervenes
-  // (joshuafolkken/kit#2464) — and the line a
-  // terminal reader following the stream sees. `run:step` reads it as `backlog:next`, so a run that
-  // stalled is pointed straight at dispatching the work rather than left waiting.
-  STALL: "stall",
-  // The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
-  // is watching (joshuafolkken/kit#2375). Emitted once per strand episode by the stop-time detector,
-  // exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
-  // than once, and a terminal reader following the stream sees the line. The strand is the step before
-  // the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
-  STRANDED: "stranded",
-  // One `josh ship` stage starting, succeeding or failing (joshuafolkken/kit#2426). It is a trace of the
-  // composite's progress rather than a position the run is at — the positions a ship leaves behind are
-  // the closed issue its `followup` merges, or a detached supervisor's `SHIP_LAUNCH` / `SHIP_STOP` below
-  // — so it is one of the `TRACE_KINDS` the last-event read skips.
-  SHIP_STAGE: "ship-stage",
-  // One progress watcher line — the `at … / next …` heartbeat `run:progress` prints
-  // (joshuafolkken/kit#2437). Printed only to the watcher's own output, a headless successor's heartbeat
-  // was buried in its log after a cut; on the stream it reaches the attached session's relay. It says
-  // the run is alive rather than where it is, so it is a trace kind like `SHIP_STAGE`.
-  HEARTBEAT: "heartbeat",
-  // The post-implementation region handed to a detached `josh ship --detach` supervisor
-  // (joshuafolkken/kit#2428). Unlike a stage trace it is a position: the agent has ended and the
-  // supervisor carries the run, so `run:step` answers `wait` until it stops or the issue closes.
-  SHIP_LAUNCH: "ship-launch",
-  // The supervisor stopped at a failed stage — a red gate, a High/Medium review, a failed push, red CI
-  // (joshuafolkken/kit#2428). The position that hands control back: `run:step` prints the command that
-  // shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
-  SHIP_STOP: "ship-stop"
-};
-var EVENT_KINDS = Object.values(EVENT_KIND);
-var TRACE_KINDS = /* @__PURE__ */ new Set([EVENT_KIND.SHIP_STAGE, EVENT_KIND.HEARTBEAT]);
-var event_schema = z.object({
-  pos: z.number(),
-  at: z.string(),
-  kind: z.string(),
-  text: z.string()
-});
-function is_event_kind(value) {
-  return EVENT_KINDS.includes(value);
-}
-function target_of(repository) {
-  return stamp_file.stamp_path(EVENT_PREFIX, repository, EVENT_SUFFIX);
-}
-function is_present(event) {
-  return event !== void 0;
-}
-function parse_line(line) {
-  return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
-}
-function read_events(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return [];
-  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line(line)).filter(is_present);
-}
-function last_position(events) {
-  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
-}
-function serialize(events) {
-  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
-}
-function append(target, kind, text2, at) {
-  if (!is_event_kind(kind)) return { appended: false, position: FIRST_POSITION };
-  const existing = read_events(target);
-  const position = last_position(existing) + POSITION_INCREMENT;
-  const bounded = [...existing, { pos: position, at, kind, text: text2 }].slice(-EVENT_CAP);
-  stamp_file.write_text_stamp(target, serialize(bounded));
-  return { appended: true, position };
-}
-function read_from(target, position) {
-  const events = read_events(target);
-  return {
-    events: events.filter((event) => event.pos > position),
-    next_position: last_position(events)
-  };
-}
-function read_last(target) {
-  return read_events(target).findLast((event) => !TRACE_KINDS.has(event.kind));
-}
-function has_since(events, kind, reset_kind) {
-  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
-  return events.slice(reset_at + POSITION_INCREMENT).some((event) => event.kind === kind);
-}
-var FIELD_SEPARATOR = " \xB7 ";
-function format_event(event) {
-  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
-}
-var run_event_stream = {
-  EVENT_CAP,
-  EVENT_KIND,
-  EVENT_KINDS,
-  EVENT_PREFIX,
-  EVENT_SUFFIX,
-  TRACE_KINDS,
-  append,
-  format_event,
-  has_since,
-  is_event_kind,
-  read_events,
-  read_from,
-  read_last,
-  target_of
-};
-
 // scripts/backlog/backlog-stalled.ts
 var STALL_THRESHOLD_MINUTES = 10;
 var MS_PER_MINUTE = 6e4;
@@ -595,7 +310,6 @@ var backlog_stalled = {
   count_ready_tokens,
   describe,
   dispatch_age_ms,
-  is_stalled,
   needs_triage,
   ready_tokens
 };
@@ -603,12 +317,20 @@ var backlog_stalled = {
 // scripts/backlog/backlog-ready.ts
 var NO_FREE = 0;
 var NONE2 = 0;
+async function free_under(limit) {
+  const lanes = await lane_registry.list_lanes();
+  const live = lanes.filter((lane) => !lane.is_stranded).length;
+  return lane_capacity.free_lanes(limit, live);
+}
 async function free_lane_count() {
   const limit = lane_capacity.lane_limit();
   if (limit.kind !== "limit") return NO_FREE;
-  const lanes = await lane_registry.list_lanes();
-  const live = lanes.filter((lane) => !lane.is_stranded).length;
-  return lane_capacity.free_lanes(limit.limit, live);
+  return await free_under(limit.limit);
+}
+async function drive_free_lane_count() {
+  const limit = lane_capacity.lane_limit();
+  if (limit.kind !== "limit") throw new Error(limit.problem);
+  return await free_under(limit.limit);
 }
 function drains_pool(carry) {
   return carry === void 0 || !run_invocation.has_only(carry.invocation);
@@ -656,6 +378,7 @@ var backlog_ready = {
   read_backlog_next,
   print_offer_hint,
   free_lane_count,
+  drive_free_lane_count,
   drains_pool,
   print_ready_line,
   read_ready,
@@ -683,12 +406,17 @@ function get_repo_name_with_owner_within(timeout_ms) {
 }
 var gh_spawn = { get_repo_name_with_owner, get_repo_name_with_owner_within };
 
-// scripts/git/telegram-notify.ts
-import { z as z2 } from "zod";
+// scripts/lib/timed-fetch.ts
+async function timed_fetch(url, init = {}, timeout_ms = FETCH_TIMEOUT_MS) {
+  return await fetch(url, { ...init, signal: AbortSignal.timeout(timeout_ms) });
+}
+
+// scripts/notify/telegram-notify.ts
+import { z } from "zod";
 var TELEGRAM_API_BASE = "https://api.telegram.org";
-var telegram_environment_schema = z2.object({
-  telegram_bot_token: z2.string().min(1, { message: "TELEGRAM_BOT_TOKEN is required" }),
-  telegram_chat_id: z2.string().min(1, { message: "TELEGRAM_CHAT_ID is required" })
+var telegram_environment_schema = z.object({
+  telegram_bot_token: z.string().min(1, { message: "TELEGRAM_BOT_TOKEN is required" }),
+  telegram_chat_id: z.string().min(1, { message: "TELEGRAM_CHAT_ID is required" })
 });
 var TASK_DEFINITIONS = {
   planning: { icon: "\u{1F4CB}", label: "Planning" },
@@ -742,9 +470,9 @@ function is_notify_disabled() {
   return parse_environment_string(process.env[NOTIFY_SWITCH_KEY]).toLowerCase() === NOTIFY_OFF_VALUE;
 }
 function build_header(task_type, repo_name) {
-  const { icon, label: label2 } = TASK_DEFINITIONS[task_type];
-  if (repo_name === void 0 || repo_name.length === 0) return `${icon} ${label2}`;
-  return `${icon} ${repo_name}: ${label2}`;
+  const { icon, label } = TASK_DEFINITIONS[task_type];
+  if (repo_name === void 0 || repo_name.length === 0) return `${icon} ${label}`;
+  return `${icon} ${repo_name}: ${label}`;
 }
 function push_if_present(target, value) {
   if (value !== void 0 && value.length > 0) target.push(value);
@@ -754,8 +482,8 @@ function build_title_block(input) {
   push_if_present(lines, input.issue_title);
   return lines.join("\n");
 }
-function append_url(parts, label2, value) {
-  if (value !== void 0 && value.length > 0) parts.push(`${label2}: ${value}`);
+function append_url(parts, label, value) {
+  if (value !== void 0 && value.length > 0) parts.push(`${label}: ${value}`);
 }
 function build_url_parts(input) {
   const parts = [];
@@ -774,7 +502,7 @@ function build_text(input) {
 }
 async function post_message(config, text2) {
   const url = `${TELEGRAM_API_BASE}/bot${config.bot_token}/sendMessage`;
-  const response = await fetch(url, {
+  const response = await timed_fetch(url, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ chat_id: config.chat_id, text: text2 })
@@ -873,7 +601,6 @@ async function stranded(input) {
   );
 }
 var telegram_notify = {
-  REPO_LOOKUP_TIMEOUT_MS,
   confirm,
   send,
   send_or_report,
@@ -882,125 +609,6 @@ var telegram_notify = {
   warn
 };
 
-// scripts/run/run-event-scope.ts
-var SINCE_SCOPE = "since";
-var UNKNOWN_SCOPE = "unknown";
-var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
-function moment_of(at) {
-  const parsed = Date.parse(at);
-  return Number.isNaN(parsed) ? void 0 : parsed;
-}
-function is_within(event, floor) {
-  const at = moment_of(event.at);
-  return at !== void 0 && at >= floor;
-}
-function scoped_events(events, scope) {
-  if (scope.kind === UNKNOWN_SCOPE) return void 0;
-  const floor = moment_of(scope.started_at);
-  if (floor === void 0) return void 0;
-  return events.filter((event) => is_within(event, floor));
-}
-function scope_of(read) {
-  if (read.kind === "carried" || read.kind === "expired") {
-    return { kind: SINCE_SCOPE, started_at: read.carry.started_at };
-  }
-  return UNKNOWN_EVENT_SCOPE;
-}
-function last_scoped_event(events, scope) {
-  return scoped_events(events, scope)?.findLast(
-    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
-  );
-}
-var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
-  run_event_stream.EVENT_KIND.SHIP_LAUNCH,
-  run_event_stream.EVENT_KIND.SHIP_STOP
-]);
-function is_foreign_ship_event(event, issue) {
-  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`#${issue} `);
-}
-function is_own_ship_event(event, issue) {
-  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue);
-}
-function last_issue_event(events, scope, issue) {
-  const own = events.filter((event) => !is_foreign_ship_event(event, issue));
-  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope);
-  return own.findLast((event) => is_own_ship_event(event, issue));
-}
-var run_event_scope = {
-  UNKNOWN_EVENT_SCOPE,
-  last_issue_event,
-  last_scoped_event,
-  scope_of,
-  scoped_events
-};
-
-// scripts/run/run-event-stream-emit.ts
-function now_iso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-async function stream_target() {
-  const repository = await run_carry.repository_directory();
-  return repository === void 0 ? void 0 : run_event_stream.target_of(repository);
-}
-async function emit(kind, text2) {
-  try {
-    const target = await stream_target();
-    if (target === void 0) return;
-    run_event_stream.append(target, kind, text2, now_iso());
-  } catch {
-  }
-}
-async function emit_once(kind, text2) {
-  try {
-    const target = await stream_target();
-    if (target === void 0 || run_event_stream.read_last(target)?.kind === kind) return false;
-    return run_event_stream.append(target, kind, text2, now_iso()).appended;
-  } catch {
-    return false;
-  }
-}
-function invocation_events(repository, target) {
-  const events = run_event_stream.read_events(target);
-  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository)));
-  return run_event_scope.scoped_events(events, scope) ?? events;
-}
-async function emit_once_since(kind, text2, reset_kind) {
-  try {
-    const repository = await run_carry.repository_directory();
-    if (repository === void 0) return false;
-    const target = run_event_stream.target_of(repository);
-    if (run_event_stream.has_since(invocation_events(repository, target), kind, reset_kind)) {
-      return false;
-    }
-    return run_event_stream.append(target, kind, text2, now_iso()).appended;
-  } catch {
-    return false;
-  }
-}
-async function emit_heartbeat(line) {
-  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
-}
-async function current_events() {
-  try {
-    const repository = await run_carry.repository_directory();
-    if (repository === void 0) return [];
-    const read = run_carry.read_carry(run_carry.carry_path(repository));
-    const scope = run_event_scope.scope_of(read);
-    const events = run_event_stream.read_events(run_event_stream.target_of(repository));
-    return run_event_scope.scoped_events(events, scope) ?? [];
-  } catch {
-    return [];
-  }
-}
-var run_event_stream_emit = {
-  current_events,
-  emit,
-  emit_heartbeat,
-  emit_once,
-  emit_once_since,
-  stream_target
-};
-
 // scripts/backlog/backlog-stalled-detect.ts
 var NO_FREE2 = 0;
 var NO_READY = 0;
@@ -1063,23 +671,24 @@ async function run_stall_check(ready = backlog_ready.DEFAULT_PORTS) {
   } catch {
   }
 }
-var backlog_stalled_detect = { DEFAULT_PORTS: DEFAULT_PORTS2, detect_and_report, gather, report, run_stall_check };
+var backlog_stalled_detect = { detect_and_report, run_stall_check };
 
 // scripts/rules/last-prompt.ts
-import { z as z3 } from "zod";
+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 = z3.object({
-  isMeta: z3.boolean().nullish(),
-  origin: z3.object({ kind: z3.string().nullish() }).nullish(),
-  message: z3.object({ content: z3.unknown() })
+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;
@@ -1106,7 +715,7 @@ function prompt_text(tail) {
 var last_prompt = { prompt_text };
 
 // scripts/rules/stop-rules.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 
 // scripts/rules/filing-offer.ts
 var OFFER_PATTERNS = [
@@ -1209,19 +818,19 @@ function is_mismatch(message2, lang) {
   if (letter_count(prose) < MIN_PROSE_LETTERS) return false;
   return matches_share(prose, script, pattern) < MATCH_SHARE_FLOOR;
 }
-var reply_language = { MIN_PROSE_LETTERS, is_mismatch, script_of };
+var reply_language = { is_mismatch, script_of };
 
 // scripts/rules/stop-rules.ts
 var SWITCH_ENV_KEY = "JOSH_STOP_GUARD";
 var BLOCK_DECISION = "block";
-var stop_payload_schema = z4.object({
-  transcript_path: z4.string().min(1),
-  stop_hook_active: z4.boolean().nullish(),
-  last_assistant_message: z4.string().nullish()
+var stop_payload_schema = z3.object({
+  transcript_path: z3.string().min(1),
+  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>\'` 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 `git switch main && git pull` believing the tree is free while you hold it. `.claude/skills/workflow-commands/SKILL.md` \u2192 \xA72f: 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 \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 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 `git switch main && git pull` believing the tree is free while you hold it. `.claude/skills/workflow-commands/SKILL.md` \u2192 \xA72f: 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 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(", ");
@@ -1258,13 +867,13 @@ function needs_filing(context) {
   return filing_offer.is_first_party_target(context.message, context.session_owner);
 }
 function is_held_idle(context) {
-  return context.hold_present && !context.agent_pending;
+  return context.hold_present && !context.agent_pending && !context.handed_off;
 }
 function needs_notify(context) {
   return is_held_idle(context) && !context.notified;
 }
 function needs_release(context) {
-  return is_held_idle(context) && context.tree_clean;
+  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);
@@ -1322,7 +931,6 @@ var stop_rules = {
   STOP_NOTIFY_REASON,
   SWITCH_ENV_KEY,
   block_envelope,
-  block_reason,
   build_language_reason,
   count_headless_refusals,
   is_enabled,
@@ -1330,6 +938,67 @@ var stop_rules = {
   stop_outcome
 };
 
+// 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 is_halfrun_stop(read, issue, is_dirty) {
+  const hold = hold_of(read);
+  return is_dirty && hold?.issue === issue && hold.is_halfrun_stop === true;
+}
+function is_own_record(read, issue) {
+  const hold = hold_of(read);
+  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;
+  run_hold.release_hold(target);
+  return run_hold.create_stop_hold(target, issue, mark) ? MARKED : FOREIGN;
+}
+function take_over(target, issue) {
+  run_hold.release_hold(target);
+  return run_hold.create_hold(target, issue, /* @__PURE__ */ new Date(), true);
+}
+function adopt_at(target, issue, is_dirty) {
+  if (!is_halfrun_stop(run_hold.read_hold(target), issue, is_dirty)) return false;
+  return take_over(target, issue);
+}
+async function hold_target() {
+  try {
+    const directory = await run_hold.worktree_directory();
+    return directory === void 0 ? void 0 : run_hold.hold_path(directory);
+  } catch {
+    return void 0;
+  }
+}
+async function is_pending(issue) {
+  const target = await hold_target();
+  if (target === void 0) return false;
+  return is_halfrun_stop(run_hold.read_hold(target), issue, await run_hold.is_tree_dirty());
+}
+async function adopt(issue) {
+  const target = await hold_target();
+  if (target === void 0) return false;
+  return adopt_at(target, issue, await run_hold.is_tree_dirty());
+}
+var run_halfrun_resume = {
+  FOREIGN,
+  MARKED,
+  UNREADABLE: UNREADABLE2,
+  adopt,
+  adopt_at,
+  hold_of,
+  hold_target,
+  is_pending,
+  mark_stop_at,
+  take_over
+};
+
 // scripts/run/run-stranded.ts
 var RECOVERY_COMMAND = "pnpm josh run:wake --start";
 var LIVE = "live";
@@ -1369,7 +1038,7 @@ var run_stranded = {
 };
 
 // scripts/run/run-wake.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
 var WAKE_PREFIX = "josh-run-wake-";
 var WAKE_LOG_PREFIX = "josh-run-wake-log-";
 var WAKE_LOG_SUFFIX = ".log";
@@ -1389,21 +1058,19 @@ var STOP_REASONS = {
   expired: "expired",
   unreadable: "unreadable"
 };
-var run_wake_schema = z5.object({
-  invocation: z5.string(),
-  started_at: z5.string(),
-  pid: z5.number(),
-  process_start: z5.string().optional(),
-  woke: z5.number(),
-  woke_at: z5.string().optional(),
+var run_wake_schema = process_owner_schema.extend({
+  invocation: z4.string(),
+  started_at: z4.string(),
+  woke: z4.number(),
+  woke_at: z4.string().optional(),
   // **Every optional field of `RunWake` has to be listed here.** `z.object` strips what it does not
   // declare, so a field added to the interface alone round-trips through disk as `undefined` — which
   // reads as "no attempt has been made yet" and would restart the retry count on every pass.
-  attempts: z5.number().optional(),
-  woke_pid: z5.number().optional(),
-  held_at: z5.string().optional(),
-  spawned: z5.array(z5.string()).optional(),
-  idle_since: z5.string().optional(),
+  attempts: z4.number().optional(),
+  woke_pid: z4.number().optional(),
+  held_at: z4.string().optional(),
+  spawned: z4.array(z4.string()).optional(),
+  idle_since: z4.string().optional(),
   profile: agent_role_profile.PROFILE_SCHEMA.optional()
 });
 function is_overdue(marked_at, now, limit_ms = WAKE_GRACE_MS) {
@@ -1555,7 +1222,6 @@ var run_wake = {
   IDLE_CEILING_MS,
   MAX_WAKE_ATTEMPTS,
   WAKE_GRACE_MS,
-  WAKE_PREFIX,
   claim,
   count_claim,
   count_wake,
@@ -1626,14 +1292,13 @@ async function run_stranded_check() {
   } catch {
   }
 }
-var run_stranded_detect = { DEFAULT_PORTS: DEFAULT_PORTS3, detect_and_report: detect_and_report2, gather: gather2, report: report2, run_stranded_check };
+var run_stranded_detect = { detect_and_report: detect_and_report2, run_stranded_check };
 
 // scripts/hooks/stop-guard.ts
-async function is_hold_present() {
+async function hold_facts() {
   const directory = await run_hold.worktree_directory();
-  if (directory === void 0) return false;
-  const read = run_hold.read_hold(run_hold.hold_path(directory));
-  return read.kind === "held" || read.kind === "stale";
+  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 };
 }
 function transcript_tail(transcript_path) {
   const transcript = time_hook_transcript.transcript_of(transcript_path, void 0);
@@ -1648,7 +1313,7 @@ function session_lang() {
 async function build_context(transcript_path, payload_tail) {
   const tail = transcript_tail(transcript_path);
   return {
-    hold_present: await is_hold_present(),
+    ...await hold_facts(),
     tree_clean: !await run_hold.is_tree_dirty(),
     notified: lane_park.mentions_confirmation_notify(tail),
     message: payload_tail.message,
@@ -1662,6 +1327,7 @@ async function build_context(transcript_path, payload_tail) {
     lane_child: lane_child_marker.is_child_of(process.cwd()),
     background_pending: lane_background.pending_background_ids(tail).length > 0,
     agent_pending: lane_background.pending_agent_ids(tail).length > 0,
+    handed_off: lane_handoff.is_handed_off(process.cwd()),
     session_lang: session_lang()
   };
 }
@@ -1681,10 +1347,23 @@ async function outcome_of(raw_payload) {
     return stop_rules.NO_OUTCOME;
   }
 }
-async function write_stop_decision(raw_payload) {
-  hook_decision.load_environment_file();
+async function has_run_record() {
+  try {
+    const directory = await run_carry.repository_directory();
+    if (directory === void 0) return false;
+    return run_carry.read_carry(run_carry.carry_path(directory)).kind === "carried";
+  } catch {
+    return false;
+  }
+}
+async function run_report_checks() {
+  if (!await has_run_record()) return;
   await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS);
   await run_stranded_detect.run_stranded_check();
+}
+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())}