@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-ZIIUBGON.js

@@ -0,0 +1,773 @@
+import {
+  tail_commands
+} from "./chunk-77LEKVEE.js";
+import {
+  cost_cli,
+  cost_verdict
+} from "./chunk-JEYITIWB.js";
+import {
+  stop_decision
+} from "./chunk-3ZEO3KOM.js";
+import {
+  bash_triggers
+} from "./chunk-2BC33QPY.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  run_cut
+} from "./chunk-TFDVTU6O.js";
+import {
+  document_section
+} from "./chunk-NDWZTWXV.js";
+import {
+  time_reported_failure,
+  time_transcript_line
+} from "./chunk-YSLGWRQN.js";
+import {
+  cost_blocks,
+  time_josh_names,
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+import {
+  hook_decision
+} from "./chunk-GB2BRQVL.js";
+import {
+  repo_party
+} from "./chunk-DKDWOE3C.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  issue_citation
+} from "./chunk-22DVQCP6.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  find_package_directory
+} from "./chunk-LR22UK5W.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/rules/run-tail-rule.ts
+var SEGMENT_PREFIX = String.raw`(?:\(\s*)?(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*(?:npx\s+|pnpm\s+(?:exec\s+|run\s+)?)?`;
+var WORD_END = String.raw`(?=\s|$|\))`;
+var PUSH_STEP_SEGMENT = new RegExp(String.raw`^${SEGMENT_PREFIX}josh\s+(?:git|g)${WORD_END}`, "u");
+var CONFIRMED_FLAG = new RegExp(String.raw`(?:^|\s)(?:-y|--yes)${WORD_END}`, "u");
+var SKIPS_THE_PUSH = new RegExp(String.raw`(?:^|\s)--skip-push${WORD_END}`, "u");
+var BACKGROUND_KEY = "run_in_background";
+var QUOTED_SPAN = /"[^"]*"|'[^']*'/gu;
+function flags_of(segment) {
+  return segment.replaceAll(QUOTED_SPAN, " ");
+}
+function is_push_step_segment(segment) {
+  if (!PUSH_STEP_SEGMENT.test(segment)) return false;
+  const flags = flags_of(segment);
+  if (SKIPS_THE_PUSH.test(flags)) return false;
+  return CONFIRMED_FLAG.test(flags);
+}
+function is_push_step(command) {
+  return shell_segments.segments_of(command).some((segment) => is_push_step_segment(segment));
+}
+function is_backgrounded(input) {
+  if (!json_value.is_record(input)) return false;
+  return input[BACKGROUND_KEY] === true;
+}
+function is_push_step_call(call) {
+  if (call.name !== cost_blocks.BASH_TOOL) return false;
+  return is_push_step(time_shell.bash_command(call.input));
+}
+function is_backgrounded_push_step(call) {
+  if (!is_backgrounded(call.input)) return false;
+  return is_push_step_call(call);
+}
+function is_foreground_push_step(call) {
+  if (is_backgrounded(call.input)) return false;
+  return is_push_step_call(call);
+}
+function decide() {
+  return true;
+}
+var RUN_TAIL_REASON = "\u26D4 run tail: this issues the commit-push-PR step in the foreground, where the harness decides when to stop waiting. Reissue it with `run_in_background` set; when it exits, go straight on to `pnpm josh followup` in the foreground \u2014 the turn never ends at the push (`.claude/skills/workflow-commands/background-commands.md`). It fires on every foreground push, not once per run.";
+var ROW = {
+  id: "run-tail",
+  is_trigger: is_foreground_push_step,
+  reason: RUN_TAIL_REASON,
+  decide,
+  keeps: is_backgrounded_push_step,
+  reaches: is_push_step_call,
+  about: {
+    title: "Idle run tail",
+    topic: "`.claude/skills/workflow-commands/background-commands.md`",
+    fires: "`pnpm josh git -y` (`josh g`, `--yes` alike) issued in the **foreground**. Every occurrence",
+    quiet: "issued in the background \u2014 its completion resumes the run"
+  }
+};
+var run_tail_rule = {
+  ROW,
+  RUN_TAIL_REASON,
+  is_backgrounded_push_step,
+  is_foreground_push_step,
+  is_push_step,
+  is_push_step_call
+};
+
+// scripts/rules/lane-background.ts
+var FOREGROUND_COMMANDS = new Set(
+  ["ship", "ship:wait", "lane:plan"].map((name) => `${time_shell.JOSH_PREFIX}${name}`)
+);
+var LONG_RUNNING_COMMANDS = /* @__PURE__ */ new Set([
+  ...["gate", "git", "followup"].map((name) => `${time_shell.JOSH_PREFIX}${name}`),
+  ...FOREGROUND_COMMANDS
+]);
+var BACKGROUND_KEY2 = "run_in_background";
+var TIMEOUT_KEY = "timeout";
+var FOREGROUND_TIMEOUT_MS = 6e5;
+function is_backgrounded2(input) {
+  return json_value.is_record(input) && input[BACKGROUND_KEY2] === true;
+}
+function long_commands_of(command) {
+  return time_josh_names.josh_commands_of(command).filter((name) => LONG_RUNNING_COMMANDS.has(name));
+}
+function ships_alone(command) {
+  const names = long_commands_of(command);
+  return names.length > 0 && names.every((name) => FOREGROUND_COMMANDS.has(name));
+}
+function backgrounded_bash_command(call) {
+  if (call.name !== cost_blocks.BASH_TOOL || !is_backgrounded2(call.input)) return void 0;
+  return time_shell.bash_command(call.input);
+}
+function is_backgrounded_ship(call) {
+  const command = backgrounded_bash_command(call);
+  return command !== void 0 && ships_alone(command);
+}
+function is_candidate(call) {
+  if (run_tail_rule.is_push_step_call(call)) return true;
+  const command = backgrounded_bash_command(call);
+  if (command === void 0 || is_backgrounded_ship(call)) return false;
+  return long_commands_of(command).length > 0;
+}
+function is_background_long_run(call, is_lane_child) {
+  return is_candidate(call) && is_lane_child();
+}
+function ship_alone_input(call) {
+  if (call.name !== cost_blocks.BASH_TOOL || !json_value.is_record(call.input)) return void 0;
+  return ships_alone(time_shell.bash_command(call.input)) ? call.input : void 0;
+}
+function is_capped_foreground(input) {
+  const timeout = input[TIMEOUT_KEY];
+  return !is_backgrounded2(input) && typeof timeout === "number" && timeout >= FOREGROUND_TIMEOUT_MS;
+}
+function foreground_input(call, is_lane_child) {
+  const input = ship_alone_input(call);
+  if (input === void 0 || is_capped_foreground(input) || !is_lane_child()) return void 0;
+  return { ...input, [BACKGROUND_KEY2]: false, [TIMEOUT_KEY]: FOREGROUND_TIMEOUT_MS };
+}
+var FOREGROUND_NOTE = "lane background: a lane child's `josh ship`, `josh ship:wait` or `josh lane:plan` backgrounded, by its flag or by outrunning the Bash timeout, dies with the headless turn \u2014 so it was run in the foreground at the 600000 ms cap, where `ship` detaches itself after the preflight. Then follow `chain-rule.md` step 0 (`josh ship:wait` on its `pending`).";
+function apply_line(open, line, launched_ids) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed === void 0) return;
+  const launched = parsed.blocks.flatMap((block) => launched_ids(block));
+  for (const id of launched) open.add(id);
+  open.delete(parsed.finished_background);
+}
+function unfinished_ids(tail, launched_ids) {
+  const open = /* @__PURE__ */ new Set();
+  for (const line of tail.split("\n")) apply_line(open, line, launched_ids);
+  open.delete("");
+  return [...open];
+}
+function pending_background_ids(tail) {
+  return unfinished_ids(tail, (block) => [block.background_id, block.agent_id]);
+}
+function pending_agent_ids(tail) {
+  return unfinished_ids(tail, (block) => [block.agent_id]);
+}
+function pending_command_ids(tail) {
+  return unfinished_ids(tail, (block) => [block.background_id]);
+}
+var LANE_BACKGROUND_REASON = '\u26D4 lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless process whose background tasks die when the turn ends. Hand over to `pnpm josh ship --detach --review "<title> #<N>"`, issued in the foreground; on `launched` it runs `josh ship:wait` itself on `cost --cut` `under`. It fires on every occurrence (`.claude/skills/workflow-commands/chain-rule.md` step 0).';
+var LANE_BACKGROUND_STOP_REASON = "\u26D4 lane background stop: this is a dispatched lane child (`JOSH_LANE_CHILD`) and a background task it launched has not finished, and ending this turn kills it. Wait for it in the foreground, or re-issue the work through `pnpm josh ship --detach` \u2014 do not notify, stop or repeat your reply.";
+var LANE_AGENT_STOP_REASON = "\u26D4 lane agent stop: this is a dispatched lane child (`JOSH_LANE_CHILD`) and a subagent it launched has not finished; ending this turn kills it. Its completion notice arrives only when a tool call ends: wait with one short foreground call at a time (`sleep 20`) until it arrives \u2014 never a loop over its `.output`. Do not notify, stop or repeat your reply.";
+var ROW2 = {
+  id: "lane-background",
+  is_trigger: (call, context) => is_background_long_run(call, () => lane_child_marker.is_child_of(context.cwd, context.env)),
+  reason: LANE_BACKGROUND_REASON,
+  decide: () => true,
+  // `pretool-guard.ts` rewrites a lone `josh ship` to the foreground rather than refusing it; this is
+  // the note it attaches, so `rule-value.ts` counts that rewrite as this row's delivery.
+  rewrite_note: FOREGROUND_NOTE,
+  // The Stop hook delivers the same rule at the turn's end, for the background task or subagent the
+  // turn would kill.
+  stop_reasons: [LANE_BACKGROUND_STOP_REASON, LANE_AGENT_STOP_REASON],
+  about: {
+    title: "Lane child background push",
+    topic: "`.claude/skills/workflow-commands/background-commands.md`",
+    fires: "a dispatched lane child backgrounding `josh gate` / `git` / `followup` / `ship`; it hands over `pnpm josh ship --detach`; the Stop hook also blocks ending a turn with its background task or subagent unfinished. Every occurrence",
+    quiet: "not a lane child, or the foreground `ship --detach`"
+  }
+};
+var lane_background = {
+  FOREGROUND_NOTE,
+  LANE_AGENT_STOP_REASON,
+  LANE_BACKGROUND_REASON,
+  LANE_BACKGROUND_STOP_REASON,
+  ROW: ROW2,
+  foreground_input,
+  is_background_long_run,
+  pending_agent_ids,
+  pending_background_ids,
+  pending_command_ids
+};
+
+// scripts/rules/stop-rules.ts
+import { z } from "zod";
+
+// scripts/rules/concise-reply.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// scripts/rules/reply-prose.ts
+var CODE_PATTERNS = [
+  /```[\s\S]*?(?:```|$)/gu,
+  /`[^`\n]*`/gu,
+  /\]\([^)\s]*\)/gu,
+  /https?:\/\/\S+/gu
+];
+var ASCII_RUN_PATTERN = /[!-~]+/gu;
+var STRUCTURE_LINE_PATTERN = /^\s*(?:\||[-*+] |[・•] ?|\d+\. )/u;
+function prose_of(message) {
+  let text = message;
+  for (const pattern of CODE_PATTERNS) text = text.replaceAll(pattern, " ");
+  return text.replaceAll(ASCII_RUN_PATTERN, (run) => run.includes("/") ? " " : run);
+}
+function narrative_of(message) {
+  return prose_of(message).split("\n").filter((line) => !STRUCTURE_LINE_PATTERN.test(line)).join("\n");
+}
+var reply_prose = { narrative_of, prose_of };
+
+// scripts/rules/concise-reply.ts
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/rules/concise-reply.ts", __josh_meta.url).href;
+var __josh_source_filename = __josh_file_path(__josh_source_url);
+var __josh_source_dirname = __josh_dirname(__josh_source_filename);
+var PROSE_LIMIT = 400;
+var EXEMPT_WORDS = ["\u8A73\u3057\u304F", "\u5177\u4F53\u7684\u306B", "\u8A73\u7D30"];
+var COUNTED_PATTERN = /[\p{L}\p{N}]/gu;
+var PRINCIPLES_FILE = "prompts/collaboration-workflow/principles.md";
+var SECTION = "concise-reply";
+var PACKAGE_DIRECTORY = find_package_directory(path.dirname(fileURLToPath(__josh_source_url)));
+var REASON_OPENING = `\u26D4 concise reply: your reply's prose outside code, tables and lists is over the limit of \`${PRINCIPLES_FILE}\` \u2192 "${SECTION}"`;
+var KEEP_DECISION = " Keep its `Recommended:` / `Alternative:` lines as they are.";
+function prose_length(message) {
+  return reply_prose.narrative_of(message).match(COUNTED_PATTERN)?.length ?? 0;
+}
+function is_exempt(prompt) {
+  return EXEMPT_WORDS.some((word) => prompt.includes(word));
+}
+function is_over(message, prompt) {
+  if (prompt === void 0 || is_exempt(prompt)) return false;
+  return prose_length(message) > PROSE_LIMIT;
+}
+function section_text(root) {
+  const markdown = document_section.read_optional(path.join(root, PRINCIPLES_FILE));
+  return markdown === void 0 ? void 0 : document_section.section(markdown, SECTION)?.text;
+}
+function decision_note(message) {
+  return stop_decision.decision_of(message) === void 0 ? "" : KEEP_DECISION;
+}
+function build_reason(message, root = PACKAGE_DIRECTORY) {
+  const head = `${REASON_OPENING} (${String(prose_length(message))} of ${String(PROSE_LIMIT)}). Rewrite it shorter as that section says \u2014 do not repeat your previous reply.${decision_note(message)}`;
+  const body = section_text(root);
+  return body === void 0 ? head : `${head}
+
+${body}`;
+}
+var ROW3 = {
+  id: SECTION,
+  reason: REASON_OPENING,
+  about: {
+    title: "Concise reply",
+    topic: `\`principles.md\` \u2192 "${SECTION}"`,
+    entry: "pnpm josh stop:guard",
+    fires: `a reply whose narrative outside code, tables and lists is over ${String(PROSE_LIMIT)} letters. Blocks the stop`,
+    quiet: "a reply under the limit, a prompt asking for the detail (`\u8A73\u3057\u304F` / `\u5177\u4F53\u7684\u306B` / `\u8A73\u7D30`), a fixed output in a code block, no prompt of the person\u2019s on the transcript tail, or a headless session"
+  }
+};
+var concise_reply = {
+  EXEMPT_WORDS,
+  PROSE_LIMIT,
+  REASON_OPENING,
+  ROW: ROW3,
+  build_reason,
+  is_over,
+  prose_length
+};
+
+// 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 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 letter_count(text) {
+  return text.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 = reply_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 = { is_mismatch, script_of };
+
+// scripts/rules/stop-rules.ts
+var SWITCH_ENV_KEY = "JOSH_STOP_GUARD";
+var BLOCK_DECISION = "block";
+var stop_payload_schema = z.object({
+  transcript_path: z.string().min(1),
+  stop_hook_active: z.boolean().nullish(),
+  last_assistant_message: z.string().nullish()
+});
+var NO_OUTCOME = { reason: void 0, actions: [], blocks_on_failure: false };
+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. Send `pnpm josh notify --task-type confirmation --issue-url "<url>" --body=$\'<reason>\' --recommended "<choice>" --alternative "<choice>"` (`rule-delivery.md` \u2192 "stop-notify"), then confirm in one line that it was sent \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. Release it with `pnpm josh run:release <N>` (bare for a `new` entry; `working-tree-hold.md`), then confirm in one line that it was released \u2014 do not repeat your previous reply.";
+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. Run `pnpm josh issue:file "<title>" --body-file <path>` (Tier A, `observation-filing.md`), 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'];
+var HEADLESS_WAIT_BODY = " this is a `claude -p` `backlogrun` parent with lanes in flight, and ending this turn kills the process and its background waits. Hand the loop back with `pnpm josh run:carry --cut` (or `--end` when the run is over), then end the turn (`backlogrun-progress.md`).";
+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. That is Tier A here (`chain-rule.md`): remove any conflict markers, run `pnpm josh git -y` (it stages and commits, a conflicted merge included) 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 concise_reason(context) {
+  if (!concise_reply.is_over(context.message, context.prompt)) return void 0;
+  return concise_reply.build_reason(context.message);
+}
+function is_unattended(context) {
+  return context.headless_agent || context.lane_child || context.backlog_parent;
+}
+function needs_filing(context) {
+  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) {
+  if (context.hold_issue === void 0 || !context.hold_owned) return false;
+  return !context.agent_pending && !context.handed_off;
+}
+function needs_notify(context) {
+  return is_held_idle(context) && !context.notified && !context.answers_question;
+}
+function needs_decision(context) {
+  return needs_notify(context) && stop_decision.decision_of(context.message) === void 0;
+}
+function needs_release(context) {
+  return is_held_idle(context) && context.tree_clean && !context.prrun_stopped;
+}
+function reply_reason(context) {
+  if (needs_filing(context)) return FILING_OFFER_REASON;
+  if (context.headless_agent) return void 0;
+  return language_reason(context) ?? concise_reason(context);
+}
+function decision_reason(context) {
+  return needs_decision(context) ? stop_decision.DECISION_REASON : void 0;
+}
+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 needs_background_wait(context) {
+  return context.lane_child && context.background_pending;
+}
+function background_wait_reason(context) {
+  if (context.command_pending) return lane_background.LANE_BACKGROUND_STOP_REASON;
+  return lane_background.LANE_AGENT_STOP_REASON;
+}
+function lane_reason(context) {
+  if (needs_index_route(context)) return LANE_INDEX_REASON;
+  if (needs_background_wait(context)) return background_wait_reason(context);
+  return void 0;
+}
+function model_reason(context) {
+  const lane = lane_reason(context);
+  if (lane !== void 0) return lane;
+  const reasons = [reply_reason(context), decision_reason(context)].filter(
+    (reason) => reason !== void 0
+  );
+  return reasons.length === 0 ? void 0 : reasons.join("\n\n");
+}
+function notify_actions(context, issue) {
+  const decision = stop_decision.decision_of(context.message);
+  if (decision === void 0 || !needs_notify(context)) return [];
+  return [{ kind: "notify", issue, message: context.message, decision }];
+}
+function hold_actions(context) {
+  const issue = context.hold_issue;
+  if (issue === void 0) return [];
+  const notify = notify_actions(context, issue);
+  return needs_release(context) ? [...notify, { kind: "release", issue }] : notify;
+}
+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 model_reason(context);
+}
+function runs_actions(context, reason) {
+  return reason === void 0 && !context.cut_pending && lane_reason(context) === void 0;
+}
+function stop_outcome(context) {
+  const reason = block_reason(context);
+  if (!runs_actions(context, reason)) return { ...NO_OUTCOME, reason };
+  const actions = hold_actions(context);
+  if (actions.length === 0) return NO_OUTCOME;
+  return { reason, actions, blocks_on_failure: !context.stop_hook_active };
+}
+function fallback_reason(action) {
+  return action.kind === "notify" ? STOP_NOTIFY_REASON : HOLD_RELEASE_REASON;
+}
+function block_envelope(reason, lang, notice) {
+  const refusal = { decision: BLOCK_DECISION, reason: `${reason} ${language_note(lang)}` };
+  return JSON.stringify(notice === void 0 ? refusal : { ...refusal, systemMessage: notice });
+}
+function notice_envelope(notice) {
+  return JSON.stringify({ systemMessage: notice });
+}
+function parse_stop_payload(raw_payload) {
+  return json_value.parse_with(raw_payload, stop_payload_schema);
+}
+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,
+  LANE_INDEX_REASON,
+  NO_OUTCOME,
+  STOP_NOTIFY_REASON,
+  SWITCH_ENV_KEY,
+  block_envelope,
+  build_language_reason,
+  count_headless_refusals,
+  fallback_reason,
+  is_enabled,
+  notice_envelope,
+  parse_stop_payload,
+  stop_outcome
+};
+
+// scripts/rules/pre-gate-cut.ts
+var GATE_COMMANDS = /* @__PURE__ */ new Set(["gate"]);
+var CUT_COMMANDS = /* @__PURE__ */ new Set(["run:cut"]);
+var CUT_MODE_FLAG = /(?:^|\s)--(?:resume|end|json)(?:[=\s]|$)/u;
+var HOLD_COMMANDS = /* @__PURE__ */ new Set(["run:hold"]);
+var HOLD_MODE_FLAG = /(?:^|\s)--release(?:[=\s]|$)/u;
+function invokes_josh(command, names, mode_flag) {
+  return shell_segments.segments_of(command).some(
+    (segment) => shell_segments.is_josh_command(segment, names) && mode_flag?.test(segment) !== true
+  );
+}
+function runs_the_gate(command) {
+  return invokes_josh(command, GATE_COMMANDS);
+}
+function takes_the_cut(command) {
+  return invokes_josh(command, CUT_COMMANDS, CUT_MODE_FLAG);
+}
+function claims_the_hold(command) {
+  return invokes_josh(command, HOLD_COMMANDS, HOLD_MODE_FLAG);
+}
+function asks_about_the_cut(command) {
+  return invokes_josh(command, CUT_COMMANDS);
+}
+function current_state(context) {
+  return {
+    directory: context.cwd,
+    carried: (now) => run_cut.carried_cut_sync(now, run_cut.worktree_git_directory_sync(context.cwd)),
+    marked_issue: lane_child_marker.marked_issue(context.env),
+    is_reviewer: agent_session_role.is_reviewer(context.env),
+    context_verdict: () => cost_cli.session_verdict(context.cwd, context.env)
+  };
+}
+function dispatched_issue(state) {
+  return state.is_reviewer ? void 0 : state.marked_issue;
+}
+function uncut_lane_issue(state) {
+  const issue = lane_paths.lane_issue_of(state.directory);
+  if (issue === void 0 || dispatched_issue(state) !== issue) return void 0;
+  return state.carried()?.issue === issue ? void 0 : issue;
+}
+function warrants_the_cut(verdict) {
+  return verdict === cost_verdict.OVER_VERDICT;
+}
+function is_uncut_gate(command, state) {
+  if (!runs_the_gate(command) || uncut_lane_issue(state) === void 0) return false;
+  return warrants_the_cut(state.context_verdict());
+}
+function is_uncut_gate_in(command, context) {
+  return is_uncut_gate(command, current_state(context));
+}
+var PRE_GATE_CUT_REASON = "\u26D4 pre-gate cut: this checkout is a lane dispatched for this issue and the gate is the boundary to cut at. Issue `pnpm josh run:cut <N>`: on `cut`, end the turn immediately \u2014 no Telegram is owed; on any other verdict (`not-a-lane`, `busy`, \u2026), reissue the gate \u2014 this fires once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
+function reaches_the_pre_gate_boundary(call, _turn, run) {
+  if (!bash_triggers.on_bash_command(asks_about_the_cut)(call)) return false;
+  return run.some((issued) => bash_triggers.on_bash_command(claims_the_hold)(issued));
+}
+var pre_gate_cut = {
+  PRE_GATE_CUT_REASON,
+  asks_about_the_cut,
+  claims_the_hold,
+  is_uncut_gate,
+  is_uncut_gate_in,
+  reaches_the_pre_gate_boundary,
+  runs_the_gate,
+  takes_the_cut,
+  uncut_lane_issue
+};
+
+// scripts/rules/turn-filings.ts
+function is_filing_use(block) {
+  if (!tail_commands.is_bash_use(block)) return false;
+  return bash_triggers.is_issue_filing(time_shell.bash_command(block.input));
+}
+function collect_block(block, found) {
+  if (block.result_id !== "" && block.is_error === true) found.failures.add(block.result_id);
+  if (is_filing_use(block)) found.filing_ids.push(block.id);
+}
+function collect_line(line, found) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed === void 0) return;
+  for (const block of parsed.blocks) collect_block(block, found);
+}
+function scan_tail(tail) {
+  const found = { filing_ids: [], failures: /* @__PURE__ */ new Set() };
+  for (const line of tail.split("\n")) collect_line(line, found);
+  return found;
+}
+function filing_count(tail) {
+  const { filing_ids, failures } = scan_tail(tail);
+  return filing_ids.filter((id) => !failures.has(id)).length;
+}
+function is_prompt_line(line) {
+  const parsed = time_transcript_line.parse_line(line);
+  if (parsed?.type !== "user") return false;
+  return parsed.blocks.every((block) => block.result_id === "");
+}
+function current_turn(tail) {
+  const lines = tail.split("\n");
+  const start = lines.findLastIndex((line) => is_prompt_line(line));
+  return lines.slice(Math.max(start, 0)).join("\n");
+}
+function turn_filing_count(tail) {
+  return filing_count(current_turn(tail));
+}
+var turn_filings = {
+  current_turn,
+  filing_count,
+  is_prompt_line,
+  turn_filing_count
+};
+
+// scripts/rules/last-prompt.ts
+import { z as z3 } from "zod";
+
+// scripts/rules/codex-prompt.ts
+import { z as z2 } from "zod";
+var content_schema = z2.array(
+  z2.object({
+    type: z2.string(),
+    text: z2.string().optional()
+  })
+);
+var provenance_schema = z2.object({ provenance: z2.object({ type: z2.string() }) });
+var metadata_schema = z2.object({ content_item_metadata: z2.array(provenance_schema) });
+var payload_schema = z2.object({
+  type: z2.literal("message"),
+  role: z2.enum(["user", "assistant"]),
+  content: content_schema,
+  internal_chat_message_metadata_passthrough: metadata_schema.optional()
+});
+var record_schema = z2.object({
+  type: z2.literal("response_item"),
+  timestamp: z2.string(),
+  payload: payload_schema
+});
+function content_text(block) {
+  if (block.type !== "input_text" && block.type !== "output_text") return "";
+  return block.text ?? "";
+}
+function person_content(payload) {
+  const metadata = payload.internal_chat_message_metadata_passthrough?.content_item_metadata;
+  if (metadata?.length !== payload.content.length) return void 0;
+  const authored = payload.content.filter((_block, index) => metadata[index]?.provenance.type === "user").map((block) => content_text(block));
+  return authored.length === 0 ? void 0 : authored.join("\n");
+}
+function normalize(line) {
+  const record = json_value.parse_with(line, record_schema);
+  if (record === void 0) return line;
+  const { payload, timestamp } = record;
+  const content = payload.role === "user" ? person_content(payload) : payload.content.map((block) => content_text(block)).join("\n");
+  return JSON.stringify({
+    type: payload.role,
+    timestamp,
+    ...content === void 0 && { origin: { kind: "harness" } },
+    message: { content: content ?? "" }
+  });
+}
+var codex_prompt = { normalize };
+
+// scripts/rules/last-prompt.ts
+var NO_PROMPT = "";
+var HUMAN_ORIGIN = "human";
+var PROMPT_LINE_SCHEMA = z3.object({
+  isMeta: z3.boolean().nullish(),
+  timestamp: z3.string().nullish(),
+  origin: z3.object({ kind: z3.string().nullish() }).nullish(),
+  message: z3.object({ content: z3.unknown() })
+});
+var TIMED_LINE_SCHEMA = z3.object({ timestamp: z3.string() });
+function is_person(line) {
+  if (line.isMeta === true) return false;
+  return line.origin === null || line.origin === void 0 || line.origin.kind === HUMAN_ORIGIN;
+}
+function person_line(line) {
+  const normalized = codex_prompt.normalize(line);
+  if (!turn_filings.is_prompt_line(normalized)) return void 0;
+  const parsed = PROMPT_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(normalized));
+  return parsed.success && is_person(parsed.data) ? parsed.data : void 0;
+}
+function person_text(line) {
+  const person = person_line(line);
+  if (person === void 0) return void 0;
+  return time_reported_failure.result_text(person.message.content);
+}
+function turn_prompt(tail) {
+  const opener = tail.split("\n").map((line) => codex_prompt.normalize(line)).findLast((line) => turn_filings.is_prompt_line(line));
+  if (opener === void 0) return NO_PROMPT;
+  return person_text(opener) ?? NO_PROMPT;
+}
+function person_prompt(tail) {
+  return tail.split("\n").map((line) => person_text(line)).findLast((text) => text !== void 0);
+}
+function prompt_time(tail) {
+  return tail.split("\n").map((line) => person_line(line)?.timestamp ?? void 0).findLast((time) => time !== void 0);
+}
+function tail_time(tail) {
+  return tail.split("\n").map((line) => TIMED_LINE_SCHEMA.safeParse(json_value.parse_or_undefined(line)).data?.timestamp).find((time) => time !== void 0);
+}
+function pause_start(tail) {
+  return prompt_time(tail) ?? tail_time(tail);
+}
+var last_prompt = { pause_start, person_prompt, turn_prompt };
+
+export {
+  concise_reply,
+  run_tail_rule,
+  lane_background,
+  stop_rules,
+  pre_gate_cut,
+  codex_prompt,
+  turn_filings,
+  last_prompt
+};