@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-OTCWA4QE.js

@@ -0,0 +1,910 @@
+import {
+  delegation_policy
+} from "./chunk-6I2JM5UX.js";
+import {
+  backlog_budget
+} from "./chunk-BYSPYVLD.js";
+import {
+  capped_print_part
+} from "./chunk-3WWQFCGX.js";
+import {
+  JOSH_TMP_DIRECTORY
+} from "./chunk-LAYSCY4L.js";
+import {
+  time_batch_guard,
+  time_search_call
+} from "./chunk-ZMWL7LZM.js";
+import {
+  time_bundle_call,
+  time_spans
+} from "./chunk-NXWVWI4U.js";
+import {
+  cost_blocks,
+  time_shell
+} from "./chunk-LHKXJD6L.js";
+import {
+  hook_decision
+} from "./chunk-HXAVYXUS.js";
+import {
+  run_hold,
+  stamp_record
+} from "./chunk-NQ4D2XZY.js";
+import {
+  transcript_record
+} from "./chunk-O3NDWYNT.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  lane_child_invocation
+} from "./chunk-VFW6XZH7.js";
+import {
+  agent_provider,
+  cost_transcript,
+  own_session
+} from "./chunk-DDZVMXZD.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  git_common_directory
+} from "./chunk-MT6TRLFD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+import {
+  git_command,
+  git_diff_reads
+} from "./chunk-KMED24C4.js";
+import {
+  git_spawn_sync
+} from "./chunk-B77ZMVHS.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/cut/run-cut-digest.ts
+import path2 from "node:path";
+
+// scripts/delegation/duplicate-read-guard.ts
+import { statSync } from "node:fs";
+
+// scripts/lane/lane-guard-policy.ts
+var DEFAULT_MODE = "refuse";
+var OFF_MODE = "off";
+var LANE_GUARD_POLICY = [
+  {
+    id: "investigation",
+    mode_in_lane_child: "refuse",
+    because: "the notice was measured not to move the reading \u2014 52% of lane cost stayed in main-line exploration \u2014 and the refusal fires once per accumulation, a round trip the child survives as it survives the rule row, so the child is refused like the main line"
+  },
+  {
+    id: "batching",
+    mode_in_lane_child: "off",
+    because: "a refusal ends a child turn and every advisory notice was measured not to move the call density, so the guard is off and the density stays readable through `josh time:density`"
+  },
+  {
+    id: "search-batching",
+    mode_in_lane_child: "refuse",
+    because: "the largest share of single-call pairs in lane children is a search chain (`grep` / `sed` issued one per turn, about 10,600 pairs in 14 days), and a refusal re-fires only every third single-call search turn, so one refused round trip (about $0.036) is repaid once it folds two later searches into one turn"
+  },
+  {
+    id: "duplicate-read",
+    mode_in_lane_child: "notice",
+    because: "a refusal ends a child turn, yet unchanged re-reads and whole reads of large files are measured in lane children above all, so the child is nudged \u2014 to scroll up to the earlier read, or to read a slice \u2014 by a notice rather than killed; the large-read guard shares this row"
+  },
+  {
+    id: "rule",
+    mode_in_lane_child: "refuse",
+    because: "it carries the lane-only rules a child depends on (`pre-gate-cut`, `implementation-cut`, `lane-park`) and the safety rules it must still obey, and a notice was rejected despite the collateral a refusal costs a batched sibling, because a cut carried as prose was measured never to fire"
+  }
+];
+var KNOWN_GUARD_IDS = LANE_GUARD_POLICY.map((entry) => entry.id);
+function entry_for(id) {
+  return LANE_GUARD_POLICY.find((entry) => entry.id === id.trim());
+}
+function mode_in_lane_child(id) {
+  return entry_for(id)?.mode_in_lane_child ?? DEFAULT_MODE;
+}
+function mode_here(id, directory = process.cwd(), source = process.env) {
+  const lane_mode = mode_in_lane_child(id);
+  if (lane_mode === DEFAULT_MODE) return DEFAULT_MODE;
+  return lane_child_marker.is_child_of(directory, source) ? lane_mode : DEFAULT_MODE;
+}
+function is_suppressed_here(id, directory = process.cwd(), source = process.env) {
+  return mode_here(id, directory, source) === OFF_MODE;
+}
+var lane_guard_policy = {
+  LANE_GUARD_POLICY,
+  KNOWN_GUARD_IDS,
+  entry_for,
+  mode_in_lane_child,
+  mode_here,
+  is_suppressed_here
+};
+
+// scripts/delegation/investigation-reads.ts
+import path from "node:path";
+
+// scripts/git/changed-paths-sync.ts
+function default_branch_reference(options) {
+  const output = git_spawn_sync.read([...git_diff_reads.DEFAULT_BRANCH_ARGUMENTS], options);
+  const default_branch = git_diff_reads.default_branch_of(output);
+  const remote_reference = git_diff_reads.remote_reference_of(default_branch);
+  const check = git_diff_reads.reference_check_arguments(remote_reference);
+  return git_spawn_sync.read(check, options) === void 0 ? default_branch : remote_reference;
+}
+function through_merge(base, reference, options) {
+  const incoming = git_spawn_sync.read(git_diff_reads.incoming_base_arguments(reference), options);
+  if (incoming === void 0) return base;
+  const kept = git_spawn_sync.read(git_diff_reads.later_base_arguments(base, incoming), options);
+  return git_diff_reads.later_base_of(kept, base);
+}
+function change_base(options) {
+  const reference = default_branch_reference(options);
+  const base = git_spawn_sync.read(git_diff_reads.merge_base_arguments(reference), options);
+  if (base === void 0) return reference;
+  return through_merge(base, reference, options);
+}
+function read_changed_paths(cwd) {
+  const options = git_spawn_sync.located(cwd);
+  const tracked = git_spawn_sync.read(
+    git_diff_reads.names_since_arguments(change_base(options)),
+    options
+  );
+  const untracked = git_spawn_sync.read(git_diff_reads.UNTRACKED_ARGUMENTS, options);
+  return [tracked, untracked].flatMap((raw = "") => changed_paths.to_paths(raw));
+}
+var changed_paths_sync = { read_changed_paths, through_merge };
+
+// 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 { INVESTIGATOR_AGENT } = delegation_policy;
+var REASON = `\u26D4 investigation: ${delegation_policy.INVESTIGATION_LIMIT}. ${delegation_policy.INVESTIGATION_STEP} Keep main-line reads to files you will edit; every read-only search turn counts. \`.claude/skills/workflow-commands/delegation.md\``;
+var INSTRUCTION_PATHS = ["prompts", ".claude/skills"];
+var INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md", "GEMINI.md"]);
+function resolved(target, root = process.cwd()) {
+  return path.resolve(root, target);
+}
+function repository_relative(absolute, root) {
+  return path.relative(root, absolute);
+}
+function is_instruction_document(target, root = process.cwd()) {
+  const relative = repository_relative(resolved(target, root), root);
+  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, root) {
+  return repository_relative(absolute, root).startsWith("..");
+}
+function is_session_artifact(target, root = process.cwd()) {
+  const absolute = resolved(target, root);
+  const segments = absolute.split(path.sep);
+  if (!is_outside_repository(absolute, root)) return false;
+  return segments.some((_segment, index) => has_state_root(segments, index)) || is_harness_output(segments) || capped_print_part.is_part_file(absolute);
+}
+function is_subject_file(target, root = process.cwd()) {
+  return !is_instruction_document(target, root) && !is_session_artifact(target, root);
+}
+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, root) {
+  return targets.filter((target) => is_nameable_file(target) && is_subject_file(target, root)).map((target) => resolved(target, root));
+}
+function call_targets(call, root) {
+  return subject_targets(time_bundle_call.call_facts(call.name, call.input).targets, root);
+}
+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, root) {
+  const written = spans.filter((span) => !is_failed_outcome(span)).flatMap((span) => subject_targets(span.writes, root));
+  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 search_turn_key(searches, span) {
+  if (span.message_id !== time_spans.NO_MESSAGE_ID) return span.message_id;
+  return `${time_spans.NO_MESSAGE_ID}#${String(searches.size)}`;
+}
+function apply_search(searches, span) {
+  if (span.is_writing) {
+    searches.clear();
+    return;
+  }
+  const turn = search_turn_key(searches, span);
+  if (time_search_call.is_read_only_search(span) && !searches.has(turn)) {
+    searches.set(turn, span.ended_ms);
+  }
+}
+function is_delegation(span) {
+  return DELEGATION_TOOLS.has(span.label) && !is_failed_outcome(span);
+}
+function apply_span(accumulation, span, edited) {
+  if (is_failed_outcome(span)) return;
+  if (is_delegation(span)) {
+    accumulation.pending.clear();
+    accumulation.searches.clear();
+    return;
+  }
+  apply_search(accumulation.searches, span);
+  if (!is_content_read(span.label)) return;
+  const fresh = subject_targets(span.targets, accumulation.root).filter(
+    (target) => !edited.has(target)
+  );
+  add_all(accumulation.pending, fresh, span.ended_ms);
+}
+function last_delegation_ms(spans) {
+  return delegation_instant(spans.findLast((span) => is_delegation(span)));
+}
+function pending_after(pending, since_ms) {
+  return [...pending.values()].filter((at_ms) => at_ms > since_ms).length;
+}
+function tally_of(text, since_ms = hook_decision.NEVER_MS, branch_files = [], root = process.cwd()) {
+  const { spans, started_ms } = time_spans.parse_timeline(text);
+  const edited = /* @__PURE__ */ new Set([...edited_files(spans, root), ...subject_targets(branch_files, root)]);
+  const accumulation = { pending: /* @__PURE__ */ new Map(), searches: /* @__PURE__ */ new Map(), root };
+  for (const span of spans) apply_span(accumulation, span, edited);
+  return {
+    pending: [...accumulation.pending.keys()],
+    pending_since: pending_after(accumulation.pending, since_ms),
+    reset_ms: last_delegation_ms(spans),
+    window_start_ms: started_ms,
+    searches: accumulation.searches.size,
+    searches_since: pending_after(accumulation.searches, since_ms),
+    edited,
+    root
+  };
+}
+function projected_count(pending, call, edited = /* @__PURE__ */ new Set(), root = process.cwd()) {
+  const added = call_targets(call, root).filter((target) => !edited.has(target));
+  return (/* @__PURE__ */ new Set([...pending, ...added])).size;
+}
+function is_at_threshold(pending_count) {
+  return pending_count + 1 >= delegation_policy.INVESTIGATION_FILE_THRESHOLD;
+}
+function is_at_search_threshold(search_count) {
+  return search_count + 1 >= delegation_policy.INVESTIGATION_SEARCH_TURN_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) || is_at_search_threshold(tally.searches_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_read_only_command(call, labels) {
+  if (call.name !== cost_blocks.BASH_TOOL) return false;
+  const label = time_shell.bash_label(time_shell.bash_command(call.input));
+  return labels.has(label) && time_batch_guard.is_read_only_call(call);
+}
+function is_search_call(call) {
+  return time_search_call.is_read_only_search(
+    time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID)
+  );
+}
+function is_refusable_call(call, root = process.cwd()) {
+  if (is_search_call(call)) return true;
+  if (call_targets(call, root).length === 0) return false;
+  if (READ_TOOLS.has(call.name)) return true;
+  return is_read_only_command(call, CONTENT_READ_LABELS);
+}
+function is_growing_past_threshold(tally, call) {
+  if (is_search_call(call)) return is_at_search_threshold(tally.searches);
+  if (!is_at_threshold(tally.pending.length)) return false;
+  return projected_count(tally.pending, call, tally.edited, tally.root) > tally.pending.length;
+}
+function is_blocking(tally, call, refused_at_ms) {
+  return is_growing_past_threshold(tally, call) && is_rearmed(tally, refused_at_ms);
+}
+function is_blocking_past_branch(text, call, refused_at_ms, root) {
+  if (!is_blocking(tally_of(text, refused_at_ms, [], root), call, refused_at_ms)) return false;
+  const branch_files = changed_paths_sync.read_changed_paths(root);
+  return is_blocking(tally_of(text, refused_at_ms, branch_files, root), call, refused_at_ms);
+}
+function should_block(text, call, refused_at_ms, run) {
+  const root = run?.context.cwd ?? process.cwd();
+  if (!is_refusable_call(call, root) || is_unit_run(run)) return false;
+  return is_blocking_past_branch(text, call, refused_at_ms, root);
+}
+var investigation_reads = {
+  DELEGATION_TOOLS,
+  INVESTIGATOR_AGENT,
+  READ_TOOLS,
+  REASON,
+  is_at_threshold,
+  is_instruction_document,
+  is_rearmed,
+  is_refusable_call,
+  is_session_artifact,
+  is_subject_file,
+  projected_count,
+  resolved,
+  should_block,
+  tally_of
+};
+
+// scripts/delegation/duplicate-read-guard.ts
+var SWITCH_ENV_KEY = "JOSH_DUPLICATE_READ_GUARD";
+var LANE_GUARD_ID = "duplicate-read";
+var STAMP_PREFIX = "josh-duplicate-read-guard-";
+var NOTICE_STAMP_PREFIX = "josh-duplicate-read-notice-";
+var READ_TOOL = "Read";
+var GLOB_CHARACTERS = /[*?]/u;
+var REASON2 = `\u26D4 duplicate read: this file was already read in this session and has not changed since (its mtime predates that read), so reading it again returns nothing new. Scroll up to the earlier result instead of re-reading it. A read with a new offset/limit, or of a file that has since changed, is allowed; set \`JOSH_DUPLICATE_READ_GUARD=off\` to disable this guard.`;
+var NOTICE = `\u26A0 duplicate read: this file was already read in this session and has not changed since, so re-reading it returns nothing new \u2014 scroll up to the earlier result instead of re-reading it. Set \`JOSH_DUPLICATE_READ_GUARD=off\` to silence this.`;
+function is_paginated(input) {
+  return input["offset"] !== void 0 || input["limit"] !== void 0;
+}
+function names_one_file(file_path) {
+  return typeof file_path === "string" && file_path !== "" && !GLOB_CHARACTERS.test(file_path);
+}
+function read_target(call, root) {
+  if (call.name !== READ_TOOL || !json_value.is_record(call.input)) return void 0;
+  const { input } = call;
+  if (is_paginated(input) || !names_one_file(input["file_path"])) return void 0;
+  return investigation_reads.resolved(input["file_path"], root);
+}
+function is_successful_read(span) {
+  const is_read = investigation_reads.READ_TOOLS.has(span.label);
+  return is_read && span.outcome !== time_spans.FAILED_OUTCOME;
+}
+function reads_target(span, target, root) {
+  return span.targets.some((one) => investigation_reads.resolved(one, root) === target);
+}
+function last_read_ms(spans, target, root) {
+  const times = spans.filter((span) => is_successful_read(span) && reads_target(span, target, root)).map((span) => span.ended_ms);
+  return times.length === 0 ? hook_decision.NEVER_MS : Math.max(...times);
+}
+function file_mtime_ms(target) {
+  try {
+    return statSync(target).mtimeMs;
+  } catch {
+    return void 0;
+  }
+}
+function read_window(tail, target, root) {
+  const { spans, started_ms } = time_spans.parse_timeline(tail);
+  return { last_ms: last_read_ms(spans, target, root), window_start_ms: started_ms };
+}
+function is_unchanged_reread(last_ms, mtime) {
+  if (mtime === void 0 || last_ms === hook_decision.NEVER_MS) return false;
+  return mtime < last_ms;
+}
+function is_rearmed2(window, fired_at_ms) {
+  if (fired_at_ms === hook_decision.NEVER_MS || fired_at_ms < window.window_start_ms) return true;
+  return window.last_ms > fired_at_ms;
+}
+function is_redundant_reread(tail, call, fired_at_ms, root) {
+  const target = read_target(call, root);
+  if (target === void 0) return false;
+  const window = read_window(tail, target, root);
+  if (!is_unchanged_reread(window.last_ms, file_mtime_ms(target))) return false;
+  return is_rearmed2(window, fired_at_ms);
+}
+function duplicate_mode(context) {
+  return lane_guard_policy.mode_here(LANE_GUARD_ID, context.cwd, context.env);
+}
+function is_candidate(call, context) {
+  return read_target(call, context.cwd) !== void 0 && duplicate_mode(context) !== "off";
+}
+function should_block_here(tail, call, refused_at_ms, run) {
+  if (duplicate_mode(run.context) !== "refuse") return false;
+  return is_redundant_reread(tail, call, refused_at_ms, run.context.cwd);
+}
+function should_notify_here(tail, call, notified_at_ms, run) {
+  if (duplicate_mode(run.context) !== "notice") return false;
+  return is_redundant_reread(tail, call, notified_at_ms, run.context.cwd);
+}
+var GUARD = hook_decision.create_transcript_guard({
+  prefix: STAMP_PREFIX,
+  switch_key: SWITCH_ENV_KEY,
+  is_candidate,
+  should_block: should_block_here,
+  reason: REASON2,
+  notify: {
+    prefix: NOTICE_STAMP_PREFIX,
+    should_notify: should_notify_here,
+    text: () => NOTICE
+  }
+});
+var duplicate_read_refusal = GUARD.refusal;
+var duplicate_read_outcome = GUARD.outcome;
+var { is_enabled, refusal_path } = GUARD;
+var notice_refusal_path = hook_decision.create_refusal_stamp(NOTICE_STAMP_PREFIX).path;
+var { deny_envelope, DISABLED_VALUES } = hook_decision;
+var duplicate_reads = {
+  is_successful_read,
+  REASON: REASON2,
+  NOTICE
+};
+
+// scripts/run/cut/run-cut-digest.ts
+import { z } from "zod";
+var session_digest_schema = z.object({
+  read: z.array(z.string()),
+  decisions: z.array(z.string())
+});
+var MAX_READ_ENTRIES = 40;
+var MAX_DECISIONS = 12;
+var MAX_DECISION_CHARS = 240;
+var DECISION_PREFIX = "Auto-decided:";
+var DECISION_LINE = /(?:^|[\s'"=])(Auto-decided: [^\n]+)/gu;
+var TRAILING_QUOTES = /['"]$/u;
+var ASSISTANT = "assistant";
+var READ_LABEL = "Already read before the cut \u2014 re-read only the lines you need";
+var DECISIONS_LABEL = "Decided before the cut \u2014 do not reopen";
+function shown_path(target, cwd) {
+  const relative = path2.relative(cwd, path2.resolve(cwd, target));
+  return relative.startsWith("..") ? target : relative;
+}
+function newest_unique(entries, limit) {
+  const unique = [...new Set(entries.toReversed())].toReversed();
+  return unique.slice(-limit);
+}
+function read_files_of(text, cwd) {
+  const reads = time_spans.parse_timeline(text).spans.filter((span) => duplicate_reads.is_successful_read(span)).flatMap((span) => span.targets.map((target) => shown_path(target, cwd)));
+  return newest_unique(reads, MAX_READ_ENTRIES);
+}
+var COMMENT_INPUT_KEYS = ["command", "content"];
+function input_strings(input) {
+  if (!json_value.is_record(input)) return [];
+  return COMMENT_INPUT_KEYS.map((key) => input[key]).filter((value) => typeof value === "string");
+}
+function assistant_texts(record) {
+  if (record?.type !== ASSISTANT) return [];
+  return transcript_record.blocks_of(record).flatMap((block) => [block.text ?? "", ...input_strings(block.input)]);
+}
+function decisions_of(text) {
+  const decisions = text.split("\n").flatMap((line) => assistant_texts(transcript_record.parse(line))).flatMap((written) => [...written.matchAll(DECISION_LINE)].map((match) => match[1] ?? "")).map((line) => line.replace(TRAILING_QUOTES, "").slice(0, MAX_DECISION_CHARS));
+  return newest_unique(decisions, MAX_DECISIONS);
+}
+function digest_of(text, cwd) {
+  return { read: read_files_of(text, cwd), decisions: decisions_of(text) };
+}
+function own_transcript(cwd, environment) {
+  if (own_session.session_id_of(environment) === void 0) return void 0;
+  const files = cost_transcript.list_sessions_across(cost_transcript.transcript_directories(cwd));
+  const selection = own_session.select_own_session(files, environment);
+  if (selection.kind === "absent") return void 0;
+  const file = files[selection.index];
+  return file === void 0 ? void 0 : cost_transcript.read_optional(file);
+}
+function own_digest(cwd = process.cwd(), environment = process.env) {
+  const text = own_transcript(cwd, environment);
+  return text === void 0 ? void 0 : digest_of(text, cwd);
+}
+function describe_list(label, entries) {
+  if (entries.length === 0) return [];
+  const bullets = entries.map((entry) => `  - ${entry}`).join("\n");
+  return [`${label}:
+${bullets}`];
+}
+function describe_digest(digest) {
+  if (digest === void 0) return void 0;
+  const blocks = [
+    ...describe_list(READ_LABEL, digest.read),
+    ...describe_list(DECISIONS_LABEL, digest.decisions)
+  ];
+  return blocks.length === 0 ? void 0 : blocks.join("\n\n");
+}
+var run_cut_digest = {
+  DECISION_PREFIX,
+  describe_digest,
+  digest_of,
+  own_digest,
+  session_digest_schema
+};
+
+// scripts/run/cut/run-cut-handoff.ts
+import { readFileSync } from "node:fs";
+import { z as z2 } from "zod";
+var handoff_schema = z2.object({
+  instruction: z2.string(),
+  completed: z2.array(z2.string()),
+  remaining: z2.array(z2.string()),
+  untouched: z2.array(z2.string()),
+  findings: z2.array(z2.string()).optional()
+});
+var COMPLETED_LABEL = "Completed";
+var REMAINING_LABEL = "Remaining";
+var UNTOUCHED_LABEL = "Deliberately untouched";
+var INSTRUCTION_LABEL = "Instruction (verbatim)";
+var FINDINGS_LABEL = "Round-1 findings, attested but not recorded \u2014 do not rerun round 1: fix them, then record them with `pnpm josh review:record --issue <N>`";
+var EMPTY_LIST_NOTE = "(none)";
+var PLACEHOLDER = "\u2026";
+var FINDINGS_PLACEHOLDER = "unrecorded";
+var EXAMPLE_LIST = `["${PLACEHOLDER}"]`;
+var EXAMPLE_VALUES = {
+  instruction: `"${PLACEHOLDER}"`,
+  completed: EXAMPLE_LIST,
+  remaining: EXAMPLE_LIST,
+  untouched: EXAMPLE_LIST,
+  findings: `["${FINDINGS_PLACEHOLDER}"]`
+};
+var HANDOFF_FORMAT = `{${handoff_schema.keyof().options.map((key) => `"${key}":${EXAMPLE_VALUES[key]}`).join(",")}}`;
+function parse_handoff(raw) {
+  return json_value.parse_with(raw, handoff_schema);
+}
+function read_handoff_file(handoff_path) {
+  try {
+    return parse_handoff(readFileSync(handoff_path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function is_complete_handoff(handoff) {
+  return handoff !== void 0 && handoff.instruction.trim() !== "";
+}
+function is_within_bound(handoff, max_bytes) {
+  return Buffer.byteLength(JSON.stringify(handoff), "utf8") <= max_bytes;
+}
+function load_handoff(handoff_path, max_bytes) {
+  if (handoff_path === void 0) return { kind: "ok", handoff: void 0 };
+  const handoff = read_handoff_file(handoff_path);
+  if (handoff === void 0) {
+    return {
+      kind: "bad",
+      note: `--handoff ${handoff_path} is not a readable handoff file \u2014 write ${HANDOFF_FORMAT}`
+    };
+  }
+  if (!is_within_bound(handoff, max_bytes)) {
+    return { kind: "bad", note: `--handoff ${handoff_path} is too large to carry across the cut` };
+  }
+  return { kind: "ok", handoff };
+}
+function describe_list2(label, items) {
+  if (items.length === 0) return `${label}: ${EMPTY_LIST_NOTE}`;
+  const bullets = items.map((item) => `  - ${item}`).join("\n");
+  return `${label}:
+${bullets}`;
+}
+function carried_findings(handoff) {
+  const findings = handoff?.findings ?? [];
+  return findings.filter(
+    (finding) => ![PLACEHOLDER, FINDINGS_PLACEHOLDER, ""].includes(finding.trim())
+  );
+}
+function describe_findings(handoff) {
+  const findings = carried_findings(handoff);
+  if (findings.length === 0) return [];
+  return [describe_list2(FINDINGS_LABEL, findings)];
+}
+function describe_handoff(handoff) {
+  return [
+    `${INSTRUCTION_LABEL}:
+${handoff.instruction}`,
+    describe_list2(COMPLETED_LABEL, handoff.completed),
+    describe_list2(REMAINING_LABEL, handoff.remaining),
+    describe_list2(UNTOUCHED_LABEL, handoff.untouched),
+    ...describe_findings(handoff)
+  ].join("\n\n");
+}
+var HANDOFF_PATH = `${JOSH_TMP_DIRECTORY}/handoff-<N>.json`;
+var ISSUE_PLACEHOLDER = "<N>";
+function handoff_path_of(issue) {
+  return HANDOFF_PATH.replace(ISSUE_PLACEHOLDER, () => issue);
+}
+var run_cut_handoff = {
+  HANDOFF_FORMAT,
+  HANDOFF_PATH,
+  handoff_path_of,
+  carried_findings,
+  describe_handoff,
+  handoff_schema,
+  is_complete_handoff,
+  load_handoff,
+  parse_handoff,
+  read_handoff_file
+};
+
+// scripts/run/cut/run-cut.ts
+import { z as z3 } from "zod";
+
+// scripts/run/cut/run-cut-adoption.ts
+function session() {
+  const selected = agent_provider.resolve_provider();
+  if (selected.kind !== "provider") return void 0;
+  const id = agent_provider.trimmed(
+    selected.provider === agent_provider.OPENAI_PROVIDER ? process.env[agent_provider.CODEX_SESSION_KEY] : own_session.session_id_of(process.env)
+  );
+  return id === void 0 ? void 0 : `${selected.provider}:${id}`;
+}
+function is_own_adoption(cut) {
+  return cut.is_handed_off === false && cut.adopted_session !== void 0 && cut.adopted_session === session();
+}
+function matches_run(previous, next) {
+  return previous.issue === next.issue && previous.branch === next.branch && previous.invocation === next.invocation;
+}
+function can_replace(previous, next) {
+  return previous.phase === agent_profile_schema.PRE_GATE_PHASE && next.phase === agent_profile_schema.IMPLEMENTATION_PHASE && is_own_adoption(previous) && matches_run(previous, next);
+}
+function release(target, cut, issue) {
+  if (cut.is_handed_off !== false || cut.invocation !== lane_child_invocation.child_invocation(issue) || cut.issue !== issue) {
+    return;
+  }
+  stamp_file.replace_stamp(target, {
+    ...cut,
+    is_handed_off: true,
+    adopted_session: void 0,
+    is_merge_relaunched: void 0
+  });
+}
+var run_cut_adoption = { can_replace, release, session };
+
+// scripts/run/cut/run-cut.ts
+var CUT_PREFIX = "josh-run-cut-";
+var { PRE_GATE_PHASE, IMPLEMENTATION_PHASE } = agent_profile_schema;
+var CUT_MAX_AGE_MS = backlog_budget.DEFAULT_IDLE_MS;
+var CUT_MAX_AGE_HOURS = backlog_budget.IDLE_WAIT_HOURS;
+var END_COMMAND = "pnpm josh run:cut --end";
+var READ_COMMAND = "pnpm josh run:cut --json";
+var MAX_HANDOFF_BYTES = 8192;
+var run_cut_schema = z3.object({
+  invocation: z3.string(),
+  issue: z3.string(),
+  branch: z3.string(),
+  phase: z3.string(),
+  cut_at: z3.string(),
+  is_handed_off: z3.boolean().optional(),
+  adopted_session: z3.string().optional(),
+  handoff: run_cut_handoff.handoff_schema.optional(),
+  digest: run_cut_digest.session_digest_schema.optional(),
+  is_merge_relaunched: z3.boolean().optional()
+});
+function cut_path(git_directory) {
+  return stamp_file.stamp_path(CUT_PREFIX, git_directory);
+}
+var { worktree_directory } = run_hold;
+function invocation_for(issue) {
+  return lane_child_invocation.child_invocation(issue);
+}
+function parse_cut(raw) {
+  return json_value.parse_with(raw, run_cut_schema);
+}
+function cut_at_of(cut) {
+  return cut.cut_at;
+}
+var CUT_SPEC = {
+  parse: parse_cut,
+  timestamp_of: cut_at_of,
+  max_age_ms: CUT_MAX_AGE_MS
+};
+function is_expired(cut, now) {
+  return stamp_record.is_older_than(cut_at_of(cut), CUT_MAX_AGE_MS, now);
+}
+function classify(raw, now) {
+  const read = stamp_record.classify(raw, CUT_SPEC, now);
+  if (!("record" in read)) return read;
+  return { kind: read.kind, cut: read.record };
+}
+function read_cut(target, now = /* @__PURE__ */ new Date()) {
+  return classify(stamp_file.read_stamp_text(target), now);
+}
+function worktree_git_directory_sync(cwd) {
+  return git_common_directory.own(cwd);
+}
+function carried_cut_sync(now = /* @__PURE__ */ new Date(), directory = worktree_git_directory_sync()) {
+  if (directory === void 0) return void 0;
+  const read = read_cut(cut_path(directory), now);
+  return read.kind === "carried" ? read.cut : void 0;
+}
+function lane_cut_sync(lane_directory) {
+  const directory = git_common_directory.own(lane_directory);
+  if (directory === void 0) return void 0;
+  const cut = carried_cut_sync(/* @__PURE__ */ new Date(), directory);
+  return cut === void 0 ? void 0 : { target: cut_path(directory), cut };
+}
+function fresh_cut(spec, now) {
+  return {
+    invocation: invocation_for(spec.issue),
+    issue: spec.issue,
+    branch: spec.branch,
+    phase: spec.phase,
+    cut_at: now.toISOString(),
+    is_handed_off: true,
+    handoff: spec.handoff,
+    digest: spec.digest
+  };
+}
+function resumes_into_implementation(phase) {
+  return phase === IMPLEMENTATION_PHASE;
+}
+function within_handoff_bound(cut) {
+  return Buffer.byteLength(JSON.stringify(cut), "utf8") <= MAX_HANDOFF_BYTES;
+}
+function record_within_bound(spec, now = /* @__PURE__ */ new Date()) {
+  return within_handoff_bound(fresh_cut(spec, now));
+}
+function with_digest(spec, digest_of2) {
+  if (spec.handoff === void 0) return spec;
+  const digested = { ...spec, digest: digest_of2() };
+  return record_within_bound(digested) ? digested : spec;
+}
+function replace_adopted(target, cut) {
+  const previous = read_cut(target);
+  if ("cut" in previous && run_cut_adoption.can_replace(previous.cut, cut)) {
+    stamp_file.replace_stamp(target, cut);
+    return true;
+  }
+  return false;
+}
+function begin_cut(target, spec, now = /* @__PURE__ */ new Date()) {
+  const cut = fresh_cut(spec, now);
+  if (!within_handoff_bound(cut)) return void 0;
+  if (replace_adopted(target, cut)) return cut;
+  return stamp_file.create_stamp(target, cut) ? cut : void 0;
+}
+function is_declared_cut(cut, issue) {
+  return cut.is_handed_off === true && cut.invocation === invocation_for(issue);
+}
+function matches_state(cut, request) {
+  return cut.branch === request.current_branch && cut.issue === request.issue && request.is_dirty && request.is_held;
+}
+function is_adopted_cut(cut, issue) {
+  return cut.is_handed_off === false && cut.invocation === invocation_for(issue);
+}
+function has_required_handoff(cut) {
+  return !resumes_into_implementation(cut.phase) || run_cut_handoff.is_complete_handoff(cut.handoff);
+}
+function is_relaunchable(cut, issue) {
+  return is_declared_cut(cut, issue) && has_required_handoff(cut) && cut.is_merge_relaunched !== true;
+}
+function mark_merge_relaunched(target, cut) {
+  stamp_file.remove_stamp(target);
+  return stamp_file.create_stamp(target, { ...cut, is_merge_relaunched: true });
+}
+function classify_resume(cut, request) {
+  if (is_adopted_cut(cut, request.issue)) return "handed-off";
+  if (!is_declared_cut(cut, request.issue) || !matches_state(cut, request)) return "stale";
+  return has_required_handoff(cut) ? "resume" : "incomplete";
+}
+function adopt_cut(target, cut) {
+  const next = { ...cut, is_handed_off: false, adopted_session: run_cut_adoption.session() };
+  stamp_file.remove_stamp(target);
+  return stamp_file.create_stamp(target, next) ? next : void 0;
+}
+function end_cut(target) {
+  stamp_file.remove_stamp(target);
+}
+function hold_of(directory) {
+  if (directory === void 0) return void 0;
+  const read = run_hold.read_hold(run_hold.hold_path(directory));
+  return read.kind === "held" || read.kind === "stale" ? read.hold : void 0;
+}
+function fullrun_issue(hold) {
+  return hold?.is_fullrun === true ? hold.issue : void 0;
+}
+function held_issue_sync(directory = worktree_git_directory_sync()) {
+  return fullrun_issue(hold_of(directory));
+}
+async function current_state() {
+  const branch = await git_command.branch();
+  const is_dirty = await run_hold.is_tree_dirty();
+  const hold = hold_of(await worktree_directory());
+  return {
+    branch,
+    is_dirty,
+    is_held: hold !== void 0,
+    held_issue: fullrun_issue(hold),
+    hold_taken_at: hold?.taken_at
+  };
+}
+function describe_cut(cut) {
+  return `${cut.invocation} cut at ${cut.cut_at} on ${cut.branch} (${cut.phase})`;
+}
+function busy_message(cut) {
+  return `Another process already resumed this cut \u2014 ${describe_cut(cut)}. Nothing was resumed here; a double launch was detected.`;
+}
+function handed_off_message(cut) {
+  return `This cut was already adopted \u2014 ${describe_cut(cut)}. Nothing was resumed here; the record alone does not establish whether its owner is still running. After a trusted repair request on an open PR and confirmed owner exit, use \`pnpm josh run:add ${cut.issue} --retry\` in a live backlogrun, or \`pnpm josh run:entry ${cut.issue}\` in its lane. Active or unreadable owners remain protected.`;
+}
+function stale_message(cut) {
+  return `This cut does not match the current tree \u2014 ${describe_cut(cut)}. Resume failed; verify the branch and the uncommitted work, then clear it with \`${END_COMMAND}\` if the run is over.`;
+}
+function incomplete_message(cut) {
+  return `This cut carries no instruction to resume on \u2014 ${describe_cut(cut)}. Resume was refused rather than continuing without it; recover the run's instruction and work state before implementing, and clear the record with \`${END_COMMAND}\` if the run is over.`;
+}
+function unreadable_message() {
+  return `A cut record is here but could not be read; clear it with \`${END_COMMAND}\` once you know no run is using it. Read it with \`${READ_COMMAND}\`.`;
+}
+function unknown_message() {
+  return "This working tree\u2019s git directory could not be read, so no cut record was acted on.";
+}
+var run_cut = {
+  CUT_MAX_AGE_HOURS,
+  CUT_MAX_AGE_MS,
+  END_COMMAND,
+  IMPLEMENTATION_PHASE,
+  MAX_HANDOFF_BYTES,
+  PRE_GATE_PHASE,
+  adopt_cut,
+  begin_cut,
+  busy_message,
+  carried_cut_sync,
+  classify,
+  classify_resume,
+  current_state,
+  with_digest,
+  cut_path,
+  describe_cut,
+  end_cut,
+  fresh_cut,
+  fullrun_issue,
+  handed_off_message,
+  has_required_handoff,
+  held_issue_sync,
+  hold_of,
+  incomplete_message,
+  invocation_for,
+  is_expired,
+  is_relaunchable,
+  lane_cut_sync,
+  mark_merge_relaunched,
+  read_cut,
+  record_within_bound,
+  resumes_into_implementation,
+  stale_message,
+  unknown_message,
+  unreadable_message,
+  within_handoff_bound,
+  worktree_directory,
+  worktree_git_directory_sync
+};
+
+export {
+  run_cut_adoption,
+  lane_guard_policy,
+  changed_paths_sync,
+  investigation_reads,
+  duplicate_read_outcome,
+  duplicate_reads,
+  run_cut_digest,
+  run_cut_handoff,
+  run_cut
+};