@joshuafolkken/kit 1.1455.0 → 1.1471.0

package/dist/hooks/batch-guard.js

@@ -9,12 +9,12 @@ import {
   load_environment_file,
   notice_refusal_path,
   refusal_path
-} from "./chunk-5H4SSDSD.js";
-import "./chunk-UT7YC3N2.js";
-import "./chunk-GPLGZ6IC.js";
-import "./chunk-LIAFCXL7.js";
-import "./chunk-OLMO72ON.js";
-import "./chunk-3C4XRYG6.js";
+} from "./chunk-YHBZAJSV.js";
+import "./chunk-SHGPANFB.js";
+import "./chunk-J47HU5H5.js";
+import "./chunk-AS74OU3D.js";
+import "./chunk-K4EOONYM.js";
+import "./chunk-E7OIKX5Z.js";
 import "./chunk-DGT54IH5.js";
 export {
   DISABLED_VALUES,

package/dist/hooks/{chunk-7WQBPLUN.js → chunk-43ZHT22P.js}

@@ -8,7 +8,7 @@ import {
   repo_origin,
   run_event_stream,
   run_event_stream_emit
-} from "./chunk-Z4XI7CZS.js";
+} from "./chunk-EUMACUK2.js";
 import {
   error_text
 } from "./chunk-CDY4NFQG.js";
@@ -30,10 +30,10 @@ import {
   time_density_hook,
   time_shell,
   time_transcript_line
-} from "./chunk-LIAFCXL7.js";
+} from "./chunk-AS74OU3D.js";
 import {
   lane_child_marker
-} from "./chunk-OLMO72ON.js";
+} from "./chunk-K4EOONYM.js";
 import {
   agent_session_environment,
   backlog_budget,
@@ -42,7 +42,7 @@ import {
   has_timed_out,
   json_value,
   process_identity
-} from "./chunk-3C4XRYG6.js";
+} from "./chunk-E7OIKX5Z.js";
 import {
   COMMAND_TIMEOUT_MS,
   PROJECT_ROOT,
@@ -86,9 +86,13 @@ var bounded_pool = { bounded_map, pool_width };
 
 // scripts/rules/shell-segments.ts
 var SEGMENT_SEPARATOR = /&&|\|\||;|\n/u;
+var SEGMENT_PARTS = new RegExp(`(${SEGMENT_SEPARATOR.source})`, "u");
 function segments_of(command) {
   return command.split(SEGMENT_SEPARATOR).map((segment) => segment.trim());
 }
+function parts_of(command) {
+  return command.split(SEGMENT_PARTS);
+}
 function is_josh_command(segment, names) {
   const named = time_shell.josh_command_of(segment);
   if (!named.startsWith(time_shell.JOSH_PREFIX)) return false;
@@ -96,6 +100,7 @@ function is_josh_command(segment, names) {
 }
 var shell_segments = {
   is_josh_command,
+  parts_of,
   segments_of
 };
 
@@ -174,7 +179,7 @@ function turn_filing_count(tail) {
 function decide(_call, run) {
   return prior_filing_count(time_density_hook.read_tail(run.transcript)) >= CAP_REACHED;
 }
-var FILING_CAP_REASON = `\u26D4 filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling \u2014 on reaching it, stop and report rather than filing more. Automatic filing is capped so a run cannot manufacture Issues faster than they can be closed (\`.claude/skills/workflow-commands/SKILL.md\` \u2192 \`prerequisite.md\`, \`observation-filing.md\`). A further Issue that genuinely must exist is a person's call, not this run's. **This rule fires on every filing past the cap, not once per run**, so reissuing the same filing will be refused again.`;
+var FILING_CAP_REASON = `\u26D4 filing cap: this run has already filed ${String(FILING_CAP)} Issues, the per-run ceiling. Stop filing and report; a further Issue is a person's call. It fires on every occurrence (\`.claude/skills/workflow-commands/observation-filing.md\`).`;
 var ROW = {
   id: "filing-cap",
   is_trigger: bash_triggers.on_bash_command(bash_triggers.is_issue_filing),
@@ -394,9 +399,11 @@ function parse_hold(raw) {
 function is_expired(hold, now) {
   return stamp_record.is_older_than(hold.taken_at, HOLD_MAX_AGE_MS, now);
 }
+function is_stop_marked(hold) {
+  return hold.is_halfrun_stop === true || hold.prrun_stop_head !== void 0;
+}
 function is_owner_gone(hold) {
-  const is_stop_mark = hold.is_halfrun_stop === true || hold.prrun_stop_head !== void 0;
-  if (is_stop_mark || hold.owner_pid === void 0) return false;
+  if (is_stop_marked(hold) || hold.owner_pid === void 0) return false;
   return process_identity.is_same_process(hold.owner_pid, hold.owner_start) === false;
 }
 function is_stale(hold, now) {
@@ -486,6 +493,7 @@ function unknown_message() {
   return `Could not read this working tree's git directory \u2014 ${NOT_IDLE}. Run this from inside the checkout the run will edit.`;
 }
 var run_hold = {
+  is_stop_marked,
   FORCE_RELEASE_COMMAND,
   HOLD_MAX_AGE_HOURS,
   HOLD_MAX_AGE_MS,
@@ -872,7 +880,13 @@ async function current_state() {
   const branch = await git_command.branch();
   const is_dirty = await run_hold.is_tree_dirty();
   const hold = hold_of(await worktree_directory2());
-  return { branch, is_dirty, is_held: hold !== void 0, held_issue: fullrun_issue(hold) };
+  return {
+    branch,
+    is_dirty,
+    is_held: hold !== void 0,
+    held_issue: fullrun_issue(hold),
+    hold_taken_at: hold?.taken_at
+  };
 }
 function describe_cut(cut) {
   return `${cut.invocation} cut at ${cut.cut_at} on ${cut.branch} (${cut.phase})`;
@@ -918,6 +932,7 @@ var run_cut = {
   handed_off_message,
   has_required_handoff,
   held_issue_sync,
+  hold_of,
   incomplete_message,
   invocation_for,
   is_expired: is_expired2,
@@ -974,7 +989,7 @@ function is_foreground_push_step(call) {
 function decide2() {
   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. In `fullrun #1501` this call was given a 900-second timeout, the harness detached it at its own 600-second cap, and nothing read the output for a further 6m28s \u2014 45m03s of wall clock on about 17 minutes of work (joshuafolkken/kit#1510). **Never give a foreground call a timeout above the harness cap**: the cap decides, not the number. A backgrounded call re-invokes you when it exits, so the completion notification is what resumes the run. **When it arrives, the turn that reads it goes straight through any branch-2 filing and `pnpm josh epic:bundle` to `pnpm josh followup` \u2014 the turn never ends at the push.** CI went green 6m06s before the merge started in that run, and it started only because the person asked; joshuafolkken/kit#1333 had already settled that the merge is issued in the turn the review closes. While the push runs, do the work that writes nothing \u2014 drafting the completion body to a file, deciding the branch-2 disposition. `pnpm josh followup` itself stays in the **foreground** \u2014 nearly every step after it reads its result. But a tail does follow the merge, measured at 3.0 min and 5.9% of a run (joshuafolkken/kit#1462), so empty it beforehand: the steps that read the merge result stay after `followup`, and the rest are composed in the turn that issues it, bar the one exception background-commands.md names. The procedure is `.claude/skills/workflow-commands/background-commands.md`, "A command that can take minutes is issued in the background". **This rule fires on every foreground push, not once per run**, so reissuing the same call in the foreground will be refused again.';
+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 run_tail_rule = {
   RUN_TAIL_REASON,
   decide: decide2,
@@ -1021,11 +1036,12 @@ function is_background_long_run(call, is_lane_child = () => lane_child_marker.is
   return is_candidate(call) && is_lane_child();
 }
 function foreground_input(call, is_lane_child = () => lane_child_marker.is_child_of(process.cwd())) {
-  if (!is_backgrounded_ship(call) || !json_value.is_record(call.input)) return void 0;
-  if (!is_lane_child()) return void 0;
+  if (!is_backgrounded_ship(call) || !json_value.is_record(call.input) || !is_lane_child()) {
+    return void 0;
+  }
   return { ...call.input, [BACKGROUND_KEY2]: false, [TIMEOUT_KEY]: FOREGROUND_TIMEOUT_MS };
 }
-var FOREGROUND_NOTE = "lane background: this lane child backgrounded `josh ship`, which would die with the headless turn before its supervisor exists \u2014 so it was run in the foreground instead, where it detaches itself after the preflight. End the turn on `launched` / `busy` (joshuafolkken/kit#3154).";
+var FOREGROUND_NOTE = "lane background: this lane child backgrounded `josh ship`, which would die with the headless turn before its supervisor exists \u2014 so it was run in the foreground instead, where it detaches itself after the preflight. End the turn on `launched` / `busy`.";
 function unfinished_ids(tail, launched_ids) {
   const lines = tail.split("\n").map((line) => time_transcript_line.parse_line(line));
   const finished = new Set(lines.map((line) => line?.finished_background ?? ""));
@@ -1039,8 +1055,8 @@ function pending_background_ids(tail) {
 function pending_agent_ids(tail) {
   return unfinished_ids(tail, (block) => [block.agent_id]);
 }
-var LANE_BACKGROUND_REASON = '\u26D4 lane background: this session is a dispatched lane child (`JOSH_LANE_CHILD`), a headless `claude -p` process whose background Bash tasks are killed when the turn ends \u2014 so a backgrounded `josh gate` / `josh git` / `josh followup` / `josh ship` never re-invokes you; it dies at `exit code 143` (joshuafolkken/kit#2704, measured on the #2606 child: implementation, review and live verification done, the run parked instead of merged). Hand the gate-to-merge region to the detached supervisor instead: `pnpm josh ship --detach --review "<title> #<N>"` (add `--cite <N>`) issued in the foreground \u2014 its preflight runs in this process before the supervisor exists, so a backgrounded `ship` dies with the turn (joshuafolkken/kit#3027; a backgrounded `ship` issued alone is moved to the foreground for you, joshuafolkken/kit#3154) \u2014 then end the turn on `launched` / `busy`. `.claude/skills/workflow-commands/chain-rule.md` step 0 is the single source. A single check you must read before continuing runs in the foreground within the tool timeout; the commit-push step does not \u2014 in a child it too belongs to the detached ship, in either spelling. This rule fires on every occurrence, not once per run.';
-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 \u2014 ending this headless turn kills it, and nothing re-invokes you afterwards (joshuafolkken/kit#2704). Do not send a notification and do not stop: wait for the task in the foreground and act on its result, or re-issue the work through `pnpm josh ship --detach`, whose supervisor outlives the turn (`.claude/skills/workflow-commands/chain-rule.md` step 0). Do not repeat your previous reply.";
+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, then end the turn on `launched` / `busy`. 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 ROW2 = {
   id: "lane-background",
   is_trigger: (call) => is_background_long_run(call),
@@ -1484,7 +1500,7 @@ var APPLIES_NEEDS_DECISION = new RegExp(
 function records_the_park(command) {
   return APPLIES_NEEDS_DECISION.test(command);
 }
-var LANE_PARK_REASON = '\u26D4 lane child park: this session is a dispatched lane child, and a stop that waits on a person must leave the question on the Issue before it sends this Telegram \u2014 otherwise the parent finds an OPEN Issue with `in-progress` and no question, and a person cannot tell what to answer (joshuafolkken/kit#2034 measured this twice in one run). The child is the only process that knows the question, the options and whether it stashed, so it records the park itself rather than leaving the parent to guess from a log. Before you notify and stop: apply `needs-decision` and post a comment carrying the question, the options, and whether work was stashed \u2014 `gh api repos/{owner}/{repo}/issues/<N>/labels -f \'labels[]=needs-decision\'` then `pnpm josh issue:comment <N> --body-file <path>`. If this stop is a `needs-human-review` or `already-done` one, that label is already on the Issue and there is nothing to add. Then reissue this notify \u2014 it fires once per run and cannot repeat on the call in hand. The procedure is `.claude/skills/workflow-commands/pre-gate-cut.md` \u2192 "A lane child records its park before it stops", and the park itself is `backlogrun-park.md` \u2192 "park and continue".';
+var LANE_PARK_REASON = "\u26D4 lane child park: this session is a dispatched lane child, so a stop for a person parks first: `gh api repos/{owner}/{repo}/issues/<N>/labels -f 'labels[]=needs-decision'`; `pnpm josh issue:comment <N> --body-file <path>` (question, options, stash); a `needs-human-review` / `already-done` stop already is. Reissue this notify, once per run (`.claude/skills/workflow-commands/pre-gate-cut.md`).";
 var ROW3 = {
   id: "lane-park",
   is_trigger: bash_triggers.on_bash_command(is_unparked_stop),

package/dist/hooks/{chunk-LIAFCXL7.js → chunk-AS74OU3D.js}

@@ -6,7 +6,7 @@ import {
   process_owner_schema,
   run_carry,
   time_instant
-} from "./chunk-3C4XRYG6.js";
+} from "./chunk-E7OIKX5Z.js";
 import {
   PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
@@ -862,8 +862,9 @@ function is_worker_flag(argument) {
   return WORKER_FLAGS.some((flag) => argument === flag || argument.startsWith(`${flag}=`));
 }
 function worker_arguments(vitest_arguments, share) {
-  if (share === void 0) return [];
-  if (vitest_arguments.some((argument) => is_worker_flag(argument))) return [];
+  if (share === void 0 || vitest_arguments.some((argument) => is_worker_flag(argument))) {
+    return [];
+  }
   return [`${WORKER_FLAG}=${String(share)}`];
 }
 function mark_run_started(target2) {
@@ -2345,6 +2346,10 @@ function without_heredoc_bodies(command) {
 function unquoted(command) {
   return without_heredoc_bodies(command).replaceAll(QUOTED_SPAN_PATTERN, " ");
 }
+function blanked(command) {
+  if (HEREDOC_MARKER.test(command)) return void 0;
+  return command.replaceAll(QUOTED_SPAN_PATTERN, (span) => " ".repeat(span.length));
+}
 function discarded_commands(command) {
   const plain = unquoted(command);
   if (PIPEFAIL_PATTERN.test(plain)) return [];
@@ -2392,6 +2397,7 @@ var time_shell = {
   JOSH_PREFIX,
   bash_command,
   bash_label,
+  blanked,
   command_segment,
   discarded_commands,
   josh_arguments,
@@ -2776,13 +2782,22 @@ var gate_schema = z4.object({
   // whichever was higher. Absent when the machine could not be read.
   external_cores: z4.number().optional()
 });
+var process_kind_schema = z4.object({
+  kind: z4.string(),
+  cpu_percent: z4.number(),
+  rss_mb: z4.number(),
+  count: z4.number()
+});
 var load_schema = z4.object({
   kind: z4.literal(KIND.LOAD),
   at: z4.string(),
   load: z4.number(),
   available_mb: z4.number().optional(),
   swapped_mb: z4.number().optional(),
-  lanes: z4.number().optional()
+  lanes: z4.number().optional(),
+  // The heaviest process kinds at the instant of the sample (`lane-process-load.ts`), so the load the
+  // core budget's ledger does not explain can be read back by what made it (joshuafolkken/kit#3874).
+  processes: z4.array(process_kind_schema).optional()
 });
 var dispatch_schema = z4.object({
   kind: z4.literal(KIND.DISPATCH),
@@ -4345,7 +4360,7 @@ var NAMED_CANDIDATE_COUNT = 3;
 var SEQUENCE_BEFORE_LIMIT = CONSECUTIVE_LIMIT - ONE_TURN;
 var RULE_POINTER = "`prompts/collaboration-workflow/turn-batching.md`";
 var STREAK = `${String(CONSECUTIVE_LIMIT)} single-call turns in a row`;
-var REASON = `\u26D4 batching: ${STREAK}. Reissue this with the calls that do not need its result \u2014 the test is whether a call's input needs another call's result, not what kind of call it is (edits are covered exactly as reads), and it never authorizes weakening a verification gate or a review. Already batching, or nothing to pair? Reissue it unchanged; this fires once per streak. ${RULE_POINTER}`;
+var REASON = `\u26D4 batching: ${STREAK}. Reissue this with the calls that do not need its result \u2014 the test is whether a call's input needs another call's result, not what kind of call it is (edits are covered exactly as reads); it never authorizes weakening a verification gate or a review. Nothing to pair? Reissue it unchanged. ${RULE_POINTER}`;
 var NOTICE = `\u{1F4A1} batching: ${STREAK}; the Write proceeds. Issue the writes that do not need its result in one turn, never by weakening a gate or a review. ${RULE_POINTER}`;
 var LANE_NOTICE = `\u{1F4A1} batching: ${STREAK}; the call proceeds. Pair independent calls. ${RULE_POINTER}`;
 var WHOLE_FILE_WRITE_TOOL = "Write";
@@ -4485,8 +4500,9 @@ function fork_path(transcript_path, agent_id) {
   return path3.join(cost_transcript.unit_directory(directory, session_id), file_name);
 }
 function transcript_of(transcript_path, agent_id) {
-  if (!is_agent_id(agent_id)) return transcript_path;
-  if (!transcript_path.endsWith(TRANSCRIPT_EXTENSION)) return transcript_path;
+  if (!is_agent_id(agent_id) || !transcript_path.endsWith(TRANSCRIPT_EXTENSION)) {
+    return transcript_path;
+  }
   return fork_path(transcript_path, agent_id);
 }
 var time_hook_transcript = {

package/dist/hooks/{chunk-3C4XRYG6.js → chunk-E7OIKX5Z.js}

@@ -51,8 +51,7 @@ import { execa as execa3 } from "execa";
 
 // scripts/git/git-execa-error.ts
 function get_exit_code(error) {
-  if (typeof error !== "object" || error === null) return void 0;
-  if (!("exitCode" in error)) return void 0;
+  if (typeof error !== "object" || error === null || !("exitCode" in error)) return void 0;
   const { exitCode: exit_code } = error;
   return typeof exit_code === "number" ? exit_code : void 0;
 }
@@ -207,16 +206,18 @@ var git_spawn = {
 var REFS_REMOTES_ORIGIN_PREFIX = "refs/remotes/origin/";
 var NAME_ONLY_FLAG = "--name-only";
 var DEFAULT_BRANCH_FALLBACK = "main";
+var DEFAULT_BRANCH_ARGUMENTS = ["symbolic-ref", "refs/remotes/origin/HEAD"];
+function default_branch_of(output) {
+  const trimmed = output?.trim() ?? "";
+  if (!trimmed.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) return DEFAULT_BRANCH_FALLBACK;
+  return trimmed.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
+}
 async function get_default_branch() {
   try {
-    const output = await git_spawn.read(["symbolic-ref", "refs/remotes/origin/HEAD"]);
-    const trimmed = output.trim();
-    if (trimmed.startsWith(REFS_REMOTES_ORIGIN_PREFIX)) {
-      return trimmed.slice(REFS_REMOTES_ORIGIN_PREFIX.length);
-    }
+    return default_branch_of(await git_spawn.read([...DEFAULT_BRANCH_ARGUMENTS]));
   } catch {
+    return DEFAULT_BRANCH_FALLBACK;
   }
-  return DEFAULT_BRANCH_FALLBACK;
 }
 var MERGE_BASE_COMMAND = "merge-base";
 async function reference_exists(reference) {
@@ -293,8 +294,10 @@ async function untracked_names() {
   ]);
 }
 var git_diff_reads = {
+  DEFAULT_BRANCH_ARGUMENTS,
   change_base,
   change_base_commit,
+  default_branch_of,
   default_branch_reference,
   diff_cached_names,
   diff_main,
@@ -1185,8 +1188,7 @@ function build_input(values, now_ms) {
   const answer = to_answer(cli_flags.string_of(values.answer));
   if (answer === void 0) return void 0;
   const started_at_ms = to_time_ms(cli_flags.string_of(values.started));
-  if (started_at_ms === void 0) return void 0;
-  if (!are_values_readable(values)) return void 0;
+  if (started_at_ms === void 0 || !are_values_readable(values)) return void 0;
   return input_of(values, { answer, now_ms, started_at_ms });
 }
 function print_json(input, decision) {
@@ -2031,8 +2033,9 @@ function is_same_conversation(carry, owner) {
   return owner.transcript !== void 0 && owner.transcript === carry.owner_transcript;
 }
 function reclaim_owner(carry, owner) {
-  if (carry.is_handed_off === true || !is_same_conversation(carry, owner)) return carry;
-  if (owner.pid === carry.owner_pid) return carry;
+  if (carry.is_handed_off === true || !is_same_conversation(carry, owner) || owner.pid === carry.owner_pid) {
+    return carry;
+  }
   return { ...carry, owner_pid: owner.pid, owner_start: owner.start };
 }
 var run_carry_conversation = {
@@ -2346,9 +2349,11 @@ export {
   process_identity,
   process_owner_schema,
   PORCELAIN_FLAG,
+  UNTRACKED_FILES_FLAG,
   git_utilities,
   has_timed_out,
   git_spawn,
+  git_diff_reads,
   GIT_LOCATION_VARIABLES,
   git_location_environment,
   git_spawn_sync,

package/dist/hooks/{chunk-Z4XI7CZS.js → chunk-EUMACUK2.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-CDY4NFQG.js";
 import {
   lane_child_marker
-} from "./chunk-OLMO72ON.js";
+} from "./chunk-K4EOONYM.js";
 import {
   ENV_FILE_NAME,
   GIT_LOCATION_VARIABLES,
@@ -23,7 +23,7 @@ import {
   process_identity,
   process_owner_schema,
   run_carry
-} from "./chunk-3C4XRYG6.js";
+} from "./chunk-E7OIKX5Z.js";
 import {
   INSTALL_TIMEOUT_MS,
   PLATFORM_TEMP_ROOT,
@@ -299,6 +299,7 @@ var run_ship_next = { COMMAND, next_step, quoted, resume_of };
 
 // scripts/lane/lane-child-invocation.ts
 var CHILD_INVOCATION = "fullrun";
+var REVIEW_INVOCATION = "the reviewer of lane";
 var RESUME_GUIDE = ".claude/skills/workflow-commands/pre-gate-cut.md";
 var SHIP_PROCESS = String.raw`(josh(\.[jt]s)? ship|run-ship-cli\.ts)`;
 function child_invocation(issue) {
@@ -307,7 +308,11 @@ function child_invocation(issue) {
 }
 function process_pattern(issue) {
   issue_number_shape.require_issue_number(issue);
-  return `(${CHILD_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`;
+  return `(${CHILD_INVOCATION}|${REVIEW_INVOCATION}|${SHIP_PROCESS} .*) ${issue_cite.plain(issue)}$`;
+}
+function review_invocation(issue) {
+  issue_number_shape.require_issue_number(issue);
+  return `${REVIEW_INVOCATION} ${issue_cite.plain(issue)}`;
 }
 function resume_invocation(issue) {
   const preamble = `Resuming the lane child for issue ${issue_cite.plain(issue)} \u2014 do not re-read the workflow-commands entry documents (SKILL.md, fullrun.md). Run \`pnpm josh run:cut --resume ${issue}\` before anything else and follow the matching verdict in ${RESUME_GUIDE}: \`resume\` goes to the gate, \`resume-impl\` continues implementation. Only on \`fresh\` proceed as an ordinary`;
@@ -327,6 +332,7 @@ var lane_child_invocation = {
   outage_resume_invocation,
   process_pattern,
   resume_invocation,
+  review_invocation,
   ship_stop_invocation
 };
 
@@ -473,8 +479,7 @@ function parse_scp_like(url) {
   const user_end = url.indexOf(USER_SEPARATOR);
   const authority = user_end === NOT_FOUND ? url : url.slice(user_end + 1);
   const host_end = authority.indexOf(HOST_SEPARATOR);
-  if (host_end === NOT_FOUND) return void 0;
-  if (!is_github_ssh_host(authority.slice(0, host_end))) return void 0;
+  if (host_end === NOT_FOUND || !is_github_ssh_host(authority.slice(0, host_end))) return void 0;
   return to_identity(authority.slice(host_end + 1));
 }
 function parse_url_like(url) {
@@ -502,8 +507,7 @@ function origin_section_lines(lines) {
 }
 function url_value(line) {
   const separator = line.indexOf("=");
-  if (separator === NOT_FOUND) return void 0;
-  if (line.slice(0, separator).trim() !== URL_KEY) return void 0;
+  if (separator === NOT_FOUND || line.slice(0, separator).trim() !== URL_KEY) return void 0;
   return line.slice(separator + 1).trim();
 }
 function parse_origin_from_config(content) {
@@ -643,8 +647,9 @@ function resolve_current_owner(repository_path) {
 }
 function main_worktree(repository_path) {
   const git_directory = resolve_git_directory(repository_path);
-  if (git_directory === void 0) return repository_path;
-  if (path2.basename(git_directory) !== GIT_DIRECTORY) return repository_path;
+  if (git_directory === void 0 || path2.basename(git_directory) !== GIT_DIRECTORY) {
+    return repository_path;
+  }
   return path2.dirname(git_directory);
 }
 function discover_repositories(repository_path, environment3 = process.env) {
@@ -731,7 +736,7 @@ function repository(cwd) {
 function select_linked(found) {
   const own_directory = found[OWN_GIT_DIRECTORY];
   const common = found[COMMON_GIT_DIRECTORY];
-  return own_directory !== void 0 && common !== void 0 && own_directory !== common ? common : void 0;
+  return own_directory === void 0 || common === void 0 || own_directory === common ? void 0 : common;
 }
 function resolve(cwd) {
   return select_linked(directories(cwd));
@@ -1253,8 +1258,9 @@ function parse_block(block, root) {
   const directory = line_value(lines, WORKTREE_PREFIX);
   const branch = line_value(lines, BRANCH_PREFIX);
   const issue = branch_issue(branch);
-  if (directory === void 0 || branch === void 0 || issue === void 0) return void 0;
-  if (!is_lane_directory(root, issue, directory)) return void 0;
+  if (directory === void 0 || branch === void 0 || issue === void 0 || !is_lane_directory(root, issue, directory)) {
+    return void 0;
+  }
   return build_lane(issue, branch, directory, is_gone(directory));
 }
 function is_lane(lane) {

package/dist/hooks/{chunk-WNLVGT7E.js → chunk-H5HVWYXK.js}

@@ -1,16 +1,16 @@
 import {
   hook_decision
-} from "./chunk-GPLGZ6IC.js";
+} from "./chunk-J47HU5H5.js";
 import {
   cost_blocks,
   time_batch_guard,
   time_bundle_call,
   time_shell,
   time_spans
-} from "./chunk-LIAFCXL7.js";
+} from "./chunk-AS74OU3D.js";
 import {
   cost_transcript
-} from "./chunk-3C4XRYG6.js";
+} from "./chunk-E7OIKX5Z.js";
 
 // scripts/delegation/investigation-reads.ts
 import path2 from "node:path";
@@ -176,7 +176,7 @@ var SEARCH_LABELS = new Set(
   SEARCH_COMMANDS.map((command) => time_shell.bash_label(command))
 );
 var INVESTIGATOR_AGENT = "investigator";
-var REASON = `\u26D4 investigation: ${String(delegation_policy.INVESTIGATION_FILE_THRESHOLD)} files read and not edited, or ${String(delegation_policy.INVESTIGATION_SEARCH_TURN_THRESHOLD)} search turns, since the last delegated unit, so the reading from here goes to a unit of its own (a successful write also starts the search count over). Ask \`pnpm josh delegate investigation\`, then dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer) with a brief of what the main line has already concluded and what is left to find out; it returns the conclusion plus its \`file:line\` citations, never the file text. Keep a read in the main line only where this run will edit that file \u2014 an \`Edit\` cannot be issued against text you do not hold. This run's own instructions and the harness's own session files \u2014 a backgrounded call's output, a persisted tool result, this session's scratchpad \u2014 never count toward the files, so they are not what took the file count here; every read-only search turn counts, whatever it names. The rule is \`.claude/skills/workflow-commands/delegation.md\` \u2192 "The pre-implementation reading".`;
+var REASON = `\u26D4 investigation: ${String(delegation_policy.INVESTIGATION_FILE_THRESHOLD)} files read and not edited, or ${String(delegation_policy.INVESTIGATION_SEARCH_TURN_THRESHOLD)} search turns, since the last delegated unit. Run \`pnpm josh delegate investigation\`, then dispatch the \`${INVESTIGATOR_AGENT}\` agent (\`kit:${INVESTIGATOR_AGENT}\` in a consumer); it returns \`file:line\` citations, never the file text. Keep main-line reads to files you will edit; every read-only search turn counts. \`.claude/skills/workflow-commands/delegation.md\``;
 var INSTRUCTION_PATHS = ["prompts", ".claude/skills"];
 var INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md", "GEMINI.md"]);
 var REPOSITORY_ROOT = process.cwd();