@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-W4BR6QNU.js

@@ -0,0 +1,1241 @@
+import {
+  run_watcher_guard
+} from "./chunk-5KAW5GPF.js";
+import {
+  run_event_plan
+} from "./chunk-NDR4PCVG.js";
+import {
+  josh_read_only
+} from "./chunk-F4SGOTUF.js";
+import {
+  run_progress_read
+} from "./chunk-ES42XPAD.js";
+import {
+  gh_usage_log
+} from "./chunk-O45BX4EL.js";
+import {
+  issue_watch_gate
+} from "./chunk-6KUA7MRG.js";
+import {
+  issue_watch
+} from "./chunk-3CJNQU7P.js";
+import {
+  hook_demoted
+} from "./chunk-3JWPTRNI.js";
+import {
+  rule_rewrite
+} from "./chunk-WCYRNNKF.js";
+import {
+  hook_ledger
+} from "./chunk-4NSIW3UB.js";
+import {
+  lane_plan
+} from "./chunk-MDGPJOLK.js";
+import {
+  batch_outcome,
+  delivered_rules,
+  investigation_outcome,
+  nested_commands
+} from "./chunk-FJMXUDEY.js";
+import {
+  implementation_cut_verdict
+} from "./chunk-ZEH2B3DF.js";
+import {
+  lane_background
+} from "./chunk-ZIIUBGON.js";
+import {
+  cost_cli,
+  cost_verdict
+} from "./chunk-JEYITIWB.js";
+import {
+  bash_revert,
+  step_zero_notice
+} from "./chunk-BRWR5YKU.js";
+import {
+  run_headless
+} from "./chunk-Q4ULMZAS.js";
+import {
+  shell_segments
+} from "./chunk-CVJHQOI3.js";
+import {
+  duplicate_read_outcome,
+  duplicate_reads,
+  investigation_reads,
+  lane_guard_policy
+} from "./chunk-TFDVTU6O.js";
+import {
+  time_spans
+} from "./chunk-R5AABJZJ.js";
+import {
+  cost_blocks,
+  time_josh_names,
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+import {
+  canonical_command
+} from "./chunk-ROJXMBXP.js";
+import {
+  hook_decision,
+  hook_tool_payload
+} from "./chunk-GB2BRQVL.js";
+import {
+  hook_context
+} from "./chunk-CUWT6UQO.js";
+import {
+  transcript_tail
+} from "./chunk-2OMIHPPE.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  run_event_scope,
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  repository_lock
+} from "./chunk-NUCFIYZL.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  gh_call_kind
+} from "./chunk-43DU7DYZ.js";
+import {
+  gh_api
+} from "./chunk-QVOFWFWC.js";
+import {
+  git_argv
+} from "./chunk-G6BXCWPH.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/delegation/large-read-guard.ts
+import { statSync } from "node:fs";
+var SWITCH_ENV_KEY = "JOSH_LARGE_READ_GUARD";
+var LANE_GUARD_ID = "duplicate-read";
+var STAMP_PREFIX = "josh-large-read-guard-";
+var NOTICE_STAMP_PREFIX = "josh-large-read-notice-";
+var READ_TOOL = "Read";
+var BYTES_PER_KB = 1024;
+var LARGE_READ_KB = 32;
+var LARGE_READ_BYTES = LARGE_READ_KB * BYTES_PER_KB;
+var LIMIT_TEXT = `${String(LARGE_READ_KB)} KB`;
+var REASON = `\u26D4 large read: this file is over ${LIMIT_TEXT}, and a whole-file read stays in context and is re-billed on every later call. Grep for the part you need and Read it with offset/limit. Repeat the same call to read the whole file anyway; set \`JOSH_LARGE_READ_GUARD=off\` to disable this guard.`;
+var NOTICE = `\u26A0 large read: this file is over ${LIMIT_TEXT} \u2014 next time Grep for the part you need and Read it with offset/limit. Set \`JOSH_LARGE_READ_GUARD=off\` to silence this.`;
+function is_whole_read(call) {
+  if (call.name !== READ_TOOL || !json_value.is_record(call.input)) return false;
+  return call.input["offset"] === void 0 && call.input["limit"] === void 0;
+}
+function file_bytes(target) {
+  try {
+    return statSync(target).size;
+  } catch {
+    return 0;
+  }
+}
+function whole_read_target(call, root) {
+  if (!is_whole_read(call)) return void 0;
+  const { file_path } = call.input;
+  if (typeof file_path !== "string" || file_path === "") return void 0;
+  return investigation_reads.resolved(file_path, root);
+}
+function is_large_read(call, root) {
+  const target = whole_read_target(call, root);
+  return target !== void 0 && file_bytes(target) > LARGE_READ_BYTES;
+}
+function large_read_mode(context) {
+  return lane_guard_policy.mode_here(LANE_GUARD_ID, context.cwd, context.env);
+}
+function is_candidate(call, context) {
+  return is_large_read(call, context.cwd) && large_read_mode(context) !== "off";
+}
+function last_read_ms(spans) {
+  const times = spans.filter((span) => duplicate_reads.is_successful_read(span)).map((span) => span.ended_ms);
+  return times.length === 0 ? hook_decision.NEVER_MS : Math.max(...times);
+}
+function is_rearmed(tail, fired_at_ms) {
+  const { spans, started_ms } = time_spans.parse_timeline(tail);
+  if (fired_at_ms === hook_decision.NEVER_MS || fired_at_ms < started_ms) return true;
+  return last_read_ms(spans) > fired_at_ms;
+}
+function is_read_of(span, target, root) {
+  const is_read = span.label === READ_TOOL;
+  return is_read && span.targets.some((one) => investigation_reads.resolved(one, root) === target);
+}
+function is_repeat_of_refusal(tail, target, root) {
+  const reads = time_spans.parse_timeline(tail).spans.filter((span) => is_read_of(span, target, root));
+  const latest = reads.at(-1);
+  return latest?.outcome === time_spans.FAILED_OUTCOME;
+}
+function refuses(tail, call, _fired_at_ms, run) {
+  const { cwd } = run.context;
+  const target = whole_read_target(call, cwd);
+  if (target === void 0 || large_read_mode(run.context) !== "refuse") return false;
+  return !is_repeat_of_refusal(tail, target, cwd);
+}
+function notifies(tail, _call, fired_at_ms, run) {
+  return large_read_mode(run.context) === "notice" && is_rearmed(tail, fired_at_ms);
+}
+var GUARD = hook_decision.create_transcript_guard({
+  prefix: STAMP_PREFIX,
+  switch_key: SWITCH_ENV_KEY,
+  is_candidate,
+  should_block: refuses,
+  reason: REASON,
+  notify: { prefix: NOTICE_STAMP_PREFIX, should_notify: notifies, text: () => NOTICE }
+});
+var large_read_outcome = GUARD.outcome;
+var large_read_refusal = GUARD.refusal;
+var { refusal_path } = GUARD;
+var notice_refusal_path = hook_decision.create_refusal_stamp(NOTICE_STAMP_PREFIX).path;
+
+// scripts/issue/issue-watch-hook.ts
+var POLL_INTERVAL_MS = 18e4;
+var POLL_TIMEOUT_MS = 5e3;
+function is_new_to_run(record2) {
+  const news = record2 === void 0 ? void 0 : issue_watch.news_of(record2);
+  return news !== void 0 && news !== record2?.shown;
+}
+function message_of(record2) {
+  return record2.pending === void 0 ? record2.notice ?? "" : issue_watch_gate.unread_message(record2);
+}
+async function new_update_reason(now, root) {
+  const options = { interval_ms: POLL_INTERVAL_MS, timeout_ms: POLL_TIMEOUT_MS, now };
+  const record2 = await issue_watch.poll(options, root);
+  if (!is_new_to_run(record2)) return void 0;
+  issue_watch.mark_shown(record2, root);
+  return message_of(record2);
+}
+async function watch_reason(context = hook_context.from_process(), now = /* @__PURE__ */ new Date()) {
+  try {
+    return await new_update_reason(now, context.cwd);
+  } catch (error) {
+    error_text.trace_swallowed("issue_watch_hook.watch_reason", error);
+    return void 0;
+  }
+}
+var issue_watch_hook = { POLL_INTERVAL_MS, watch_reason };
+
+// scripts/lane/lane-phase.ts
+var LOCK_WAIT_MS = 5e3;
+function implement_text(issue) {
+  return `${issue_cite.plain_for("program", issue)} implement`;
+}
+async function has_implement(issue) {
+  const events = await run_event_stream_emit.invocation_or_all_events();
+  return run_event_scope.since_own_launch(events, issue).some(
+    (event) => event.kind === run_event_stream.EVENT_KIND.LANE_PHASE && event.text === implement_text(issue)
+  );
+}
+async function mark_once(issue) {
+  if (await has_implement(issue)) return;
+  await run_event_plan.emit_plan(issue);
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.LANE_PHASE, implement_text(issue));
+}
+async function mark_implement(directory = process.cwd(), source = process.env) {
+  const issue = lane_child_marker.marked_issue(source);
+  if (issue === void 0 || !lane_child_marker.is_child_of(directory, source)) return;
+  await repository_lock.with_lock(
+    async () => {
+      await mark_once(issue);
+    },
+    repository_lock.lock_path(`josh-lane-phase-${issue}-`, directory),
+    LOCK_WAIT_MS
+  );
+}
+var lane_phase = { mark_implement };
+
+// scripts/run/run-watcher-hook.ts
+import { z } from "zod";
+var SWITCH_ENV_KEY2 = "JOSH_WATCHER_GUARD";
+var STAMP_PREFIX2 = "josh-watcher-guard-";
+var payload_schema = z.object({ transcript_path: z.string().min(1) });
+function transcript_of(raw_payload) {
+  return json_value.parse_with(raw_payload, payload_schema)?.transcript_path;
+}
+function fires_once(transcript, now_ms) {
+  const stamp = hook_decision.create_refusal_stamp(STAMP_PREFIX2);
+  const target = stamp.path(transcript);
+  if (stamp.last_ms(target) !== hook_decision.NEVER_MS) return false;
+  return stamp.record(target, now_ms);
+}
+function is_active(context) {
+  return hook_decision.is_switch_enabled(SWITCH_ENV_KEY2) && lane_child_marker.marked_issue(context.env) === void 0;
+}
+async function stale_reason(transcript, now_ms, ancestry) {
+  const result = await run_watcher_guard.check(await run_progress_read.live_target(), ancestry);
+  if (result.kind === "ok") return void 0;
+  return fires_once(transcript, now_ms) ? result.note : void 0;
+}
+async function watcher_hook_reason(raw_payload, context = hook_context.from_process(), now_ms = Date.now()) {
+  if (!is_active(context)) return void 0;
+  const transcript = transcript_of(raw_payload);
+  if (transcript === void 0) return void 0;
+  return await stale_reason(transcript, now_ms, context.ancestry);
+}
+var run_watcher_hook = { transcript_of, watcher_hook_reason };
+
+// scripts/run/run-parent-cut-hook.ts
+var SWITCH_ENV_KEY3 = "JOSH_PARENT_CUT_GUARD";
+var STAMP_PREFIX3 = "josh-parent-cut-guard-";
+var QUIET_WINDOW_MS = 6e5;
+function current_state(context = hook_context.from_process()) {
+  return {
+    carry: async () => await run_headless.driving_carry(context.env, context.ancestry),
+    verdict: () => implementation_cut_verdict.reused_verdict(
+      () => cost_cli.session_verdict(context.cwd, context.env),
+      context.cwd
+    )
+  };
+}
+var THRESHOLD_TEXT = "`pnpm josh cost --cut`";
+var PARENT_CUT_REASON = `\u26D4 backlogrun parent hand-off: this session drives a \`backlogrun\` and its recent context crossed the ${THRESHOLD_TEXT} threshold between merges. Take the hand-off now: open no new lane, follow \`backlogrun-progress.md\` \u2192 "The hand-off" (\`pnpm josh run:handoff-lanes\`, then the \`next:\` line its \`cut\` / \`blocked\` / \`capped\` verdict prints). Reissue this call once done or if it cannot be taken.`;
+async function is_due(state) {
+  const carry = await state.carry();
+  if (carry === void 0 || run_headless.is_cut_capped(carry)) return false;
+  return state.verdict() === cost_verdict.OVER_VERDICT;
+}
+function is_quiet(target, now_ms) {
+  const last_ms = hook_decision.create_refusal_stamp(STAMP_PREFIX3).last_ms(target);
+  return last_ms !== hook_decision.NEVER_MS && now_ms - last_ms < QUIET_WINDOW_MS;
+}
+async function refusal_for(transcript, now_ms, state) {
+  const stamp = hook_decision.create_refusal_stamp(STAMP_PREFIX3);
+  const target = stamp.path(transcript);
+  if (is_quiet(target, now_ms) || !await is_due(state)) return void 0;
+  return stamp.record(target, now_ms) ? PARENT_CUT_REASON : void 0;
+}
+function is_unit_call(raw_payload) {
+  try {
+    return (hook_decision.parse_hook_payload(raw_payload)?.agent_id ?? "") !== "";
+  } catch (error) {
+    error_text.trace_swallowed("run_parent_cut_hook.is_unit_call", error);
+    return false;
+  }
+}
+function is_exempt(raw_payload) {
+  return !hook_decision.is_switch_enabled(SWITCH_ENV_KEY3) || is_unit_call(raw_payload);
+}
+async function parent_cut_reason(raw_payload, now_ms = Date.now(), state = current_state()) {
+  if (is_exempt(raw_payload)) return void 0;
+  const transcript = run_watcher_hook.transcript_of(raw_payload);
+  if (transcript === void 0) return void 0;
+  return await refusal_for(transcript, now_ms, state);
+}
+var run_parent_cut_hook = {
+  PARENT_CUT_REASON,
+  QUIET_WINDOW_MS,
+  SWITCH_ENV_KEY: SWITCH_ENV_KEY3,
+  current_state,
+  parent_cut_reason
+};
+
+// scripts/run/run-poll-hook.ts
+var SWITCH_ENV_KEY4 = "JOSH_POLL_GUARD";
+var BASH_TOOL = "Bash";
+var STATE_READS = /* @__PURE__ */ new Set([
+  "josh lane:list",
+  "josh lane:output",
+  "josh run:board",
+  "josh run:carry",
+  "josh run:liveness",
+  "josh run:progress",
+  "josh run:wake"
+]);
+var POLL_REASON = "\u26D4 poll: this `backlogrun` session repeats a state read with nothing decided in between, on every occurrence. Wait on `pnpm josh backlog:drive`, or `pnpm josh lane:await <N...>` in the background, and end the turn; its exit is the wake.";
+var WRITING_FLAGS = /* @__PURE__ */ new Set([
+  "--begin",
+  "--cut",
+  "--done",
+  "--end",
+  "--every",
+  "--filed",
+  "--loop",
+  "--mark",
+  "--merged",
+  "--resume",
+  "--retrospective",
+  "--start",
+  "--stop",
+  "--wait"
+]);
+var FLAG_PREFIX = "-";
+var NAME_WORDS = 2;
+var SIGNATURE_SEPARATOR = " ";
+function read_key(signature) {
+  const words = signature.split(SIGNATURE_SEPARATOR);
+  const name = words.slice(0, NAME_WORDS).join(SIGNATURE_SEPARATOR);
+  if (!STATE_READS.has(name) || words.some((word) => WRITING_FLAGS.has(word))) return void 0;
+  return words.filter((word) => !word.startsWith(FLAG_PREFIX)).join(SIGNATURE_SEPARATOR);
+}
+function read_keys(signatures) {
+  return signatures.map((signature) => read_key(signature)).filter((key) => key !== void 0);
+}
+function state_reads_of(command) {
+  return read_keys(time_josh_names.josh_signatures_of(command));
+}
+function command_of(input) {
+  if (typeof input !== "object" || input === null || !("command" in input)) return "";
+  return typeof input.command === "string" ? input.command : "";
+}
+function candidate_reads(raw_payload) {
+  const payload = hook_decision.parse_hook_payload(raw_payload);
+  if (payload?.tool_name !== BASH_TOOL || (payload.agent_id ?? "") !== "") return [];
+  return state_reads_of(command_of(payload.tool_input));
+}
+function last_step(tail) {
+  return time_spans.parse_timeline(tail).spans.findLast((span) => span.category !== time_spans.MODEL_CATEGORY);
+}
+function repeats_last_call(tail, reads) {
+  const last = last_step(tail);
+  if (last?.category !== time_spans.TOOL_CATEGORY) return false;
+  const last_reads = read_keys(last.josh_signatures);
+  return reads.some((key) => last_reads.includes(key));
+}
+function is_repeat(raw_payload) {
+  const reads = hook_decision.is_switch_enabled(SWITCH_ENV_KEY4) ? candidate_reads(raw_payload) : [];
+  const transcript = reads.length === 0 ? void 0 : run_watcher_hook.transcript_of(raw_payload);
+  if (transcript === void 0) return false;
+  return repeats_last_call(transcript_tail.read_tail(transcript), reads);
+}
+async function poll_reason(raw_payload, is_parent = run_headless.is_backlog_parent) {
+  if (!is_repeat(raw_payload)) return void 0;
+  return await is_parent() ? POLL_REASON : void 0;
+}
+async function safe_poll_reason(raw_payload, context = hook_context.from_process()) {
+  try {
+    return await poll_reason(
+      raw_payload,
+      async () => await run_headless.is_backlog_parent(context.env, context.ancestry)
+    );
+  } catch (error) {
+    error_text.trace_swallowed("run_poll_hook.poll_reason", error);
+    return void 0;
+  }
+}
+var run_poll_hook = {
+  POLL_REASON,
+  SWITCH_ENV_KEY: SWITCH_ENV_KEY4,
+  poll_reason,
+  safe_poll_reason
+};
+
+// scripts/hooks/direct-gh-usage.ts
+var PREFIX = "direct:";
+var API = "api";
+var FREE_ENDPOINT = "rate_limit";
+var LEADING_SLASH = /^\//u;
+var SUBCOMMAND_WORDS = 2;
+function gh_words(segment) {
+  return git_argv.arguments_of(segment, "gh")?.filter((word) => !word.startsWith("-")) ?? [];
+}
+function is_free(api_words) {
+  return api_words.some((word) => word.replace(LEADING_SLASH, "") === FREE_ENDPOINT);
+}
+function subcommand_of(segment) {
+  const words = gh_words(segment);
+  const [head, ...rest] = words;
+  if (head === API) return is_free(rest) ? void 0 : API;
+  return head === void 0 ? void 0 : words.slice(0, SUBCOMMAND_WORDS).join(" ");
+}
+function direct_call_of(segment) {
+  const subcommand = subcommand_of(segment);
+  if (subcommand === void 0) return void 0;
+  const kind = gh_call_kind.of(git_argv.arguments_of(segment, "gh") ?? []);
+  return { command: `${PREFIX}${subcommand}`, kind };
+}
+function direct_calls(command) {
+  return nested_commands.commands_of(command).map((segment) => direct_call_of(segment)).filter((call) => call !== void 0);
+}
+function calls_of(raw_payload) {
+  const payload = hook_tool_payload.parse(raw_payload);
+  if (payload?.tool_name !== "Bash") return [];
+  return direct_calls(time_shell.bash_command(payload.tool_input));
+}
+function log_target(context) {
+  if (context.env["VITEST"] !== void 0) return void 0;
+  const repository = git_common_directory.repository(context.cwd);
+  return repository === void 0 ? void 0 : gh_usage_log.target_of(repository);
+}
+function append_all(target, calls, environment) {
+  const marked = lane_child_marker.marked_issue(environment);
+  const issue = marked === void 0 ? void 0 : Number(marked);
+  for (const { command, kind } of calls) {
+    const at = (/* @__PURE__ */ new Date()).toISOString();
+    const endpoints = { [kind]: { calls: 1, not_modified: 0 } };
+    gh_usage_log.append(target, {
+      at,
+      command,
+      issue,
+      calls: 1,
+      not_modified: 0,
+      elapsed_ms: 0,
+      endpoints
+    });
+  }
+}
+async function record(raw_payload, context = hook_context.from_process()) {
+  try {
+    const calls = calls_of(raw_payload);
+    const target = calls.length === 0 ? void 0 : log_target(context);
+    if (target !== void 0) append_all(target, calls, context.env);
+  } catch (error) {
+    error_text.trace_swallowed("direct_gh_usage.record", error);
+  }
+}
+var direct_gh_usage = { record };
+
+// scripts/hooks/implementation-shell.ts
+import path from "node:path";
+
+// scripts/hooks/implementation-shell-deny-expansion.ts
+var DYNAMIC = /[$`]/u;
+function is_dynamic(word) {
+  return DYNAMIC.test(word);
+}
+function refusal(program, word) {
+  return `\`${program} ${word}\`, an expansion that may spell a write`;
+}
+var implementation_shell_deny_expansion = { is_dynamic, refusal };
+
+// scripts/hooks/implementation-shell-deny-git.ts
+var GIT_WRITES = /* @__PURE__ */ new Set([
+  "add",
+  "am",
+  "apply",
+  "bisect",
+  "checkout",
+  "checkout-index",
+  "cherry-pick",
+  "clean",
+  "commit",
+  "credential",
+  "fetch",
+  "filter-branch",
+  "gc",
+  "init",
+  "maintenance",
+  "merge",
+  "mv",
+  "pack-refs",
+  "prune",
+  "prune-packed",
+  "pull",
+  "push",
+  "read-tree",
+  "rebase",
+  "repack",
+  "replace",
+  "reset",
+  "restore",
+  "revert",
+  "rm",
+  "send-email",
+  "sparse-checkout",
+  "stage",
+  "submodule",
+  "switch",
+  "symbolic-ref",
+  "update-index",
+  "update-ref"
+]);
+var BRANCH_CHANGE = /^--(?:delete|move|copy|force|set-upstream-to|unset-upstream|edit-description)/u;
+var BRANCH_CHANGE_LETTERS = "dDmMcCfu";
+var CONFIG_READ = /^(?:--get|--list$|-l$)/u;
+var LIST_MODE = /^(?:-l$|--list$|-n\d*$|--contains|--no-contains|--points-at|--merged|--no-merged)/u;
+var LIST_VALUE_FLAGS = /* @__PURE__ */ new Set(["--sort", "--format"]);
+var REFLOG_WRITES = /* @__PURE__ */ new Set(["expire", "delete"]);
+var GIT_WRITE_FLAGS = /^-c$|^--(?:config-env|exec-path|output|ext-diff|textconv)/u;
+var QUOTES = /['"\\]/gu;
+function is_branch_change(argument) {
+  return BRANCH_CHANGE.test(argument) || git_argv.short_cluster_has(argument, BRANCH_CHANGE_LETTERS);
+}
+function names_a_reference(args) {
+  return args.some(
+    (argument, index) => !argument.startsWith("-") && !LIST_VALUE_FLAGS.has(args[index - 1] ?? "")
+  );
+}
+function is_listing(args) {
+  return !names_a_reference(args) || args.some((argument) => LIST_MODE.test(argument));
+}
+var GIT_READ_FORMS = /* @__PURE__ */ new Map([
+  ["branch", (args) => is_listing(args) && args.every((argument) => !is_branch_change(argument))],
+  ["stash", (args) => ["list", "show"].includes(args[0] ?? "")],
+  ["worktree", (args) => args[0] === "list"],
+  ["notes", (args) => ["list", "show"].includes(args[0] ?? "")],
+  ["remote", (args) => ["", "-v", "show", "get-url"].includes(args[0] ?? "")],
+  ["config", (args) => args.some((argument) => CONFIG_READ.test(argument))],
+  ["tag", is_listing],
+  ["reflog", (args) => !REFLOG_WRITES.has(args[0] ?? "")]
+]);
+function is_git_write(subcommand, args) {
+  if (GIT_WRITES.has(subcommand)) return true;
+  const read_form = GIT_READ_FORMS.get(subcommand);
+  if (read_form === void 0) return false;
+  return args.some((argument) => implementation_shell_deny_expansion.is_dynamic(argument)) || !read_form(args);
+}
+function parsed_git(segment) {
+  return git_argv.parse(segment) ?? git_argv.parse(segment.replaceAll(QUOTES, ""));
+}
+function subcommand_refusal(segment) {
+  const call = parsed_git(segment);
+  if (call?.subcommand === void 0) return void 0;
+  if (implementation_shell_deny_expansion.is_dynamic(call.subcommand)) return implementation_shell_deny_expansion.refusal("git", call.subcommand);
+  const subcommand = call.subcommand.replaceAll(QUOTES, "");
+  const args = call.args.map((argument) => argument.replaceAll(QUOTES, ""));
+  return is_git_write(subcommand, args) ? `\`git ${subcommand}\`, a git write` : void 0;
+}
+function refusal2(segment, args) {
+  if (args.some((argument) => GIT_WRITE_FLAGS.test(argument))) {
+    return "a git option that rewrites its configuration, runs a program or writes a file";
+  }
+  return subcommand_refusal(segment);
+}
+var implementation_shell_deny_git = { refusal: refusal2 };
+
+// scripts/hooks/implementation-shell-deny.ts
+var GH_READS = /* @__PURE__ */ new Set([
+  "checks",
+  "code",
+  "commits",
+  "diff",
+  "issues",
+  "list",
+  "prs",
+  "repos",
+  "status",
+  "token",
+  "view",
+  "watch"
+]);
+var GH_WRITES = /* @__PURE__ */ new Set([
+  "add",
+  "archive",
+  "cancel",
+  "checkout",
+  "clone",
+  "close",
+  "comment",
+  "copy",
+  "create",
+  "delete",
+  "develop",
+  "disable",
+  "edit",
+  "enable",
+  "field-create",
+  "field-delete",
+  "fork",
+  "install",
+  "item-add",
+  "item-archive",
+  "item-create",
+  "item-delete",
+  "item-edit",
+  "link",
+  "lock",
+  "login",
+  "logout",
+  "mark-template",
+  "merge",
+  "pin",
+  "ready",
+  "refresh",
+  "remove",
+  "rename",
+  "reopen",
+  "rerun",
+  "revert",
+  "review",
+  "run",
+  "set",
+  "setup-git",
+  "sync",
+  "transfer",
+  "unarchive",
+  "unlink",
+  "unlock",
+  "unpin",
+  "update-branch",
+  "upgrade",
+  "upload"
+]);
+var GRAPHQL_MUTATION = /\bmutation\b|=@|^--input/u;
+var PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["npm", "yarn"]);
+var PACKAGE_WRITES = /* @__PURE__ */ new Set([
+  "add",
+  "ci",
+  "dedupe",
+  "i",
+  "install",
+  "link",
+  "patch-commit",
+  "publish",
+  "rebuild",
+  "remove",
+  "un",
+  "uninstall",
+  "unlink",
+  "unpublish",
+  "up",
+  "update",
+  "upgrade",
+  // Commits and tags the version bump.
+  "version"
+]);
+var JOSH_SHARED_WRITES = /* @__PURE__ */ new Set([
+  "adopt",
+  "bump",
+  "dogfood:commit",
+  "followup",
+  "git",
+  "init",
+  "latest",
+  "latest:corepack",
+  "latest:update",
+  "overrides",
+  "pr",
+  "release",
+  "release:github",
+  "ship",
+  "stash:pop",
+  "stash:push",
+  "sync",
+  "uninstall"
+]);
+function is_gh_api_write(args) {
+  if (args.includes("graphql")) return args.some((argument) => GRAPHQL_MUTATION.test(argument));
+  return gh_api.is_write(["gh", ...args].join(" "));
+}
+function is_gh_verb(argument) {
+  return GH_WRITES.has(argument) || GH_READS.has(argument) || implementation_shell_deny_expansion.is_dynamic(argument);
+}
+function verb_refusal(group, args) {
+  const verb = args.slice(1).find((argument) => is_gh_verb(argument));
+  if (verb === void 0 || GH_READS.has(verb)) return void 0;
+  return implementation_shell_deny_expansion.is_dynamic(verb) ? implementation_shell_deny_expansion.refusal(`gh ${group}`, verb) : `\`gh ${group} ${verb}\`, a GitHub write`;
+}
+function gh_refusal(args) {
+  const group = args[0] ?? "";
+  if (group === "api") return is_gh_api_write(args) ? "a `gh api` call other than GET" : void 0;
+  return implementation_shell_deny_expansion.is_dynamic(group) ? implementation_shell_deny_expansion.refusal("gh", group) : verb_refusal(group, args);
+}
+function is_flag(argument) {
+  return argument.startsWith("-");
+}
+function is_action_word(args, index) {
+  const previous = args[index - 1] ?? "";
+  return !is_flag(args[index] ?? "-") && (!is_flag(previous) || previous.includes("="));
+}
+function package_actions(call) {
+  if (!PACKAGE_MANAGERS.has(call.name)) return [call.name];
+  const end = call.args.findIndex((_argument, index) => is_action_word(call.args, index));
+  const read = end === -1 ? call.args : call.args.slice(0, end + 1);
+  const actions = read.filter((word) => !is_flag(word));
+  return end === -1 && call.name === "yarn" ? [...actions, "install"] : actions;
+}
+function action_refusal(manager, action) {
+  if (implementation_shell_deny_expansion.is_dynamic(action)) return implementation_shell_deny_expansion.refusal(manager, action);
+  return PACKAGE_WRITES.has(action) ? `\`${action}\`, a dependency change` : void 0;
+}
+function package_refusal(call) {
+  return package_actions(call).map((action) => action_refusal(call.name, action)).find((rule) => rule !== void 0);
+}
+function josh_refusal(args) {
+  const command = canonical_command(args[0] ?? "");
+  if (implementation_shell_deny_expansion.is_dynamic(command)) return implementation_shell_deny_expansion.refusal("josh", command);
+  if (!JOSH_SHARED_WRITES.has(command)) return void 0;
+  const rule = josh_read_only.refusal(args);
+  return rule === void 0 ? void 0 : `\`josh ${command}\`, a shared-state write: ${rule}`;
+}
+function refusal3(segment, call) {
+  if (implementation_shell_deny_expansion.is_dynamic(call.name)) return `\`${call.name}\`, a program an expansion names`;
+  if (call.name === "git") return implementation_shell_deny_git.refusal(segment, call.args);
+  if (call.name === "gh") return gh_refusal(call.args);
+  if (call.name === "josh") return josh_refusal(call.args);
+  return package_refusal(call);
+}
+var implementation_shell_deny = { refusal: refusal3 };
+
+// scripts/hooks/implementation-shell-nested.ts
+var SUBSTITUTION = /\$\(([^()]*)\)|`([^`]*)`|[<>]\(([^()]*)\)/u;
+var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash"]);
+var SHELL_COMMAND_LETTER = "c";
+var SHELL_STDIN_LETTER = "s";
+var FIND_RUNNERS = /^-(?:exec|execdir|ok|okdir)$/u;
+var FIND_ENDS = /* @__PURE__ */ new Set([";", String.raw`\;`, "';'", "+"]);
+var JOSH_SCRIPT = /(?:^|\/)josh[\w-]*\.ts$/u;
+var INPUT_WORDS = "$xargs";
+var AFTER_VALUE = 2;
+var QUOTED = /^(?<quote>['"])(?<body>[\s\S]*)\k<quote>$/u;
+var LAUNCHERS = /* @__PURE__ */ new Map([
+  [
+    "xargs",
+    {
+      value_flags: /* @__PURE__ */ new Set(["-I", "-L", "-n", "-P", "-s", "-d", "-E", "-a"]),
+      operands: 0,
+      is_appending: true
+    }
+  ],
+  [
+    "timeout",
+    {
+      value_flags: /* @__PURE__ */ new Set(["-s", "--signal", "-k", "--kill-after"]),
+      operands: 1,
+      is_appending: false
+    }
+  ],
+  ["nice", { value_flags: /* @__PURE__ */ new Set(["-n", "--adjustment"]), operands: 0, is_appending: false }],
+  ["nohup", { value_flags: /* @__PURE__ */ new Set(), operands: 0, is_appending: false }],
+  ["stdbuf", { value_flags: /* @__PURE__ */ new Set(["-i", "-o", "-e"]), operands: 0, is_appending: false }],
+  ["watch", { value_flags: /* @__PURE__ */ new Set(["-n", "--interval"]), operands: 0, is_appending: false }]
+]);
+function unquoted(word) {
+  return QUOTED.exec(word)?.groups?.["body"] ?? word;
+}
+function substitution_bodies(command) {
+  const bodies = [];
+  let rest = time_shell.literal_blanked(command);
+  let match = SUBSTITUTION.exec(rest);
+  while (match !== null) {
+    bodies.push(match.slice(1).join(""));
+    rest = `${rest.slice(0, match.index)} ${rest.slice(match.index + match[0].length)}`;
+    match = SUBSTITUTION.exec(rest);
+  }
+  return bodies;
+}
+function after_flag(launcher, args, index) {
+  return index + (launcher.value_flags.has(args[index] ?? "") ? AFTER_VALUE : 1);
+}
+function launched_commands(launcher, args) {
+  let index = 0;
+  while (args[index]?.startsWith("-") === true) index = after_flag(launcher, args, index);
+  const words = args.slice(index + launcher.operands);
+  if (words.length === 0) return [];
+  return [[...words, ...launcher.is_appending ? [INPUT_WORDS] : []].join(" ")];
+}
+function josh_script_commands(args) {
+  const index = args.findIndex((argument) => JOSH_SCRIPT.test(argument));
+  return index === -1 ? [] : [["josh", ...args.slice(index + 1)].join(" ")];
+}
+function find_body(args, start) {
+  const end = args.findIndex((argument, index) => index >= start && FIND_ENDS.has(argument));
+  return args.slice(start, end === -1 ? void 0 : end).join(" ");
+}
+function find_commands(args) {
+  return args.flatMap(
+    (argument, index) => FIND_RUNNERS.test(argument) ? find_body(args, index + 1) : []
+  );
+}
+function shell_commands(args) {
+  const index = args.findIndex(
+    (argument) => git_argv.short_cluster_has(argument, SHELL_COMMAND_LETTER)
+  );
+  const body = index === -1 ? void 0 : args[index + 1];
+  return body === void 0 ? [] : [unquoted(body)];
+}
+function eval_commands(args) {
+  return [args.map((argument) => unquoted(argument)).join(" ")];
+}
+var RUNNERS = new Map([
+  ["find", find_commands],
+  ["eval", eval_commands],
+  ["node", josh_script_commands],
+  ...[...SHELLS].map((shell) => [shell, shell_commands])
+]);
+function call_commands(call) {
+  const launcher = LAUNCHERS.get(call.name);
+  if (launcher !== void 0) return launched_commands(launcher, call.args);
+  return RUNNERS.get(call.name)?.(call.args) ?? [];
+}
+function reads_stdin(call) {
+  if (!SHELLS.has(call.name)) return false;
+  if (call.args.some((argument) => git_argv.short_cluster_has(argument, SHELL_STDIN_LETTER))) {
+    return true;
+  }
+  return call.args.every((argument) => argument.startsWith("-"));
+}
+var implementation_shell_nested = { call_commands, reads_stdin, substitution_bodies };
+
+// scripts/hooks/implementation-shell.ts
+var FILE_PROGRAMS = /* @__PURE__ */ new Set(["tee", "touch", "rm", "truncate"]);
+var COPY_PROGRAMS = /* @__PURE__ */ new Set(["cp", "ln", "install", "rsync", "scp"]);
+var MOVE_PROGRAMS = /* @__PURE__ */ new Set([
+  ...COPY_PROGRAMS,
+  "mv",
+  "dd",
+  "patch",
+  "tar",
+  "unzip"
+]);
+var TARGET_DIRECTORY = /^-(?:[A-Za-z]*t|-target-directory)/u;
+var IN_PLACE_PROGRAMS = /* @__PURE__ */ new Set(["sed", "perl"]);
+var IN_PLACE = /^-(?:[A-Za-z]*i|-in-place)/u;
+var REDIRECT = /(?<![<>])(?:<>|>[>|&]?)(?![>&])/gu;
+var DESCRIPTOR = /^(?:\d+[+-]?|-)$/u;
+var QUOTES2 = /^['"]|['"]$/gu;
+var DYNAMIC_PATH = /[$`*?{}\\]/u;
+var COMPOUND_HEAD = /^\s*(?:[({!]\s*|(?:if|then|else|elif|while|until|do)\s+)+/u;
+var COMPOUND_CLOSERS = /* @__PURE__ */ new Set([")", "}", " ", "	", "\n"]);
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "for",
+  "do",
+  "done",
+  "then",
+  "else",
+  "fi",
+  "case",
+  "select",
+  "function",
+  "esac"
+]);
+var FUNCTION_START = /^(?:function\s|[\w.:-]+\s*\(\s*\))/u;
+var FUNCTION_HEAD = /^(?:function\s+)?[\w.:-]+(?:\s*\()?$/u;
+var UNREAD_ARMS = [/^case\s[\s\S]*\)/u, /^[^\s$`]*\)/u];
+var ARGUMENT_QUOTES = /['"\\]/gu;
+var TIME_PROGRAM = /(?:^|\/)time$/u;
+var TIME_WRITE = /^-(?:[A-Za-z]*o|-o)/u;
+var CD_WRITE = "a write beside `cd`, whose target is not read off the repository root";
+var STDIN_SHELL = "a shell running the commands its standard input spells, which may be any write";
+function unsafe_path(target, root) {
+  const file_path = target.replaceAll(QUOTES2, "");
+  if (file_path === "/dev/null") return false;
+  return DYNAMIC_PATH.test(file_path) || step_zero_notice.is_runtime_file(file_path, root, true);
+}
+function redirected_paths(command) {
+  const plain = time_shell.blanked(command);
+  if (plain === void 0) return [];
+  return [...plain.matchAll(REDIRECT)].map((match) => {
+    const following = command.slice(match.index + match[0].length);
+    const target = git_argv.words_of(following)[0] ?? "$unknown";
+    return match[0].endsWith(">&") && DESCRIPTOR.test(target) ? "/dev/null" : target;
+  });
+}
+function write_args_are_unsafe(args, root) {
+  return args.filter((argument) => argument !== "-a").some((argument) => unsafe_path(argument, root));
+}
+function plain_argument(word) {
+  if (/^'[^']*'$/u.test(word) || /^"[^"\\$`]*"$/u.test(word)) return word.slice(1, -1);
+  if (/['"\\$`]/u.test(word)) return void 0;
+  return word;
+}
+function wrapper_writes(segment) {
+  const words = git_argv.words_of(segment);
+  const index = words.findIndex((word) => TIME_PROGRAM.test(word));
+  if (index === -1) return false;
+  const call = git_argv.program_of(segment);
+  const program_index = words.length - (call?.args.length ?? 0) - 1;
+  return words.slice(index + 1, program_index).some((word) => {
+    const argument = plain_argument(word);
+    return argument === void 0 || TIME_WRITE.test(argument);
+  });
+}
+function is_copy_to_last(call) {
+  if (!COPY_PROGRAMS.has(call.name)) return false;
+  return call.args.every((argument) => !TARGET_DIRECTORY.test(argument));
+}
+function written_args(call) {
+  const written = is_copy_to_last(call) ? call.args.slice(-1) : call.args;
+  return written.map((argument) => argument.slice(argument.indexOf("=") + 1));
+}
+function is_outside(target, root) {
+  const relative = path.relative(root, path.resolve(root, target.replaceAll(QUOTES2, "")));
+  return relative.startsWith("..") || path.isAbsolute(relative);
+}
+function file_write_refusal(call, root) {
+  return write_args_are_unsafe(call.args, root) ? `\`${call.name}\` to a runtime path` : void 0;
+}
+function writes_elsewhere(call) {
+  if (MOVE_PROGRAMS.has(call.name)) return true;
+  return IN_PLACE_PROGRAMS.has(call.name) && call.args.some((argument) => IN_PLACE.test(argument));
+}
+function outside_write_refusal(call, root) {
+  if (!writes_elsewhere(call)) return void 0;
+  const target = written_args(call).find(
+    (argument) => is_outside(argument, root) && unsafe_path(argument, root)
+  );
+  return target === void 0 ? void 0 : `\`${call.name}\` to a runtime path outside this checkout`;
+}
+function call_refusal(segment, call, root) {
+  if (FILE_PROGRAMS.has(call.name)) return file_write_refusal(call, root);
+  if (implementation_shell_nested.reads_stdin(call)) return STDIN_SHELL;
+  const args = call.args.map((argument) => argument.replaceAll(ARGUMENT_QUOTES, ""));
+  const name = call.name.replaceAll(ARGUMENT_QUOTES, "");
+  const outside = outside_write_refusal(call, root);
+  return outside ?? implementation_shell_deny.refusal(segment, { name, args });
+}
+function body_of(segment) {
+  const body = segment.replace(COMPOUND_HEAD, "");
+  let end = body.length;
+  while (end > 0 && COMPOUND_CLOSERS.has(body.charAt(end - 1))) end -= 1;
+  return body.slice(0, end);
+}
+function call_of(segment) {
+  const body = body_of(segment);
+  if (KEYWORDS.has(git_argv.words_of(body)[0] ?? "")) return void 0;
+  return git_argv.program_of(body);
+}
+function command_refusal(segment, root) {
+  const call = call_of(segment);
+  return call === void 0 ? void 0 : call_refusal(body_of(segment), call, root);
+}
+function is_unread_body(body) {
+  if (FUNCTION_START.test(body)) return !FUNCTION_HEAD.test(body);
+  return UNREAD_ARMS.some((pattern) => pattern.test(body));
+}
+function segment_refusal(segment, root) {
+  if (wrapper_writes(segment)) return "a time output file";
+  if (is_unread_body(body_of(segment))) return "a `case` arm or function body";
+  const target = redirected_paths(segment).find((redirected) => unsafe_path(redirected, root));
+  return target === void 0 ? command_refusal(segment, root) : `redirect to \`${target}\``;
+}
+function is_cd(segment) {
+  return call_of(segment)?.name === "cd";
+}
+function is_write(segment) {
+  const call = call_of(segment);
+  if (call !== void 0 && (FILE_PROGRAMS.has(call.name) || writes_elsewhere(call))) return true;
+  return redirected_paths(segment).some((redirected) => redirected !== "/dev/null");
+}
+function segments_refusal(segments, root) {
+  const is_moved = segments.some((segment) => is_cd(segment));
+  if (is_moved && segments.some((segment) => is_write(segment))) return CD_WRITE;
+  return segments.map((segment) => segment_refusal(segment, root)).find((rule) => rule !== void 0);
+}
+function nested_lines(line, segments) {
+  const launched = segments.flatMap((segment) => {
+    const call = call_of(segment);
+    return call === void 0 ? [] : implementation_shell_nested.call_commands(call);
+  });
+  return [...implementation_shell_nested.substitution_bodies(line), ...launched];
+}
+function segments_of(command) {
+  const segments = [];
+  const pending = [command];
+  let line = pending.pop();
+  while (line !== void 0) {
+    const cut = shell_segments.quote_aware_commands_of(line);
+    segments.push(...cut);
+    pending.push(...nested_lines(line, cut));
+    line = pending.pop();
+  }
+  return segments;
+}
+function input_refusal(command) {
+  if (command.trim() === "") return "an empty command";
+  return time_shell.has_heredoc(command) ? "a heredoc" : void 0;
+}
+function refusal4(command, root = process.cwd()) {
+  return input_refusal(command) ?? segments_refusal(segments_of(command), root);
+}
+function is_unsafe(command, root = process.cwd()) {
+  return refusal4(command, root) !== void 0;
+}
+var implementation_shell = { is_unsafe, refusal: refusal4 };
+
+// scripts/hooks/implementation-authority.ts
+var HANDOFF = " Implementation refused before execution. Record the plan with issue:plan or issue:comment and hand it to lane:dispatch; repeating the request does not grant authority.";
+var UNKNOWN = " Cannot verify the write targets of this shell or patch input. Use explicit Edit/Write paths for operational records, or hand implementation to a worker lane.";
+var MATCHED = " Matched rule: ";
+function edit_refusal(tool_input) {
+  return step_zero_notice.edited_paths(tool_input).length === 0 ? "no edited path" : void 0;
+}
+function unverified_write(raw_payload) {
+  const payload = hook_tool_payload.parse(raw_payload);
+  if (payload === void 0) return "an unparsed hook payload";
+  if (["apply_patch", "exec"].includes(payload.tool_name)) return `\`${payload.tool_name}\` input`;
+  if (["Edit", "Write"].includes(payload.tool_name)) return edit_refusal(payload.tool_input);
+  if (payload.tool_name !== "Bash") return void 0;
+  return implementation_shell.refusal(time_shell.bash_command(payload.tool_input));
+}
+function reason(raw_payload, context = hook_context.from_process()) {
+  if (agent_session_role.can_implement(context.env)) return void 0;
+  const scope = agent_session_role.scope_line(context.env);
+  if (step_zero_notice.is_runtime_edit(raw_payload, context.cwd, true)) return scope + HANDOFF;
+  const rule = unverified_write(raw_payload);
+  if (rule === void 0) return void 0;
+  return `${scope}${HANDOFF}${UNKNOWN}${MATCHED}${rule}.`;
+}
+var implementation_authority = { reason };
+
+// scripts/hooks/lane-plan-guard.ts
+var COMMAND_DOC = '`docs/josh-commands-lane.md` \u2192 "`josh lane:plan`"';
+var OUTCOMES = "on `yield` end the session with no edit (its lane is given back); on `wait` run it again";
+function reason_text(issue) {
+  const command = `\`pnpm josh lane:plan ${issue} <path>...\``;
+  return `\u26D4 lane plan: run ${command} naming every file the work summary changes before the first implementation edit \u2014 ${OUTCOMES} (${COMMAND_DOC}).`;
+}
+function lane_child_edit(raw_payload, directory, source) {
+  if (!lane_child_marker.is_child_of(directory, source)) return void 0;
+  return step_zero_notice.is_runtime_edit(raw_payload, directory) ? lane_child_marker.marked_issue(source) : void 0;
+}
+function reason2(raw_payload, directory = process.cwd(), source = process.env) {
+  const issue = lane_child_edit(raw_payload, directory, source);
+  if (issue === void 0) return void 0;
+  return lane_plan.is_uncleared(Number(issue), directory) ? reason_text(issue) : void 0;
+}
+var lane_plan_guard = { reason: reason2 };
+
+// scripts/hooks/shell-rules-notice.ts
+var STAMP_PREFIX4 = "josh-shell-rules-notice-";
+var NOTICE2 = "Shell rules: change an existing file with Edit or Write, never a script or heredoc that writes it (file-edits.md); run a josh check with no pipe or under `set -o pipefail`, never `| head` (output-bounds.md).";
+var STAMP = hook_decision.create_refusal_stamp(STAMP_PREFIX4);
+function notice(raw_payload) {
+  const payload = hook_decision.parse_hook_payload(raw_payload);
+  if (payload?.tool_name !== cost_blocks.BASH_TOOL) return void 0;
+  const target = STAMP.path(payload.transcript_path);
+  if (STAMP.last_ms(target) !== hook_decision.NEVER_MS || !STAMP.record(target, Date.now())) {
+    return void 0;
+  }
+  return NOTICE2;
+}
+var shell_rules_notice = { NOTICE: NOTICE2, notice, stamp_path: STAMP.path };
+
+// scripts/hooks/pretool-guard.ts
+var CLEAR = { reason: void 0, notice: void 0, fault: void 0 };
+var HOOK_NAME = "pretool-guard";
+function is_clear(outcome) {
+  return outcome.reason === void 0 && outcome.notice === void 0 && outcome.fault === void 0;
+}
+function combine_outcomes(outcomes, rule_reason, demoted = hook_demoted.rules()) {
+  const reasons = [...outcomes.map((outcome) => outcome.reason), rule_reason].filter(
+    (reason3) => reason3 !== void 0
+  );
+  return hook_demoted.verdict(reasons, demoted) ?? outcomes.find((outcome) => !is_clear(outcome)) ?? CLEAR;
+}
+function with_session_notice(outcome, raw_payload, context) {
+  if (!is_clear(outcome)) return outcome;
+  const notice2 = step_zero_notice.notice(raw_payload, context.cwd) ?? shell_rules_notice.notice(raw_payload);
+  return notice2 === void 0 ? outcome : { reason: void 0, notice: notice2, fault: void 0 };
+}
+function guarded_call(raw_payload) {
+  try {
+    const payload = hook_decision.parse_hook_payload(raw_payload);
+    return payload === void 0 ? void 0 : { name: payload.tool_name, input: payload.tool_input };
+  } catch {
+    return void 0;
+  }
+}
+function authority_outcome(raw_payload, context) {
+  return {
+    reason: implementation_authority.reason(raw_payload, context),
+    notice: void 0,
+    fault: void 0
+  };
+}
+function lane_plan_outcome(raw_payload, context) {
+  const reason3 = lane_plan_guard.reason(raw_payload, context.cwd, context.env);
+  return { reason: reason3, notice: void 0, fault: void 0 };
+}
+function clocked(outcome) {
+  return function clocked_outcome(raw_payload, context) {
+    return outcome(raw_payload, Date.now(), context);
+  };
+}
+var READ_ONLY_TOOLS = /* @__PURE__ */ new Set(["Read", "Glob", "Grep"]);
+var SYNC_GUARDS = [
+  { outcome: authority_outcome, reads: false },
+  { outcome: clocked(batch_outcome), reads: true },
+  { outcome: clocked(investigation_outcome), reads: true },
+  { outcome: clocked(duplicate_read_outcome), reads: true },
+  { outcome: clocked(large_read_outcome), reads: true },
+  { outcome: lane_plan_outcome, reads: false }
+];
+function guard_outcome(raw_payload, context) {
+  const is_read = READ_ONLY_TOOLS.has(guarded_call(raw_payload)?.name ?? "");
+  const outcomes = SYNC_GUARDS.filter((guard) => guard.reads || !is_read).map(
+    (guard) => guard.outcome(raw_payload, context)
+  );
+  return combine_outcomes(
+    outcomes,
+    delivered_rules.delivery(raw_payload, Date.now(), context),
+    hook_demoted.rules(context.env)
+  );
+}
+function pretool_outcome(raw_payload, context = hook_context.from_process()) {
+  return with_session_notice(guard_outcome(raw_payload, context), raw_payload, context);
+}
+async function mark_phase(outcome, raw_payload, context = hook_context.from_process()) {
+  const is_allowed_edit = outcome.reason === void 0 && step_zero_notice.is_runtime_edit(raw_payload, context.cwd);
+  if (is_allowed_edit) await lane_phase.mark_implement(context.cwd, context.env);
+}
+async function async_reason(raw_payload, context) {
+  const watcher = await run_watcher_hook.watcher_hook_reason(raw_payload, context);
+  const state = run_parent_cut_hook.current_state(context);
+  const cut = watcher ?? await run_parent_cut_hook.parent_cut_reason(raw_payload, Date.now(), state);
+  const poll = cut ?? await run_poll_hook.safe_poll_reason(raw_payload, context);
+  return poll ?? await issue_watch_hook.watch_reason(context);
+}
+async function pretool_outcome_async(raw_payload, context = hook_context.from_process()) {
+  const base = guard_outcome(raw_payload, context);
+  if (base.reason !== void 0) return base;
+  const reason3 = await async_reason(raw_payload, context);
+  if (reason3 !== void 0) return { reason: reason3, notice: void 0, fault: void 0 };
+  const outcome = with_session_notice(base, raw_payload, context);
+  await mark_phase(outcome, raw_payload, context);
+  return outcome;
+}
+function rewrite_context(note, outcome) {
+  return [note, outcome.notice ?? outcome.fault].filter(Boolean).join("\n\n");
+}
+function foreground_input_of(raw_payload, is_lane_child) {
+  const call = guarded_call(raw_payload);
+  return call === void 0 ? void 0 : lane_background.foreground_input(call, is_lane_child);
+}
+function foreground_rewrite(outcome, raw_payload, is_lane_child, rewrite) {
+  const input = outcome.reason === void 0 ? foreground_input_of(raw_payload, is_lane_child) : void 0;
+  if (input === void 0) return void 0;
+  const note = [rewrite?.note, lane_background.FOREGROUND_NOTE].filter(Boolean).join("\n\n");
+  const envelope_of = rewrite === void 0 ? hook_decision.rewrite_envelope : hook_decision.flow_rewrite_envelope;
+  return envelope_of(input, rewrite_context(note, outcome));
+}
+function rule_envelope(outcome, rewrite) {
+  if (rewrite === void 0 || outcome.reason !== void 0) return void 0;
+  return hook_decision.flow_rewrite_envelope(rewrite.input, rewrite_context(rewrite.note, outcome));
+}
+function emit(raw_payload, outcome, rewrite, context = hook_context.from_process()) {
+  const is_lane_child = lane_child_marker.is_child_of.bind(void 0, context.cwd, context.env);
+  const envelope = foreground_rewrite(outcome, raw_payload, is_lane_child, rewrite) ?? rule_envelope(outcome, rewrite);
+  if (envelope === void 0) hook_decision.emit_outcome(outcome);
+  else process.stdout.write(`${envelope}
+`);
+}
+async function record_refusal(judged_payload, outcome, context = hook_context.from_process(), demoted = hook_demoted.rules(context.env)) {
+  const refusal5 = outcome.reason ?? hook_demoted.refusal_of(outcome.notice, demoted);
+  await hook_ledger.record_reason(HOOK_NAME, refusal5, judged_payload, context);
+  if (outcome.reason === void 0) await direct_gh_usage.record(judged_payload, context);
+}
+async function respond(raw_payload, context = hook_context.from_process()) {
+  const rewrite = rule_rewrite.rewrite(raw_payload, context);
+  const judged = rewrite?.payload ?? raw_payload;
+  bash_revert.stamp(judged, context.cwd);
+  const outcome = await pretool_outcome_async(judged, context);
+  emit(judged, outcome, rewrite, context);
+  await record_refusal(judged, outcome, context);
+}
+var pretool_guard = {
+  combine_outcomes,
+  emit,
+  foreground_rewrite,
+  mark_phase,
+  pretool_outcome,
+  record_refusal,
+  respond
+};
+
+export {
+  pretool_guard
+};