@joshuafolkken/kit 1.1050.0 → 1.1128.0

package/dist/hooks/stop-guard.js

@@ -1,32 +1,38 @@
 #!/usr/bin/env tsx
 import {
+  FETCH_TIMEOUT_MS,
   RUN_LANE_LABEL,
   RUN_SOLO_LABEL,
   agent_role_profile,
   backlog_budget,
   filing_cap,
   git_gh_api_path,
+  git_gh_command,
   git_gh_exec,
   has_label_name,
   issue_cite,
   lane_background,
+  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
-} from "./chunk-RLDX5SOC.js";
+} from "./chunk-AIOIOMPX.js";
 import {
   session_language
 } from "./chunk-6V5OPIUU.js";
 import {
   hook_decision,
   lane_child_marker
-} from "./chunk-WQ4OSBSS.js";
+} from "./chunk-MKVGBQPA.js";
 import {
   PROJECT_ROOT,
   json_value,
@@ -34,7 +40,7 @@ import {
   time_density_hook,
   time_hook_transcript,
   time_reported_failure
-} from "./chunk-7VPDUBRN.js";
+} from "./chunk-4JZDP5X5.js";
 import "./chunk-WPALEIRX.js";
 import "./chunk-RKUAD3I6.js";
 
@@ -62,6 +68,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";
@@ -82,12 +105,10 @@ 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
 };
@@ -96,26 +117,31 @@ var lane_capacity = {
 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) {
@@ -126,13 +152,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;
 }
@@ -231,144 +260,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;
@@ -420,7 +311,6 @@ var backlog_stalled = {
   count_ready_tokens,
   describe,
   dispatch_age_ms,
-  is_stalled,
   needs_triage,
   ready_tokens
 };
@@ -428,12 +318,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);
@@ -452,19 +350,23 @@ async function read_ready(ports = DEFAULT_PORTS) {
   if (free_lanes2 <= NO_FREE) return { issues: [], free_lanes: free_lanes2 };
   return { issues: await ports.ready_issues(), free_lanes: free_lanes2 };
 }
-function ready_line(reading) {
+function ready_line(reading, slug) {
   if (reading.issues.length === NONE2 || reading.free_lanes <= NO_FREE) return void 0;
-  const issues = reading.issues.map((issue) => `#${issue}`).join(" ");
+  const cite = issue_cite.citer(slug, /* @__PURE__ */ new Map());
+  const issues = reading.issues.map((issue) => cite(issue)).join(" ");
   return `ready ${issues} \xB7 free lanes ${String(reading.free_lanes)}`;
 }
-async function parent_ready_line(ports, is_parent) {
+async function parent_ready_line(ports, is_parent, read_repo) {
   if (!await is_parent()) return void 0;
-  return ready_line(await read_ready(ports));
+  const reading = await read_ready(ports);
+  return reading.issues.length === NONE2 ? void 0 : ready_line(reading, await read_repo());
 }
-async function print_ready_line(ports = DEFAULT_PORTS, is_parent = run_headless.is_backlog_parent) {
+function print_line(line) {
+  if (line !== void 0) console.info(line);
+}
+async function print_ready_line(ports = DEFAULT_PORTS, is_parent = run_headless.is_backlog_parent, read_repo = git_gh_command.repo_get_name_with_owner) {
   try {
-    const line = await parent_ready_line(ports, is_parent);
-    if (line !== void 0) console.info(line);
+    print_line(await parent_ready_line(ports, is_parent, read_repo));
   } catch {
   }
 }
@@ -481,6 +383,7 @@ var backlog_ready = {
   read_backlog_next,
   print_offer_hint,
   free_lane_count,
+  drive_free_lane_count,
   drains_pool,
   print_ready_line,
   read_ready,
@@ -508,12 +411,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" },
@@ -599,7 +507,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 })
@@ -698,7 +606,6 @@ async function stranded(input) {
   );
 }
 var telegram_notify = {
-  REPO_LOOKUP_TIMEOUT_MS,
   confirm,
   send,
   send_or_report,
@@ -707,125 +614,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;
@@ -888,23 +676,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;
@@ -931,7 +720,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 = [
@@ -1034,19 +823,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(", ");
@@ -1056,8 +845,8 @@ function build_citation_reason(references) {
 var FILING_OFFER_REASON = '\u26D4 filing offer: your reply offers to file an Issue instead of filing it. Filing into a first-party repository is Tier A \u2014 the trigger is the judgement that it is worth filing, not the run\'s progress (`.claude/skills/workflow-commands/SKILL.md` \u2192 \xA72i, `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 HEADLESS_WAIT_MARKER = "\u26D4 headless parent:";
 var HEADLESS_REFUSAL_CAP = 3;
-var HEADLESS_WAIT_CALLS = ['"command":"pnpm josh lane:await', '"command":"pnpm josh run:progress'];
-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. Wait in the foreground instead: run `pnpm josh lane:await <N...>` for the in-flight lanes (and `pnpm josh run:progress --wait` for the heartbeat) as foreground commands within the tool timeout, act on what they report, and continue the loop. End the turn only after `pnpm josh run:carry --cut` or `--end` (`backlogrun-progress.md` \u2192 "The parent keeps no clock of its own").';
+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. Wait in the foreground instead: run `pnpm josh lane:await <N...>` for the in-flight lanes as a foreground command within the tool timeout (with `pnpm josh run:progress --wait` in the background for the heartbeat, which streams its reports itself and lives while this turn does), act on what it reports, and continue the loop. End the turn only after `pnpm josh run:carry --cut` or `--end` (`backlogrun-progress.md` \u2192 "The parent keeps no clock of its own").';
 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;
@@ -1083,13 +872,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);
@@ -1147,7 +936,6 @@ var stop_rules = {
   STOP_NOTIFY_REASON,
   SWITCH_ENV_KEY,
   block_envelope,
-  block_reason,
   build_language_reason,
   count_headless_refusals,
   is_enabled,
@@ -1155,6 +943,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";
@@ -1194,7 +1043,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";
@@ -1214,21 +1063,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) {
@@ -1380,7 +1227,6 @@ var run_wake = {
   IDLE_CEILING_MS,
   MAX_WAKE_ATTEMPTS,
   WAKE_GRACE_MS,
-  WAKE_PREFIX,
   claim,
   count_claim,
   count_wake,
@@ -1451,14 +1297,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);
@@ -1473,7 +1318,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,
@@ -1487,6 +1332,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()
   };
 }
@@ -1506,10 +1352,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())}