@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-W4BR6QNU.js

@@ -1,1241 +0,0 @@
-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
-};