@joshuafolkken/kit 1.1383.0 → 1.1435.0

package/dist/hooks/{chunk-6AC4C2IO.js → chunk-YZXYOAZ3.js}

@@ -6,9 +6,9 @@ import {
   lane_child_invocation,
   repo_discovery,
   repo_origin,
-  repository_lock,
-  run_ship_stage
-} from "./chunk-2X2ART5G.js";
+  run_event_stream,
+  run_event_stream_emit
+} from "./chunk-YW452ZAX.js";
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
@@ -30,10 +30,10 @@ import {
   time_density_hook,
   time_shell,
   time_transcript_line
-} from "./chunk-TT742SIO.js";
+} from "./chunk-XER6SSIB.js";
 import {
   lane_child_marker
-} from "./chunk-Y5R47QHU.js";
+} from "./chunk-4BHUPFKF.js";
 import {
   agent_session_environment,
   backlog_budget,
@@ -41,13 +41,13 @@ import {
   git_command,
   has_timed_out,
   json_value,
-  process_identity,
-  run_carry
-} from "./chunk-4MGHBTOM.js";
+  process_identity
+} from "./chunk-3LE6VLSR.js";
 import {
   COMMAND_TIMEOUT_MS,
+  PROJECT_ROOT,
   stamp_file
-} from "./chunk-NEC4AT4Z.js";
+} from "./chunk-DGT54IH5.js";
 
 // scripts/lib/bounded-pool.ts
 function pool_width(limit, total) {
@@ -1061,406 +1061,7 @@ var lane_background = {
 // scripts/run/ship/run-ship-detach.ts
 import { randomUUID } from "node:crypto";
 import { setTimeout as sleep } from "node:timers/promises";
-
-// scripts/run/event/run-event-stream.ts
 import { z as z4 } 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 WORD_SEPARATOR = " ";
-var STAGE_PHASE_INDEX = 2;
-var LOCK_SUFFIX = ".lock";
-var LOCK_WAIT_MS = 5e3;
-var EVENT_KIND = {
-  PLAN: "plan",
-  CHILD_LAUNCH: "child-launch",
-  MERGE: "merge",
-  PARK: "park",
-  SPLIT: "split",
-  OUTAGE: "outage",
-  CUT: "cut",
-  // A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`. The
-  // resume clears the cut record, so without this the `cut` would stay the newest position and
-  // `run:step` would keep answering the resume command it had just run.
-  RESUME: "resume",
-  // The backlog emptied while nothing of the run's own was in flight — the drain. 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. 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. 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 — 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. 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. 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. Printed only to
-  // the watcher's own output, a headless successor's heartbeat would be 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. 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
-  // 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",
-  // An Issue the run filed on its way, written by `issue:file`, so a run started from the command line
-  // still surfaces what it found — `run:board`'s findings section reads it.
-  FILED: "filed",
-  // A one-line observation short of an Issue, written with `run:event --append note` and shown in the
-  // same section.
-  NOTE: "note",
-  // A lane child reached a phase no other event marks — its first implementation edit, written by the
-  // PreToolUse hook — so `run:board` draws how far the child has got. A trace,
-  // like `SHIP_STAGE`: it says where the child's work is, not where the run is.
-  LANE_PHASE: "lane-phase",
-  // An issue `run:add` put into the live run. The parent's `--wait` watcher
-  // ends on it, so the issue takes the next free lane without waiting out the arrival probe's minute. A
-  // trace: it says what the run was handed, not where the run is.
-  ADD: "add",
-  // `josh lane:limit` raised a live run's lane limit. The `--wait` watcher's
-  // arrival probe reads it as a wake: the lanes a raise frees are new room for a pool its baseline
-  // already holds. A trace: it says the run gained room, not where the run is.
-  LANE_LIMIT: "lane-limit"
-};
-var EVENT_KINDS = Object.values(EVENT_KIND);
-var TRACE_KINDS = /* @__PURE__ */ new Set([
-  EVENT_KIND.SHIP_STAGE,
-  EVENT_KIND.HEARTBEAT,
-  EVENT_KIND.FILED,
-  EVENT_KIND.NOTE,
-  EVENT_KIND.LANE_PHASE,
-  EVENT_KIND.ADD,
-  EVENT_KIND.LANE_LIMIT
-]);
-var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([EVENT_KIND.SHIP_STAGE, EVENT_KIND.HEARTBEAT]);
-var event_schema = z4.object({
-  pos: z4.number(),
-  at: z4.string(),
-  kind: z4.string(),
-  text: z4.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_lines(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 read_events(target) {
-  return read_lines(target).filter((event) => is_event_kind(event.kind));
-}
-function last_position(events) {
-  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
-}
-function issue_of(event) {
-  return event.text.split(WORD_SEPARATOR)[FIRST_POSITION] ?? "";
-}
-function newest_stages(events) {
-  const newest = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    if (event.kind === EVENT_KIND.SHIP_STAGE) newest.set(issue_of(event), event);
-  }
-  return new Set(newest.values());
-}
-function is_stage_start(event) {
-  if (event.kind !== EVENT_KIND.SHIP_STAGE) return false;
-  return event.text.split(WORD_SEPARATOR)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START;
-}
-function droppable(events) {
-  const kept = newest_stages(events);
-  const disposable = events.filter((event) => DISPOSABLE_KINDS.has(event.kind) && !kept.has(event));
-  return [
-    ...disposable.filter((event) => !is_stage_start(event)),
-    ...disposable.filter((event) => is_stage_start(event))
-  ];
-}
-function bounded(events) {
-  const excess = events.length - EVENT_CAP;
-  if (excess <= 0) return events;
-  const dropped = new Set(droppable(events).slice(0, excess));
-  return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP);
-}
-function serialize(events) {
-  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
-}
-function append_held(target, event) {
-  const position = last_position(read_lines(target)) + POSITION_INCREMENT;
-  const events = bounded([...read_events(target), { pos: position, ...event }]);
-  stamp_file.replace_text_stamp(target, serialize(events));
-  return position;
-}
-function append(target, kind, text2, at) {
-  if (!is_event_kind(kind)) return { appended: false, position: FIRST_POSITION };
-  const lock = `${target}${LOCK_SUFFIX}`;
-  const position = repository_lock.with_lock_sync(
-    () => append_held(target, { at, kind, text: text2 }),
-    lock,
-    LOCK_WAIT_MS
-  );
-  if (position === void 0) {
-    const message = `run event stream: gave up waiting for the lock at ${lock}`;
-    process.stderr.write(`${message}
-`);
-    throw new Error(message);
-  }
-  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,
-  TRACE_KINDS,
-  append,
-  format_event,
-  has_since,
-  is_stage_start,
-  read_events,
-  read_from,
-  read_last,
-  target_of
-};
-
-// scripts/run/event/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") return UNKNOWN_EVENT_SCOPE;
-  return { kind: SINCE_SCOPE, started_at: read.carry.started_at };
-}
-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
-]);
-var KIND = run_event_stream.EVENT_KIND;
-var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
-  KIND.CHILD_LAUNCH,
-  KIND.PARK,
-  KIND.SPLIT,
-  KIND.RETROSPECTIVE,
-  KIND.STRANDED
-]);
-var ISSUE_REFERENCE = /#(\d+)/u;
-function is_foreign_ship_event(event, issue2) {
-  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain(issue2)} `);
-}
-function is_own_ship_event(event, issue2) {
-  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue2);
-}
-function issue_named(event) {
-  return ISSUE_REFERENCE.exec(event.text)?.[1];
-}
-function names_issue(event, issue2) {
-  return issue_named(event) === issue2;
-}
-function is_lane_position(event, issue2) {
-  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue2);
-}
-function since_own_launch(events, issue2) {
-  const launch2 = events.findLastIndex(
-    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue2)
-  );
-  return events.slice(launch2 + 1);
-}
-function is_foreign_event(event, issue2, is_lane_child) {
-  if (is_lane_child) return !is_lane_position(event, issue2);
-  return is_foreign_ship_event(event, issue2);
-}
-function last_issue_event(events, scope, issue2, is_lane_child) {
-  const attempt = is_lane_child ? since_own_launch(events, issue2) : events;
-  const own = attempt.filter((event) => !is_foreign_event(event, issue2, is_lane_child));
-  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own, scope);
-  return own.findLast((event) => is_own_ship_event(event, issue2));
-}
-var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
-  KIND.CHILD_LAUNCH,
-  KIND.MERGE,
-  KIND.PARK,
-  KIND.SPLIT
-]);
-function is_merge_owed(events, scope, issue2) {
-  const newest = (scoped_events(events, scope) ?? []).findLast(
-    (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue2)
-  );
-  return newest?.kind === KIND.CHILD_LAUNCH;
-}
-var run_event_scope = {
-  UNKNOWN_EVENT_SCOPE,
-  is_merge_owed,
-  issue_named,
-  last_issue_event,
-  last_scoped_event,
-  moment_of,
-  scope_of,
-  scoped_events,
-  since_own_launch
-};
-
-// scripts/run/event/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 (error) {
-    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
-    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 (error) {
-    error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
-    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 [];
-  }
-}
-async function invocation_or_all_events() {
-  try {
-    const repository = await run_carry.repository_directory();
-    return repository === void 0 ? [] : invocation_events(repository, run_event_stream.target_of(repository));
-  } catch {
-    return [];
-  }
-}
-async function all_events() {
-  try {
-    const target = await stream_target();
-    return target === void 0 ? [] : run_event_stream.read_events(target);
-  } catch {
-    return [];
-  }
-}
-var run_event_stream_emit = {
-  all_events,
-  current_events,
-  emit,
-  emit_heartbeat,
-  emit_once,
-  emit_once_since,
-  invocation_or_all_events,
-  stream_target
-};
-
-// scripts/run/ship/run-ship-detach.ts
-import { z as z5 } from "zod";
 var LOG_PREFIX = "josh-ship-log-";
 var PID_PREFIX = "josh-ship-pid-";
 var BODY_PREFIX = "josh-ship-notify-";
@@ -1481,14 +1082,14 @@ var RESULT_PREFIX = "josh-ship-result-";
 var RECORD_POLL_MS = 25;
 var RECORD_WAIT_ATTEMPTS = 200;
 var CLAIM_WINDOW_MS = 12e4;
-var ship_record_schema = z5.object({
-  pid: z5.number().int().positive().optional(),
-  process_start: z5.string().optional(),
-  launched_at: z5.number().optional(),
-  launcher_pid: z5.number().int().positive().optional(),
-  launcher_start: z5.string().optional(),
-  launch_id: z5.string(),
-  result: z5.enum(["success", "failed"]).optional()
+var ship_record_schema = z4.object({
+  pid: z4.number().int().positive().optional(),
+  process_start: z4.string().optional(),
+  launched_at: z4.number().optional(),
+  launcher_pid: z4.number().int().positive().optional(),
+  launcher_start: z4.string().optional(),
+  launch_id: z4.string(),
+  result: z4.enum(["success", "failed"]).optional()
 });
 var LAUNCH_MARK = " \xB7 started by process ";
 var HEADER_START = "\n";
@@ -1701,6 +1302,7 @@ var lane_handoff = { is_handed_off, is_ship_running };
 
 // scripts/issue/issue-labels.ts
 var EPIC_LABEL = "epic";
+var BUG_LABEL = "bug";
 var ENHANCEMENT_LABEL = "enhancement";
 var BREAKING_CHANGE_LABEL = "breaking-change";
 var IN_PROGRESS_LABEL = "in-progress";
@@ -1709,9 +1311,11 @@ var NEEDS_DECISION_LABEL = "needs-decision";
 var RUN_SOLO_LABEL = "run:solo";
 var RUN_LANE_LABEL = "run:lane";
 var PRIORITY_HIGH_LABEL = "priority:high";
+var AUTO_OK_LABEL = "auto-ok";
 var NEEDS_HUMAN_REVIEW_LABEL = "needs-human-review";
 var ALREADY_DONE_LABEL = "already-done";
 var RELEASE_LABEL = "release";
+var REVIEW_ROUND2_SKIPPED_LABEL = "review-round2-skipped";
 var INTERRUPT_ROUTE_LABEL = "route:interrupt";
 var REVIEW_CAP_ROUTE_LABEL = "route:review-cap";
 var SPLIT_ROUTE_LABEL = "route:split";
@@ -1790,6 +1394,32 @@ var WORKFLOW_LABELS = [
     color: "fef2c0",
     description: "Tracks the next release; its blockers are the merged work it publishes"
   },
+  {
+    name: AUTO_OK_LABEL,
+    color: "0e8a16",
+    description: "Opted in to unattended execution outside an epic"
+  },
+  {
+    name: NEEDS_DECISION_LABEL,
+    color: "d93f0b",
+    description: "Parked: needs a decision before it can run"
+  },
+  {
+    name: NEEDS_HUMAN_REVIEW_LABEL,
+    color: "d93f0b",
+    description: "Implement and verify, but stop before committing so a person can look"
+  },
+  {
+    name: ALREADY_DONE_LABEL,
+    color: "6f42c1",
+    description: "Verified already merged \u2014 a person closes it"
+  },
+  {
+    name: REVIEW_ROUND2_SKIPPED_LABEL,
+    color: "c5def5",
+    description: "Review round 2 was skipped under the condition in prompts/review.md"
+  },
+  { name: BUG_LABEL, color: "d73a4a", description: "Something isn't working" },
   ...FILING_ROUTE_LABELS,
   ...DEPTH_LABELS
 ];
@@ -2021,8 +1651,8 @@ var parse_json = {
 };
 
 // scripts/gh/git-gh-failure.ts
-import { z as z6 } from "zod";
-var error_document_schema = z6.object({ status: z6.union([z6.string(), z6.number()]).optional() }).catch({});
+import { z as z5 } from "zod";
+var error_document_schema = z5.object({ status: z5.union([z5.string(), z5.number()]).optional() }).catch({});
 var GH_FAILURE_FIELD = "gh_failure";
 function has_gh_failure(error) {
   return error instanceof Error && Object.hasOwn(error, GH_FAILURE_FIELD);
@@ -2225,7 +1855,7 @@ var git_gh_helpers = {
 };
 
 // scripts/gh/git-gh-issue-rest.ts
-import { z as z7 } from "zod";
+import { z as z6 } from "zod";
 
 // scripts/gh/git-gh-rest-state.ts
 var MERGED_STATE = "MERGED";
@@ -2234,11 +1864,11 @@ function to_gh_state(state) {
 }
 
 // scripts/gh/git-gh-issue-rest.ts
-var rest_issue_schema = z7.looseObject({
-  number: z7.number(),
-  issue_dependencies_summary: z7.looseObject({ total_blocked_by: z7.number().optional() }).nullish(),
+var rest_issue_schema = z6.looseObject({
+  number: z6.number(),
+  issue_dependencies_summary: z6.looseObject({ total_blocked_by: z6.number().optional() }).nullish(),
   // Present only on a pull request, which this endpoint serves as readily as an issue.
-  pull_request: z7.looseObject({ merged_at: z7.string().nullish() }).nullish()
+  pull_request: z6.looseObject({ merged_at: z6.string().nullish() }).nullish()
 });
 var REPOSITORY_URL = /\/repos\/([\w.-]+\/[\w.-]+)$/u;
 var REPOSITORY_URL_GROUP = 1;
@@ -2246,7 +1876,7 @@ var BLOCKED_BY_FIELD = "blockedBy";
 var BLOCKED_BY_COUNT_FIELD = "blocked_by_count";
 var STATE_FIELD = "state";
 var BODY_FIELD = "body";
-var FIELD_SEPARATOR2 = ",";
+var FIELD_SEPARATOR = ",";
 var EMPTY_BODY = "";
 var REST_FIELD_NAMES = /* @__PURE__ */ new Map([
   ["url", "html_url"],
@@ -2260,7 +1890,7 @@ function rest_field_name(field) {
   return REST_FIELD_NAMES.get(field) ?? field;
 }
 function split_fields(fields) {
-  return fields.split(FIELD_SEPARATOR2).map((field) => field.trim()).filter((field) => field.length > 0);
+  return fields.split(FIELD_SEPARATOR).map((field) => field.trim()).filter((field) => field.length > 0);
 }
 function to_issue_state(rest, value) {
   if (typeof rest.pull_request?.merged_at === "string") return MERGED_STATE;
@@ -2451,10 +2081,10 @@ async function issue_get_plan_fields_classified(issue_number) {
 async function issue_get_labels_and_body(issue_number) {
   return await issue_view_json(issue_number, "number,state,labels,body");
 }
-async function issue_list_comments(issue_number) {
+async function issue_list_comments(issue_number, timeout_ms) {
   const path = `${git_gh_api_path.issue_comments_api_path(issue_number)}${git_gh_api_path.FULL_PAGE_QUERY}`;
   try {
-    return await git_gh_exec.exec_gh_api({ path, should_paginate: true });
+    return await git_gh_exec.exec_gh_api({ path, should_paginate: true, timeout_ms });
   } catch {
     return void 0;
   }
@@ -2581,6 +2211,89 @@ var git_gh_issue_list = {
   issue_list
 };
 
+// scripts/issue/issue-watch-diff.ts
+import { z as z7 } from "zod";
+var RUN_MARKER = "<!-- josh:run -->";
+var BOT_TYPE = "Bot";
+var BOT_SUFFIX = "[bot]";
+var NO_COMMENT_ID = 0;
+var UNKNOWN_AUTHOR = "(unknown)";
+var UNKNOWN_TIME = "(undated)";
+var BODY_HEADING = "Body edited:";
+var REMOVED_PREFIX = "- ";
+var ADDED_PREFIX = "+ ";
+var COMMENT_HEADING = "New comment by ";
+var AT = " at ";
+var SECTION_SEPARATOR = "\n\n";
+var LINE_SEPARATOR = "\n";
+var CRLF = "\r\n";
+var comment_schema = z7.looseObject({
+  id: z7.number(),
+  user: z7.looseObject({ login: z7.string(), type: z7.string().optional() }).nullish(),
+  created_at: z7.string().optional(),
+  body: z7.string().nullish()
+});
+function is_bot(user) {
+  return user?.type === BOT_TYPE || (user?.login.endsWith(BOT_SUFFIX) ?? false);
+}
+function is_automated(user, body) {
+  return is_bot(user) || body.includes(RUN_MARKER);
+}
+function to_comment(raw) {
+  const body = raw.body ?? "";
+  const author = raw.user?.login ?? UNKNOWN_AUTHOR;
+  const created_at = raw.created_at ?? UNKNOWN_TIME;
+  return { id: raw.id, author, is_automated: is_automated(raw.user, body), created_at, body };
+}
+function parse_comments(json) {
+  if (json === void 0) return void 0;
+  const listing = read_json_listing(json, comment_schema);
+  return listing.kind === "read" ? listing.rows.map((row) => to_comment(row)) : void 0;
+}
+function last_comment_id(comments) {
+  return Math.max(NO_COMMENT_ID, ...comments.map((comment) => comment.id));
+}
+function baseline_of(snapshot) {
+  return { body: snapshot.body, last_comment_id: last_comment_id(snapshot.comments) };
+}
+function lines_missing_from(source, other) {
+  const present = new Set(other.split(LINE_SEPARATOR));
+  return source.split(LINE_SEPARATOR).filter((line) => line.trim() !== "" && !present.has(line));
+}
+function to_lf(body) {
+  return body.split(CRLF).join(LINE_SEPARATOR);
+}
+function body_section(previous_raw, current_raw) {
+  const previous = to_lf(previous_raw);
+  const current = to_lf(current_raw);
+  if (previous === current) return void 0;
+  const removed = lines_missing_from(previous, current).map((line) => `${REMOVED_PREFIX}${line}`);
+  const added = lines_missing_from(current, previous).map((line) => `${ADDED_PREFIX}${line}`);
+  return [BODY_HEADING, ...removed, ...added].join(LINE_SEPARATOR);
+}
+function comment_section(comment) {
+  return `${COMMENT_HEADING}${comment.author}${AT}${comment.created_at}${LINE_SEPARATOR}${comment.body}`;
+}
+function new_person_comments(baseline, snapshot) {
+  return snapshot.comments.filter(
+    (comment) => comment.id > baseline.last_comment_id && !comment.is_automated
+  );
+}
+function unread_diff(baseline, snapshot) {
+  const body = body_section(baseline.body, snapshot.body);
+  const comments = new_person_comments(baseline, snapshot).map(
+    (comment) => comment_section(comment)
+  );
+  const sections = [...body === void 0 ? [] : [body], ...comments];
+  return sections.length === 0 ? void 0 : sections.join(SECTION_SEPARATOR);
+}
+var issue_watch_diff = {
+  RUN_MARKER,
+  baseline_of,
+  parse_comments,
+  unread_diff
+};
+
 // scripts/gh/git-gh-issue-write.ts
 var PATCH_METHOD = "PATCH";
 var DELETE_METHOD = "DELETE";
@@ -2613,7 +2326,9 @@ async function issue_edit_body(issue_number, body) {
 async function issue_comment(issue_number, body) {
   return await git_gh_exec.exec_gh_api({
     path: `${git_gh_api_path.issue_api_path(issue_number)}${COMMENTS_SEGMENT}`,
-    body: JSON.stringify({ body }),
+    body: JSON.stringify({ body: `${body}
+
+${issue_watch_diff.RUN_MARKER}` }),
     jq_filter: HTML_URL_FILTER
   });
 }
@@ -2754,7 +2469,7 @@ var git_gh_issue_write = {
 
 // scripts/gh/git-gh-issue.ts
 var NUMBER_AND_BODY_FIELDS = "number,body";
-var BACKLOG_SCAN_FIELDS = `number,title,body,${BLOCKED_BY_COUNT_FIELD}`;
+var BACKLOG_SCAN_FIELDS = `number,title,body,labels,${BLOCKED_BY_COUNT_FIELD}`;
 var NUMBER_TITLE_AND_LABELS_FIELDS = "number,title,labels";
 var SUMMARY_FIELDS = "number,title,labels,createdAt";
 var PICKUP_FIELDS = `${SUMMARY_FIELDS},blockedBy,body`;
@@ -3606,6 +3321,7 @@ async function wait_for_pr_success(options) {
   let carried = { next_stable_count: 0, next_failure_count: 0 };
   for (let attempt = 0; attempt < options.max_attempts; attempt += 1) {
     console.info(`Checking PR status\u2026 (${String(attempt + 1)}/${String(options.max_attempts)})`);
+    await options.before_poll?.();
     carried = await attempt_pr_success_poll({
       options,
       stable_count: carried.next_stable_count,
@@ -3623,6 +3339,14 @@ async function default_fetch_pr_state(branch_name, should_read_review_decision =
   const decision = await git_gh_pr_snapshot.pr_get_review_decision(checks.pr_number);
   return { ...snapshot, review_decision: read_string(decision) };
 }
+function observed_fetcher(observe) {
+  if (observe === void 0) return default_fetch_pr_state;
+  return async function fetch_observed(branch_name, should_read_review_decision) {
+    const snapshot = await default_fetch_pr_state(branch_name, should_read_review_decision);
+    await observe(snapshot);
+    return snapshot;
+  };
+}
 
 // scripts/gh/git-pr-checks-watch.ts
 var PR_CHECKS_WATCH_TIMEOUT_MS = 12e4;
@@ -3652,10 +3376,10 @@ var CHECKS_SETTLED_EVALUATOR = {
   describe: describe_checks_failure,
   should_read_review_decision: should_never_read_review_decision
 };
-async function watch_until_settled(branch_name) {
+async function watch_until_settled(branch_name, observe) {
   await wait_for_pr_success({
     branch_name,
-    fetcher: default_fetch_pr_state,
+    fetcher: observed_fetcher(observe),
     interval_ms: CHECK_WAIT_INTERVAL_MS,
     max_attempts: compute_max_attempts(
       PR_CHECKS_WATCH_TIMEOUT_MS / SECONDS_TO_MS,
@@ -3669,9 +3393,9 @@ async function fail_when_no_checks(branch_name) {
   const snapshot = await default_fetch_pr_state(branch_name, should_never_read_review_decision);
   if (snapshot.rollup.length === 0) throw new Error(NO_CHECKS_MESSAGE);
 }
-async function pr_checks_watch(branch_name) {
+async function pr_checks_watch(branch_name, observe) {
   try {
-    await watch_until_settled(branch_name);
+    await watch_until_settled(branch_name, observe);
     return { timed_out: false };
   } catch (error) {
     if (!is_pr_checks_timeout(error)) throw error;
@@ -3691,18 +3415,42 @@ var git_gh_command = {
   ...git_gh_repo
 };
 
+// scripts/gh/gh-spawn.ts
+var NO_BUDGET = 0;
+function fetch_repo_name(timeout_ms) {
+  const stdout = git_gh_exec.read_gh_api_sync({
+    path: git_gh_api_path.repo_api_path(),
+    jq_filter: ".full_name",
+    cwd: PROJECT_ROOT,
+    timeout_ms: timeout_ms ?? NO_BUDGET
+  });
+  const name = stdout?.trim();
+  return name === "" ? void 0 : name;
+}
+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 };
+
 export {
   bounded_pool,
-  run_event_stream,
-  run_event_scope,
-  run_event_stream_emit,
+  git_gh_api_path,
+  read_json_listing,
+  parse_json_object_or_undefined,
+  has_stdout_field,
+  git_gh_exec,
+  git_gh_issue_read,
+  issue_watch_diff,
+  issue_citation,
+  session_cite,
   shell_segments,
   bash_triggers,
   tail_commands,
   filing_cap,
   CONTEXT_CUT_THRESHOLD,
-  issue_citation,
-  session_cite,
   run_hold,
   run_cut_handoff,
   run_cut,
@@ -3718,12 +3466,8 @@ export {
   has_label_name,
   lane_handoff,
   lane_park,
+  gh_spawn,
   repo_party,
-  git_gh_api_path,
-  read_json_listing,
-  parse_json_object_or_undefined,
-  git_gh_exec,
-  git_gh_issue_read,
   git_gh_pr_read,
   git_gh_command
 };