@joshuafolkken/kit 1.1240.0 → 1.1370.0

package/dist/hooks/stop-guard.js

@@ -2,53 +2,59 @@
 import {
   RUN_LANE_LABEL,
   RUN_SOLO_LABEL,
-  agent_headless,
-  agent_role_profile,
-  backlog_budget,
   filing_cap,
   git_gh_api_path,
   git_gh_command,
   git_gh_exec,
   has_label_name,
-  issue_cite,
+  issue_citation,
   lane_background,
   lane_handoff,
   lane_park,
-  lane_registry,
   repo_party,
-  run_carry,
   run_cut,
   run_event_stream,
   run_event_stream_emit,
-  run_headless,
-  run_hold,
-  run_invocation
-} from "./chunk-KHX4U3BG.js";
+  run_hold
+} from "./chunk-MXVQMLDP.js";
 import {
   session_language
 } from "./chunk-6V5OPIUU.js";
+import {
+  agent_headless,
+  agent_role_profile,
+  issue_cite,
+  lane_registry,
+  run_headless
+} from "./chunk-SYSRHRWU.js";
 import {
   timed_fetch
-} from "./chunk-5VNDSNG3.js";
+} from "./chunk-FZ6FUSBM.js";
 import "./chunk-CDY4NFQG.js";
 import {
-  hook_decision,
+  hook_decision
+} from "./chunk-KPM4YIIX.js";
+import {
+  time_density_hook,
+  time_hook_transcript,
+  time_reported_failure
+} from "./chunk-TLJYAGZK.js";
+import {
   lane_child_marker
-} from "./chunk-ZQGD4GBY.js";
+} from "./chunk-Z5TMJIPW.js";
 import {
+  backlog_budget,
+  issue_number_shape,
   json_value,
   process_identity,
   process_owner_schema,
-  time_density_hook,
-  time_hook_transcript,
-  time_reported_failure
-} from "./chunk-WK2XSHSI.js";
-import "./chunk-WPALEIRX.js";
-import "./chunk-RKUAD3I6.js";
+  run_carry,
+  run_invocation
+} from "./chunk-NZN2UFI6.js";
 import {
   PROJECT_ROOT,
   stamp_file
-} from "./chunk-ELCN5LCH.js";
+} from "./chunk-NEC4AT4Z.js";
 
 // scripts/hooks/stop-guard.ts
 import { text } from "node:stream/consumers";
@@ -74,6 +80,44 @@ async function josh_run(args, should_forward_stderr = false, timeout_ms) {
 }
 var josh_command = { josh_run };
 
+// scripts/lane/lane-limit-override.ts
+var STREAM_START = 0;
+async function carry_target() {
+  const repository = await run_carry.repository_directory();
+  return repository === void 0 ? void 0 : run_carry.carry_path(repository);
+}
+function live_carry(target) {
+  const read = run_carry.read_carry(target);
+  return read.kind === "carried" ? read.carry : void 0;
+}
+async function read_override() {
+  const target = await carry_target();
+  return target === void 0 ? void 0 : live_carry(target)?.lane_limit;
+}
+async function write_override(limit) {
+  const target = await carry_target();
+  const carry = target === void 0 ? void 0 : live_carry(target);
+  if (target === void 0 || carry === void 0) return false;
+  stamp_file.write_stamp(target, { ...carry, lane_limit: limit });
+  return true;
+}
+async function emit_raise(text2) {
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.LANE_LIMIT, text2);
+}
+function never_raised() {
+  return false;
+}
+async function watch_raise() {
+  const target = await run_event_stream_emit.stream_target();
+  if (target === void 0) return never_raised;
+  const start = run_event_stream.read_from(target, STREAM_START).next_position;
+  return function is_raised() {
+    const { events } = run_event_stream.read_from(target, start);
+    return events.some((event) => event.kind === run_event_stream.EVENT_KIND.LANE_LIMIT);
+  };
+}
+var lane_limit_override = { emit_raise, read_override, watch_raise, write_override };
+
 // scripts/lane/lane-seed.ts
 var FIRST_LANE_SEAT = 1;
 var LAST_LANE_SEAT = 9;
@@ -96,156 +140,31 @@ 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) {
+function read_limit(raw, name) {
   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: "problem", problem: `${name} must be a positive integer, not "${trimmed}"` };
   }
   return { kind: "limit", limit: Number(trimmed) };
 }
-function lane_limit(environment = process.env) {
-  return read_limit(environment[LANE_LIMIT_KEY]);
+async function lane_limit(environment = process.env, read_override2 = lane_limit_override.read_override) {
+  const override = await read_override2();
+  if (override !== void 0) return { kind: "limit", limit: override };
+  return read_limit(environment[LANE_LIMIT_KEY], LANE_LIMIT_KEY);
+}
+function seated_limit(limit) {
+  return Math.min(limit, lane_seed_policy.LAST_LANE_SEAT);
 }
 function free_lanes(limit, occupied) {
-  return Math.max(NO_LANES, Math.min(limit, lane_seed_policy.LAST_LANE_SEAT) - occupied);
+  return Math.max(NO_LANES, seated_limit(limit) - occupied);
 }
 var lane_capacity = {
   LANE_LIMIT_KEY,
+  free_lanes,
   lane_limit,
-  free_lanes
-};
-
-// 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 NUMBER_CONTINUATION = /^(?:\w|-[a-z])/iu;
-var CONTINUATION_WIDTH = 2;
-var GLUED_LEAD = /[&./]/u;
-var FENCE_MARKER = /^\s*(?:`{3,}|~{3,})/u;
-var QUOTE_LINE = /^\s*>/u;
-var PR_PREFIX = /\b(?:pr|pull request)\s*$/iu;
-var BACKTICK_PAIR = 2;
-function link_covers(link, index) {
-  const start = link.index ?? 0;
-  return index >= start && index < start + link[0].length;
-}
-function is_linked_at(line, index) {
-  for (const link of line.matchAll(MARKDOWN_LINK)) {
-    if (link_covers(link, index)) return true;
-  }
-  return false;
-}
-function lead_token(message2, hash_index) {
-  let start = hash_index;
-  while (start > 0 && !REFERENCE_BOUNDARY.test(message2.charAt(start - 1))) start -= 1;
-  return message2.slice(start, hash_index);
-}
-function repo_prefix(message2, hash_index) {
-  const token = lead_token(message2, hash_index);
-  return OWNER_REPO.test(token) ? token : "";
-}
-function is_inline_code_at(line, index) {
-  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 is_glued(line, reference) {
-  const end = reference.index + reference.text.length;
-  if (NUMBER_CONTINUATION.test(line.slice(end, end + CONTINUATION_WIDTH))) return true;
-  return reference.prefix === "" && GLUED_LEAD.test(lead_token(line, reference.index));
-}
-function line_references(line) {
-  const references = [];
-  for (const match of line.matchAll(ISSUE_NUMBER)) {
-    const reference = { index: match.index, prefix: repo_prefix(line, match.index), text: match[0] };
-    if (!is_glued(line, reference) && is_bare_at(line, match.index)) references.push(reference);
-  }
-  return references;
-}
-function collect_line_references(line, found) {
-  for (const reference of line_references(line)) found.push(`${reference.prefix}${reference.text}`);
-}
-function lines_outside_fences(message2) {
-  const lines = [];
-  let is_in_fence = false;
-  for (const line of message2.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(message2) {
-  return lines_outside_fences(message2).filter((line) => !QUOTE_LINE.test(line));
-}
-function bare_references(message2) {
-  const found = [];
-  for (const line of prose_lines(message2)) collect_line_references(line, found);
-  return [...new Set(found)];
-}
-function prompt_references(prompt) {
-  const found = /* @__PURE__ */ new Set();
-  for (const match of prompt.matchAll(ISSUE_NUMBER)) {
-    found.add(repo_prefix(prompt, match.index) + match[0]);
-  }
-  return found;
-}
-function unquoted_references(message2, prompt) {
-  const quoted = prompt_references(prompt);
-  return bare_references(message2).filter((reference) => !quoted.has(reference));
-}
-function has_bare_reference(message2) {
-  return bare_references(message2).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(message2, slug) {
-  const out = [];
-  let is_in_fence = false;
-  for (const line of message2.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,
-  unquoted_references
+  read_limit,
+  seated_limit
 };
 
 // scripts/epic/epic-triage.ts
@@ -260,7 +179,7 @@ function untriaged(children) {
   return children.filter((child) => !is_triaged(child));
 }
 function message(children, repo) {
-  const numbers = children.map((child) => `#${String(child.number)}`).join(", ");
+  const numbers = children.map((child) => issue_cite.plain(child.number)).join(", ");
   return issue_citation.linkify(
     `Untriaged: ${numbers} carry neither \`${RUN_SOLO_LABEL}\` nor \`${RUN_LANE_LABEL}\` in ${repo}, so nothing is offered until each is judged. Read each one, record its blocked-by order and one of the two labels with a comment saying why, then ask again.`,
     repo
@@ -300,9 +219,8 @@ 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));
+  return out.split("\n").map((token) => token.trim()).filter((token) => issue_number_shape.is_issue_number(token));
 }
 function count_ready_tokens(out) {
   return ready_tokens(out).length;
@@ -326,18 +244,20 @@ var backlog_stalled = {
 // scripts/backlog/backlog-ready.ts
 var NO_FREE = 0;
 var NONE2 = 0;
-async function free_under(limit) {
+async function live_lane_count() {
   const lanes = await lane_registry.list_lanes();
-  const live = lanes.filter((lane) => !lane.is_stranded).length;
-  return lane_capacity.free_lanes(limit, live);
+  return lanes.filter((lane) => !lane.is_stranded).length;
+}
+async function free_under(limit) {
+  return lane_capacity.free_lanes(limit, await live_lane_count());
 }
 async function free_lane_count() {
-  const limit = lane_capacity.lane_limit();
+  const limit = await lane_capacity.lane_limit();
   if (limit.kind !== "limit") return NO_FREE;
   return await free_under(limit.limit);
 }
 async function drive_free_lane_count() {
-  const limit = lane_capacity.lane_limit();
+  const limit = await lane_capacity.lane_limit();
   if (limit.kind !== "limit") throw new Error(limit.problem);
   return await free_under(limit.limit);
 }
@@ -391,6 +311,7 @@ var backlog_ready = {
   read_backlog_next,
   print_offer_hint,
   free_lane_count,
+  live_lane_count,
   drive_free_lane_count,
   drains_pool,
   print_ready_line,
@@ -437,7 +358,8 @@ var TASK_DEFINITIONS = {
   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" }
+  stranded: { icon: "\u{1F6A8}", label: "Run stranded \u2014 nobody is driving it" },
+  progress: { icon: "\u{1F4CA}", label: "Progress" }
 };
 var NOTIFY_SWITCH_KEY = "JOSH_NOTIFY";
 var NOTIFY_OFF_VALUE = "off";
@@ -622,8 +544,22 @@ async function stranded(input) {
     input.recovery
   );
 }
+async function progress(body) {
+  return await send_or_report(
+    {
+      task_type: "progress",
+      repo_name: gh_spawn.get_repo_name_with_owner_within(REPO_LOOKUP_TIMEOUT_MS),
+      issue_title: void 0,
+      body,
+      issue_url: void 0,
+      pr_url: void 0
+    },
+    "pnpm josh run:board --chat"
+  );
+}
 var telegram_notify = {
   confirm,
+  progress,
   send,
   send_or_report,
   stalled,
@@ -852,14 +788,14 @@ var stop_payload_schema = z3.object({
 });
 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. The workflow-commands skill \u2192 `working-tree-hold.md`: a stop that leaves the tree clean releases the hold with `pnpm josh run:release <N>` (bare for a `new` entry). A `halfrun` pre-commit stop and a `needs-human-review` stop keep the hold because their tree is dirty, and a `prrun` stop keeps it by its stop mark \u2014 this row is silent there. Release it, then end with a one-line confirmation that it was released \u2014 do not repeat your previous reply.";
+var HOLD_RELEASE_REASON = "\u26D4 working-tree hold not released: this working tree is clean but its `run:hold` record is still in place, so the next run here runs `pnpm josh ms` believing the tree is free while you hold it. The workflow-commands skill \u2192 `working-tree-hold.md`: a stop that leaves the tree clean releases the hold with `pnpm josh run:release <N>` (bare for a `new` entry). A `halfrun` pre-commit stop and a `needs-human-review` stop keep the hold because their tree is dirty, and a `prrun` stop keeps it by its stop mark \u2014 this row is silent there. Release it, then end with a one-line confirmation that it was released \u2014 do not repeat your previous reply.";
 var 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 (the workflow-commands skill \u2192 `observation-filing.md`). Run `pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2>` \u2014 it scouts, lints, labels and runs `epic:bundle` itself \u2014 then end with the one-line citation of what was filed; do not repeat your previous reply. If it is not worth filing after all, say so in one line instead.';
+var FILING_OFFER_REASON = '\u26D4 filing offer: your reply offers to file an Issue instead of filing it, and this run is unattended \u2014 nobody is there to answer. Filing into a first-party repository there is Tier A \u2014 the trigger is the judgement that it is worth filing, not the run\'s progress (the workflow-commands skill \u2192 `observation-filing.md`). Run `pnpm josh issue:file "<title>" --body-file <path> --depth <0|1|2>` \u2014 it scouts, lints, labels and runs `epic:bundle` itself \u2014 then end with the one-line citation of what was filed; do not repeat your previous reply. If it is not worth filing after all, say so in one line instead.';
 var HEADLESS_WAIT_MARKER = "\u26D4 headless parent:";
 var HEADLESS_REFUSAL_CAP = 3;
 var HEADLESS_WAIT_CALLS = ['"command":"pnpm josh lane:await'];
@@ -884,9 +820,12 @@ 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 is_unattended(context) {
+  return context.headless_agent || context.lane_child || context.backlog_parent;
+}
 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);
+  if (!is_unattended(context) || context.filed) return false;
+  return filing_offer.offers_filing(context.message) && filing_offer.is_first_party_target(context.message, context.session_owner);
 }
 function is_held_idle(context) {
   return context.hold_present && !context.agent_pending && !context.handed_off;
@@ -1050,9 +989,7 @@ var run_wake_schema = process_owner_schema.extend({
   started_at: z4.string(),
   woke: z4.number(),
   woke_at: z4.string().optional(),
-  // **Every optional field of `RunWake` has to be listed here.** `z.object` strips what it does not
-  // declare, so a field added to the interface alone round-trips through disk as `undefined` — which
-  // reads as "no attempt has been made yet" and would restart the retry count on every pass.
+  // Every optional `RunWake` field must be listed: `z.object` strips undeclared ones on the round trip.
   attempts: z4.number().optional(),
   woke_pid: z4.number().optional(),
   spawned: z4.array(z4.string()).optional(),
@@ -1090,11 +1027,7 @@ 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;
-  }
+  return json_value.parse_with(raw, run_wake_schema);
 }
 function read_wake(target) {
   const raw = stamp_file.read_stamp_text(target);
@@ -1125,11 +1058,7 @@ function carried_state(existing, invocation) {
     woke_at: existing.woke_at,
     attempts: existing.attempts,
     woke_pid: existing.woke_pid,
-    // **`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 }
   };
@@ -1322,6 +1251,14 @@ function was_filed(tail) {
 function session_lang() {
   return session_language.resolve_session_lang().lang;
 }
+async function session_role_facts() {
+  return {
+    headless_waiting: await run_headless.must_keep_waiting(),
+    lane_child: lane_child_marker.is_child_of(process.cwd()),
+    headless_agent: agent_headless.is_headless(),
+    backlog_parent: await run_headless.is_backlog_parent()
+  };
+}
 async function build_context(transcript_path, payload_tail) {
   const tail = transcript_tail(transcript_path);
   return {
@@ -1334,14 +1271,12 @@ async function build_context(transcript_path, payload_tail) {
     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(),
+    ...await session_role_facts(),
     headless_refusals: stop_rules.count_headless_refusals(tail),
-    lane_child: lane_child_marker.is_child_of(process.cwd()),
     background_pending: lane_background.pending_background_ids(tail).length > 0,
     agent_pending: lane_background.pending_agent_ids(tail).length > 0,
     handed_off: lane_handoff.is_handed_off(process.cwd()),
-    session_lang: session_lang(),
-    headless_agent: agent_headless.is_headless()
+    session_lang: session_lang()
   };
 }
 async function stop_outcome_for_payload(raw_payload) {