@joshuafolkken/kit 1.872.0

package/dist/hooks/stop-guard.js

@@ -0,0 +1,1597 @@
+#!/usr/bin/env tsx
+import {
+  agent_role_profile,
+  backlog_budget,
+  filing_cap,
+  git_gh_api_path,
+  git_gh_exec,
+  lane_child_invocation,
+  lane_park,
+  lane_registry,
+  process_identity,
+  repo_party,
+  run_carry,
+  run_cut,
+  run_hold,
+  run_invocation,
+  run_watcher_guard
+} from "./chunk-2XIGZQMQ.js";
+import {
+  session_language
+} from "./chunk-6V5OPIUU.js";
+import {
+  hook_decision,
+  lane_child_marker
+} from "./chunk-GXKKK23T.js";
+import {
+  PROJECT_ROOT,
+  stamp_file,
+  time_density_hook,
+  time_hook_transcript
+} from "./chunk-KABG6AEW.js";
+import "./chunk-FXAKJKTB.js";
+import "./chunk-SSX23SJ2.js";
+
+// scripts/hooks/stop-guard.ts
+import { text } from "node:stream/consumers";
+import { fileURLToPath } from "node:url";
+
+// scripts/josh/josh-run.ts
+import { execa } from "execa";
+var PNPM = "pnpm";
+var JOSH = "josh";
+var NONZERO_EXIT = 1;
+var FORWARDED_STDERR = ["pipe", "inherit"];
+async function josh_run(args, should_forward_stderr = false, timeout_ms) {
+  const result = await execa(PNPM, [JOSH, ...args], {
+    reject: false,
+    stderr: should_forward_stderr ? FORWARDED_STDERR : "pipe",
+    ...timeout_ms !== void 0 && { timeout: timeout_ms }
+  });
+  return {
+    code: result.exitCode ?? NONZERO_EXIT,
+    out: result.stdout.trim(),
+    err: result.stderr.trim()
+  };
+}
+var josh_command = { josh_run };
+
+// scripts/lane/lane-capacity.ts
+var DEFAULT_LANE_LIMIT = 6;
+var LANE_LIMIT_KEY = "JOSH_LANE_LIMIT";
+var POSITIVE_INTEGER = /^[1-9]\d*$/u;
+var NO_LANES = 0;
+function read_limit(raw) {
+  const trimmed = raw?.trim() ?? "";
+  if (trimmed === "") return { kind: "limit", limit: DEFAULT_LANE_LIMIT };
+  if (!POSITIVE_INTEGER.test(trimmed)) {
+    return {
+      kind: "problem",
+      problem: `${LANE_LIMIT_KEY} must be a positive integer, not "${trimmed}"`
+    };
+  }
+  return { kind: "limit", limit: Number(trimmed) };
+}
+function lane_limit(environment2 = process.env) {
+  return read_limit(environment2[LANE_LIMIT_KEY]);
+}
+function free_lanes(limit, occupied) {
+  return Math.max(NO_LANES, limit - 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,
+  must_keep_waiting
+};
+
+// 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) {
+  try {
+    return event_schema.safeParse(JSON.parse(line)).data;
+  } catch {
+    return void 0;
+  }
+}
+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;
+var STALL_THRESHOLD_MS = STALL_THRESHOLD_MINUTES * MS_PER_MINUTE;
+var NONE = 0;
+var STALLED = "stalled";
+var OK = "ok";
+var UNREADABLE = "unreadable";
+function is_stalled(reading, threshold_ms) {
+  return reading.ready_count > NONE && reading.free_lanes > NONE && reading.dispatch_age_ms > threshold_ms;
+}
+function assess(reading, threshold_ms) {
+  if (reading === void 0) return UNREADABLE;
+  if (is_stalled(reading, threshold_ms)) return STALLED;
+  return OK;
+}
+function dispatch_reference_iso(events) {
+  const last_launch = events.findLast(
+    (event) => event.kind === run_event_stream.EVENT_KIND.CHILD_LAUNCH
+  );
+  return last_launch?.at ?? events[0]?.at;
+}
+function dispatch_age_ms(events, now_ms) {
+  const iso = dispatch_reference_iso(events);
+  if (iso === void 0) return void 0;
+  const at = Date.parse(iso);
+  return Number.isNaN(at) ? void 0 : now_ms - at;
+}
+function describe(reading) {
+  const minutes = Math.floor(reading.dispatch_age_ms / MS_PER_MINUTE);
+  return `${String(reading.ready_count)} ready, ${String(reading.free_lanes)} free lane(s), ${String(minutes)}m since the last dispatch`;
+}
+var NUMERIC_TOKEN = /^\d+$/u;
+function ready_tokens(out) {
+  return out.split("\n").map((token) => token.trim()).filter((token) => NUMERIC_TOKEN.test(token));
+}
+function count_ready_tokens(out) {
+  return ready_tokens(out).length;
+}
+var backlog_stalled = {
+  STALLED,
+  OK,
+  UNREADABLE,
+  STALL_THRESHOLD_MS,
+  assess,
+  count_ready_tokens,
+  describe,
+  dispatch_age_ms,
+  is_stalled,
+  ready_tokens
+};
+
+// scripts/backlog/backlog-ready.ts
+var NO_FREE = 0;
+var NONE2 = 0;
+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);
+}
+function drains_pool(carry) {
+  return carry === void 0 || !run_invocation.has_only(carry.invocation);
+}
+async function read_backlog_next(timeout_ms) {
+  if (!drains_pool(await run_headless.current_carry())) return void 0;
+  return await josh_command.josh_run(["backlog:next"], timeout_ms === void 0, timeout_ms);
+}
+async function ready_issues() {
+  const result = await read_backlog_next();
+  return result === void 0 ? [] : backlog_stalled.ready_tokens(result.out);
+}
+var DEFAULT_PORTS = { free_lane_count, ready_issues };
+async function read_ready(ports = DEFAULT_PORTS) {
+  const free_lanes2 = await ports.free_lane_count();
+  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) {
+  if (reading.issues.length === NONE2 || reading.free_lanes <= NO_FREE) return void 0;
+  const issues = reading.issues.map((issue) => `#${issue}`).join(" ");
+  return `ready ${issues} \xB7 free lanes ${String(reading.free_lanes)}`;
+}
+async function parent_ready_line(ports, is_parent) {
+  if (!await is_parent()) return void 0;
+  return ready_line(await read_ready(ports));
+}
+async function print_ready_line(ports = DEFAULT_PORTS, is_parent = run_headless.is_backlog_parent) {
+  try {
+    const line = await parent_ready_line(ports, is_parent);
+    if (line !== void 0) console.info(line);
+  } catch {
+  }
+}
+var OFFER_HINT = "\u21BB backlogrun parent: a child just entered an epic \u2014 run `pnpm josh backlog:offer` next, so a runnable filing is dispatched now rather than on the next wake.";
+async function print_offer_hint(is_parent = run_headless.is_backlog_parent) {
+  try {
+    if (await is_parent()) console.info(OFFER_HINT);
+  } catch {
+  }
+}
+var backlog_ready = {
+  DEFAULT_PORTS,
+  OFFER_HINT,
+  read_backlog_next,
+  print_offer_hint,
+  free_lane_count,
+  drains_pool,
+  print_ready_line,
+  read_ready,
+  ready_issues,
+  ready_line
+};
+
+// scripts/gh/gh-spawn.ts
+import { execaSync } from "execa";
+function fetch_repo_name(timeout_ms) {
+  const result = execaSync("gh", ["api", git_gh_api_path.repo_api_path(), "--jq", ".full_name"], {
+    ...git_gh_exec.direct_environment(),
+    cwd: PROJECT_ROOT,
+    reject: false,
+    ...timeout_ms !== void 0 && { timeout: timeout_ms }
+  });
+  if (result.exitCode !== 0 || !result.stdout) return void 0;
+  return result.stdout.trim() || void 0;
+}
+function get_repo_name_with_owner() {
+  return fetch_repo_name(void 0);
+}
+function get_repo_name_with_owner_within(timeout_ms) {
+  return fetch_repo_name(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";
+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 TASK_DEFINITIONS = {
+  planning: { icon: "\u{1F4CB}", label: "Planning" },
+  completion: { icon: "\u2705", label: "Completion" },
+  failure: { icon: "\u274C", label: "Failure" },
+  warning: { icon: "\u26A0\uFE0F", label: "Completed with a warning" },
+  kickoff_retry: { icon: "\u{1F504}", label: "Kickoff retry" },
+  confirmation: { icon: "\u23F8\uFE0F", label: "Confirmation required" },
+  stalled: { icon: "\u23F3", label: "Ready work is sitting undispatched" },
+  stranded: { icon: "\u{1F6A8}", label: "Run stranded \u2014 nobody is driving it" }
+};
+var NOT_CONFIGURED_PREFIX = "Telegram is not configured";
+var SEND_FAILED_PREFIX = "Telegram notification failed";
+var REDACTED = "<redacted>";
+var UNKNOWN_ERROR_TEXT = "unknown error";
+function parse_environment_string(value) {
+  return value?.trim() ?? "";
+}
+function join_cause(error) {
+  const { cause } = error;
+  if (!(cause instanceof Error) || cause.message.length === 0) return error.message;
+  return `${error.message}: ${cause.message}`;
+}
+function describe_non_error(error) {
+  return typeof error === "string" ? error : UNKNOWN_ERROR_TEXT;
+}
+function describe_error(error) {
+  if (error instanceof Error) return join_cause(error);
+  return describe_non_error(error);
+}
+function describe_symptom(error) {
+  return error instanceof Error ? error.message : describe_non_error(error);
+}
+function redact_credentials(text2, config) {
+  return text2.split(config.bot_token).join(REDACTED).split(config.chat_id).join(REDACTED);
+}
+function load_config() {
+  const result = telegram_environment_schema.safeParse({
+    telegram_bot_token: parse_environment_string(process.env["TELEGRAM_BOT_TOKEN"]),
+    telegram_chat_id: parse_environment_string(process.env["TELEGRAM_CHAT_ID"])
+  });
+  if (!result.success) {
+    const error_list = result.error.issues.map((issue) => issue.message).join(", ");
+    throw new Error(`${NOT_CONFIGURED_PREFIX}: ${error_list}`);
+  }
+  return { bot_token: result.data.telegram_bot_token, chat_id: result.data.telegram_chat_id };
+}
+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}`;
+}
+function push_if_present(target, value) {
+  if (value !== void 0 && value.length > 0) target.push(value);
+}
+function build_title_block(input) {
+  const lines = [build_header(input.task_type, input.repo_name)];
+  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 build_url_parts(input) {
+  const parts = [];
+  append_url(parts, "Issue", input.issue_url);
+  append_url(parts, "PR", input.pr_url);
+  return parts;
+}
+function build_blocks(input) {
+  const blocks = [build_title_block(input)];
+  push_if_present(blocks, input.body);
+  blocks.push(...build_url_parts(input));
+  return blocks;
+}
+function build_text(input) {
+  return build_blocks(input).join("\n\n");
+}
+async function post_message(config, text2) {
+  const url = `${TELEGRAM_API_BASE}/bot${config.bot_token}/sendMessage`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: config.chat_id, text: text2 })
+  });
+  if (!response.ok) {
+    throw new Error(`Telegram API error: ${String(response.status)} ${response.statusText}`);
+  }
+}
+function build_send_failure(error, config) {
+  const reason = redact_credentials(describe_error(error), config);
+  return new Error(`${SEND_FAILED_PREFIX}: ${reason}`, { cause: new Error(reason) });
+}
+async function send(input) {
+  const config = load_config();
+  const text2 = build_text(input);
+  try {
+    await post_message(config, text2);
+  } catch (error) {
+    throw build_send_failure(error, config);
+  }
+  console.info("\u{1F4F1} Telegram notification sent.");
+}
+function report_send_failure(error, recovery) {
+  console.error("");
+  console.error(`\u2757 ${describe_symptom(error)}`);
+  console.error("   Nobody was notified, and the run carried on.");
+  if (recovery !== void 0) console.error(`   Recovery: ${recovery}`);
+  console.error("");
+}
+async function send_or_report(input, recovery) {
+  try {
+    await send(input);
+    return true;
+  } catch (error) {
+    report_send_failure(error, recovery);
+    return false;
+  }
+}
+var REPO_LOOKUP_TIMEOUT_MS = 5e3;
+async function warn(input) {
+  return await send_or_report(
+    {
+      task_type: "warning",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: input.issue_title,
+      body: input.body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function confirm(input) {
+  return await send_or_report(
+    {
+      task_type: "confirmation",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: input.issue_title,
+      body: input.body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function stalled(input) {
+  return await send_or_report(
+    {
+      task_type: "stalled",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: void 0,
+      body: input.body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+async function stranded(input) {
+  return await send_or_report(
+    {
+      task_type: "stranded",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: void 0,
+      body: input.body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    input.recovery
+  );
+}
+var telegram_notify = {
+  REPO_LOOKUP_TIMEOUT_MS,
+  confirm,
+  send,
+  send_or_report,
+  stalled,
+  stranded,
+  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;
+var NO_AGE = 0;
+var STALL_RECOVERY = "Dispatch the ready work with `pnpm josh backlog:next`.";
+function ready_count_of(ready) {
+  return async function() {
+    const issues = await ready.ready_issues();
+    return issues.length;
+  };
+}
+async function real_emit_stall(text2) {
+  const { STALL, CHILD_LAUNCH } = run_event_stream.EVENT_KIND;
+  return await run_event_stream_emit.emit_once_since(STALL, text2, CHILD_LAUNCH);
+}
+async function real_notify_stalled(body) {
+  return await telegram_notify.stalled({ body, recovery: STALL_RECOVERY });
+}
+function ports_over(ready) {
+  return {
+    resolve_target: run_event_stream_emit.stream_target,
+    read_events: run_event_stream.read_events,
+    now_ms: () => Date.now(),
+    free_lane_count: ready.free_lane_count,
+    ready_count: ready_count_of(ready),
+    emit_stall: real_emit_stall,
+    notify_stalled: real_notify_stalled
+  };
+}
+var DEFAULT_PORTS2 = ports_over(backlog_ready.DEFAULT_PORTS);
+function ok_reading(dispatch_age_ms2) {
+  return { ready_count: NO_READY, free_lanes: NO_FREE2, dispatch_age_ms: dispatch_age_ms2 };
+}
+async function probe_reading(ports, dispatch_age_ms2) {
+  const free_lanes2 = await ports.free_lane_count();
+  if (free_lanes2 <= NO_FREE2) return { ready_count: NO_READY, free_lanes: free_lanes2, dispatch_age_ms: dispatch_age_ms2 };
+  return { ready_count: await ports.ready_count(), free_lanes: free_lanes2, dispatch_age_ms: dispatch_age_ms2 };
+}
+async function gather(ports, threshold_ms) {
+  const target = await ports.resolve_target();
+  if (target === void 0) return void 0;
+  const age = backlog_stalled.dispatch_age_ms(ports.read_events(target), ports.now_ms());
+  if (age === void 0) return ok_reading(NO_AGE);
+  if (age <= threshold_ms) return ok_reading(age);
+  return await probe_reading(ports, age);
+}
+async function report(ports, reading) {
+  const text2 = backlog_stalled.describe(reading);
+  if (await ports.emit_stall(text2)) await ports.notify_stalled(text2);
+}
+async function detect_and_report(ports = DEFAULT_PORTS2, threshold_ms = backlog_stalled.STALL_THRESHOLD_MS) {
+  const reading = await gather(ports, threshold_ms);
+  const verdict = backlog_stalled.assess(reading, threshold_ms);
+  if (reading !== void 0 && verdict === backlog_stalled.STALLED) await report(ports, reading);
+  return verdict;
+}
+async function run_stall_check(ready = backlog_ready.DEFAULT_PORTS) {
+  try {
+    await detect_and_report(ports_over(ready));
+  } catch {
+  }
+}
+var backlog_stalled_detect = { DEFAULT_PORTS: DEFAULT_PORTS2, detect_and_report, gather, report, run_stall_check };
+
+// scripts/rules/stop-rules.ts
+import { z as z3 } from "zod";
+
+// 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 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 is_linked_at(line, index) {
+  for (const link of line.matchAll(MARKDOWN_LINK)) {
+    if (text_span_covers(link, index)) return true;
+  }
+  return false;
+}
+function repo_prefix(message, hash_index) {
+  let start = hash_index;
+  while (start > 0 && !REFERENCE_BOUNDARY.test(message.charAt(start - 1))) start -= 1;
+  const token = message.slice(start, hash_index);
+  return OWNER_REPO.test(token) ? token : "";
+}
+function is_inline_code_at(line, index) {
+  const backticks = line.slice(0, index).split("`").length - 1;
+  return backticks % BACKTICK_PAIR === 1;
+}
+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 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] });
+    }
+  }
+  return references;
+}
+function collect_line_references(line, found) {
+  for (const reference of line_references(line)) found.push(`${reference.prefix}${reference.text}`);
+}
+function lines_outside_fences(message) {
+  const lines = [];
+  let is_in_fence = false;
+  for (const line of message.split("\n")) {
+    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
+    else if (!is_in_fence) lines.push(line);
+  }
+  return lines;
+}
+function prose_lines(message) {
+  return lines_outside_fences(message).filter((line) => !QUOTE_LINE.test(line));
+}
+function bare_references(message) {
+  const found = [];
+  for (const line of prose_lines(message)) collect_line_references(line, found);
+  return [...new Set(found)];
+}
+function has_bare_reference(message) {
+  return bare_references(message).length > 0;
+}
+function cite_argument(reference) {
+  return reference.startsWith("#") ? reference.slice(1) : reference;
+}
+function cite_arguments(references) {
+  return references.map((reference) => cite_argument(reference));
+}
+function reference_link(reference, default_slug) {
+  const slug = reference.prefix === "" ? default_slug : reference.prefix;
+  const number = reference.text.slice(1);
+  return `[${reference.prefix}${reference.text}](${issue_cite.issue_url(slug, number)})`;
+}
+function linkify_line(line, slug) {
+  let result = "";
+  let cursor = 0;
+  for (const reference of line_references(line)) {
+    const start = reference.index - reference.prefix.length;
+    result += line.slice(cursor, start) + reference_link(reference, slug);
+    cursor = reference.index + reference.text.length;
+  }
+  return result + line.slice(cursor);
+}
+function rewrite_line(line, slug, is_in_fence) {
+  if (is_in_fence || FENCE_MARKER.test(line) || QUOTE_LINE.test(line)) return line;
+  return linkify_line(line, slug);
+}
+function linkify(message, slug) {
+  const out = [];
+  let is_in_fence = false;
+  for (const line of message.split("\n")) {
+    if (FENCE_MARKER.test(line)) is_in_fence = !is_in_fence;
+    out.push(rewrite_line(line, slug, is_in_fence));
+  }
+  return out.join("\n");
+}
+var issue_citation = { bare_references, cite_arguments, has_bare_reference, linkify, prose_lines };
+
+// scripts/rules/filing-offer.ts
+var OFFER_PATTERNS = [
+  /起票(?:して)?(?:も)?(?:よければ|よろしければ|よいですか|良いですか|よろしいですか|いいですか)/u,
+  /起票(?:しましょうか|しますか|するのが妥当|すべきだと|すべきと|を提案|をご提案)/u,
+  /Issue\s*[化に](?:しましょうか|しますか|してよければ)/iu,
+  /\b(?:shall|should)\s+I\s+(?:file|open|raise)\b/iu,
+  /\b(?:want|like)\s+me\s+to\s+(?:file|open|raise)\b/iu,
+  /\blet\s+me\s+know\s+if\s+you\s+(?:want|would\s+like)\s+(?:me\s+to\s+file|it\s+filed)\b/iu
+];
+var GITHUB_URL_OWNER = /github\.com\/([\w.-]+)\//gu;
+var OWNER_SEPARATOR = "/";
+function is_offer_line(line) {
+  return OFFER_PATTERNS.some((pattern) => pattern.test(line));
+}
+function offers_filing(message) {
+  return issue_citation.prose_lines(message).some((line) => is_offer_line(line));
+}
+function url_owners(message) {
+  return [...message.matchAll(GITHUB_URL_OWNER)].map((match) => match[1] ?? "");
+}
+function qualified_owners(message) {
+  return issue_citation.bare_references(message).filter((reference) => reference.includes(OWNER_SEPARATOR)).map((reference) => reference.split(OWNER_SEPARATOR)[0] ?? "");
+}
+function mentioned_owners(message) {
+  return [...url_owners(message), ...qualified_owners(message)];
+}
+function is_first_party_target(message, session_owner) {
+  if (session_owner === void 0) return false;
+  return mentioned_owners(message).every(
+    (owner) => repo_party.classify(session_owner, owner) === repo_party.FIRST_PARTY
+  );
+}
+var filing_offer = { is_first_party_target, mentioned_owners, offers_filing };
+
+// scripts/rules/reply-language.ts
+var LATIN_SCRIPT = "Latn";
+var COMPOUND_SCRIPTS = {
+  Jpan: ["Hira", "Kana", "Hani"],
+  Kore: ["Hang", "Hani"],
+  Hans: ["Hani"],
+  Hant: ["Hani"]
+};
+var MIN_PROSE_LETTERS = 20;
+var MATCH_SHARE_FLOOR = 0.5;
+var MIN_VOTING_LETTERS = 8;
+var CODE_PATTERNS = [
+  /```[\s\S]*?(?:```|$)/gu,
+  /`[^`\n]*`/gu,
+  /\]\([^)\s]*\)/gu,
+  /https?:\/\/\S+/gu
+];
+var ASCII_RUN_PATTERN = /[!-~]+/gu;
+var LETTER_PATTERN = new RegExp("\\p{L}", "gu");
+var NON_LATIN_LETTER_PATTERN = new RegExp("(?![\\p{Script=Latn}\\p{Script=Common}\\p{Script=Inherited}])\\p{L}", "u");
+function script_of(lang) {
+  try {
+    return new Intl.Locale(lang).maximize().script;
+  } catch {
+    return void 0;
+  }
+}
+function letter_pattern(script) {
+  const scripts = COMPOUND_SCRIPTS[script] ?? [script];
+  const classes = scripts.map((name) => String.raw`\p{Script=${name}}`).join("");
+  try {
+    return new RegExp(`[${classes}]`, "u");
+  } catch {
+    return void 0;
+  }
+}
+function prose_of(message) {
+  let text2 = message;
+  for (const pattern of CODE_PATTERNS) text2 = text2.replaceAll(pattern, " ");
+  return text2.replaceAll(ASCII_RUN_PATTERN, (run) => run.includes("/") ? " " : run);
+}
+function letter_count(text2) {
+  return text2.match(LETTER_PATTERN)?.length ?? 0;
+}
+function is_line_in_script(line, script, pattern) {
+  if (script === LATIN_SCRIPT) return !NON_LATIN_LETTER_PATTERN.test(line);
+  return pattern.test(line);
+}
+function voting_lines(prose) {
+  const lines = prose.split("\n").filter((line) => letter_count(line) > 0);
+  const voting = lines.filter((line) => letter_count(line) >= MIN_VOTING_LETTERS);
+  return voting.length > 0 ? voting : lines;
+}
+function matches_share(prose, script, pattern) {
+  const lines = voting_lines(prose);
+  const matched = lines.filter((line) => is_line_in_script(line, script, pattern));
+  return matched.length / lines.length;
+}
+function is_mismatch(message, 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(message);
+  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 };
+
+// scripts/rules/stop-rules.ts
+var SWITCH_ENV_KEY = "JOSH_STOP_GUARD";
+var BLOCK_DECISION = "block";
+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 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. 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:scout "<title>"`, file it, run `pnpm josh epic:bundle <new>`, then end with the one-line citation of what was filed \u2014 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_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(message) {
+  return INDEX_COMMAND_PATTERN.test(message) && PERMISSION_PATTERN.test(message);
+}
+function needs_index_route(context) {
+  return context.lane_child && asks_index_permission(context.message);
+}
+function language_note(lang) {
+  return `Write your reply in the session language (JOSH_SESSION_LANG: ${lang}); code, commands and identifiers stay as they are.`;
+}
+function build_language_reason(lang) {
+  return `\u26D4 session language: your reply is not written in the session language (JOSH_SESSION_LANG: ${lang}). Rewrite it in that language and keep writing in it on the turns that follow, whatever language a notification, tool output or hook message was in (\`CLAUDE.md\` \u2192 "Output language").`;
+}
+function language_reason(context) {
+  if (!reply_language.is_mismatch(context.message, context.session_lang)) return void 0;
+  return build_language_reason(context.session_lang);
+}
+function needs_filing(context) {
+  if (context.filed || !filing_offer.offers_filing(context.message)) return false;
+  return filing_offer.is_first_party_target(context.message, context.session_owner);
+}
+function needs_notify(context) {
+  return context.hold_present && !context.notified;
+}
+function needs_release(context) {
+  return context.hold_present && context.tree_clean;
+}
+function citation_reason(message) {
+  const references = issue_citation.bare_references(message);
+  if (references.length === 0) return void 0;
+  return build_citation_reason(references);
+}
+function reply_reason(context) {
+  if (needs_filing(context)) return FILING_OFFER_REASON;
+  return citation_reason(context.message) ?? language_reason(context);
+}
+function is_headless_held(context) {
+  if (!context.headless_waiting) return false;
+  return !context.stop_hook_active || context.headless_refusals < HEADLESS_REFUSAL_CAP;
+}
+function count_headless_refusals(tail) {
+  const last_wait = Math.max(...HEADLESS_WAIT_CALLS.map((call) => tail.lastIndexOf(call)));
+  return tail.slice(Math.max(last_wait, 0)).split(HEADLESS_WAIT_MARKER).length - 1;
+}
+function hold_reason(context) {
+  if (needs_index_route(context)) return LANE_INDEX_REASON;
+  if (needs_notify(context)) return STOP_NOTIFY_REASON;
+  if (needs_release(context)) return HOLD_RELEASE_REASON;
+  return void 0;
+}
+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);
+}
+function stop_outcome(context) {
+  return { reason: block_reason(context) };
+}
+function block_envelope(reason, lang) {
+  return JSON.stringify({ decision: BLOCK_DECISION, reason: `${reason} ${language_note(lang)}` });
+}
+function parse_stop_payload(raw_payload) {
+  const parsed = stop_payload_schema.safeParse(JSON.parse(raw_payload));
+  return parsed.success ? parsed.data : void 0;
+}
+function is_enabled() {
+  return hook_decision.is_switch_enabled(SWITCH_ENV_KEY);
+}
+var stop_rules = {
+  FILING_OFFER_REASON,
+  HEADLESS_REFUSAL_CAP,
+  HEADLESS_WAIT_REASON,
+  HOLD_RELEASE_REASON,
+  ISSUE_CITATION_REASON,
+  LANE_INDEX_REASON,
+  NO_OUTCOME,
+  STOP_NOTIFY_REASON,
+  SWITCH_ENV_KEY,
+  block_envelope,
+  block_reason,
+  build_language_reason,
+  count_headless_refusals,
+  is_enabled,
+  parse_stop_payload,
+  stop_outcome
+};
+
+// scripts/run/run-stranded.ts
+var RECOVERY_COMMAND = "pnpm josh run:wake --start";
+var LIVE = "live";
+var GONE = "gone";
+var UNKNOWN = "unknown";
+var STRANDED = "stranded";
+var OK2 = "ok";
+function supervisor_liveness(wake, same_process = process_identity.is_same_process) {
+  if (wake === void 0) return GONE;
+  const is_same = same_process(wake.pid, wake.process_start);
+  if (is_same === void 0) return UNKNOWN;
+  return is_same ? LIVE : GONE;
+}
+function is_stranded(input) {
+  if (input.read.kind !== "carried" || input.read.carry.is_handed_off !== true || input.is_owner_live) {
+    return false;
+  }
+  return input.supervisor === GONE;
+}
+function describe2(carry) {
+  return `Run stranded \u2014 ${run_carry.describe_carry(carry)}. The owner is gone, no cut successor claimed the budget, and no supervisor is watching.`;
+}
+function verdict_of(is_run_stranded) {
+  return is_run_stranded ? STRANDED : OK2;
+}
+var run_stranded = {
+  GONE,
+  LIVE,
+  OK: OK2,
+  RECOVERY_COMMAND,
+  STRANDED,
+  UNKNOWN,
+  describe: describe2,
+  is_stranded,
+  supervisor_liveness,
+  verdict_of
+};
+
+// scripts/run/run-wake.ts
+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";
+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" };
+var IDLE_DECISION = { kind: "idle" };
+var WAIT_DECISION = { kind: "wait" };
+var PENDING_DECISION = { kind: "pending" };
+var HOLD_DECISION = { kind: "hold" };
+var FAILED_DECISION = { kind: "failed" };
+var STOP_REASONS = {
+  none: "ended",
+  expired: "expired",
+  unreadable: "unreadable"
+};
+var run_wake_schema = z4.object({
+  invocation: z4.string(),
+  started_at: z4.string(),
+  pid: z4.number(),
+  process_start: z4.string().optional(),
+  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: 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) {
+  const marked = Date.parse(marked_at);
+  if (Number.isNaN(marked)) return true;
+  return now.getTime() - marked > limit_ms;
+}
+function launch_or_idle(input) {
+  if (input.has_work !== false) return WAKE_DECISION;
+  if (input.idle_since === void 0) return IDLE_DECISION;
+  return is_overdue(input.idle_since, input.now, IDLE_CEILING_MS) ? WAKE_DECISION : IDLE_DECISION;
+}
+function decide_launch(input) {
+  if (input.woke_at === void 0) return launch_or_idle(input);
+  if (!is_overdue(input.woke_at, input.now)) return PENDING_DECISION;
+  return input.attempts < MAX_WAKE_ATTEMPTS ? launch_or_idle(input) : FAILED_DECISION;
+}
+function decide_not_handed_off(input) {
+  if (input.is_owner_live) return WAIT_DECISION;
+  return decide_launch(input);
+}
+function is_predecessor_exiting(input) {
+  if (input.woke_at !== void 0 || !input.is_owner_live) return false;
+  return input.held_at === void 0 || !is_overdue(input.held_at, input.now);
+}
+function decide(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);
+  if (is_predecessor_exiting(input)) return HOLD_DECISION;
+  return decide_launch(input);
+}
+function wake_path(git_directory) {
+  return stamp_file.stamp_path(WAKE_PREFIX, git_directory);
+}
+function wake_log_path(git_directory) {
+  return stamp_file.stamp_path(WAKE_LOG_PREFIX, git_directory, WAKE_LOG_SUFFIX);
+}
+function parse_wake(raw) {
+  try {
+    return run_wake_schema.parse(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+}
+function read_wake(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? void 0 : parse_wake(raw);
+}
+function write_wake(target, wake) {
+  stamp_file.write_stamp(target, wake);
+}
+function remove_wake(target) {
+  stamp_file.remove_stamp(target);
+}
+function fresh_wake(invocation, now, profile) {
+  return {
+    invocation,
+    ...profile && { profile },
+    started_at: now.toISOString(),
+    woke: NO_WAKES,
+    ...process_identity.own_fields()
+  };
+}
+function is_supervisor_live(wake) {
+  return process_identity.is_same_process(wake.pid, wake.process_start) !== false;
+}
+function carried_state(existing, invocation) {
+  if (existing?.invocation !== invocation) return { woke: NO_WAKES };
+  return {
+    woke: existing.woke,
+    woke_at: existing.woke_at,
+    attempts: existing.attempts,
+    woke_pid: existing.woke_pid,
+    held_at: existing.held_at,
+    // **`spawned` carries across too, or a restart mid-run would lose the ids of every session it
+    // already started** (joshuafolkken/kit#2407) — and `josh time --run`, reading the record after
+    // the restart, would under-count the whiffs and read the loss as a saving.
+    spawned: existing.spawned,
+    // And `idle_since`, or a restart would slide the idle ceiling by the time already spent idle.
+    idle_since: existing.idle_since,
+    ...existing.profile && { profile: existing.profile }
+  };
+}
+function is_held_by_live_supervisor(existing) {
+  return existing !== void 0 && is_supervisor_live(existing);
+}
+function reclaim(target, wake) {
+  if (is_held_by_live_supervisor(read_wake(target))) return void 0;
+  remove_wake(target);
+  return stamp_file.create_stamp(target, wake) ? wake : void 0;
+}
+function claim(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) };
+  return stamp_file.create_stamp(target, wake) ? wake : reclaim(target, wake);
+}
+function count_wake(wake, now, pid, session_id) {
+  const attempts = (wake.attempts ?? NO_WAKES) + ONE_WAKE;
+  const spawned = [...wake.spawned ?? [], session_id];
+  const woke_at = now.toISOString();
+  return {
+    ...wake,
+    attempts,
+    spawned,
+    woke_at,
+    woke_pid: pid,
+    held_at: void 0,
+    idle_since: void 0
+  };
+}
+function mark_wait(wake, now) {
+  return wake.held_at === void 0 ? { ...wake, held_at: now.toISOString() } : wake;
+}
+function mark_idle(wake, now) {
+  return wake.idle_since === void 0 ? { ...wake, idle_since: now.toISOString() } : wake;
+}
+function count_claim(wake) {
+  const woke = wake.woke_at === void 0 ? wake.woke : wake.woke + ONE_WAKE;
+  return {
+    ...wake,
+    woke,
+    woke_at: void 0,
+    attempts: void 0,
+    held_at: void 0,
+    idle_since: void 0
+  };
+}
+function is_own_wake(wake) {
+  return process_identity.is_own_process(wake.pid, wake.process_start);
+}
+function read_own_wake(target) {
+  const wake = read_wake(target);
+  return wake !== void 0 && is_own_wake(wake) ? wake : void 0;
+}
+function tidy_own_wake(target) {
+  const wake = read_wake(target);
+  if (wake === void 0) return "absent";
+  if (!is_own_wake(wake)) return "superseded";
+  remove_wake(target);
+  return "removed";
+}
+function update_wake(target, wake) {
+  if (read_own_wake(target) === void 0) return false;
+  write_wake(target, wake);
+  return true;
+}
+var run_wake = {
+  IDLE_CEILING_MS,
+  MAX_WAKE_ATTEMPTS,
+  WAKE_GRACE_MS,
+  WAKE_PREFIX,
+  claim,
+  count_claim,
+  count_wake,
+  decide,
+  fresh_wake,
+  is_supervisor_live,
+  mark_idle,
+  mark_wait,
+  parse_wake,
+  read_own_wake,
+  read_wake,
+  remove_wake,
+  tidy_own_wake,
+  update_wake,
+  wake_log_path,
+  wake_path,
+  write_wake
+};
+
+// scripts/run/run-stranded-detect.ts
+var STRAND_RECOVERY = `Restart supervision with \`${run_stranded.RECOVERY_COMMAND}\` \u2014 it wakes a fresh successor to claim the budget; the cutting session must not resume it itself.`;
+async function real_resolve_targets() {
+  const directory = await run_carry.repository_directory();
+  if (directory === void 0) return void 0;
+  return { carry: run_carry.carry_path(directory), wake: run_wake.wake_path(directory) };
+}
+async function real_emit_stranded(text2) {
+  return await run_event_stream_emit.emit_once(run_event_stream.EVENT_KIND.STRANDED, text2);
+}
+async function real_notify_stranded(body) {
+  return await telegram_notify.stranded({ body, recovery: STRAND_RECOVERY });
+}
+var DEFAULT_PORTS3 = {
+  resolve_targets: real_resolve_targets,
+  read_carry: (target) => run_carry.read_carry(target),
+  is_owner_live: run_carry.is_owner_live,
+  read_wake: (target) => run_wake.read_wake(target),
+  supervisor_liveness: (wake) => run_stranded.supervisor_liveness(wake),
+  emit_stranded: real_emit_stranded,
+  notify_stranded: real_notify_stranded
+};
+async function gather2(ports) {
+  const targets = await ports.resolve_targets();
+  if (targets === void 0) return void 0;
+  const read = ports.read_carry(targets.carry);
+  if (read.kind !== "carried") return void 0;
+  return {
+    read,
+    is_owner_live: ports.is_owner_live(read.carry),
+    supervisor: ports.supervisor_liveness(ports.read_wake(targets.wake))
+  };
+}
+async function report2(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);
+}
+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);
+  return run_stranded.verdict_of(is_run_stranded);
+}
+async function run_stranded_check() {
+  try {
+    await detect_and_report2();
+  } catch {
+  }
+}
+var run_stranded_detect = { DEFAULT_PORTS: DEFAULT_PORTS3, detect_and_report: detect_and_report2, gather: gather2, report: report2, run_stranded_check };
+
+// scripts/hooks/stop-guard.ts
+async function is_hold_present() {
+  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";
+}
+function transcript_tail(transcript_path) {
+  const transcript = time_hook_transcript.transcript_of(transcript_path, void 0);
+  return time_density_hook.read_tail(transcript);
+}
+function was_filed(tail) {
+  return filing_cap.turn_filing_count(tail) > 0;
+}
+function session_lang() {
+  return session_language.resolve_session_lang().lang;
+}
+async function build_context(transcript_path, payload_tail) {
+  const tail = transcript_tail(transcript_path);
+  return {
+    hold_present: await is_hold_present(),
+    tree_clean: !await run_hold.is_tree_dirty(),
+    notified: lane_park.mentions_confirmation_notify(tail),
+    message: payload_tail.message,
+    stop_hook_active: payload_tail.stop_hook_active,
+    cut_pending: run_cut.carried_cut_sync() !== void 0,
+    filed: was_filed(tail),
+    session_owner: repo_party.current_owner(),
+    headless_waiting: await run_headless.must_keep_waiting(),
+    headless_refusals: stop_rules.count_headless_refusals(tail),
+    lane_child: lane_child_marker.is_child_of(process.cwd()),
+    session_lang: session_lang()
+  };
+}
+async function stop_outcome_for_payload(raw_payload) {
+  const payload = stop_rules.parse_stop_payload(raw_payload);
+  if (payload === void 0 || !stop_rules.is_enabled()) return stop_rules.NO_OUTCOME;
+  const context = await build_context(payload.transcript_path, {
+    stop_hook_active: payload.stop_hook_active ?? false,
+    message: payload.last_assistant_message ?? ""
+  });
+  return stop_rules.stop_outcome(context);
+}
+async function outcome_of(raw_payload) {
+  try {
+    return await stop_outcome_for_payload(raw_payload);
+  } catch {
+    return stop_rules.NO_OUTCOME;
+  }
+}
+async function write_stop_decision(raw_payload) {
+  hook_decision.load_environment_file();
+  await backlog_stalled_detect.run_stall_check(backlog_ready.DEFAULT_PORTS);
+  await run_stranded_detect.run_stranded_check();
+  const { reason } = await outcome_of(raw_payload);
+  if (reason === void 0) return;
+  process.stdout.write(`${stop_rules.block_envelope(reason, session_lang())}
+`);
+}
+var stop_guard = { outcome_of, stop_outcome_for_payload };
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  if (process.stdin.isTTY) hook_decision.report_no_payload("stop:guard");
+  else await write_stop_decision(await text(process.stdin));
+}
+export {
+  stop_guard,
+  write_stop_decision
+};