@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-GAVSK6P6.js

@@ -1,230 +0,0 @@
-import {
-  git_gh_pr_read
-} from "./chunk-5IHEBIPD.js";
-import {
-  git_stash
-} from "./chunk-WROJTXWZ.js";
-import {
-  lane_registry
-} from "./chunk-NEOCCN6D.js";
-import {
-  run_hold
-} from "./chunk-F5N2QIFD.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  issue_number_shape
-} from "./chunk-G75GWNNY.js";
-import {
-  git_command
-} from "./chunk-IXZZSST7.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/run-preflight.ts
-import { z } from "zod";
-var CLEAN_VERDICT = "clean";
-var RECLAIM_VERDICT = "reclaim";
-var RESUME_VERDICT = "resume";
-var PARK_VERDICT = "park";
-var NO_PR = "none";
-var OPEN_PR = "open";
-var MERGED_PR = "merged";
-var CLOSED_PR = "closed";
-var NO_CHILD_WORK = { branch_name: void 0, pr_state: NO_PR };
-var pr_info_schema = z.object({ state: z.string().optional() });
-var GH_PR_STATES = /* @__PURE__ */ new Map([
-  ["CLOSED", CLOSED_PR],
-  ["MERGED", MERGED_PR],
-  ["OPEN", OPEN_PR]
-]);
-var CLEAN_REASON = "Nothing was left behind: the tree is clean, HEAD is on the default branch, and this issue has no pull request and no branch holding work.";
-var CLEAN_ADVICE = "Start the child.";
-var RESUME_ADVICE = "Reuse the branch and run the whole verification gate from the start \u2014 refactor, `pnpm josh gate`, `/code-review` \u2014 never only the part the interrupted run had not reached. Nobody verified what it already committed.";
-var PARK_ADVICE = "Park the child: add `needs-decision` and comment what was found. Do not delete the branch, do not reopen the pull request, and do not commit on top of it.";
-var STASH_LABEL_PREFIX = "run:hold reclaimed before #";
-var { require_issue_number } = issue_number_shape;
-var UNREADABLE_PR_MESSAGE = "The pull request could not be read for branch ";
-function needs_reclaim(tree) {
-  return tree.is_dirty || tree.branch !== tree.default_branch;
-}
-function is_pr_decided(state) {
-  return state === MERGED_PR || state === CLOSED_PR;
-}
-function has_leftover_work(child) {
-  return child.branch_name !== void 0 || child.pr_state === OPEN_PR;
-}
-function to_verdict(tree, child) {
-  if (needs_reclaim(tree)) return RECLAIM_VERDICT;
-  if (is_pr_decided(child.pr_state)) return PARK_VERDICT;
-  if (has_leftover_work(child)) return RESUME_VERDICT;
-  return CLEAN_VERDICT;
-}
-function reclaim_reason(tree) {
-  const findings = [
-    tree.is_dirty ? "uncommitted changes" : void 0,
-    tree.branch === tree.default_branch ? void 0 : `HEAD on ${tree.branch}`
-  ].filter((entry) => entry !== void 0);
-  return `An earlier run left ${findings.join(" and ")} in this working tree.`;
-}
-function park_reason(state) {
-  return `The pull request for this issue is ${state}, so whether any work is still owed is a person's call.`;
-}
-function resume_reason(child) {
-  const branch_part = child.branch_name === void 0 ? "" : ` on branch ${child.branch_name}`;
-  const pr_part = child.pr_state === OPEN_PR ? ", and its pull request is still open" : "";
-  return `An earlier run left a partial implementation${branch_part}${pr_part}.`;
-}
-function to_reason(verdict, tree, child) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_reason(tree);
-  if (verdict === PARK_VERDICT) return park_reason(child.pr_state);
-  if (verdict === RESUME_VERDICT) return resume_reason(child);
-  return CLEAN_REASON;
-}
-function reclaim_steps(tree, issue) {
-  if (!tree.is_dirty) return [];
-  return [
-    `pnpm josh stash:push "${STASH_LABEL_PREFIX}${issue}"`,
-    `Record the stash on ${session_cite.issue(issue)} \u2014 the comment is what gets it popped; nothing pops it for you.`
-  ];
-}
-function reclaim_advice(tree, issue) {
-  return [
-    ...reclaim_steps(tree, issue),
-    "pnpm josh ms",
-    "Then ask this command again: it is re-askable, and the clean tree gets its own answer."
-  ].join("\n");
-}
-function to_advice(verdict, issue, tree) {
-  if (verdict === RECLAIM_VERDICT) return reclaim_advice(tree, issue);
-  if (verdict === RESUME_VERDICT) return RESUME_ADVICE;
-  if (verdict === PARK_VERDICT) return PARK_ADVICE;
-  return CLEAN_ADVICE;
-}
-function decide(tree, child, issue) {
-  const verdict = to_verdict(tree, child);
-  return {
-    advice: to_advice(verdict, issue, tree),
-    reason: to_reason(verdict, tree, child),
-    verdict
-  };
-}
-function read_pr_field(raw) {
-  return json_value.parse_with(raw, pr_info_schema)?.state;
-}
-function to_pr_state(raw) {
-  const state = read_pr_field(raw);
-  return (state === void 0 ? void 0 : GH_PR_STATES.get(state)) ?? NO_PR;
-}
-async function has_stashable_work() {
-  try {
-    return await git_stash.has_stashable_changes();
-  } catch (error) {
-    error_text.trace_swallowed("run_preflight.has_stashable_work", error);
-    return true;
-  }
-}
-async function read_tree_state() {
-  const [is_dirty, current, default_branch] = await Promise.all([
-    has_stashable_work(),
-    git_command.branch(),
-    git_command.get_default_branch()
-  ]);
-  return { branch: current, default_branch, is_dirty };
-}
-async function read_pr_state(branch_name) {
-  if (!await git_gh_pr_read.pr_exists(branch_name)) return NO_PR;
-  const raw = await git_gh_pr_read.pr_view(branch_name);
-  if (raw === "") throw new Error(`${UNREADABLE_PR_MESSAGE}${branch_name}`);
-  return to_pr_state(raw);
-}
-function is_pr_open(state) {
-  return state === OPEN_PR;
-}
-async function read_pr_of_branch(branch_name) {
-  return { branch_name, pr_state: await read_pr_state(branch_name) };
-}
-function pick_child_state(reads) {
-  const decided = reads.find((read) => is_pr_decided(read.pr_state));
-  const open = reads.find((read) => is_pr_open(read.pr_state));
-  return decided ?? open ?? { branch_name: reads[0]?.branch_name, pr_state: NO_PR };
-}
-var ISSUE_BRANCH_SUFFIX = "-*";
-var ANY_REMOTE_PREFIX = "*/";
-var REMOTE_SEPARATOR = "/";
-var NOT_FOUND_INDEX = -1;
-function to_head_branch(name) {
-  const separator_index = name.indexOf(REMOTE_SEPARATOR);
-  return separator_index === NOT_FOUND_INDEX ? name : name.slice(separator_index + 1);
-}
-function group_by_head(pairs) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const [name, reference] of pairs) groups.set(name, [...groups.get(name) ?? [], reference]);
-  return groups;
-}
-async function read_branch_candidates(issue) {
-  const pattern = `${issue}${ISSUE_BRANCH_SUFFIX}`;
-  const [local, remote] = await Promise.all([
-    git_command.branch_names(pattern),
-    git_command.branch_names_remote(`${ANY_REMOTE_PREFIX}${pattern}`)
-  ]);
-  return group_by_head([
-    ...local.map((name) => [name, name]),
-    ...remote.map((reference) => [to_head_branch(reference), reference])
-  ]);
-}
-async function has_commits_beyond(base, references) {
-  const counts = await Promise.all(
-    references.map(async (reference) => await git_command.commit_count_beyond(base, reference))
-  );
-  return counts.some((count) => count > 0);
-}
-async function is_held_dirty(name, lane) {
-  if (lane?.branch !== name || lane.is_stranded) return false;
-  return await run_hold.is_tree_dirty(lane.directory);
-}
-async function read_candidate(name, references, context) {
-  const state = await read_pr_of_branch(name);
-  if (state.pr_state !== NO_PR || await has_commits_beyond(context.base, references)) return state;
-  return await is_held_dirty(name, context.lane) ? state : void 0;
-}
-async function read_child_state(issue) {
-  const candidates = await read_branch_candidates(issue);
-  if (candidates.size === 0) return NO_CHILD_WORK;
-  const [base, lane] = await Promise.all([
-    git_command.default_branch_reference(),
-    lane_registry.find_open_lane(issue)
-  ]);
-  const reads = await Promise.all(
-    [...candidates].map(
-      async ([name, references]) => await read_candidate(name, references, { base, lane })
-    )
-  );
-  return pick_child_state(reads.filter((read) => read !== void 0));
-}
-async function check(issue) {
-  require_issue_number(issue);
-  const tree = await read_tree_state();
-  if (needs_reclaim(tree)) return decide(tree, NO_CHILD_WORK, issue);
-  return decide(tree, await read_child_state(issue), issue);
-}
-var run_preflight = {
-  CLEAN_VERDICT,
-  RESUME_ADVICE,
-  MERGED_PR,
-  STASH_LABEL_PREFIX,
-  check,
-  decide,
-  read_child_state,
-  read_pr_state,
-  to_pr_state
-};
-
-export {
-  run_preflight
-};

package/dist/commands/chunk-GB2BRQVL.js

@@ -1,300 +0,0 @@
-import {
-  hook_context
-} from "./chunk-CUWT6UQO.js";
-import {
-  time_hook_transcript,
-  transcript_tail
-} from "./chunk-2OMIHPPE.js";
-import {
-  josh_environment_file
-} from "./chunk-NFKULY26.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-import {
-  file_reader
-} from "./chunk-ZNX2LJCQ.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/josh/hook-payload-capture.ts
-import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { z } from "zod";
-var CAPTURE_DIR_KEY = "JOSH_HOOK_CAPTURE_DIR";
-var NO_TOOL = "none";
-var FILE_EXTENSION = ".json";
-var UNSAFE_NAME_CHARACTERS = /[^\w.-]/gu;
-var MAX_ATTEMPTS = 32;
-var tool_schema = z.looseObject({ tool_name: z.string().min(1) });
-function safe_name(name) {
-  return name.replaceAll(UNSAFE_NAME_CHARACTERS, "-");
-}
-function tool_label(raw_payload) {
-  return safe_name(json_value.parse_with(raw_payload, tool_schema)?.tool_name ?? NO_TOOL);
-}
-function write_new(file, raw_payload) {
-  try {
-    writeFileSync(file, raw_payload, { flag: "wx" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function write_capture(directory, hook, raw_payload) {
-  const prefix = `${safe_name(hook)}-${tool_label(raw_payload)}-`;
-  const first = readdirSync(directory).filter((name) => name.startsWith(prefix)).length + 1;
-  for (let index = first; index < first + MAX_ATTEMPTS; index += 1) {
-    const file = path.join(directory, `${prefix}${String(index)}${FILE_EXTENSION}`);
-    if (write_new(file, raw_payload)) return file;
-  }
-  return void 0;
-}
-function capture(hook, raw_payload, environment = process.env) {
-  const directory = environment[CAPTURE_DIR_KEY];
-  if (directory === void 0 || directory === "") return void 0;
-  try {
-    mkdirSync(directory, { recursive: true });
-    return write_capture(directory, hook, raw_payload);
-  } catch {
-    return void 0;
-  }
-}
-var hook_payload_capture = { CAPTURE_DIR_KEY, capture };
-
-// scripts/josh/hook-decision.ts
-import { text } from "node:stream/consumers";
-import { z as z3 } from "zod";
-
-// scripts/josh/hook-envelope.ts
-var HOOK_EVENT_NAME = "PreToolUse";
-var DENY_DECISION = "deny";
-var ALLOW_DECISION = "allow";
-function deny_envelope(reason) {
-  return JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      permissionDecision: DENY_DECISION,
-      permissionDecisionReason: reason
-    }
-  });
-}
-function rewrite_envelope(updated_input, context) {
-  return JSON.stringify({
-    systemMessage: context,
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      permissionDecision: ALLOW_DECISION,
-      updatedInput: updated_input,
-      additionalContext: context
-    }
-  });
-}
-function flow_rewrite_envelope(updated_input, context) {
-  return JSON.stringify({
-    systemMessage: context,
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      updatedInput: updated_input,
-      additionalContext: context
-    }
-  });
-}
-function notice_envelope(notice) {
-  return JSON.stringify({
-    systemMessage: notice,
-    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: notice }
-  });
-}
-var hook_envelope = { deny_envelope, flow_rewrite_envelope, notice_envelope, rewrite_envelope };
-
-// scripts/josh/hook-tool-payload.ts
-import { z as z2 } from "zod";
-var schema = z2.object({
-  tool_name: z2.string().min(1),
-  tool_input: z2.unknown()
-});
-function parse(raw_payload) {
-  return json_value.parse_with(raw_payload, schema);
-}
-var hook_tool_payload = { parse, schema };
-
-// scripts/josh/hook-decision.ts
-var payload_schema = hook_tool_payload.schema.extend({
-  transcript_path: z3.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: z3.string().nullish(),
-  // The session's model where the harness hands it over (a Codex payload); Claude Code names it on
-  // the transcript's assistant entries instead (`scripts/rules/main-model.ts`).
-  model: z3.string().nullish()
-});
-var refusal_schema = z3.object({ refused_at_ms: z3.number() });
-var NEVER_MS = 0;
-var DISABLED_VALUES = ["off", "0", "false", "no"];
-function is_switch_enabled(key, environment = process.env) {
-  return !DISABLED_VALUES.includes((environment[key] ?? "").trim().toLowerCase());
-}
-var ENABLED_VALUES = ["on", "1", "true", "yes"];
-function is_switch_opt_in(key) {
-  return ENABLED_VALUES.includes((process.env[key] ?? "").trim().toLowerCase());
-}
-function parse_hook_payload(raw_payload) {
-  return json_value.parse_with(raw_payload, payload_schema);
-}
-var { deny_envelope: deny_envelope2, flow_rewrite_envelope: flow_rewrite_envelope2, notice_envelope: notice_envelope2, rewrite_envelope: rewrite_envelope2 } = hook_envelope;
-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 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 (file_reader.is_absent(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;
-  return json_value.parse_with(raw, refusal_schema)?.refused_at_ms ?? 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 path2(transcript_path) {
-    return stamp_file.stamp_path(prefix, transcript_path);
-  }
-  return { path: path2, 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, hook) {
-  const call = { name: payload.tool_name, input: payload.tool_input };
-  if (!parts.spec.is_candidate(call, hook)) return NO_OUTCOME;
-  const transcript = time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
-  const tail = transcript_tail.read_tail(transcript);
-  const is_unit = typeof payload.agent_id === "string" && payload.agent_id.length > 0;
-  const run = { transcript, now_ms, model: payload.model ?? void 0, is_unit, context: hook };
-  const context = { ...parts, tail, call, run };
-  const blocked = block_outcome(context);
-  if (!is_clear(blocked)) return blocked;
-  return notify_outcome(context);
-}
-function guard_outcome(parts, raw_payload, now_ms, hook) {
-  const payload = parse_hook_payload(raw_payload);
-  if (payload === void 0 || !is_switch_enabled(parts.spec.switch_key, hook.env)) {
-    return NO_OUTCOME;
-  }
-  return guard_reason_for_payload(parts, payload, now_ms, hook);
-}
-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(environment = process.env) {
-    return is_switch_enabled(spec.switch_key, environment);
-  }
-  function outcome(raw_payload, now_ms = Date.now(), hook = hook_context.from_process()) {
-    try {
-      return guard_outcome(parts, raw_payload, now_ms, hook);
-    } catch (error) {
-      return { reason: void 0, notice: void 0, fault: fault_notice(spec.switch_key, error) };
-    }
-  }
-  function refusal(...call) {
-    return outcome(...call).reason;
-  }
-  return { is_enabled, outcome, refusal, refusal_path: stamp.path };
-}
-function emit_outcome(outcome) {
-  const { reason, notice, fault } = outcome;
-  if (reason !== void 0) process.stdout.write(`${deny_envelope2(reason)}
-`);
-  else if (notice !== void 0) process.stdout.write(`${notice_envelope2(notice)}
-`);
-  else if (fault !== void 0) process.stdout.write(`${notice_envelope2(fault)}
-`);
-}
-function report_no_payload(command) {
-  process.stderr.write(
-    `${command} reads a Claude Code hook payload on stdin; it is not run by hand.
-`
-  );
-}
-async function respond_from_stdin(command, respond) {
-  if (process.stdin.isTTY) {
-    report_no_payload(command);
-    return;
-  }
-  const raw_payload = await text(process.stdin);
-  load_environment_file();
-  hook_payload_capture.capture(command, raw_payload);
-  await respond(raw_payload);
-}
-var hook_decision = {
-  DISABLED_VALUES,
-  ENABLED_VALUES,
-  NEVER_MS,
-  create_refusal_stamp,
-  create_transcript_guard,
-  deny_envelope: deny_envelope2,
-  emit_outcome,
-  flow_rewrite_envelope: flow_rewrite_envelope2,
-  is_switch_enabled,
-  is_switch_opt_in,
-  load_environment_file,
-  notice_envelope: notice_envelope2,
-  parse_hook_payload,
-  respond_from_stdin,
-  rewrite_envelope: rewrite_envelope2,
-  stamp_fault
-};
-
-export {
-  hook_payload_capture,
-  hook_tool_payload,
-  hook_decision
-};

package/dist/commands/chunk-GBMZXFFC.js

@@ -1,44 +0,0 @@
-import {
-  lane_ledger_archive
-} from "./chunk-ESUY7KTZ.js";
-import {
-  lane_implement_rate_read
-} from "./chunk-PJYTUUTH.js";
-import {
-  lane_net_time
-} from "./chunk-SNSZ25XZ.js";
-import {
-  run_event_stream_emit
-} from "./chunk-26JL4UU4.js";
-import {
-  run_event_stream
-} from "./chunk-KGSEWOKI.js";
-
-// scripts/lane/lane-net-read.ts
-var { implement_rate, measurements, read_ledger } = lane_implement_rate_read;
-async function read_events(context) {
-  if (context.events_path !== void 0) return run_event_stream.read_events(context.events_path);
-  return await run_event_stream_emit.all_events();
-}
-async function read_records(context) {
-  return {
-    entries: await lane_ledger_archive.read_history(context),
-    events: await read_events(context)
-  };
-}
-async function net_minutes_of(issue, context = {}) {
-  const events = await read_events(context);
-  return lane_net_time.net_minutes(await lane_ledger_archive.read_history(context), events, issue);
-}
-var lane_net_read = {
-  implement_rate,
-  measurements,
-  net_minutes_of,
-  read_events,
-  read_ledger,
-  read_records
-};
-
-export {
-  lane_net_read
-};

package/dist/commands/chunk-GGWXF7RJ.js

@@ -1,70 +0,0 @@
-import {
-  lane_ledger_write
-} from "./chunk-KIS7JFNP.js";
-import {
-  git_common_directory
-} from "./chunk-JPMAW2VZ.js";
-import {
-  stamp_file
-} from "./chunk-VLN6TSPJ.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/review/review-stop-log.ts
-import { mkdirSync } from "node:fs";
-import path from "node:path";
-import { z } from "zod";
-var LOG_FILE = "review-stops.jsonl";
-var LINE_SEPARATOR = "\n";
-var stop_line_schema = z.object({
-  at: z.string(),
-  issue: z.number(),
-  stage: z.string(),
-  kind: z.string(),
-  location: z.string(),
-  sentence: z.string(),
-  fixed: z.boolean().optional()
-});
-function target() {
-  if (process.env["VITEST"] !== void 0) return void 0;
-  const common = git_common_directory.repository();
-  return common === void 0 ? void 0 : path.join(common, git_common_directory.STATE_DIRECTORY, LOG_FILE);
-}
-function write(destination, stop) {
-  const at = (/* @__PURE__ */ new Date()).toISOString();
-  const mark = stop.is_fixed === true ? { fixed: true } : {};
-  mkdirSync(path.dirname(destination), { recursive: true });
-  for (const finding of stop.findings) {
-    lane_ledger_write.append(destination, {
-      at,
-      issue: stop.issue,
-      stage: stop.stage,
-      ...finding,
-      ...mark
-    });
-  }
-}
-function record(stop, log_path = target()) {
-  if (log_path === void 0 || stop.findings.length === 0) return;
-  try {
-    write(log_path, stop);
-  } catch {
-  }
-}
-function parse_line(line) {
-  return stop_line_schema.safeParse(json_value.parse_or_undefined(line)).data;
-}
-function is_present(line) {
-  return line !== void 0;
-}
-function read(log_path = target()) {
-  const raw = log_path === void 0 ? void 0 : stamp_file.read_stamp_text(log_path);
-  if (raw === void 0) return [];
-  return raw.split(LINE_SEPARATOR).map((line) => parse_line(line.trim())).filter(is_present);
-}
-var review_stop_log = { read, record, target };
-
-export {
-  review_stop_log
-};

package/dist/commands/chunk-GHOTKHI4.js

@@ -1,30 +0,0 @@
-import {
-  git_branch
-} from "./chunk-YEQFAEVW.js";
-import {
-  lane_ledger_write
-} from "./chunk-KIS7JFNP.js";
-import {
-  git_command
-} from "./chunk-IXZZSST7.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
-};