@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-NILSN7A4.js

@@ -1,158 +0,0 @@
-import {
-  review_reviewed_tree
-} from "./chunk-GITT5A5A.js";
-import {
-  review_record
-} from "./chunk-JVKXJ763.js";
-import {
-  issue_watch_gate
-} from "./chunk-OVWPZDWP.js";
-import {
-  run_preflight
-} from "./chunk-AJ65WNJB.js";
-import {
-  git_worktree
-} from "./chunk-W3FX7FYN.js";
-import {
-  run_hold
-} from "./chunk-X3TNPALI.js";
-import {
-  run_ship_stage
-} from "./chunk-OHNP3QL2.js";
-import {
-  git_common_directory
-} from "./chunk-FFHEGWPK.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-import {
-  git_command
-} from "./chunk-AKQYYHP2.js";
-
-// scripts/review/review-round-reuse.ts
-async function is_stale_here() {
-  try {
-    return await issue_watch_gate.review_refusal_here() !== void 0;
-  } catch (error) {
-    error_text.trace_swallowed("review_round_reuse.is_stale_here", error);
-    return false;
-  }
-}
-var REUSE = { AGAIN: "again", DELTA: "delta", HELD: "held" };
-var { MOVEMENT } = review_reviewed_tree;
-var STALE_CAUSE = "the issue changed after the recorded round's brief";
-var UNRECORDED_CAUSE = "no review round is recorded for this issue";
-function reused_with(kind, note) {
-  return note === void 0 ? { reuse: kind } : { reuse: kind, note };
-}
-async function recorded_answer(issue) {
-  const { movement, cause, note } = await review_reviewed_tree.standing_here();
-  if (movement === MOVEMENT.HELD) return reused_with(REUSE.HELD, note);
-  const is_delta = movement === MOVEMENT.DELTA || review_reviewed_tree.is_stopped_on(issue);
-  return is_delta ? reused_with(REUSE.DELTA, note) : { reuse: REUSE.AGAIN, cause };
-}
-async function answer(issue, is_stale) {
-  if (is_stale) return { reuse: REUSE.AGAIN, cause: STALE_CAUSE };
-  const recorded = await review_record.check(issue);
-  if (recorded.status !== "ok") return { reuse: REUSE.AGAIN, cause: UNRECORDED_CAUSE };
-  return await recorded_answer(issue);
-}
-async function reuse(issue, is_stale) {
-  const reused = await answer(issue, is_stale);
-  return reused.reuse;
-}
-async function is_reusable(issue, is_stale) {
-  return await reuse(issue, is_stale) !== REUSE.AGAIN;
-}
-async function answer_here(issue) {
-  return await answer(issue, await is_stale_here());
-}
-async function reuse_here(issue) {
-  const reused = await answer_here(issue);
-  return reused.reuse;
-}
-async function is_reusable_here(issue) {
-  return await reuse_here(issue) !== REUSE.AGAIN;
-}
-var review_round_reuse = {
-  REUSE,
-  answer,
-  answer_here,
-  is_reusable,
-  is_reusable_here,
-  is_stale_here,
-  reuse_here
-};
-
-// scripts/run/ship/run-ship-probe.ts
-var REMOTE_SHA_INDEX = 0;
-var REMOTE_FIELD_SEPARATOR = /\s/u;
-var HEAD_REFERENCE = "HEAD";
-async function or_false(is_true) {
-  try {
-    return await is_true();
-  } catch (error) {
-    error_text.trace_swallowed("run_ship_probe.or_false", error);
-    return false;
-  }
-}
-async function read_committed(is_dirty) {
-  if (is_dirty) return false;
-  const base = await git_command.default_branch_reference();
-  return await git_command.commit_count_beyond(base, HEAD_REFERENCE) > 0;
-}
-async function read_pushed(branch_name) {
-  const [remote, head] = await Promise.all([
-    git_worktree.ls_remote_branch(branch_name),
-    git_command.head_commit()
-  ]);
-  return remote.split(REMOTE_FIELD_SEPARATOR)[REMOTE_SHA_INDEX] === head;
-}
-async function read_merged(branch_name) {
-  if (await run_preflight.read_pr_state(branch_name) !== run_preflight.MERGED_PR) return false;
-  const base = await git_command.default_branch_reference();
-  return await git_command.commit_count_beyond(base, HEAD_REFERENCE) === 0;
-}
-async function read_review_stale() {
-  return await review_round_reuse.is_stale_here();
-}
-var NOTHING_DONE = { is_committed: false, is_pushed: false, is_merged: false };
-async function read_branch_state(branch_name) {
-  const is_dirty = await run_hold.is_tree_dirty();
-  const [is_committed, is_pushed, is_merged, is_review_stale] = await Promise.all([
-    or_false(async () => await read_committed(is_dirty)),
-    or_false(async () => await read_pushed(branch_name)),
-    or_false(async () => await read_merged(branch_name)),
-    read_review_stale()
-  ]);
-  return { is_committed, is_pushed, is_merged, is_review_stale, is_dirty };
-}
-async function is_pushed_clean() {
-  if (await run_hold.is_tree_dirty()) return false;
-  return await or_false(async () => await read_pushed(await git_command.branch()));
-}
-async function read_state() {
-  try {
-    return await read_branch_state(await git_command.branch());
-  } catch {
-    return NOTHING_DONE;
-  }
-}
-async function record_target(issue) {
-  const repository = await git_common_directory.read_repository();
-  return repository === void 0 ? void 0 : run_ship_stage.record_path(repository, issue);
-}
-var run_ship_probe = {
-  is_pushed_clean,
-  read_review_stale,
-  read_state,
-  record_target,
-  // The leaf's read, kept on the ship's surface for its own callers; a module outside the ship's
-  // stages imports `git_common_directory` so it does not reach the review modules this one does.
-  repository_directory: git_common_directory.read_repository
-};
-
-export {
-  review_round_reuse,
-  run_ship_probe
-};

package/dist/commands/chunk-NOLFSPOB.js

@@ -1,74 +0,0 @@
-import {
-  scoped_green
-} from "./chunk-WTH6NTXU.js";
-import {
-  verification_inputs
-} from "./chunk-34KZDKQJ.js";
-import {
-  input_fingerprint
-} from "./chunk-MGF64OHV.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  PROJECT_ROOT
-} from "./chunk-3CCGKX7Y.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/gate/tree-verdict.ts
-import { z } from "zod";
-var verdict_schema = z.object({
-  tree: z.string(),
-  exit_code: z.number(),
-  tail: z.string(),
-  at: z.string()
-});
-var SHORT_HASH_LENGTH = 12;
-var REUSED_PREFIX = "reused: tree ";
-function record_path(name) {
-  return stamp_file.stamp_path(`josh-tree-verdict-${name}-`, PROJECT_ROOT);
-}
-function tree_hash(tree) {
-  const files = Object.entries(tree.files).map(([file, digest]) => `${file}	${digest}`);
-  const inputs = verification_inputs.fingerprint(verification_inputs.DECLARED_LABELS);
-  return input_fingerprint.of_entries([...files, `base	${tree.base ?? ""}`, `inputs	${inputs}`]);
-}
-function read_record(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  return raw === void 0 ? void 0 : json_value.parse_with(raw, verdict_schema);
-}
-function read(tree, target) {
-  if (tree?.base === void 0) return void 0;
-  const verdict = read_record(target);
-  return verdict?.tree === tree_hash(tree) ? verdict : void 0;
-}
-function reused_line(verdict, target) {
-  const is_green = verdict.exit_code === 0;
-  const state = is_green ? "green" : "red";
-  const line = `${REUSED_PREFIX}${verdict.tree.slice(0, SHORT_HASH_LENGTH)} ${state} at ${verdict.at}`;
-  return is_green ? line : `${line} \u2014 remove ${target} to run it again`;
-}
-function is_replay(out) {
-  return out.includes(REUSED_PREFIX);
-}
-function replay(verdict, target, live = []) {
-  const notices = live.map((notice) => notice === void 0 ? "" : `
-${notice}
-`).join("");
-  process.stdout.write(`${reused_line(verdict, target)}
-${notices}${verdict.tail}`);
-  return verdict.exit_code;
-}
-async function record(entry, read_after, target) {
-  const { before, exit_code, tail } = entry;
-  if (before?.base === void 0 || !scoped_green.is_unmoved(before, await read_after())) return;
-  const at = (/* @__PURE__ */ new Date()).toISOString();
-  stamp_file.replace_stamp(target, { tree: tree_hash(before), exit_code, tail, at });
-}
-var tree_verdict = { is_replay, read, record, record_path, replay, reused_line };
-
-export {
-  tree_verdict
-};

package/dist/commands/chunk-NSAVEXVR.js

@@ -1,353 +0,0 @@
-import {
-  repository_lock
-} from "./chunk-P4KIQRSL.js";
-import {
-  run_ship_stage
-} from "./chunk-OHNP3QL2.js";
-import {
-  durable_state
-} from "./chunk-MPGJ4ONJ.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/run/event/run-event-stream.ts
-import { z } from "zod";
-var EVENT_PREFIX = durable_state.PREFIX.EVENTS;
-var EVENT_SUFFIX = ".jsonl";
-var EVENT_CAP = 15e3;
-var FIRST_POSITION = 0;
-var POSITION_INCREMENT = 1;
-var LINE_SEPARATOR = "\n";
-var WORD_SEPARATOR = " ";
-var STAGE_PHASE_INDEX = 2;
-var LOCK_SUFFIX = ".lock";
-var LOCK_WAIT_MS = 5e3;
-var EVENT_KIND = {
-  PLAN: "plan",
-  CHILD_LAUNCH: "child-launch",
-  MERGE: "merge",
-  PARK: "park",
-  HUMAN_REVIEW: "human-review",
-  SPLIT: "split",
-  OUTAGE: "outage",
-  // A Claude usage limit stopped a lane child (joshuafolkken/kit#4745). Its text names the reset time,
-  // which `backlog:drive` reads to hold launches until then; it counts against no streak, so it is not an
-  // `OUTAGE`.
-  USAGE_LIMIT: "usage-limit",
-  CUT: "cut",
-  // A fresh session adopted an implementation cut — `run:cut --resume` answered `resume-impl`. The
-  // resume clears the cut record, so without this the `cut` would stay the newest position and
-  // `run:step` would keep answering the resume command it had just run.
-  RESUME: "resume",
-  // A person stopped a running lane child and re-dispatched its issue in a fresh session
-  // (`lane:restart`). It follows the fresh dispatch's `CHILD_LAUNCH`, so it is a launch to the parent and
-  // the board, and — like that launch — a batch record a lane child never reads as its own position.
-  RESTART: "restart",
-  // A person withdrew a lane child — stopped it and left its issue open for the next run (`lane:withdraw`).
-  // It is written before the stop, so `run:merge` settles the child as withdrawn whatever GitHub says
-  // by the time the parent collects it, and counts it as neither a merge, a failure nor an outage.
-  WITHDRAW: "withdraw",
-  // The backlog emptied while nothing of the run's own was in flight — the drain. It marks the position
-  // at which the end-of-run retrospective is owed, *before* the idle watch opens, so `run:step` fires
-  // the retrospective at the drain rather than after the watch runs its course. It is not itself a
-  // stop: the run watches on once the retrospective has run, and the real `STOP` follows when the watch
-  // expires.
-  DRAIN: "drain",
-  STOP: "stop",
-  PR_OPENED: "pr-opened",
-  REVIEW_ROUND: "review-round",
-  // The end-of-run retrospective's result, recorded when the run marks the retrospective done. A
-  // retrospective that files zero improvements and one that never ran look
-  // the same from outside — no new Issue either way — so the result is put on the stream the report is
-  // generated from: the issues filed (or that none were), and the candidates dropped with why. It is
-  // emitted from the `run:carry --retrospective` close, so marking the retrospective done and recording
-  // what it found are one action rather than two the run could do only one of.
-  RETROSPECTIVE: "retrospective",
-  // Ready backlog work is sitting undispatched while a lane is free and nothing has dispatched for a
-  // while. Emitted once per stall episode by the stop-time detector, it is both the dedup marker —
-  // `emit_once_since` refuses a second until a `CHILD_LAUNCH` intervenes — and the line a terminal
-  // reader following the stream sees. `run:step` reads it as `backlog:next`, so a run that
-  // stalled is pointed straight at dispatching the work rather than left waiting.
-  STALL: "stall",
-  // The run's own driver is gone: the cut handed the budget off, the owner has died, and no supervisor
-  // is watching. Emitted once per strand episode by the stop-time detector — or by the `run:wake`
-  // supervisor as it fails, leaves that state behind and has warned of it —
-  // exactly as `STALL` is — the newest-event dedup keeps a run polled every stop from notifying more
-  // than once, and a terminal reader following the stream sees the line. The strand is the step before
-  // the stall: a stalled run still has a driver that could dispatch, a stranded one has none.
-  STRANDED: "stranded",
-  // One `josh ship` stage starting, succeeding or failing. It is a trace of the
-  // composite's progress rather than a position the run is at — the positions a ship leaves behind are
-  // the closed issue its `followup` merges, or a detached supervisor's `SHIP_LAUNCH` / `SHIP_STOP` below
-  // — so it is one of the `TRACE_KINDS` the last-event read skips.
-  SHIP_STAGE: "ship-stage",
-  // One progress watcher line — the `at … / next …` heartbeat `run:progress` prints. Printed only to
-  // the watcher's own output, a headless successor's heartbeat would be buried in its log after a cut;
-  // on the stream it reaches the attached session's relay. It says
-  // the run is alive rather than where it is, so it is a trace kind like `SHIP_STAGE`.
-  HEARTBEAT: "heartbeat",
-  // The post-implementation region handed to a detached `josh ship --detach` supervisor. Unlike a stage
-  // trace it is a position: the agent has ended and the
-  // supervisor carries the run, so `run:step` answers `wait` until it stops or the issue closes.
-  SHIP_LAUNCH: "ship-launch",
-  // The supervisor stopped at a failed stage — a red gate, a High/Medium review, a failed push, red CI
-  // The position that hands control back: `run:step` prints the command that
-  // shows the stopped report, so the agent fixes it and relaunches rather than rebuilding the context.
-  SHIP_STOP: "ship-stop",
-  // The relaunch meant to answer a `SHIP_STOP` started nothing — the broker refused it, or the direct
-  // spawn failed (joshuafolkken/kit#4765). `run:merge` reads it, not the transcript's mtime, to tell the
-  // stop went unanswered, and a re-dispatch cap's park names its reason. A trace: the stop stays the
-  // position `run:step` answers.
-  RELAUNCH_FAILED: "relaunch-failed",
-  // An Issue the run filed on its way, written by `issue:file`, so a run started from the command line
-  // still surfaces what it found — `run:board`'s findings section reads it.
-  FILED: "filed",
-  // A one-line observation short of an Issue, written with `run:event --append note` and shown in the
-  // same section.
-  NOTE: "note",
-  // A lane child reached a phase no other event marks — its first implementation edit, written by the
-  // PreToolUse hook — so `run:board` draws how far the child has got. The backlog driver writes its own
-  // `collect` / `launch` steps on a child as this kind too, which no reader draws as a phase
-  // (`backlog-drive-trace.ts`). A trace, like `SHIP_STAGE`: it says where the child's work is, not where
-  // the run is.
-  LANE_PHASE: "lane-phase",
-  // The fullrun step `run:step` or `run:entry` computed for an issue: `#<N> step <n>/<total> <name>`,
-  // written once per change of step (`run-event-step.ts`), so `run:board` draws it (joshuafolkken/kit#6598).
-  // A trace: it says which step the issue's run reached, not where the run is.
-  STEP: "step",
-  // An issue `run:add` put into the live run. The parent's `--wait` watcher
-  // ends on it, so the issue takes the next free lane without waiting out the arrival probe's minute. A
-  // trace: it says what the run was handed, not where the run is.
-  ADD: "add",
-  // `josh lane:limit` raised a live run's lane limit. The `--wait` watcher's
-  // arrival probe reads it as a wake: the lanes a raise frees are new room for a pool its baseline
-  // already holds. A trace: it says the run gained room, not where the run is.
-  LANE_LIMIT: "lane-limit",
-  // One stage of the run's start — the session starting, the plan, the hand-off to the supervisor, a
-  // lane opening (`run-event-setup.ts`). `run:board` draws it while the run stands at it, so the
-  // minutes before one read as work rather than as a run that has stopped. A trace: it says the run is
-  // getting ready, not where the run is.
-  SETUP: "setup",
-  // A child's pull request checks as `josh followup` last polled them — the CI counts and CodeRabbit's
-  // state (`run-event-checks.ts`), written only when they change, so `run:board` draws a child waiting
-  // in followup without asking GitHub (joshuafolkken/kit#3770). A trace: it says how the checks stand,
-  // not where the run is.
-  PR_CHECKS: "pr-checks",
-  // `backlog:drive` reached a watch with no child running and nothing to dispatch — the point a person's
-  // hand is wanted. Emitted once per idle episode (`emit_once_since_with`, reset by `CHILD_LAUNCH`), it
-  // is the dedup marker for the one idle Telegram. A trace: a drain's retrospective is read off the
-  // position beneath it, so the marker must not stand over it.
-  IDLE_NOTICE: "idle-notice",
-  // A person paused or resumed a lane child (`lane:pause` / `lane:resume`), so who halted a lane and
-  // when is on the stream rather than only in a shell history (joshuafolkken/kit#4268). A trace: it
-  // says what a lane's processes were told, not where the run is.
-  LANE_STATE: "lane-state",
-  // `backlog:drive` found nothing of the run in flight and only paused lanes left, paused past the
-  // silent window (joshuafolkken/kit#4270). Emitted once per pause episode (`emit_once_since_with`,
-  // reset by `LANE_STATE`), it is the dedup marker for the one paused-lane Telegram. A trace.
-  PAUSED_NOTICE: "paused-notice",
-  // `backlog:drive` ran a due issue's measurement declaration itself, found it within its bound and
-  // closed the issue through `issue:measured` — no lane was launched for it (joshuafolkken/kit#4621).
-  // `run:board` draws it merged. A trace: the parent's position is the drive's, not this close.
-  MEASURED: "measured",
-  // `backlog:drive` ran a due issue's measurement declaration and found no sample to read yet, so the
-  // issue waits without a lane (joshuafolkken/kit#6503). A trace: `offer_exclude` keeps it out of the
-  // run's offers, the way the drive's own `waiting` list does.
-  SAMPLE_WAIT: "sample-wait",
-  // The host slept while `backlog:drive` sampled its load (joshuafolkken/kit#5032): the sampler's timer
-  // ran late by more than a few intervals. `at` is the wake and `elapsed_ms` how long the sleep
-  // lasted; every lane's net time takes it out (`lane-sleep.ts`). A trace.
-  SLEEP: "sleep",
-  // A lane's `lane:plan` blocking on a holder of its files (joshuafolkken/kit#6140): `#<N> start #<M>`
-  // as one ask begins to wait, `#<N> end #<M>` as it ends, so `lane:breakdown` counts
-  // the wait under its own row rather than the stage it fell in (`lane-plan-wait-event.ts`). A trace.
-  PLAN_WAIT: "plan-wait",
-  // GitHub's REST core rate limit read around one `backlog:drive` offer cycle (joshuafolkken/kit#6558):
-  // JSON text with the cycle's `used_delta`, `remaining` and `reset`, or `is_missing` when a read failed
-  // (`backlog-drive-rate.ts`). A trace written every cycle, so the bound rolls it off with the heartbeats.
-  RATE_LIMIT: "rate-limit"
-};
-var EVENT_KINDS = Object.values(EVENT_KIND);
-var TRACE_KINDS = /* @__PURE__ */ new Set([
-  EVENT_KIND.SHIP_STAGE,
-  EVENT_KIND.HEARTBEAT,
-  EVENT_KIND.FILED,
-  EVENT_KIND.NOTE,
-  EVENT_KIND.LANE_PHASE,
-  EVENT_KIND.STEP,
-  EVENT_KIND.ADD,
-  EVENT_KIND.LANE_LIMIT,
-  EVENT_KIND.SETUP,
-  EVENT_KIND.PR_CHECKS,
-  EVENT_KIND.IDLE_NOTICE,
-  EVENT_KIND.LANE_STATE,
-  EVENT_KIND.PAUSED_NOTICE,
-  EVENT_KIND.MEASURED,
-  EVENT_KIND.SAMPLE_WAIT,
-  EVENT_KIND.RELAUNCH_FAILED,
-  EVENT_KIND.SLEEP,
-  EVENT_KIND.PLAN_WAIT,
-  EVENT_KIND.RATE_LIMIT
-]);
-var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
-  EVENT_KIND.SHIP_STAGE,
-  EVENT_KIND.HEARTBEAT,
-  EVENT_KIND.SETUP,
-  EVENT_KIND.PR_CHECKS,
-  EVENT_KIND.RATE_LIMIT
-]);
-var event_schema = z.object({
-  pos: z.number(),
-  at: z.string(),
-  kind: z.string(),
-  text: z.string(),
-  // The child's time on a lane, recorded once by the writer of an ending (joshuafolkken/kit#4481), so a
-  // reader never has to find its launch again. An event written before it has none. A `sleep` event
-  // carries the sleep's length here.
-  elapsed_ms: z.number().optional(),
-  // The ship stop a park was taken at — its stage and `Cause` class (joshuafolkken/kit#6864) — so a
-  // reader re-dispatching the park reads them without parsing text. Free strings: an event a later
-  // version wrote with a new class still parses. A park written before it, or no ship's, has none —
-  // as does one a lane on older code rewrote, since its schema drops the key, so none is a normal read.
-  stop: z.object({ stage: z.string(), cause: z.string() }).optional()
-});
-function is_event_kind(value) {
-  return EVENT_KINDS.includes(value);
-}
-function target_of(repository) {
-  return durable_state.path(EVENT_PREFIX, repository, EVENT_SUFFIX);
-}
-function is_present(event) {
-  return event !== void 0;
-}
-function parse_line(line) {
-  return event_schema.safeParse(json_value.parse_or_undefined(line)).data;
-}
-function lines_of(raw) {
-  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line(line)).filter(is_present);
-}
-function events_of_text(raw) {
-  return lines_of(raw).filter((event) => is_event_kind(event.kind));
-}
-function read_lines(target, is_required = false) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0 && is_required) throw new Error("Could not read the run event stream.");
-  if (raw === void 0) return [];
-  return lines_of(raw);
-}
-function read_events(target, is_required = false) {
-  return read_lines(target, is_required).filter((event) => is_event_kind(event.kind));
-}
-function last_position(events) {
-  return events[events.length - POSITION_INCREMENT]?.pos ?? FIRST_POSITION;
-}
-function issue_of(event) {
-  return event.text.split(WORD_SEPARATOR)[FIRST_POSITION] ?? "";
-}
-function newest_by_issue(events, kind) {
-  const newest = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    if (event.kind === kind) newest.set(issue_of(event), event);
-  }
-  return new Set(newest.values());
-}
-function is_stage_start(event) {
-  if (event.kind !== EVENT_KIND.SHIP_STAGE) return false;
-  return event.text.split(WORD_SEPARATOR)[STAGE_PHASE_INDEX] === run_ship_stage.PHASE.START;
-}
-function drawn_lines(events) {
-  const setup = events.findLast((event) => event.kind === EVENT_KIND.SETUP);
-  return /* @__PURE__ */ new Set([
-    ...newest_by_issue(events, EVENT_KIND.SHIP_STAGE),
-    ...newest_by_issue(events, EVENT_KIND.PR_CHECKS),
-    ...setup === void 0 ? [] : [setup]
-  ]);
-}
-function droppable(events) {
-  const kept = drawn_lines(events);
-  const disposable = events.filter((event) => DISPOSABLE_KINDS.has(event.kind) && !kept.has(event));
-  return [
-    ...disposable.filter((event) => !is_stage_start(event)),
-    ...disposable.filter((event) => is_stage_start(event))
-  ];
-}
-function bounded(events) {
-  const excess = events.length - EVENT_CAP;
-  if (excess <= 0) return events;
-  const dropped = new Set(droppable(events).slice(0, excess));
-  return events.filter((event) => !dropped.has(event)).slice(-EVENT_CAP);
-}
-function serialize(events) {
-  return `${events.map((event) => JSON.stringify(event)).join(LINE_SEPARATOR)}${LINE_SEPARATOR}`;
-}
-function append_held(target, event) {
-  const position = last_position(read_lines(target)) + POSITION_INCREMENT;
-  const events = bounded([...read_events(target), { pos: position, ...event }]);
-  stamp_file.replace_text_stamp(target, serialize(events));
-  return position;
-}
-function append_event(target, event) {
-  if (!is_event_kind(event.kind)) return { appended: false, position: FIRST_POSITION };
-  const lock = `${target}${LOCK_SUFFIX}`;
-  const position = repository_lock.with_lock_sync(
-    () => append_held(target, event),
-    lock,
-    LOCK_WAIT_MS
-  );
-  if (position === void 0) {
-    const message = `run event stream: gave up waiting for the lock at ${lock}`;
-    process.stderr.write(`${message}
-`);
-    throw new Error(message);
-  }
-  return { appended: true, position };
-}
-function append(target, kind, text, at) {
-  return append_event(target, { at, kind, text });
-}
-function read_from(target, position) {
-  const events = read_events(target);
-  return {
-    events: events.filter((event) => event.pos > position),
-    next_position: last_position(events)
-  };
-}
-function read_last(target) {
-  return read_events(target).findLast((event) => !TRACE_KINDS.has(event.kind));
-}
-function since(events, reset_kind) {
-  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
-  return events.slice(reset_at + POSITION_INCREMENT);
-}
-function has_since(events, kind, reset_kind) {
-  return since(events, reset_kind).some((event) => event.kind === kind);
-}
-var FIELD_SEPARATOR = " \xB7 ";
-function format_event(event) {
-  return [event.at, event.kind, event.text].join(FIELD_SEPARATOR);
-}
-var run_event_stream = {
-  EVENT_CAP,
-  EVENT_KIND,
-  EVENT_KINDS,
-  TRACE_KINDS,
-  append,
-  append_event,
-  events_of_text,
-  format_event,
-  has_since,
-  is_stage_start,
-  read_events,
-  read_from,
-  read_last,
-  since,
-  target_of
-};
-
-export {
-  run_event_stream
-};

package/dist/commands/chunk-NT67QTZO.js

@@ -1,65 +0,0 @@
-import {
-  observation_ledger_home
-} from "./chunk-WWVYEHQT.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/hooks/hook-ledger-read.ts
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { z } from "zod";
-var LEDGER_EXTENSION = ".jsonl";
-var HOURS_PER_DAY = 24;
-var MS_PER_HOUR = 36e5;
-var MS_PER_DAY = HOURS_PER_DAY * MS_PER_HOUR;
-var KEY_SEPARATOR = "	";
-var line_schema = z.object({
-  at: z.string(),
-  hook: z.string(),
-  rule: z.string(),
-  tool: z.string(),
-  session: z.string(),
-  command: z.string()
-});
-function period_start(period_days, now) {
-  return now.getTime() - period_days * MS_PER_DAY;
-}
-function day_files(directory, period_days, now) {
-  const count = Math.ceil(period_days) + 1;
-  const days = Array.from(
-    { length: count },
-    (_, index) => observation_ledger_home.ledger_date(new Date(now.getTime() - (count - 1 - index) * MS_PER_DAY))
-  );
-  return days.map((day) => path.join(directory, `${day}${LEDGER_EXTENSION}`));
-}
-async function read_text(file) {
-  try {
-    return await readFile(file, "utf8");
-  } catch {
-    return "";
-  }
-}
-function lines_of(text) {
-  return text.split("\n").map((line) => json_value.parse_with(line, line_schema)).filter((line) => line !== void 0);
-}
-async function read_lines(directory, period_days, now) {
-  const files = day_files(directory, period_days, now);
-  const texts = await Promise.all(files.map(async (file) => await read_text(file)));
-  const start = period_start(period_days, now);
-  return texts.flatMap((text) => lines_of(text)).filter((line) => Date.parse(line.at) >= start);
-}
-function group(lines) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    const key = `${line.hook}${KEY_SEPARATOR}${line.rule}`;
-    const found = groups.get(key) ?? { hook: line.hook, rule: line.rule, lines: [] };
-    groups.set(key, { ...found, lines: [...found.lines, line] });
-  }
-  return [...groups.values()].toSorted((left, right) => right.lines.length - left.lines.length);
-}
-var hook_ledger_read = { group, period_start, read_lines };
-
-export {
-  hook_ledger_read
-};