@joshuafolkken/kit 1.872.0 → 1.881.0

package/dist/hooks/chunk-AD3XE3QZ.js

@@ -1,397 +0,0 @@
-import {
-  lane_guard_policy,
-  time_batch_guard
-} from "./chunk-BODUSXKK.js";
-import {
-  hook_decision
-} from "./chunk-GX4HO7SJ.js";
-import {
-  cost_blocks,
-  cost_transcript,
-  time_bundle_call,
-  time_shell,
-  time_spans
-} from "./chunk-ECXVCCVD.js";
-
-// scripts/delegation/investigation-guard.ts
-import { text } from "node:stream/consumers";
-import { fileURLToPath } from "node:url";
-
-// scripts/delegation/investigation-reads.ts
-import path from "node:path";
-
-// scripts/delegation/delegation-policy.ts
-var DELEGATE_VERDICT = "delegate";
-var KEEP_VERDICT = "keep";
-var INVESTIGATION_FILE_THRESHOLD = 3;
-var DELEGATABLE_STEPS = [
-  {
-    name: "gate-fix",
-    does: "apply the fixes the verification gate already named \u2014 a lint rule, a type error, a spelling the dictionary rejects",
-    verifier: "`pnpm josh gate` is re-run; a wrong fix fails it again, and the failure names the file"
-  },
-  {
-    name: "epic-child",
-    // One row, two entry points: an epic's child under `epicrun` and one named issue of a
-    // `backlogrun` are the same unit — same brief, same summary, same verifier
-    // (joshuafolkken/kit#1149, folded from `queue` into `backlogrun` by joshuafolkken/kit#1984). A
-    // second row for the batch would be the clone `CLAUDE.md` prohibits.
-    does: "run one child of a batch end to end in an isolated unit \u2014 an epic's child or one named issue of a `backlogrun` alike \u2014 plan, verification gate, PR, merge \u2014 and return only its summary to the parent loop",
-    verifier: "the parent reads the child's state from GitHub with `pnpm josh issue:state`, not from the summary; a child reported done but not merged is still open, which is the failure showing rather than a run continuing, and its own gate, `/code-review` and CI ran inside the unit before `followup` would touch the PR"
-  },
-  {
-    name: "followup-filing",
-    // The late-run follow-up filing chain — issue:scout → file the Issue → epic:bundle → epic --add
-    // — is a dependency chain `batch:guard` correctly keeps one call per step, and what makes it
-    // expensive is the ~340k context it runs in at the tail of a run, not the step count
-    // (joshuafolkken/kit#1892). A fresh unit runs the same chain at a small context, and the review
-    // round cap already composed the finding text, so what the unit is handed is mechanical: run the
-    // four commands and act on their deterministic answers. This is not `batch:guard`'s business —
-    // the chain stays one call per step; delegation only moves it to a cheaper context.
-    does: "run the late-run follow-up filing chain in an isolated unit \u2014 issue:scout, file the Issue, epic:bundle, epic --add \u2014 given the finding text the parent already composed, and return the new Issue number and the epic:bundle answer",
-    verifier: "the parent reads the filed Issue from GitHub with `pnpm josh issue:state <new>`, not the unit's summary; a follow-up reported filed but not created is still absent, the way `epic-child`'s reported-done-but-not-merged child is still open. The finding text came from the parent and `issue:scout` / `epic:bundle` are deterministic, so the unit's work is the mechanical execution `issue:state` confirms"
-  },
-  {
-    name: "survey",
-    does: "read across many files and report where something appears \u2014 every reference to a symbol, which documents carry a marker",
-    verifier: "the reported locations are checked directly; a fabricated or missed location does not survive one `grep` of what it claimed"
-  },
-  {
-    name: "investigation",
-    // Not `survey`: that row reports *where* something appears and is checked by one `grep`, while
-    // this one reports *how the subject works* and is checked by opening the lines it cited. The two
-    // verifiers differ, so widening `survey` would put both in one field and lose the boundary below.
-    // **No ordinal.** `${N}rd` would print `1rd` for any other threshold, past a test that only looks
-    // for the numeral, so the count is phrased as a plain "N or more".
-    does: `read the Issue's subject to find out how it currently works \u2014 once ${String(INVESTIGATION_FILE_THRESHOLD)} or more files the run will not edit have to be read \u2014 and return the conclusion plus the \`file:line\` citations that support it, never the file text, which would put the cost back where it was. A throwaway probe script is written, run and deleted inside the unit, which returns its output alone`,
-    verifier: "the parent opens the cited lines; a conclusion those lines do not support fails there, and reading a handful of cited regions costs far less than redoing the reading. The unit reports what the code does and never what to change \u2014 deciding that is `diagnosis`, which stays kept, so a unit returning a root cause would be delegating the rejected row under this name"
-  }
-];
-var REJECTED_STEPS = [
-  {
-    name: "notify-body",
-    because: "no verifier. A notification with a wrong body is sent and read as though it were right; nothing in the run disagrees with it afterwards"
-  },
-  {
-    name: "issue-comment",
-    because: "no verifier. A decision log or completion comment that says the wrong thing is the record, so there is nothing left to check it against"
-  },
-  {
-    name: "status-read",
-    because: "a misread routes the run to the wrong child, and no later step disagrees. Running the status command is already cheap; what is expensive is acting on it, which is not this step"
-  },
-  {
-    name: "diagnosis",
-    because: "a wrong root cause produces a fix that passes the gate and leaves the defect"
-  },
-  {
-    name: "design",
-    because: "the cost of a wrong design is paid by every step after it"
-  },
-  {
-    name: "split-assessment",
-    because: "a missed split widens one Issue into a batch nobody authorized"
-  },
-  {
-    name: "review",
-    because: "the review is the last thing between a defect and a merge; a cheaper one finds less"
-  }
-];
-function find_step(name) {
-  return DELEGATABLE_STEPS.find((step2) => step2.name === name.trim());
-}
-function verdict_for(name) {
-  return find_step(name) === void 0 ? KEEP_VERDICT : DELEGATE_VERDICT;
-}
-function rejection_for(name) {
-  return REJECTED_STEPS.find((step2) => step2.name === name.trim());
-}
-function reason_for(name) {
-  const step2 = find_step(name);
-  if (step2 !== void 0) return `delegatable: ${step2.verifier}`;
-  const rejected = rejection_for(name);
-  if (rejected !== void 0) return `kept deliberately: ${rejected.because}`;
-  return "kept by default: not on the delegatable list, and the list is the whole of it";
-}
-var delegation_policy = {
-  DELEGATE_VERDICT,
-  INVESTIGATION_FILE_THRESHOLD,
-  KEEP_VERDICT,
-  DELEGATABLE_STEPS,
-  REJECTED_STEPS,
-  find_step,
-  verdict_for,
-  rejection_for,
-  reason_for
-};
-
-// scripts/delegation/investigation-reads.ts
-var READ_TOOLS = /* @__PURE__ */ new Set(["Read"]);
-var DELEGATION_TOOLS = /* @__PURE__ */ new Set(["Agent", "Task"]);
-var CONTENT_READ_COMMANDS = [
-  "bat",
-  "cat",
-  "head",
-  "less",
-  "more",
-  "nl",
-  "sed",
-  "tail"
-];
-var CONTENT_READ_LABELS = new Set(
-  CONTENT_READ_COMMANDS.map((command) => time_shell.bash_label(command))
-);
-var REASON = `\u26D4 investigation: ${String(delegation_policy.INVESTIGATION_FILE_THRESHOLD)} files read and not edited since the last delegated unit, so the reading from here goes to a unit of its own. Ask \`pnpm josh delegate investigation\`, then brief a unit with what the main line has already concluded and what is left to find out; it returns the conclusion plus its \`file:line\` citations, never the file text. Keep a read in the main line only where this run will edit that file \u2014 an \`Edit\` cannot be issued against text you do not hold. This run's own instructions and the harness's own session files \u2014 a backgrounded call's output, a persisted tool result, this session's scratchpad \u2014 are never counted, so they are not what took the count here. The rule is \`.claude/skills/workflow-commands/SKILL.md\` \u2192 \xA72b, "The pre-implementation reading".`;
-var INSTRUCTION_PATHS = ["prompts", ".claude/skills"];
-var INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md", "GEMINI.md"]);
-var REPOSITORY_ROOT = process.cwd();
-function resolved(target) {
-  return path.resolve(REPOSITORY_ROOT, target);
-}
-function repository_relative(absolute) {
-  return path.relative(REPOSITORY_ROOT, absolute);
-}
-function is_instruction_document(target) {
-  const relative = repository_relative(resolved(target));
-  const segments = relative.split(path.sep);
-  return INSTRUCTION_FILES.has(segments.at(-1) ?? "") || INSTRUCTION_PATHS.some((prefix) => relative.startsWith(`${prefix}${path.sep}`));
-}
-var SESSION_TEMP_SEGMENT = /^claude-\d+$/u;
-var SESSION_STATE_SEGMENTS = cost_transcript.TRANSCRIPT_ROOT.split(path.sep);
-var HARNESS_OUTPUT_DIRECTORY = "tasks";
-var HARNESS_OUTPUT_EXTENSION = ".output";
-var FILE_SEGMENT_INDEX = -1;
-var PARENT_SEGMENT_INDEX = -2;
-function has_state_root(segments, index) {
-  return SESSION_STATE_SEGMENTS.every((segment, offset) => segments[index + offset] === segment);
-}
-function is_harness_output(segments) {
-  return segments.some((segment) => SESSION_TEMP_SEGMENT.test(segment)) && segments.at(PARENT_SEGMENT_INDEX) === HARNESS_OUTPUT_DIRECTORY && (segments.at(FILE_SEGMENT_INDEX) ?? "").endsWith(HARNESS_OUTPUT_EXTENSION);
-}
-function is_outside_repository(absolute) {
-  return repository_relative(absolute).startsWith("..");
-}
-function is_session_artifact(target) {
-  const absolute = resolved(target);
-  const segments = absolute.split(path.sep);
-  if (!is_outside_repository(absolute)) return false;
-  return segments.some((_segment, index) => has_state_root(segments, index)) || is_harness_output(segments);
-}
-function is_subject_file(target) {
-  return !is_instruction_document(target) && !is_session_artifact(target);
-}
-function is_nameable_file(target) {
-  return !target.includes("*") && !target.includes("?");
-}
-function is_content_read(label) {
-  return READ_TOOLS.has(label) || CONTENT_READ_LABELS.has(label);
-}
-function subject_targets(targets) {
-  return targets.filter((target) => is_nameable_file(target) && is_subject_file(target)).map((target) => resolved(target));
-}
-function call_targets(call) {
-  return subject_targets(time_bundle_call.call_facts(call.name, call.input).targets);
-}
-function delegation_instant(span) {
-  return span === void 0 ? hook_decision.NEVER_MS : span.ended_ms;
-}
-function is_failed_outcome(span) {
-  return span.outcome === time_spans.FAILED_OUTCOME;
-}
-function edited_files(spans) {
-  const written = spans.filter((span) => !is_failed_outcome(span)).flatMap((span) => subject_targets(span.writes));
-  return new Set(written);
-}
-function add_all(pending, targets, at_ms) {
-  for (const target of targets) if (!pending.has(target)) pending.set(target, at_ms);
-}
-function apply_span(pending, span, edited) {
-  if (DELEGATION_TOOLS.has(span.label)) {
-    pending.clear();
-    return;
-  }
-  if (!is_content_read(span.label) || is_failed_outcome(span)) return;
-  const fresh = subject_targets(span.targets).filter((target) => !edited.has(target));
-  add_all(pending, fresh, span.ended_ms);
-}
-function last_delegation_ms(spans) {
-  return delegation_instant(spans.findLast((span) => DELEGATION_TOOLS.has(span.label)));
-}
-function pending_after(pending, since_ms) {
-  return [...pending.values()].filter((at_ms) => at_ms > since_ms).length;
-}
-function tally_of(text2, since_ms = hook_decision.NEVER_MS) {
-  const { spans, started_ms } = time_spans.parse_timeline(text2);
-  const edited = edited_files(spans);
-  const pending = /* @__PURE__ */ new Map();
-  for (const span of spans) apply_span(pending, span, edited);
-  return {
-    pending: [...pending.keys()],
-    pending_since: pending_after(pending, since_ms),
-    reset_ms: last_delegation_ms(spans),
-    window_start_ms: started_ms,
-    edited
-  };
-}
-function projected_count(pending, call, edited = /* @__PURE__ */ new Set()) {
-  return (/* @__PURE__ */ new Set([...pending, ...call_targets(call).filter((target) => !edited.has(target))])).size;
-}
-function is_at_threshold(pending_count) {
-  return pending_count + 1 >= delegation_policy.INVESTIGATION_FILE_THRESHOLD;
-}
-function has_cleared_the_disarm(tally, refused_at_ms) {
-  return tally.reset_ms > refused_at_ms || refused_at_ms < tally.window_start_ms;
-}
-function is_rearmed(tally, refused_at_ms) {
-  if (refused_at_ms === hook_decision.NEVER_MS || has_cleared_the_disarm(tally, refused_at_ms)) {
-    return true;
-  }
-  return is_at_threshold(tally.pending_since);
-}
-function is_unit_transcript(transcript) {
-  return transcript.split(path.sep).includes(cost_transcript.UNIT_DIRECTORY);
-}
-function is_unit_run(run) {
-  return run !== void 0 && is_unit_transcript(run.transcript);
-}
-function is_refusable_command(call) {
-  const label = time_shell.bash_label(time_shell.bash_command(call.input));
-  return CONTENT_READ_LABELS.has(label) && time_batch_guard.is_read_only_call(call);
-}
-function is_refusable_call(call) {
-  if (call_targets(call).length === 0) return false;
-  if (READ_TOOLS.has(call.name)) return true;
-  return call.name === cost_blocks.BASH_TOOL && is_refusable_command(call);
-}
-function should_block(text2, call, refused_at_ms, run) {
-  if (!is_refusable_call(call) || is_unit_run(run)) return false;
-  const tally = tally_of(text2, refused_at_ms);
-  if (!is_at_threshold(tally.pending.length)) return false;
-  return projected_count(tally.pending, call, tally.edited) > tally.pending.length && is_rearmed(tally, refused_at_ms);
-}
-var EDIT_TARGET_CLASS = "edit targets";
-var UNDER_THRESHOLD_CLASS = "under the threshold";
-var REFUSED_CLASS = "refused";
-var LET_THROUGH_CLASS = "let through";
-var READ_CLASSES = [
-  EDIT_TARGET_CLASS,
-  UNDER_THRESHOLD_CLASS,
-  REFUSED_CLASS,
-  LET_THROUGH_CLASS
-];
-var NEVER_REFUSED_LABELS = /* @__PURE__ */ new Set([time_shell.bash_label("sed")]);
-function tally_now(replay) {
-  return {
-    pending: [...replay.pending.keys()],
-    pending_since: pending_after(replay.pending, replay.refused_at_ms),
-    reset_ms: replay.reset_ms,
-    window_start_ms: replay.window_start_ms,
-    edited: replay.edited
-  };
-}
-function reaches_threshold(replay, targets) {
-  const added = targets.filter((target) => !replay.pending.has(target));
-  return added.length > 0 && is_at_threshold(replay.pending.size);
-}
-function would_refuse(replay, span) {
-  if (NEVER_REFUSED_LABELS.has(span.label)) return false;
-  return is_rearmed(tally_now(replay), replay.refused_at_ms);
-}
-function class_of(replay, span, edited) {
-  const fresh = subject_targets(span.targets).filter((target) => !edited.has(target));
-  if (fresh.length === 0) return EDIT_TARGET_CLASS;
-  if (!reaches_threshold(replay, fresh)) return UNDER_THRESHOLD_CLASS;
-  return would_refuse(replay, span) ? REFUSED_CLASS : LET_THROUGH_CLASS;
-}
-function read_class(replay, span, edited) {
-  if (!is_content_read(span.label)) return void 0;
-  if (subject_targets(span.targets).length === 0) return void 0;
-  return class_of(replay, span, edited);
-}
-function step(replay, span, edited) {
-  if (DELEGATION_TOOLS.has(span.label)) {
-    replay.reset_ms = span.ended_ms;
-    apply_span(replay.pending, span, edited);
-    return void 0;
-  }
-  const found = read_class(replay, span, edited);
-  if (found === REFUSED_CLASS) replay.refused_at_ms = span.ended_ms;
-  apply_span(replay.pending, span, edited);
-  return found;
-}
-var FIRST_SPAN = 0;
-function fresh_replay(spans, edited) {
-  return {
-    pending: /* @__PURE__ */ new Map(),
-    reset_ms: hook_decision.NEVER_MS,
-    window_start_ms: spans[FIRST_SPAN]?.ended_ms ?? hook_decision.NEVER_MS,
-    refused_at_ms: hook_decision.NEVER_MS,
-    edited
-  };
-}
-function classified_reads(spans) {
-  const edited = edited_files(spans);
-  const replay = fresh_replay(spans, edited);
-  const reads = [];
-  for (const [index, span] of spans.entries()) {
-    const found = step(replay, span, edited);
-    if (found !== void 0) reads.push({ found, index });
-  }
-  return reads;
-}
-var investigation_reads = {
-  CONTENT_READ_COMMANDS,
-  EDIT_TARGET_CLASS,
-  LET_THROUGH_CLASS,
-  READ_CLASSES,
-  REFUSED_CLASS,
-  UNDER_THRESHOLD_CLASS,
-  classified_reads,
-  subject_targets,
-  DELEGATION_TOOLS,
-  READ_TOOLS,
-  REASON,
-  is_at_threshold,
-  is_content_read,
-  is_instruction_document,
-  is_rearmed,
-  is_refusable_call,
-  is_session_artifact,
-  is_subject_file,
-  projected_count,
-  resolved,
-  should_block,
-  tally_of
-};
-
-// scripts/delegation/investigation-guard.ts
-var SWITCH_ENV_KEY = "JOSH_INVESTIGATION_GUARD";
-function should_block2(tail, call, refused_at_ms, run) {
-  if (lane_guard_policy.is_suppressed_here("investigation")) return false;
-  return investigation_reads.should_block(tail, call, refused_at_ms, run);
-}
-var GUARD = hook_decision.create_transcript_guard({
-  prefix: "josh-investigation-guard-",
-  switch_key: SWITCH_ENV_KEY,
-  is_candidate: investigation_reads.is_refusable_call,
-  should_block: should_block2,
-  reason: investigation_reads.REASON
-});
-var investigation_refusal = GUARD.refusal;
-var { is_enabled, refusal_path } = GUARD;
-var { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision;
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("investigation:guard");
-  else hook_decision.write_decision(await text(process.stdin), investigation_refusal);
-}
-
-export {
-  investigation_reads,
-  SWITCH_ENV_KEY,
-  investigation_refusal,
-  is_enabled,
-  refusal_path,
-  deny_envelope,
-  load_environment_file,
-  DISABLED_VALUES
-};

package/dist/hooks/chunk-AENFZPZH.js

@@ -1,230 +0,0 @@
-import {
-  lane_paths,
-  stamp_file,
-  time_density_hook,
-  time_hook_transcript
-} from "./chunk-Q32WETDO.js";
-import {
-  josh_environment_file
-} from "./chunk-ITVJ2MKQ.js";
-
-// scripts/josh/hook-decision.ts
-import { z } from "zod";
-var payload_schema = z.object({
-  transcript_path: z.string().min(1),
-  // **`nullish`, not `optional`.** A payload spelling the absent agent as `null` has to read as "no
-  // fork"; rejected, it would fail `safeParse` for the whole payload and take the guard off every
-  // call of the main line, in silence — the failure every other path here is written to avoid.
-  agent_id: z.string().nullish(),
-  tool_name: z.string().min(1),
-  tool_input: z.unknown()
-});
-var refusal_schema = z.object({ refused_at_ms: z.number() });
-var HOOK_EVENT_NAME = "PreToolUse";
-var DENY_DECISION = "deny";
-var NEVER_MS = 0;
-var MISSING_FILE = "ENOENT";
-var DISABLED_VALUES = ["off", "0", "false", "no"];
-function is_switch_enabled(key) {
-  return !DISABLED_VALUES.includes((process.env[key] ?? "").trim().toLowerCase());
-}
-function parse_hook_payload(raw_payload) {
-  const parsed = payload_schema.safeParse(JSON.parse(raw_payload));
-  return parsed.success ? parsed.data : void 0;
-}
-function deny_envelope(reason) {
-  return JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      permissionDecision: DENY_DECISION,
-      permissionDecisionReason: reason
-    }
-  });
-}
-function notice_envelope(notice) {
-  return JSON.stringify({
-    systemMessage: notice,
-    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: notice }
-  });
-}
-function stamp_fault(switch_key) {
-  return `\u26A0 ${switch_key}: the run is past the limit but the refusal stamp could not be written, so this call was allowed rather than refused. Without the stamp a refusal could repeat and wedge the run. Batch the calls that do not need each other anyway, and check the temp directory is writable.`;
-}
-function is_missing_file(error) {
-  if (!(error instanceof Error) || !("code" in error)) return false;
-  return typeof error.code === "string" && error.code === MISSING_FILE;
-}
-function error_text(error) {
-  if (error instanceof Error) return error.message;
-  return typeof error === "string" ? error : "a value that is not an error";
-}
-function fault_notice(switch_key, error) {
-  if (is_missing_file(error)) return void 0;
-  const detail = error_text(error);
-  return `\u26A0 ${switch_key}: the guard could not read the run's history, so this call was allowed without being checked \u2014 silence here is not evidence that the run is batching. Cause: ${detail}`;
-}
-function last_refusal_ms(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return NEVER_MS;
-  try {
-    return refusal_schema.parse(JSON.parse(raw)).refused_at_ms;
-  } catch {
-    return NEVER_MS;
-  }
-}
-function record_refusal(target, now_ms) {
-  try {
-    stamp_file.write_stamp(target, { refused_at_ms: now_ms });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function create_refusal_stamp(prefix) {
-  function path(transcript_path) {
-    return stamp_file.stamp_path(prefix, transcript_path);
-  }
-  return { path, last_ms: last_refusal_ms, record: record_refusal };
-}
-var { load_environment_file } = josh_environment_file;
-var NO_OUTCOME = { reason: void 0, notice: void 0, fault: void 0 };
-function fire_once(stamp, run, should_fire, switch_key) {
-  const target = stamp.path(run.transcript);
-  if (!should_fire(stamp.last_ms(target))) return { fired: false, fault: void 0 };
-  if (!stamp.record(target, run.now_ms)) return { fired: false, fault: stamp_fault(switch_key) };
-  return { fired: true, fault: void 0 };
-}
-function block_outcome(context) {
-  const { spec, stamp, tail, call, run } = context;
-  const result = fire_once(
-    stamp,
-    run,
-    (last_fired_ms) => spec.should_block(tail, call, last_fired_ms, run),
-    spec.switch_key
-  );
-  if (result.fired) return { reason: spec.reason, notice: void 0, fault: void 0 };
-  return { reason: void 0, notice: void 0, fault: result.fault };
-}
-function notify_outcome(context) {
-  const { spec, notify_stamp, tail, call, run } = context;
-  if (notify_stamp === void 0 || spec.notify === void 0) return NO_OUTCOME;
-  const { notify } = spec;
-  const result = fire_once(
-    notify_stamp,
-    run,
-    (last_fired_ms) => notify.should_notify(tail, call, last_fired_ms, run),
-    spec.switch_key
-  );
-  if (result.fired) return { reason: void 0, notice: notify.text(call, tail), fault: void 0 };
-  return { reason: void 0, notice: void 0, fault: result.fault };
-}
-function is_clear(outcome) {
-  return outcome.reason === void 0 && outcome.notice === void 0 && outcome.fault === void 0;
-}
-function guard_reason_for_payload(parts, payload, now_ms) {
-  const call = { name: payload.tool_name, input: payload.tool_input };
-  if (!parts.spec.is_candidate(call)) return NO_OUTCOME;
-  const transcript = time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
-  const tail = time_density_hook.read_tail(transcript);
-  const context = { ...parts, tail, call, run: { transcript, now_ms } };
-  const blocked = block_outcome(context);
-  if (!is_clear(blocked)) return blocked;
-  return notify_outcome(context);
-}
-function guard_outcome(parts, raw_payload, now_ms) {
-  const payload = parse_hook_payload(raw_payload);
-  if (payload === void 0 || !is_switch_enabled(parts.spec.switch_key)) return NO_OUTCOME;
-  return guard_reason_for_payload(parts, payload, now_ms);
-}
-function create_transcript_guard(spec) {
-  const stamp = create_refusal_stamp(spec.prefix);
-  const notify_stamp = spec.notify ? create_refusal_stamp(spec.notify.prefix) : void 0;
-  const parts = { spec, stamp, notify_stamp };
-  function is_enabled() {
-    return is_switch_enabled(spec.switch_key);
-  }
-  function refusal_path(transcript_path) {
-    return stamp.path(transcript_path);
-  }
-  function outcome(raw_payload, now_ms = Date.now()) {
-    try {
-      return guard_outcome(parts, raw_payload, now_ms);
-    } catch (error) {
-      return { reason: void 0, notice: void 0, fault: fault_notice(spec.switch_key, error) };
-    }
-  }
-  function refusal(raw_payload, now_ms = Date.now()) {
-    return outcome(raw_payload, now_ms).reason;
-  }
-  return { is_enabled, outcome, refusal, refusal_path };
-}
-function write_outcome(raw_payload, outcome) {
-  load_environment_file();
-  const { reason, notice, fault } = outcome(raw_payload);
-  if (reason !== void 0) process.stdout.write(`${deny_envelope(reason)}
-`);
-  else if (notice !== void 0) process.stdout.write(`${notice_envelope(notice)}
-`);
-  else if (fault !== void 0) process.stdout.write(`${notice_envelope(fault)}
-`);
-}
-function write_decision(raw_payload, refusal) {
-  write_outcome(raw_payload, (raw) => ({
-    reason: refusal(raw),
-    notice: void 0,
-    fault: void 0
-  }));
-}
-function report_no_payload(command) {
-  process.stderr.write(
-    `${command} reads a Claude Code hook payload on stdin; it is not run by hand.
-`
-  );
-}
-var hook_decision = {
-  DISABLED_VALUES,
-  NEVER_MS,
-  create_refusal_stamp,
-  create_transcript_guard,
-  deny_envelope,
-  fault_notice,
-  is_switch_enabled,
-  load_environment_file,
-  notice_envelope,
-  parse_hook_payload,
-  report_no_payload,
-  stamp_fault,
-  write_decision,
-  write_outcome
-};
-
-// scripts/run/run-issue-number.ts
-var ISSUE_NUMBER_PATTERN = /^[1-9]\d*$/u;
-var BAD_ISSUE_MESSAGE = "Not an issue number: ";
-function require_issue_number(issue) {
-  if (!ISSUE_NUMBER_PATTERN.test(issue)) throw new Error(`${BAD_ISSUE_MESSAGE}${issue}`);
-}
-var run_issue_number = { BAD_ISSUE_MESSAGE, ISSUE_NUMBER_PATTERN, require_issue_number };
-
-// scripts/lane/lane-child-marker.ts
-var KEY = "JOSH_LANE_CHILD";
-function environment_for(issue) {
-  run_issue_number.require_issue_number(issue);
-  return { [KEY]: issue };
-}
-function marked_issue(source = process.env) {
-  const value = source[KEY];
-  if (value === void 0) return void 0;
-  return run_issue_number.ISSUE_NUMBER_PATTERN.test(value) ? value : void 0;
-}
-function is_child_of(directory, source = process.env) {
-  const marked = marked_issue(source);
-  return marked !== void 0 && marked === lane_paths.lane_issue_of(directory, { ...source });
-}
-var lane_child_marker = { KEY, env_for: environment_for, is_child_of, marked_issue };
-
-export {
-  hook_decision,
-  run_issue_number,
-  lane_child_marker
-};

package/dist/hooks/chunk-AFKRFQ6W.js

@@ -1,68 +0,0 @@
-import {
-  investigation_reads
-} from "./chunk-AXQBNFEF.js";
-import {
-  lane_guard_policy
-} from "./chunk-I4D3NVUD.js";
-import {
-  hook_decision
-} from "./chunk-3PWPYDD2.js";
-
-// scripts/delegation/investigation-guard.ts
-import { text } from "node:stream/consumers";
-import { fileURLToPath } from "node:url";
-var SWITCH_ENV_KEY = "JOSH_INVESTIGATION_GUARD";
-var STAMP_PREFIX = "josh-investigation-guard-";
-var NOTICE_STAMP_PREFIX = "josh-investigation-guard-notice-";
-function investigation_mode() {
-  return lane_guard_policy.mode_here("investigation");
-}
-function should_block(tail, call, refused_at_ms, run) {
-  if (investigation_mode() !== "refuse") return false;
-  return investigation_reads.should_block(tail, call, refused_at_ms, run);
-}
-function should_notify(tail, call, notified_at_ms, run) {
-  if (investigation_mode() !== "notice") return false;
-  return investigation_reads.should_block(tail, call, notified_at_ms, run);
-}
-var NOTICE = `\u{1F4A1} investigation: files read and not edited since the last delegated unit reached the threshold, so the reading from here should go to a unit of its own. This is a notice, not a refusal \u2014 the read proceeds, because a dispatched lane child ends its turn on a denial. Ask \`pnpm josh delegate investigation\`, then brief a unit with what the main line has already concluded and what is left to find out; it returns the conclusion plus its \`file:line\` citations, never the file text. Keep a read in the main line only where this run will edit that file. This recurs on the next accumulation.`;
-function notice_text(_call, tail) {
-  const pending = investigation_reads.tally_of(tail).pending.map((absolute) => investigation_reads.repository_relative(absolute));
-  return pending.length === 0 ? NOTICE : `${NOTICE} Read and not edited so far: ${pending.join(" ")}.`;
-}
-var GUARD = hook_decision.create_transcript_guard({
-  prefix: STAMP_PREFIX,
-  switch_key: SWITCH_ENV_KEY,
-  is_candidate: investigation_reads.is_refusable_call,
-  should_block,
-  reason: investigation_reads.REASON,
-  // The lane-child notice fires where the refusal is withheld (kit#2382), on a record of its own so it
-  // never spends the refusal's stamp.
-  notify: {
-    prefix: NOTICE_STAMP_PREFIX,
-    should_notify,
-    text: notice_text
-  }
-});
-var investigation_refusal = GUARD.refusal;
-var investigation_outcome = GUARD.outcome;
-var { is_enabled, refusal_path } = GUARD;
-var investigation_notice_path = hook_decision.create_refusal_stamp(NOTICE_STAMP_PREFIX).path;
-var { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision;
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("investigation:guard");
-  else hook_decision.write_outcome(await text(process.stdin), investigation_outcome);
-}
-
-export {
-  SWITCH_ENV_KEY,
-  NOTICE,
-  investigation_refusal,
-  investigation_outcome,
-  is_enabled,
-  refusal_path,
-  investigation_notice_path,
-  deny_envelope,
-  load_environment_file,
-  DISABLED_VALUES
-};