@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-37RULO76.js

@@ -0,0 +1,220 @@
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PROJECT_ROOT
+} from "./chunk-3CCGKX7Y.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/review/review-checkout.ts
+async function read_checkout() {
+  const [root, branch, head] = await Promise.all([
+    git_command.repository_root(),
+    git_command.branch(),
+    git_command.head_commit()
+  ]);
+  return { root, branch, head };
+}
+function is_same_checkout(expected, actual) {
+  return expected.root === actual.root && expected.branch === actual.branch && expected.head === actual.head;
+}
+function describe_checkout(checkout) {
+  return `${checkout.root} (branch ${checkout.branch}, HEAD ${checkout.head})`;
+}
+var review_checkout = { describe_checkout, is_same_checkout, read_checkout };
+
+// scripts/review/review-attest.ts
+import { randomBytes } from "node:crypto";
+import { lstatSync } from "node:fs";
+var REVIEW_SLOT = { CODE: "code", INTERACTION: "interaction" };
+var REVIEW_SLOTS = [REVIEW_SLOT.CODE, REVIEW_SLOT.INTERACTION];
+var POINTER_PREFIXES = {
+  code: "josh-review-target-",
+  interaction: "josh-review-interaction-target-"
+};
+var EXPECT_PREFIX = "josh-review-expect-";
+var ATTEST_PREFIX = "josh-review-attest-";
+var NONCE_BYTES = 8;
+var HOURS_BEFORE_STALE = 8;
+var MILLISECONDS_PER_HOUR = 36e5;
+var STALE_AFTER_MS = HOURS_BEFORE_STALE * MILLISECONDS_PER_HOUR;
+function pointer_path(root = PROJECT_ROOT, slot = REVIEW_SLOT.CODE) {
+  return stamp_file.stamp_path(POINTER_PREFIXES[slot], root);
+}
+function expect_path(nonce) {
+  return stamp_file.stamp_path(EXPECT_PREFIX, nonce);
+}
+function attest_path(nonce) {
+  return stamp_file.stamp_path(ATTEST_PREFIX, nonce);
+}
+function read_json(source) {
+  const raw = stamp_file.read_stamp_text(source);
+  return raw === void 0 ? void 0 : json_value.parse_or_undefined(raw);
+}
+function string_field(value, key) {
+  const field = value[key];
+  return typeof field === "string" ? field : void 0;
+}
+function to_checkout(value) {
+  if (!json_value.is_record(value)) return void 0;
+  const root = string_field(value, "root");
+  const branch = string_field(value, "branch");
+  const head = string_field(value, "head");
+  if (root === void 0 || branch === void 0 || head === void 0) return void 0;
+  return { root, branch, head };
+}
+function to_pointer(value) {
+  if (!json_value.is_record(value)) return void 0;
+  const nonce = string_field(value, "nonce");
+  const taken_at = string_field(value, "taken_at");
+  if (nonce !== void 0 && taken_at !== void 0) return { nonce, taken_at };
+  return void 0;
+}
+function read_pointer(root, slot) {
+  return to_pointer(read_json(pointer_path(root, slot)));
+}
+function read_expectation(nonce) {
+  return to_checkout(read_json(expect_path(nonce)));
+}
+function read_attestation(nonce) {
+  return to_checkout(read_json(attest_path(nonce)));
+}
+function drop_records(pointer) {
+  if (pointer === void 0) return;
+  stamp_file.remove_stamp(expect_path(pointer.nonce));
+  stamp_file.remove_stamp(attest_path(pointer.nonce));
+}
+function drop_slot(root, slot) {
+  const pointer = read_pointer(root, slot);
+  stamp_file.remove_stamp(pointer_path(root, slot));
+  drop_records(pointer);
+}
+function is_stale(taken_at, now) {
+  const taken = Date.parse(taken_at);
+  return Number.isNaN(taken) || now - taken > STALE_AFTER_MS;
+}
+function record_target(checkout, root, slot = REVIEW_SLOT.CODE) {
+  const nonce = randomBytes(NONCE_BYTES).toString("hex");
+  const taken_at = (/* @__PURE__ */ new Date()).toISOString();
+  if (slot === REVIEW_SLOT.CODE) drop_slot(root, REVIEW_SLOT.INTERACTION);
+  drop_records(read_pointer(root, slot));
+  stamp_file.write_stamp(expect_path(nonce), { ...checkout, taken_at });
+  stamp_file.write_stamp(pointer_path(root, slot), { nonce, taken_at });
+  return nonce;
+}
+function attest(nonce, actual) {
+  const expected = read_expectation(nonce);
+  if (expected === void 0) return { status: "missing", nonce, actual };
+  stamp_file.write_stamp(attest_path(nonce), { ...actual, taken_at: (/* @__PURE__ */ new Date()).toISOString() });
+  if (review_checkout.is_same_checkout(expected, actual)) {
+    return { status: "ok", nonce, expected, actual };
+  }
+  return { status: "mismatch", nonce, expected, actual };
+}
+function not_required() {
+  return { status: "not-required" };
+}
+function verdict_for(nonce) {
+  const expected = read_expectation(nonce);
+  if (expected === void 0) return { status: "missing", nonce };
+  const actual = read_attestation(nonce);
+  if (actual === void 0) return { status: "missing", nonce, expected };
+  if (review_checkout.is_same_checkout(expected, actual)) {
+    return { status: "ok", nonce, expected, actual };
+  }
+  return { status: "mismatch", nonce, expected, actual };
+}
+function check_slot(now, root, slot) {
+  const pointer = read_pointer(root, slot);
+  if (pointer === void 0) return not_required();
+  const verdict = verdict_for(pointer.nonce);
+  if (verdict.status === "missing" && is_stale(pointer.taken_at, now)) return not_required();
+  return verdict;
+}
+function is_passing(verdict) {
+  return verdict.status === "ok" || verdict.status === not_required().status;
+}
+function check(now = Date.now(), root) {
+  const verdicts = REVIEW_SLOTS.map((slot) => check_slot(now, root, slot));
+  return verdicts.find((verdict) => !is_passing(verdict)) ?? verdicts.find((verdict) => verdict.status === "ok") ?? not_required();
+}
+function is_written_since(source, taken_at) {
+  try {
+    const stats = lstatSync(source);
+    return stats.isFile() && stats.mtimeMs >= Date.parse(taken_at);
+  } catch {
+    return false;
+  }
+}
+function is_attested_on(checkout, root) {
+  const pointer = read_pointer(root);
+  if (pointer === void 0) return false;
+  const verdict = verdict_for(pointer.nonce);
+  return verdict.status === "ok" && verdict.expected?.branch === checkout.branch;
+}
+function is_reviewed_on(checkout, findings_path, root) {
+  const pointer = read_pointer(root);
+  if (pointer === void 0 || !is_attested_on(checkout, root)) return false;
+  return is_written_since(findings_path, pointer.taken_at);
+}
+function is_briefed_since(written_at, root) {
+  const pointer = read_pointer(root);
+  return pointer !== void 0 && written_at >= pointer.taken_at;
+}
+async function check_here(now = Date.now()) {
+  return check(now, await git_command.repository_root());
+}
+function clear(root) {
+  for (const slot of REVIEW_SLOTS) drop_slot(root, slot);
+}
+async function clear_here() {
+  clear(await git_command.repository_root());
+}
+var MISMATCH_VERDICT = "REVIEW TARGET MISMATCH";
+function describe_side(label, checkout) {
+  if (checkout === void 0) return `${label}: unknown`;
+  return `${label}: ${review_checkout.describe_checkout(checkout)}`;
+}
+var MISSING_REASON = "The review left no attestation, so there is no evidence it read this checkout at all. A review that read the wrong tree finds nothing wrong and reports no findings, which is indistinguishable from a clean review \u2014 so an absent attestation is treated as no review (joshuafolkken/kit#1522).";
+var MISMATCH_REASON = `${MISMATCH_VERDICT}: the review attested a different checkout from the one it was briefed on. Its findings \u2014 including "no findings" \u2014 describe another tree.`;
+var REMEDY = "Re-run `/code-review` with the brief `pnpm josh review:brief` prints, against the checkout named above, and let it run `pnpm josh review:attest <nonce>` from there before it reports.";
+function refusal_message(verdict) {
+  const reason = verdict.status === "mismatch" ? MISMATCH_REASON : MISSING_REASON;
+  return [
+    reason,
+    describe_side("Briefed on", verdict.expected),
+    describe_side("Reviewed", verdict.actual),
+    REMEDY
+  ].join("\n");
+}
+var review_attest = {
+  attest,
+  check,
+  check_here,
+  clear,
+  clear_here,
+  expect_path,
+  is_attested_on,
+  is_briefed_since,
+  is_reviewed_on,
+  MISMATCH_VERDICT,
+  MISSING_REASON,
+  read_attestation,
+  read_expectation,
+  read_pointer,
+  record_target,
+  refusal_message,
+  REVIEW_SLOT,
+  REVIEW_SLOTS,
+  STALE_AFTER_MS
+};
+
+export {
+  review_checkout,
+  review_attest
+};

package/dist/commands/chunk-3EYRE3GI.js

@@ -0,0 +1,173 @@
+import {
+  run_ship_probe
+} from "./chunk-VD4ELMDA.js";
+import {
+  run_ship_detach
+} from "./chunk-Z7C2O5JC.js";
+import {
+  run_ship_stage
+} from "./chunk-PUQA7F6Y.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/ship/run-ship-wait-cli.ts
+import { setTimeout as sleep2 } from "node:timers/promises";
+
+// scripts/run/ship/run-ship-waiter.ts
+import { setTimeout as sleep } from "node:timers/promises";
+import { z } from "zod";
+var HEARTBEAT_PREFIX = "josh-ship-waiter-";
+var HANDOFF_PREFIX = "josh-ship-handoff-";
+var DECISION_PREFIX = "josh-ship-handoff-taken-";
+var KEY_SEPARATOR = "-";
+var TAKEN = "taken";
+var WITHDRAWN = "withdrawn";
+var SESSION_GAP_MS = 12e4;
+var OFFER_POLL_MS = 1e3;
+var heartbeat_schema = z.object({ at: z.number() });
+var offer_schema = z.object({ at: z.number(), note: z.string() });
+function path_of(prefix, repository, issue) {
+  return stamp_file.stamp_path(`${prefix}${issue}${KEY_SEPARATOR}`, repository);
+}
+function beat(repository, issue, at = Date.now()) {
+  stamp_file.replace_stamp(path_of(HEARTBEAT_PREFIX, repository, issue), { at });
+}
+function leave(repository, issue) {
+  stamp_file.remove_stamp(path_of(HEARTBEAT_PREFIX, repository, issue));
+}
+function is_waited(repository, issue, now = Date.now()) {
+  const raw = stamp_file.read_stamp_text(path_of(HEARTBEAT_PREFIX, repository, issue));
+  const heartbeat = raw === void 0 ? void 0 : json_value.parse_with(raw, heartbeat_schema);
+  return heartbeat !== void 0 && now - heartbeat.at < SESSION_GAP_MS;
+}
+function decide(repository, issue, decision) {
+  return stamp_file.create_stamp(path_of(DECISION_PREFIX, repository, issue), decision);
+}
+function clear_offer(repository, issue) {
+  stamp_file.remove_stamp(path_of(HANDOFF_PREFIX, repository, issue));
+  stamp_file.remove_stamp(path_of(DECISION_PREFIX, repository, issue));
+}
+function offered_note(repository, issue, now) {
+  const raw = stamp_file.read_stamp_text(path_of(HANDOFF_PREFIX, repository, issue));
+  const offered = raw === void 0 ? void 0 : json_value.parse_with(raw, offer_schema);
+  return offered !== void 0 && now - offered.at < SESSION_GAP_MS ? offered.note : void 0;
+}
+function take(repository, issue, now = Date.now()) {
+  const note = offered_note(repository, issue, now);
+  if (note === void 0 || !decide(repository, issue, TAKEN)) return void 0;
+  stamp_file.remove_stamp(path_of(HANDOFF_PREFIX, repository, issue));
+  return note;
+}
+async function await_taken(repository, issue) {
+  const decision = path_of(DECISION_PREFIX, repository, issue);
+  const is_taken = await poll.poll_until(() => stamp_file.read_stamp_text(decision) !== void 0, {
+    attempts: Math.ceil(SESSION_GAP_MS / OFFER_POLL_MS),
+    interval_ms: OFFER_POLL_MS,
+    sleeper: sleep
+  });
+  if (is_taken) return true;
+  await sleep(OFFER_POLL_MS);
+  return !decide(repository, issue, WITHDRAWN);
+}
+async function offer(repository, issue, note) {
+  if (!is_waited(repository, issue)) return false;
+  clear_offer(repository, issue);
+  stamp_file.replace_stamp(path_of(HANDOFF_PREFIX, repository, issue), { at: Date.now(), note });
+  const is_taken = await await_taken(repository, issue);
+  stamp_file.remove_stamp(path_of(HANDOFF_PREFIX, repository, issue));
+  return is_taken;
+}
+var run_ship_waiter = { SESSION_GAP_MS, beat, is_waited, leave, offer, take };
+
+// scripts/run/ship/run-ship-wait-cli.ts
+var VERDICT = {
+  RETURNED: "returned",
+  PASSED: "passed",
+  ENDED: "ended",
+  PENDING: "pending"
+};
+var CHUNK_MS = 27e4;
+var POLL_MS = 2e3;
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+var USAGE = "Usage: josh ship:wait <N>";
+var NO_REPOSITORY_NOTE = "not inside a git repository";
+var { COMMIT, FOLLOWUP, REPORT } = run_ship_stage.STAGE;
+var PAST_COMMIT = /* @__PURE__ */ new Set([FOLLOWUP, REPORT]);
+function is_committed(repository, issue) {
+  const target = run_ship_stage.record_path(repository, issue);
+  const started = run_ship_stage.read_started(target);
+  if (started.some((stage) => PAST_COMMIT.has(stage))) return true;
+  return started.includes(COMMIT) && run_ship_stage.read_done(target).has(COMMIT);
+}
+function ended(repository, issue) {
+  const result = run_ship_detach.read_result(repository, issue)?.result;
+  if (result === "running") return void 0;
+  return { verdict: result === "success" ? VERDICT.PASSED : VERDICT.ENDED };
+}
+function settled(repository, issue) {
+  const note = run_ship_waiter.take(repository, issue);
+  if (note !== void 0) return { verdict: VERDICT.RETURNED, note };
+  if (is_committed(repository, issue)) return { verdict: VERDICT.PASSED };
+  return ended(repository, issue);
+}
+async function wait_within(repository, issue, deadline) {
+  return await poll.wait_for(
+    () => {
+      if (Date.now() >= deadline) return { verdict: VERDICT.PENDING };
+      run_ship_waiter.beat(repository, issue);
+      return settled(repository, issue);
+    },
+    { interval_ms: POLL_MS, sleeper: sleep2 }
+  );
+}
+async function wait_for(repository, issue, chunk_ms = CHUNK_MS) {
+  const waited = await wait_within(repository, issue, Date.now() + chunk_ms);
+  if (waited.verdict !== VERDICT.PENDING) run_ship_waiter.leave(repository, issue);
+  return waited;
+}
+function chunk_left() {
+  return CHUNK_MS - performance.now();
+}
+function next_action(issue) {
+  return {
+    [VERDICT.RETURNED]: "the ship stopped: fix what the note below says, then ship again",
+    [VERDICT.PASSED]: "the supervisor ships the rest: end the turn",
+    [VERDICT.ENDED]: "nothing is left to wait for: end the turn",
+    [VERDICT.PENDING]: `still before the commit: on \`pnpm josh cost --cut\` \`under\`, run \`pnpm josh ship:wait ${issue}\` again; else end the turn`
+  };
+}
+function report(issue, waited) {
+  console.info(`${waited.verdict} \u2014 ${next_action(issue)[waited.verdict]}`);
+  if (waited.note !== void 0) console.info(waited.note);
+}
+async function run(argv) {
+  const issue = issue_number_shape.single_of(argv);
+  if (issue === void 0) {
+    console.error(USAGE);
+    return FAILURE_EXIT_CODE;
+  }
+  const repository = await run_ship_probe.repository_directory();
+  if (repository === void 0) {
+    console.error(NO_REPOSITORY_NOTE);
+    return FAILURE_EXIT_CODE;
+  }
+  report(issue, await wait_for(repository, issue, chunk_left()));
+  return SUCCESS_EXIT_CODE;
+}
+var run_ship_wait_cli = { CHUNK_MS, VERDICT, run, wait_for };
+
+export {
+  run_ship_waiter,
+  run_ship_wait_cli
+};

package/dist/commands/chunk-3IXIYDC3.js

@@ -0,0 +1,179 @@
+import {
+  agent_argv
+} from "./chunk-IV6ETHVB.js";
+import {
+  run_event_setup
+} from "./chunk-WEEJU3EH.js";
+import {
+  run_headless
+} from "./chunk-UACWDTJ5.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  detached_launch
+} from "./chunk-MOAPWO34.js";
+import {
+  durable_state,
+  run_carry
+} from "./chunk-JSJS3OT7.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/backlog/backlogrun-launch.ts
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+var LAUNCH_PREFIX = durable_state.PREFIX.BACKLOGRUN_LAUNCH;
+var LOG_PREFIX = durable_state.PREFIX.BACKLOGRUN_LOG;
+var LOG_SUFFIX = ".log";
+var launch_schema = z.object({
+  pid: z.number(),
+  start: z.string().optional(),
+  session: z.string().optional(),
+  // What the parent was started to run and when, so `run:board` has a run to draw and a clock to count
+  // before the parent claims the carry record. Absent on a record an earlier version wrote.
+  invocation: z.string().optional(),
+  started_at: z.string().optional(),
+  scheduler_provider: agent_provider.PROVIDER_SCHEMA.optional()
+});
+function launch_path(git_directory) {
+  return durable_state.path(LAUNCH_PREFIX, git_directory);
+}
+function log_path(git_directory) {
+  return durable_state.path(LOG_PREFIX, git_directory, LOG_SUFFIX);
+}
+function read_launch(target) {
+  return json_value.parse_with(stamp_file.read_stamp_text(target) ?? "", launch_schema);
+}
+function is_launch_live(record) {
+  if (record === void 0) return false;
+  return process_identity.is_same_process(record.pid, record.start) !== false;
+}
+function is_carry_live(read) {
+  return read.kind === "carried" && run_carry.is_owner_live(read.carry);
+}
+function is_running(git_directory) {
+  if (is_carry_live(run_carry.read_carry(run_carry.carry_path(git_directory)))) return true;
+  return is_launch_live(read_launch(launch_path(git_directory)));
+}
+function chosen_environment(provider, environment = process.env) {
+  return {
+    ...environment,
+    ...agent_session_environment.removed_environment(environment),
+    [agent_role_profile.CODEX_SESSION_KEY]: void 0,
+    [agent_role_profile.HANDED_PROVIDER_KEY]: provider
+  };
+}
+function session_for(provider) {
+  return provider === "anthropic" ? randomUUID() : void 0;
+}
+function argv_of(invocation, provider, worktree, session) {
+  const environment = chosen_environment(provider);
+  const resolved = agent_role_profile.resolve(agent_role_profile.SCHEDULER, environment);
+  if (resolved.kind === "rejected") return resolved;
+  return agent_argv.with_profile_in(invocation, resolved.profile, worktree, session);
+}
+function note_to_stderr(note) {
+  console.error(`backlogrun: ${note}`);
+}
+function record_launch(git_directory, launch) {
+  const now = /* @__PURE__ */ new Date();
+  const identity = process_identity.read_start(launch.pid);
+  const record = { ...launch, start: identity, started_at: now.toISOString() };
+  stamp_file.replace_stamp(launch_path(git_directory), record);
+  run_event_setup.emit_in(git_directory, run_event_setup.STAGE.STARTING, now);
+}
+function live_launch(git_directory) {
+  const record = read_launch(launch_path(git_directory));
+  return is_launch_live(record) ? record : void 0;
+}
+function pending_launch(git_directory) {
+  const { invocation, started_at, scheduler_provider } = live_launch(git_directory) ?? {};
+  if (invocation === void 0 || started_at === void 0) return void 0;
+  return { invocation, started_at, ...scheduler_provider && { scheduler_provider } };
+}
+function started_for(git_directory, owner_pid) {
+  const record = live_launch(git_directory);
+  if (record?.started_at === void 0 || record.pid !== owner_pid) return void 0;
+  const started_ms = Date.parse(record.started_at);
+  return Number.isNaN(started_ms) ? void 0 : new Date(started_ms);
+}
+function signal_parent(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    note_to_stderr(`process ${String(pid)} could not be signalled; its launch record is removed.`);
+  }
+}
+function running_parent(git_directory) {
+  return live_launch(git_directory)?.pid;
+}
+function stop_parent(git_directory) {
+  const record = live_launch(git_directory);
+  stamp_file.remove_stamp(launch_path(git_directory));
+  if (record === void 0) return void 0;
+  signal_parent(record.pid);
+  return record.pid;
+}
+function spawn_parent(argv, provider, target) {
+  const environment = {
+    ...run_headless.environment(),
+    [agent_role_profile.CODEX_SESSION_KEY]: void 0,
+    [agent_role_profile.HANDED_PROVIDER_KEY]: provider
+  };
+  const log = log_path(target.git_directory);
+  return detached_launch.launch(
+    {
+      argv: argv.argv,
+      cwd: target.worktree,
+      env: environment,
+      log_path: log,
+      profile: argv.profile
+    },
+    note_to_stderr
+  );
+}
+function start(invocation, provider, target) {
+  const session = session_for(provider);
+  const built = argv_of(invocation, provider, target.worktree, session);
+  if (built.kind === "rejected") return { kind: "failed", note: built.note };
+  const result = spawn_parent(built, provider, target);
+  if (result.kind === "failed") return result;
+  record_launch(target.git_directory, {
+    pid: result.pid,
+    session,
+    invocation,
+    scheduler_provider: built.profile.provider
+  });
+  const launched = { pid: result.pid, session, log_path: log_path(target.git_directory) };
+  return { kind: "launched", launched };
+}
+var backlogrun_launch = {
+  argv_of,
+  chosen_environment,
+  is_running,
+  launch_path,
+  log_path,
+  pending_launch,
+  running_parent,
+  start,
+  started_for,
+  stop_parent
+};
+
+export {
+  backlogrun_launch
+};

package/dist/commands/chunk-3OFJCJN4.js

@@ -0,0 +1,30 @@
+import {
+  git_branch
+} from "./chunk-C7CDGSMW.js";
+import {
+  lane_ledger_write
+} from "./chunk-V56NLG7I.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/run/early-push-record.ts
+async function record(source, result, slots) {
+  try {
+    const issue = git_branch.issue_from_branch(await git_command.branch());
+    const head = await git_command.head_commit();
+    await lane_ledger_write.record_early_push({
+      source,
+      result,
+      head,
+      ...issue !== void 0 && { issue },
+      ...slots !== void 0 && { slots }
+    });
+  } catch {
+  }
+}
+var early_push_record = { record };
+
+export {
+  early_push_record
+};

package/dist/commands/chunk-3OSUM6DM.js

@@ -0,0 +1,53 @@
+import {
+  observation_ledger
+} from "./chunk-SV4FZR24.js";
+import {
+  input_fingerprint
+} from "./chunk-GA2YSPFH.js";
+import {
+  changed_paths
+} from "./chunk-AL2H63BP.js";
+import {
+  change_base
+} from "./chunk-FVPRBMHE.js";
+import {
+  git_command
+} from "./chunk-KMED24C4.js";
+
+// scripts/review/review-tree.ts
+var ABSENT_DIGEST = input_fingerprint.ABSENT;
+function tree_of(root, paths) {
+  return input_fingerprint.of_files(
+    root,
+    paths.filter((relative) => !observation_ledger.is_ledger_path(relative))
+  );
+}
+async function read_changed_tree(paths, root) {
+  return tree_of(
+    root ?? await git_command.repository_root(),
+    paths ?? await changed_paths.read_changed_paths(false)
+  );
+}
+var review_tree = { ABSENT_DIGEST, read_changed_tree, tree_of };
+
+// scripts/gate/gate-tree.ts
+async function read_changed_files() {
+  try {
+    return await review_tree.read_changed_tree();
+  } catch {
+    return {};
+  }
+}
+async function read_base() {
+  return await change_base.resolved_through_merge();
+}
+async function read_gate_tree() {
+  const [files, base] = await Promise.all([read_changed_files(), read_base()]);
+  return { files, base };
+}
+var gate_tree = { read_gate_tree };
+
+export {
+  review_tree,
+  gate_tree
+};