@joshuafolkken/kit 1.1379.0 → 1.1387.0

package/dist/hooks/{chunk-546X4PX3.js → chunk-IYVOLN6A.js}

@@ -1,12 +1,12 @@
 import {
   investigation_reads
-} from "./chunk-QARPP36N.js";
+} from "./chunk-WNFJLBXI.js";
 import {
   lane_guard_policy
-} from "./chunk-DHSKBAQ2.js";
+} from "./chunk-EAQEGME7.js";
 import {
   hook_decision
-} from "./chunk-E7LZL5AN.js";
+} from "./chunk-EBSHN25W.js";
 
 // scripts/delegation/investigation-guard.ts
 import { text } from "node:stream/consumers";

package/dist/hooks/{chunk-NBEAGPS4.js → chunk-J3KSS7II.js}

@@ -2,7 +2,7 @@ import {
   ENV_FILE_NAME,
   issue_number_shape,
   lane_paths
-} from "./chunk-RW4XMF47.js";
+} from "./chunk-2YSW3CXH.js";
 
 // scripts/josh/josh-environment-file.ts
 function load_environment_file() {

package/dist/hooks/{chunk-7ZM464OW.js → chunk-LMWBRJIP.js}

@@ -1,12 +1,12 @@
 import {
   lane_guard_policy
-} from "./chunk-DHSKBAQ2.js";
+} from "./chunk-EAQEGME7.js";
 import {
   hook_decision
-} from "./chunk-E7LZL5AN.js";
+} from "./chunk-EBSHN25W.js";
 import {
   time_batch_guard
-} from "./chunk-TORRSNDJ.js";
+} from "./chunk-SL4GQ2XP.js";
 
 // scripts/hooks/batch-guard.ts
 import { text } from "node:stream/consumers";

package/dist/hooks/{chunk-TORRSNDJ.js → chunk-SL4GQ2XP.js}

@@ -6,7 +6,7 @@ import {
   process_owner_schema,
   run_carry,
   time_instant
-} from "./chunk-RW4XMF47.js";
+} from "./chunk-2YSW3CXH.js";
 import {
   PLATFORM_TEMP_ROOT,
   PROBE_TIMEOUT_MS,
@@ -739,7 +739,7 @@ var AI_COMMANDS = {
     // `.env` rather than the ambient environment: the strand notification needs the Telegram
     // credentials, the same reason `run:wake` carries these flags.
     tsx_arguments: OPTIONAL_ENV_FILE_FLAGS,
-    description: "Report whether the run is stranded \u2014 budget handed off, owner gone, and no supervisor watching",
+    description: "Report whether the run is stranded \u2014 owner gone, no successor holding the budget, and no supervisor watching",
     category: "AI tools",
     reference: ["", "automation", ["processes", "notifications"]]
   },
@@ -1903,7 +1903,7 @@ var PROJECT_COMMANDS = {
     description: "Set a project up for the GitHub Issue workflow, from git init to the setup PR",
     category: "Project",
     reference: [
-      `${PROFILE_ARGUMENTS} [--yes] [--github] [--public] [--init-command <command>]`,
+      `${PROFILE_ARGUMENTS} [--yes] [--github] [--public] [--init-command <command>] [--push-preflight-command <command>]`,
       "developer",
       ["files", "git", "network", "processes"]
     ]

package/dist/hooks/{chunk-PV3FWDSQ.js → chunk-STDSEPWU.js}

@@ -5,11 +5,11 @@ import {
 import {
   ESLINT_EDIT_CACHE_FLAGS,
   time_density_hook
-} from "./chunk-TORRSNDJ.js";
+} from "./chunk-SL4GQ2XP.js";
 import {
   file_reader,
   json_value
-} from "./chunk-RW4XMF47.js";
+} from "./chunk-2YSW3CXH.js";
 import {
   HOOK_PROCESS_TIMEOUT_MS
 } from "./chunk-NEC4AT4Z.js";

package/dist/hooks/{chunk-YSDAH73S.js → chunk-U32VSRNG.js}

@@ -1,6 +1,9 @@
+import {
+  error_text
+} from "./chunk-CDY4NFQG.js";
 import {
   lane_child_marker
-} from "./chunk-NBEAGPS4.js";
+} from "./chunk-J3KSS7II.js";
 import {
   ENV_FILE_NAME,
   GIT_LOCATION_VARIABLES,
@@ -20,7 +23,7 @@ import {
   process_identity,
   process_owner_schema,
   run_carry
-} from "./chunk-RW4XMF47.js";
+} from "./chunk-2YSW3CXH.js";
 import {
   INSTALL_TIMEOUT_MS,
   PLATFORM_TEMP_ROOT,
@@ -1327,6 +1330,418 @@ var run_headless = {
   must_keep_waiting
 };
 
+// scripts/run/event/run-event-stream.ts
+import { z as z3 } from "zod";
+var EVENT_PREFIX = "josh-run-events-";
+var EVENT_SUFFIX = ".jsonl";
+var EVENT_CAP = 500;
+var FIRST_POSITION = 0;
+var POSITION_INCREMENT = 1;
+var LINE_SEPARATOR = "\n";
+var WORD_SEPARATOR2 = " ";
+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",
+  SPLIT: "split",
+  OUTAGE: "outage",
+  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",
+  // 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",
+  // 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. A trace,
+  // like `SHIP_STAGE`: it says where the child's work is, not where the run is.
+  LANE_PHASE: "lane-phase",
+  // 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 until the first child launches, 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"
+};
+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.ADD,
+  EVENT_KIND.LANE_LIMIT,
+  EVENT_KIND.SETUP
+]);
+var DISPOSABLE_KINDS = /* @__PURE__ */ new Set([
+  EVENT_KIND.SHIP_STAGE,
+  EVENT_KIND.HEARTBEAT,
+  EVENT_KIND.SETUP
+]);
+var event_schema = z3.object({
+  pos: z3.number(),
+  at: z3.string(),
+  kind: z3.string(),
+  text: z3.string()
+});
+function is_event_kind(value) {
+  return EVENT_KINDS.includes(value);
+}
+function target_of(repository2) {
+  return stamp_file.stamp_path(EVENT_PREFIX, repository2, 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 read_lines(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  if (raw === void 0) return [];
+  return raw.split(LINE_SEPARATOR).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => parse_line(line)).filter(is_present);
+}
+function read_events(target) {
+  return read_lines(target).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_SEPARATOR2)[FIRST_POSITION] ?? "";
+}
+function newest_stages(events) {
+  const newest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.kind === EVENT_KIND.SHIP_STAGE) 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_SEPARATOR2)[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_stages(events), ...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(target, kind, text, at) {
+  if (!is_event_kind(kind)) return { appended: false, position: FIRST_POSITION };
+  const lock = `${target}${LOCK_SUFFIX}`;
+  const position = repository_lock.with_lock_sync(
+    () => append_held(target, { at, kind, text }),
+    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 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 has_since(events, kind, reset_kind) {
+  const reset_at = events.findLastIndex((event) => event.kind === reset_kind);
+  return events.slice(reset_at + POSITION_INCREMENT).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,
+  format_event,
+  has_since,
+  is_stage_start,
+  read_events,
+  read_from,
+  read_last,
+  target_of
+};
+
+// scripts/run/event/run-event-scope.ts
+var SINCE_SCOPE = "since";
+var UNKNOWN_SCOPE = "unknown";
+var UNKNOWN_EVENT_SCOPE = { kind: UNKNOWN_SCOPE };
+function moment_of(at) {
+  const parsed = Date.parse(at);
+  return Number.isNaN(parsed) ? void 0 : parsed;
+}
+function is_within(event, floor) {
+  const at = moment_of(event.at);
+  return at !== void 0 && at >= floor;
+}
+function scoped_events(events, scope) {
+  if (scope.kind === UNKNOWN_SCOPE) return void 0;
+  const floor = moment_of(scope.started_at);
+  if (floor === void 0) return void 0;
+  return events.filter((event) => is_within(event, floor));
+}
+function scope_of(read) {
+  if (read.kind !== "carried") return UNKNOWN_EVENT_SCOPE;
+  return { kind: SINCE_SCOPE, started_at: read.carry.started_at };
+}
+function last_scoped_event(events, scope) {
+  return scoped_events(events, scope)?.findLast(
+    (event) => !run_event_stream.TRACE_KINDS.has(event.kind)
+  );
+}
+var SHIP_POSITION_KINDS = /* @__PURE__ */ new Set([
+  run_event_stream.EVENT_KIND.SHIP_LAUNCH,
+  run_event_stream.EVENT_KIND.SHIP_STOP
+]);
+var KIND = run_event_stream.EVENT_KIND;
+var BATCH_RECORD_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.PARK,
+  KIND.SPLIT,
+  KIND.RETROSPECTIVE,
+  KIND.STRANDED
+]);
+var ISSUE_REFERENCE = /#(\d+)/u;
+function is_foreign_ship_event(event, issue) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !event.text.startsWith(`${issue_cite.plain(issue)} `);
+}
+function is_own_ship_event(event, issue) {
+  return SHIP_POSITION_KINDS.has(event.kind) && !is_foreign_ship_event(event, issue);
+}
+function issue_named(event) {
+  return ISSUE_REFERENCE.exec(event.text)?.[1];
+}
+function names_issue(event, issue) {
+  return issue_named(event) === issue;
+}
+function is_lane_position(event, issue) {
+  return !BATCH_RECORD_KINDS.has(event.kind) && names_issue(event, issue);
+}
+function since_own_launch(events, issue) {
+  const launch2 = events.findLastIndex(
+    (event) => event.kind === KIND.CHILD_LAUNCH && names_issue(event, issue)
+  );
+  return events.slice(launch2 + 1);
+}
+function is_foreign_event(event, issue, is_lane_child) {
+  if (is_lane_child) return !is_lane_position(event, issue);
+  return is_foreign_ship_event(event, issue);
+}
+function last_issue_event(events, scope, issue, is_lane_child) {
+  const attempt = is_lane_child ? since_own_launch(events, issue) : events;
+  const own2 = attempt.filter((event) => !is_foreign_event(event, issue, is_lane_child));
+  if (scope.kind === SINCE_SCOPE) return last_scoped_event(own2, scope);
+  return own2.findLast((event) => is_own_ship_event(event, issue));
+}
+var LAUNCH_OR_SETTLE_KINDS = /* @__PURE__ */ new Set([
+  KIND.CHILD_LAUNCH,
+  KIND.MERGE,
+  KIND.PARK,
+  KIND.SPLIT
+]);
+function is_merge_owed(events, scope, issue) {
+  const newest = (scoped_events(events, scope) ?? []).findLast(
+    (event) => LAUNCH_OR_SETTLE_KINDS.has(event.kind) && names_issue(event, issue)
+  );
+  return newest?.kind === KIND.CHILD_LAUNCH;
+}
+var run_event_scope = {
+  UNKNOWN_EVENT_SCOPE,
+  is_merge_owed,
+  issue_named,
+  last_issue_event,
+  last_scoped_event,
+  moment_of,
+  scope_of,
+  scoped_events,
+  since_own_launch
+};
+
+// scripts/run/event/run-event-stream-emit.ts
+function now_iso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function stream_target() {
+  const repository2 = await run_carry.repository_directory();
+  return repository2 === void 0 ? void 0 : run_event_stream.target_of(repository2);
+}
+async function emit(kind, text) {
+  try {
+    const target = await stream_target();
+    if (target === void 0) return;
+    run_event_stream.append(target, kind, text, now_iso());
+  } catch {
+  }
+}
+async function emit_once(kind, text) {
+  try {
+    const target = await stream_target();
+    if (target === void 0 || run_event_stream.read_last(target)?.kind === kind) return false;
+    return run_event_stream.append(target, kind, text, now_iso()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once", error);
+    return false;
+  }
+}
+function invocation_events(repository2, target) {
+  const events = run_event_stream.read_events(target);
+  const scope = run_event_scope.scope_of(run_carry.read_carry(run_carry.carry_path(repository2)));
+  return run_event_scope.scoped_events(events, scope) ?? events;
+}
+async function emit_once_since(kind, text, reset_kind) {
+  try {
+    const repository2 = await run_carry.repository_directory();
+    if (repository2 === void 0) return false;
+    const target = run_event_stream.target_of(repository2);
+    if (run_event_stream.has_since(invocation_events(repository2, target), kind, reset_kind)) {
+      return false;
+    }
+    return run_event_stream.append(target, kind, text, now_iso()).appended;
+  } catch (error) {
+    error_text.trace_swallowed("run_event_stream_emit.emit_once_since", error);
+    return false;
+  }
+}
+async function emit_heartbeat(line) {
+  await emit(run_event_stream.EVENT_KIND.HEARTBEAT, line);
+}
+async function current_events() {
+  try {
+    const repository2 = await run_carry.repository_directory();
+    if (repository2 === void 0) return [];
+    const read = run_carry.read_carry(run_carry.carry_path(repository2));
+    const scope = run_event_scope.scope_of(read);
+    const events = run_event_stream.read_events(run_event_stream.target_of(repository2));
+    return run_event_scope.scoped_events(events, scope) ?? [];
+  } catch {
+    return [];
+  }
+}
+async function invocation_or_all_events() {
+  try {
+    const repository2 = await run_carry.repository_directory();
+    return repository2 === void 0 ? [] : invocation_events(repository2, run_event_stream.target_of(repository2));
+  } catch {
+    return [];
+  }
+}
+async function all_events() {
+  try {
+    const target = await stream_target();
+    return target === void 0 ? [] : run_event_stream.read_events(target);
+  } catch {
+    return [];
+  }
+}
+var run_event_stream_emit = {
+  all_events,
+  current_events,
+  emit,
+  emit_heartbeat,
+  emit_once,
+  emit_once_since,
+  invocation_or_all_events,
+  stream_target
+};
+
 // scripts/run/detached-launch.ts
 import { spawn } from "node:child_process";
 import { closeSync, constants, openSync, writeSync } from "node:fs";
@@ -1547,8 +1962,9 @@ var detached_launch = {
 export {
   issue_cite,
   git_common_directory,
-  repository_lock,
-  run_ship_stage,
+  run_event_stream,
+  run_event_scope,
+  run_event_stream_emit,
   agent_role_profile,
   agent_session_role,
   lane_child_invocation,

package/dist/hooks/{chunk-QARPP36N.js → chunk-WNFJLBXI.js}

@@ -1,16 +1,16 @@
 import {
   hook_decision
-} from "./chunk-E7LZL5AN.js";
+} from "./chunk-EBSHN25W.js";
 import {
   cost_blocks,
   time_batch_guard,
   time_bundle_call,
   time_shell,
   time_spans
-} from "./chunk-TORRSNDJ.js";
+} from "./chunk-SL4GQ2XP.js";
 import {
   cost_transcript
-} from "./chunk-RW4XMF47.js";
+} from "./chunk-2YSW3CXH.js";
 
 // scripts/delegation/investigation-reads.ts
 import path2 from "node:path";

package/dist/hooks/codex-hook-adapter.js

@@ -1,33 +1,33 @@
 #!/usr/bin/env tsx
 import {
   pretool_guard
-} from "./chunk-HGA4EG5S.js";
-import "./chunk-4RWRP3FF.js";
+} from "./chunk-GJ7JPIHN.js";
+import "./chunk-DCY2GWHC.js";
 import {
   bounded_pool
-} from "./chunk-TG2AB3W6.js";
+} from "./chunk-GNDJ7NJ7.js";
 import {
   build_envelope,
   compose_context,
   format_edited_payload
-} from "./chunk-PV3FWDSQ.js";
+} from "./chunk-STDSEPWU.js";
 import "./chunk-JBBMAPC4.js";
-import "./chunk-YSDAH73S.js";
+import "./chunk-U32VSRNG.js";
 import "./chunk-CDY4NFQG.js";
-import "./chunk-7ZM464OW.js";
-import "./chunk-546X4PX3.js";
-import "./chunk-QARPP36N.js";
-import "./chunk-DHSKBAQ2.js";
+import "./chunk-LMWBRJIP.js";
+import "./chunk-IYVOLN6A.js";
+import "./chunk-WNFJLBXI.js";
+import "./chunk-EAQEGME7.js";
 import {
   hook_decision
-} from "./chunk-E7LZL5AN.js";
+} from "./chunk-EBSHN25W.js";
 import {
   time_density_hook
-} from "./chunk-TORRSNDJ.js";
-import "./chunk-NBEAGPS4.js";
+} from "./chunk-SL4GQ2XP.js";
+import "./chunk-J3KSS7II.js";
 import {
   json_value
-} from "./chunk-RW4XMF47.js";
+} from "./chunk-2YSW3CXH.js";
 import "./chunk-NEC4AT4Z.js";
 
 // scripts/hooks/codex-hook-adapter.ts

package/dist/hooks/duplicate-read-guard.js

@@ -9,13 +9,13 @@ import {
   is_enabled,
   notice_refusal_path,
   refusal_path
-} from "./chunk-4RWRP3FF.js";
-import "./chunk-QARPP36N.js";
-import "./chunk-DHSKBAQ2.js";
-import "./chunk-E7LZL5AN.js";
-import "./chunk-TORRSNDJ.js";
-import "./chunk-NBEAGPS4.js";
-import "./chunk-RW4XMF47.js";
+} from "./chunk-DCY2GWHC.js";
+import "./chunk-WNFJLBXI.js";
+import "./chunk-EAQEGME7.js";
+import "./chunk-EBSHN25W.js";
+import "./chunk-SL4GQ2XP.js";
+import "./chunk-J3KSS7II.js";
+import "./chunk-2YSW3CXH.js";
 import "./chunk-NEC4AT4Z.js";
 export {
   DISABLED_VALUES,

package/dist/hooks/format-edited.js

@@ -2,10 +2,10 @@
 import {
   report_no_payload,
   run_hook
-} from "./chunk-PV3FWDSQ.js";
+} from "./chunk-STDSEPWU.js";
 import "./chunk-JBBMAPC4.js";
-import "./chunk-TORRSNDJ.js";
-import "./chunk-RW4XMF47.js";
+import "./chunk-SL4GQ2XP.js";
+import "./chunk-2YSW3CXH.js";
 import "./chunk-NEC4AT4Z.js";
 
 // scripts/hooks/format-edited-cli.ts