@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-HAT7AFBF.js

@@ -0,0 +1,85 @@
+import {
+  split_measure
+} from "./chunk-P6ASP2DY.js";
+import {
+  git_path_quoting,
+  split_assess
+} from "./chunk-ZGEUWHFF.js";
+import {
+  changed_paths
+} from "./chunk-U5EO4QEV.js";
+import {
+  change_base
+} from "./chunk-LBVYFW3I.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/review/review-size.ts
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+function tracked_counts(raw) {
+  const rows = raw.split("\n").filter((row) => row !== "");
+  if (rows.some((row) => !/^\d+\t\d+\t.+$/u.test(row))) throw new Error("Unknown diff size");
+  const changes = split_assess.parse_numstat(raw);
+  return new Map(
+    changes.map((change) => [git_path_quoting.unquote(change.path), change.changed_lines])
+  );
+}
+async function tracked_numstat(is_staged) {
+  if (is_staged) {
+    return await git_spawn.read([
+      "-c",
+      "core.quotePath=false",
+      "diff",
+      "--cached",
+      "--numstat",
+      "--no-relative",
+      "--no-renames",
+      "--"
+    ]);
+  }
+  const base = await change_base.resolved_through_merge();
+  if (base === void 0) throw new Error("Unresolved change base");
+  return await git_command.diff_numstat_since(base);
+}
+async function untracked_count(root, file) {
+  const content = await readFile(path.join(root, file));
+  if (content.includes(0)) throw new Error("Binary diff size");
+  return split_measure.line_count(content);
+}
+async function counts_here(is_staged) {
+  const counts = tracked_counts(await tracked_numstat(is_staged));
+  if (is_staged) return counts;
+  const files = changed_paths.to_paths(await git_command.untracked_names());
+  const root = await git_spawn.read(["rev-parse", "--show-toplevel"]);
+  const additions = await Promise.all(
+    files.map(async (file) => {
+      const unquoted = git_path_quoting.unquote(file);
+      return [unquoted, await untracked_count(root, unquoted)];
+    })
+  );
+  return new Map([...counts, ...additions]);
+}
+function total_of(counts) {
+  let total = 0;
+  for (const lines of counts.values()) total += lines;
+  return total;
+}
+async function read(paths, is_staged = false) {
+  try {
+    const counts = await counts_here(is_staged);
+    if (paths.some((file) => !counts.has(git_path_quoting.unquote(file)))) return void 0;
+    return total_of(counts);
+  } catch {
+    return void 0;
+  }
+}
+var review_size = { read };
+
+export {
+  review_size
+};

package/dist/commands/chunk-HDVSZ6CZ.js

@@ -0,0 +1,292 @@
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  agent_profile_schema
+} from "./chunk-F7B4ESZE.js";
+import {
+  agent_safe_text
+} from "./chunk-3LZXX5GL.js";
+import {
+  run_carry_session,
+  run_headless_keys
+} from "./chunk-DS53UUDH.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  lane_paths
+} from "./chunk-G75GWNNY.js";
+import {
+  PLATFORM_TEMP_ROOT,
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/agent/agent-headless.ts
+var KEY = "JOSH_AGENT_HEADLESS";
+var VALUE = "1";
+function environment() {
+  return { [KEY]: VALUE };
+}
+function is_headless(source = process.env) {
+  return source[KEY] === VALUE;
+}
+var agent_headless = { KEY, environment, is_headless };
+
+// scripts/run/detached-launch.ts
+import { spawn } from "node:child_process";
+import { closeSync, constants, openSync, writeSync as writeSync2 } from "node:fs";
+
+// scripts/agent/agent-launch-environment.ts
+var OPENAI_PROVIDER = "openai";
+function build(profile, environment2 = {}) {
+  if (profile === void 0) return { ...environment2, [agent_session_role.KEY]: void 0 };
+  const marked = {
+    ...agent_headless.environment(),
+    ...environment2,
+    ...agent_session_role.env_for(profile.role)
+  };
+  return profile.provider === OPENAI_PROVIDER ? { TMPDIR: PLATFORM_TEMP_ROOT, ...marked } : marked;
+}
+var agent_launch_environment = { build };
+
+// scripts/agent/codex-launch-identity.ts
+var CONFIG_FLAG = "-c";
+var SHELL_SET = "shell_environment_policy.set.";
+function identity_environment(request) {
+  return {
+    [lane_paths.LANE_ROOT_KEY]: process.env[lane_paths.LANE_ROOT_KEY],
+    ...request.env
+  };
+}
+function identity_arguments(request) {
+  const source = identity_environment(request);
+  if (!lane_child_marker.is_child_of(request.cwd, source)) return [];
+  return [lane_child_marker.KEY, lane_paths.LANE_ROOT_KEY].flatMap(
+    (key) => source[key] === void 0 ? [] : [CONFIG_FLAG, `${SHELL_SET}${key}=${JSON.stringify(source[key])}`]
+  );
+}
+function is_codex_worker(request) {
+  const { argv, profile } = request;
+  return profile?.provider === "openai" && profile.role === agent_profile_schema.WORKER && argv.command === "codex" && argv.ends_with_prompt === true;
+}
+function scheduler_arguments(request) {
+  if (request.profile?.role !== agent_profile_schema.SCHEDULER) return [];
+  const keys = [run_carry_session.KEY, ...run_headless_keys.MARK_KEYS];
+  return keys.flatMap(
+    (key) => request.env?.[key] === void 0 ? [] : [CONFIG_FLAG, `${SHELL_SET}${key}=${JSON.stringify(request.env[key])}`]
+  );
+}
+function is_codex(request) {
+  return request.profile?.provider === "openai" && request.argv.command === "codex";
+}
+function arguments_for(request) {
+  const { argv } = request;
+  if (!is_codex(request) || argv.ends_with_prompt !== true) return argv.args;
+  const identity = is_codex_worker(request) ? identity_arguments(request) : scheduler_arguments(request);
+  return [...argv.args.slice(0, -1), ...identity, ...argv.args.slice(-1)];
+}
+var codex_launch_identity = { arguments_for };
+
+// scripts/run/launch-priority.ts
+import { setPriority } from "node:os";
+var LANE_NICENESS = 10;
+function lower(pid, set_priority = setPriority) {
+  if (pid === void 0) return;
+  try {
+    set_priority(pid, LANE_NICENESS);
+  } catch {
+  }
+}
+var launch_priority = {
+  LANE_NICENESS,
+  lower
+};
+
+// scripts/run/attached-log.ts
+import { writeSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { z } from "zod";
+var EVENT_SCHEMA = z.looseObject({ type: z.string(), timestamp: z.string().optional() });
+function stamped_line(line, timestamp) {
+  const event = EVENT_SCHEMA.safeParse(json_value.parse_or_undefined(line)).data;
+  if (event === void 0) return line;
+  return JSON.stringify({ ...event, timestamp: event.timestamp ?? timestamp });
+}
+function record(child, log, on_error) {
+  if (child.stdout === null) return;
+  const lines = createInterface({ input: child.stdout });
+  lines.on("line", (line) => {
+    if (log === void 0) return;
+    try {
+      writeSync(log, `${stamped_line(line, (/* @__PURE__ */ new Date()).toISOString())}
+`);
+    } catch (error) {
+      on_error(`the session log could not be written: ${String(error)}`);
+    }
+  });
+}
+var attached_log = { record, stamped_line };
+
+// scripts/run/detached-launch.ts
+var NO_PID_NOTE = "the process started without a pid";
+var UNSAFE_NOTE = "the wake command or its arguments are empty, over length, or contain characters that are not safe to execute";
+var { is_safe_prompt, is_safe_value } = agent_safe_text;
+var LAST = -1;
+function is_safe_element(argv, value, index) {
+  const is_prompt = argv.ends_with_prompt === true && index === argv.args.length + LAST;
+  return is_prompt ? is_safe_prompt(value) : is_safe_value(value);
+}
+function is_safe_argv(argv) {
+  return is_safe_value(argv.command) && argv.args.every((value, index) => is_safe_element(argv, value, index));
+}
+function note_of(error) {
+  return error instanceof Error ? error.message : JSON.stringify(error);
+}
+function launched(pid) {
+  return { kind: "launched", pid };
+}
+var LOG_FLAGS = constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW;
+var LOG_MODE = 384;
+function profile_suffix(profile) {
+  return profile === void 0 ? "" : ` \xB7 ${agent_profile_schema.describe(profile)}`;
+}
+function log_header(argv, profile) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString();
+  return `
+=== ${stamp} \xB7 started by process ${String(process.pid)} \xB7 ${argv.command}${profile_suffix(profile)} ===
+`;
+}
+function opened_log(log_path, on_error) {
+  const descriptor = openSync(log_path, LOG_FLAGS, LOG_MODE);
+  if (!stamp_file.is_own_regular_file(log_path)) {
+    closeSync(descriptor);
+    on_error(`${log_path} is not this account's own file, so nothing is kept there`);
+    return void 0;
+  }
+  return descriptor;
+}
+function stamped(descriptor, argv, profile, on_error) {
+  if (descriptor === void 0) return;
+  try {
+    writeSync2(descriptor, log_header(argv, profile));
+  } catch (error) {
+    on_error(`the session log could not be written: ${note_of(error)}`);
+  }
+}
+function open_log(log_path, on_error) {
+  if (log_path === void 0) return void 0;
+  try {
+    return opened_log(log_path, on_error);
+  } catch (error) {
+    on_error(`the session log at ${log_path} could not be opened: ${note_of(error)}`);
+    return void 0;
+  }
+}
+function ensure_log(log_path, on_error) {
+  const descriptor = open_log(log_path, on_error);
+  if (descriptor !== void 0) closeSync(descriptor);
+}
+function spawn_options(cwd, log, environment2 = {}, is_detached = true) {
+  const output = log ?? "ignore";
+  return {
+    cwd,
+    detached: is_detached,
+    stdio: ["ignore", is_detached ? output : "pipe", output],
+    env: { ...process.env, ...agent_session_environment.removed_environment(), ...environment2 }
+  };
+}
+function notify_spawn(pid, on_spawn, on_error) {
+  if (pid === void 0) return;
+  try {
+    on_spawn(pid);
+  } catch (error) {
+    on_error(`the child state could not be recorded: ${note_of(error)}`);
+  }
+}
+async function attached_spawn(request, log, on_error, on_spawn) {
+  return await new Promise((resolve) => {
+    const environment2 = agent_launch_environment.build(request.profile, request.env);
+    const child = spawn(
+      request.argv.command,
+      [...request.argv.args],
+      spawn_options(request.cwd, log, environment2, false)
+    );
+    child.once("error", (error) => {
+      on_error(note_of(error));
+      resolve({ kind: "failed", note: note_of(error) });
+    });
+    attached_log.record(child, log, on_error);
+    child.once("close", (exit_code) => {
+      resolve({ kind: "completed", pid: child.pid ?? 0, exit_code });
+    });
+    launch_priority.lower(child.pid);
+    notify_spawn(child.pid, on_spawn, on_error);
+  });
+}
+function ignore_spawn(_pid) {
+}
+function spawned(request, log, on_error) {
+  const { command, args } = request.argv;
+  const environment2 = agent_launch_environment.build(request.profile, request.env);
+  const child = spawn(command, [...args], spawn_options(request.cwd, log, environment2));
+  child.on("error", (error) => {
+    on_error(note_of(error));
+  });
+  child.unref();
+  launch_priority.lower(child.pid);
+  return child.pid === void 0 ? { kind: "failed", note: NO_PID_NOTE } : launched(child.pid);
+}
+function prepared_request(request) {
+  return {
+    ...request,
+    argv: { ...request.argv, args: codex_launch_identity.arguments_for(request) }
+  };
+}
+function launch(input, on_error) {
+  const request = prepared_request(input);
+  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
+  const log = open_log(request.log_path, on_error);
+  try {
+    stamped(log, request.argv, request.profile, on_error);
+    return spawned(request, log, on_error);
+  } catch (error) {
+    return { kind: "failed", note: note_of(error) };
+  } finally {
+    if (log !== void 0) closeSync(log);
+  }
+}
+async function launch_attached(input, on_error, on_spawn = ignore_spawn) {
+  const request = prepared_request(input);
+  if (!is_safe_argv(request.argv)) return { kind: "failed", note: UNSAFE_NOTE };
+  const log = open_log(request.log_path, on_error);
+  try {
+    stamped(log, request.argv, request.profile, on_error);
+    return await attached_spawn(request, log, on_error, on_spawn);
+  } catch (error) {
+    return { kind: "failed", note: note_of(error) };
+  } finally {
+    if (log !== void 0) closeSync(log);
+  }
+}
+var detached_launch = {
+  UNSAFE_NOTE,
+  ensure_log,
+  is_safe_argv,
+  is_safe_value,
+  launch,
+  launch_attached,
+  log_header,
+  note_of
+};
+
+export {
+  agent_headless,
+  detached_launch
+};

package/dist/commands/chunk-HE3GOMR7.js

@@ -0,0 +1,88 @@
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+
+// scripts/git/main-merge-guard.ts
+var STATUS_CODE_LENGTH = 2;
+var STATUS_PREFIX_LENGTH = STATUS_CODE_LENGTH + 1;
+var RENAME_SEPARATOR = " -> ";
+var UNMERGED_CODES = /* @__PURE__ */ new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
+var UNSTAGED_INDEX_CODES = /* @__PURE__ */ new Set([" ", "?", "!"]);
+var DIRECTORY_SUFFIX = "/";
+var COMMIT_COMMAND = "`pnpm josh git -y`";
+var LANE_COMMIT_COMMAND = '`pnpm josh git -y --skip-push --skip-pr "<title> #<N>"`';
+var PROCEDURE_POINTER = '`.claude/skills/workflow-commands/chain-rule.md` \u2192 "origin/main is merged in before the gate"';
+var MERGE_RERUN = "`pnpm josh main:merge`";
+function status_lines(status) {
+  return status.split("\n").filter((line) => line.length > STATUS_PREFIX_LENGTH);
+}
+function line_paths(line) {
+  return line.slice(STATUS_PREFIX_LENGTH).split(RENAME_SEPARATOR);
+}
+function unmerged_paths(status) {
+  return status_lines(status).filter((line) => UNMERGED_CODES.has(line.slice(0, STATUS_CODE_LENGTH))).flatMap((line) => line_paths(line));
+}
+function staged_paths(status) {
+  return status_lines(status).filter((line) => !UNSTAGED_INDEX_CODES.has(line.charAt(0))).flatMap((line) => line_paths(line));
+}
+function covers(uncommitted, incoming) {
+  if (uncommitted.endsWith(DIRECTORY_SUFFIX)) return incoming.startsWith(uncommitted);
+  return uncommitted === incoming;
+}
+function overlapping_paths(status, incoming) {
+  const uncommitted = status_lines(status).flatMap((line) => line_paths(line));
+  return uncommitted.filter((path) => incoming.some((changed) => covers(path, changed)));
+}
+function commit_command(is_lane_child = lane_child_marker.is_child_of(process.cwd())) {
+  return is_lane_child ? LANE_COMMIT_COMMAND : COMMIT_COMMAND;
+}
+function unresolved_message(prefix, paths, rerun, commit = commit_command()) {
+  return `${prefix}: the index still holds unresolved paths (${paths.join(", ")}). Remove the conflict markers, then finish through ${commit} \u2014 it stages and commits them, so no \`git add\` permission is needed, and inside a lane this is Tier A. Rerun ${rerun} after it (${PROCEDURE_POINTER}).`;
+}
+function staged_message(paths, commit) {
+  return `main:merge: the index holds staged changes (${paths.join(", ")}), which git refuses to merge over. Commit them first through ${commit}, then rerun \`pnpm josh main:merge\` (${PROCEDURE_POINTER}).`;
+}
+function overlap_message(default_branch, paths, commit) {
+  return `main:merge: uncommitted changes touch files origin/${default_branch} also changed (${paths.join(", ")}). Commit the work first through ${commit}, then rerun \`pnpm josh main:merge\`. Never stash around the merge \u2014 a stash reapplied over it leaves the conflict half-recorded in the index (${PROCEDURE_POINTER}).`;
+}
+function conflict_hint(commit = commit_command()) {
+  return `main:merge: finish a conflicted merge by removing the conflict markers, then ${commit} records the merge commit \u2014 no \`git add\` permission is needed (${PROCEDURE_POINTER}).`;
+}
+function merge_refusal(status, incoming, default_branch, commit) {
+  if (incoming.length === 0) return void 0;
+  const staged = staged_paths(status);
+  if (staged.length > 0) return staged_message(staged, commit);
+  const overlap = overlapping_paths(status, incoming);
+  return overlap.length > 0 ? overlap_message(default_branch, overlap, commit) : void 0;
+}
+function refusal(status, incoming, default_branch, commit = commit_command()) {
+  const unmerged = unmerged_paths(status);
+  if (unmerged.length > 0) return unresolved_message("main:merge", unmerged, MERGE_RERUN, commit);
+  return merge_refusal(status, incoming, default_branch, commit);
+}
+async function incoming_paths(default_branch) {
+  const output = await git_spawn.read([
+    "diff",
+    "--name-only",
+    "--no-renames",
+    `HEAD...origin/${default_branch}`
+  ]);
+  return output.split("\n").filter((line) => line !== "");
+}
+var main_merge_guard = {
+  commit_command,
+  conflict_hint,
+  incoming_paths,
+  overlapping_paths,
+  refusal,
+  staged_paths,
+  unmerged_paths,
+  unresolved_message
+};
+
+export {
+  main_merge_guard
+};

package/dist/commands/chunk-HEFUC4ZW.js

@@ -0,0 +1,65 @@
+import {
+  gate_tree
+} from "./chunk-R36VZIKU.js";
+import {
+  project_checks
+} from "./chunk-RO4QEZJO.js";
+import {
+  release_approval_prune
+} from "./chunk-QSJCZATC.js";
+import {
+  buffered_process
+} from "./chunk-JZHY7D6D.js";
+
+// scripts/gate/metrics-totals.ts
+var METRICS_TOTALS_COMMAND = ["josh", "metrics", "--totals-only"];
+var METRICS_RERECORD_COMMAND = [...METRICS_TOTALS_COMMAND, "--rerecord"];
+var NOTICE_HEADING = "\u26A0 josh metrics --totals-only did not pass \u2014 settle it before `josh run:review`, whose open stops on it (a total the branch approval names is re-recorded there):";
+var REVIEW_REFUSAL_HEADING = "run:review refused: josh metrics --totals-only did not pass \u2014 record the reason the totals grew (or bring them back down), then run run:review again:";
+async function growth_notice(directory) {
+  if (!project_checks.is_kit_repository(directory)) return void 0;
+  const result = await buffered_process.run_buffered_process(METRICS_TOTALS_COMMAND, {
+    cwd: directory
+  });
+  if (!buffered_process.is_process_failed(result)) return void 0;
+  return `${NOTICE_HEADING}
+${result.output.trim()}`;
+}
+async function totals_check(directory) {
+  if (!project_checks.is_kit_repository(directory)) return void 0;
+  return await buffered_process.run_buffered_process(METRICS_RERECORD_COMMAND, { cwd: directory });
+}
+async function totals_refusal(directory) {
+  const result = await totals_check(directory);
+  if (result === void 0 || !buffered_process.is_process_failed(result)) return void 0;
+  return `${REVIEW_REFUSAL_HEADING}
+${result.output.trim()}`;
+}
+function carries_approval(files) {
+  return Object.keys(files).some((file) => release_approval_prune.is_approval(file));
+}
+async function rerecord(directory, files) {
+  if (!project_checks.is_kit_repository(directory) || !carries_approval(files)) return false;
+  await buffered_process.run_buffered_process(METRICS_RERECORD_COMMAND, { cwd: directory });
+  return true;
+}
+var metrics_totals = {
+  METRICS_RERECORD_COMMAND,
+  METRICS_TOTALS_COMMAND,
+  NOTICE_HEADING,
+  REVIEW_REFUSAL_HEADING,
+  growth_notice,
+  rerecord,
+  // Finish the existing approval writer before fixing the tree any verification will read.
+  async rerecorded_tree(read = gate_tree.read_gate_tree, directory = process.cwd()) {
+    const tree = await read();
+    const is_rerecorded = await metrics_totals.rerecord(directory, tree.files);
+    return is_rerecorded ? await read() : tree;
+  },
+  totals_check,
+  totals_refusal
+};
+
+export {
+  metrics_totals
+};

package/dist/commands/chunk-HESWKELD.js

@@ -0,0 +1,60 @@
+import {
+  gate_skip
+} from "./chunk-NOSG3RUP.js";
+import {
+  observation_ledger
+} from "./chunk-SV4FZR24.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/gate/hook-gate-reuse.ts
+var GATE_REUSING_TARGETS = ["pre-commit-type-check", "pre-push-unit"];
+var WORKTREE_COLUMN = 1;
+var UNMODIFIED = " ";
+function is_force_requested(force_environment) {
+  return (process.env[force_environment] ?? "") !== "";
+}
+async function read_status_lines() {
+  try {
+    const status = await git_command.status();
+    return status.split("\n").filter((line) => line !== "").filter((line) => !observation_ledger.is_ledger_line(line));
+  } catch {
+    return void 0;
+  }
+}
+function is_worktree_clean(lines) {
+  return lines?.length === 0;
+}
+function is_index_matching_worktree(lines) {
+  return lines?.every((line) => line[WORKTREE_COLUMN] === UNMODIFIED) === true;
+}
+var ARGUMENTS_MISS = "arguments were passed to the hook";
+function force_miss(force_environment) {
+  return `${force_environment} is set`;
+}
+function hook_reuse(input) {
+  if (input.extra_arguments.length > 0) return { miss: ARGUMENTS_MISS };
+  if (is_force_requested(input.force_env)) return { miss: force_miss(input.force_env) };
+  if (!input.is_tree_carried) return { miss: input.carry_miss };
+  return gate_skip.gate_reuse(input.tree.files, input.tree.base, input.source);
+}
+function miss_kind(miss, input) {
+  if (miss === ARGUMENTS_MISS) return "arguments";
+  if (miss === force_miss(input.force_env)) return "forced";
+  if (miss === input.carry_miss) return "tree-not-carried";
+  return gate_skip.miss_kind(miss);
+}
+var hook_gate_reuse = {
+  GATE_REUSING_TARGETS,
+  hook_reuse,
+  is_force_requested,
+  is_index_matching_worktree,
+  is_worktree_clean,
+  miss_kind,
+  read_status_lines
+};
+
+export {
+  hook_gate_reuse
+};

package/dist/commands/chunk-HNFBEB4L.js

@@ -0,0 +1,77 @@
+import {
+  issue_outcome
+} from "./chunk-2WRDAQPJ.js";
+import {
+  run_hold_cli
+} from "./chunk-GWTBIGYC.js";
+import {
+  cli_body
+} from "./chunk-7IZJ5MG2.js";
+import {
+  git_gh_command
+} from "./chunk-NRULNBYI.js";
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  cli_flags
+} from "./chunk-2FE3C4PH.js";
+
+// scripts/issue/issue-evidence-exit.ts
+var FAILURE_EXIT_CODE = 1;
+var EVIDENCE_FILE_FLAG = "--evidence-file";
+var OPTIONS = { "evidence-file": { type: "string" }, outcome: { type: "string" } };
+function parse_request(argv) {
+  const parsed = cli_flags.arguments_of(argv, OPTIONS);
+  if (parsed === void 0) return void 0;
+  const issue_number = issue_number_shape.single_of(parsed.positionals);
+  const file_path = parsed.values["evidence-file"];
+  if (issue_number === void 0 || file_path === void 0) return void 0;
+  const evidence = cli_body.read_file_or_stdin(file_path).trim();
+  if (evidence.length === 0) throw new Error(`Evidence file is empty: ${file_path}`);
+  return {
+    issue_number,
+    evidence: issue_outcome.body_of({ body: evidence, summary: parsed.values.outcome })
+  };
+}
+function resolve_request(argv, command) {
+  try {
+    const request = parse_request(argv);
+    if (request === void 0) {
+      console.error(`Usage: josh ${command} <issue-number> ${EVIDENCE_FILE_FLAG} <path>`);
+    }
+    return request;
+  } catch (error) {
+    console.error(error_text.message_of(error));
+    return void 0;
+  }
+}
+async function post_evidence(request) {
+  try {
+    console.info(await git_gh_command.issue_comment(request.issue_number, request.evidence));
+    return true;
+  } catch (error) {
+    console.error(`Evidence comment not posted: ${error_text.message_of(error)}`);
+    return false;
+  }
+}
+async function write_exit(request, exit) {
+  const { issue_number, evidence } = request;
+  return await post_evidence(request) && await exit.finish(issue_number, evidence);
+}
+async function is_admitted(request, exit) {
+  return exit.admit === void 0 || await exit.admit(request.issue_number);
+}
+async function run(argv, exit) {
+  const request = resolve_request(argv, exit.command);
+  if (request === void 0 || !await is_admitted(request, exit)) return FAILURE_EXIT_CODE;
+  return await write_exit(request, exit) ? await run_hold_cli.run(["--release", request.issue_number]) : FAILURE_EXIT_CODE;
+}
+var issue_evidence_exit = { run, write: write_exit };
+
+export {
+  issue_evidence_exit
+};