@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-MWO6FOSZ.js

@@ -1,393 +0,0 @@
-import {
-  lane_yield
-} from "./chunk-EGIHAEMT.js";
-import {
-  lane_stage_stats
-} from "./chunk-IBAYXCMU.js";
-import {
-  run_ship_planned
-} from "./chunk-TAEGXID2.js";
-import {
-  lane_sleep,
-  lane_stats
-} from "./chunk-XXC32PVL.js";
-import {
-  lane_ledger
-} from "./chunk-ZNR75OXP.js";
-import {
-  lane_spans
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  run_ship_stage
-} from "./chunk-OHNP3QL2.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  MS_PER_MINUTE
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lane/lane-stop-stats.ts
-var COLUMNS = [
-  "stop",
-  "wait median (min)",
-  "wait max (min)",
-  "wait total (min)",
-  "runs",
-  "not resumed",
-  "causes"
-];
-var { STAGE } = run_ship_stage;
-var { is_dispatch, is_number, is_stage } = lane_stage_stats;
-var REASONS = [
-  STAGE.PREFLIGHT,
-  STAGE.REVIEW,
-  STAGE.SYNC,
-  run_ship_stage.CONFLICT,
-  STAGE.GATE,
-  STAGE.COMMIT,
-  STAGE.ROUND_TWO,
-  STAGE.FOLLOWUP,
-  STAGE.REPORT
-];
-var EVENT_ISSUE = /#([1-9]\d*)\b/u;
-var UNRECORDED_CAUSE = "unrecorded";
-var NO_CAUSES = "-";
-var NOTICED = " (noticed)";
-function is_stop(entry) {
-  return entry.kind === lane_ledger.KIND.STOP;
-}
-function issue_of(event) {
-  return Number(EVENT_ISSUE.exec(event.text)?.[1]);
-}
-function events_of(events, kind) {
-  return events.filter((event) => event.kind === kind).map((event) => ({ issue: issue_of(event), at_ms: Date.parse(event.at) }));
-}
-function parks_of(events) {
-  return events_of(events, run_event_stream.EVENT_KIND.PARK);
-}
-function dispatches_of(entries) {
-  return entries.filter((entry) => is_dispatch(entry)).map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }));
-}
-function ends_of(entries, parks) {
-  const resumes = entries.filter((entry) => is_stage(entry)).map((stage) => ({ issue: stage.issue, at_ms: lane_stage_stats.started_ms(stage) }));
-  return [...resumes, ...dispatches_of(entries), ...parks];
-}
-function wait_ms(stop, ends) {
-  const later = ends.filter((end) => end.issue === stop.issue && end.at_ms >= stop.at_ms).map((end) => end.at_ms - stop.at_ms);
-  return later.length === 0 ? void 0 : Math.min(...later);
-}
-function instant_of(stop) {
-  return { issue: stop.issue, at_ms: Date.parse(stop.at) };
-}
-function notices_of(entries) {
-  return entries.filter((entry) => entry.kind === lane_ledger.KIND.UNPLANNED_NOTICE).map((entry) => ({ issue: entry.issue, at_ms: Date.parse(entry.at) }));
-}
-function noticed(cause, stop, notices) {
-  if (cause !== run_ship_planned.PRECONDITION) return cause;
-  const is_noticed = notices.some(
-    (notice) => notice.issue === stop.issue && notice.at_ms <= stop.at_ms
-  );
-  return is_noticed ? `${cause}${NOTICED}` : cause;
-}
-function causes_of(stop, notices) {
-  const { preconditions = [], findings = [] } = stop;
-  const kinds = [...preconditions, ...findings];
-  if (kinds.length === 0) return [stop.cause ?? UNRECORDED_CAUSE];
-  return kinds.map((kind) => noticed(kind, instant_of(stop), notices));
-}
-function waits_of(entries, ends, notices) {
-  return entries.filter(is_stop).map((stop) => ({
-    stop,
-    reason: stop.reason,
-    causes: causes_of(stop, notices),
-    wait_ms: wait_ms(instant_of(stop), ends)
-  }));
-}
-function total(values) {
-  return values.length === 0 ? void 0 : values.reduce((sum, value) => sum + value, 0);
-}
-function causes_cell(waits2) {
-  const all = waits2.flatMap((wait) => wait.causes);
-  const counted = [...new Set(all)].map((cause) => ({
-    cause,
-    count: all.filter((each) => each === cause).length
-  }));
-  const ranked = counted.toSorted((left, right) => right.count - left.count);
-  return ranked.length === 0 ? NO_CAUSES : ranked.map(({ cause, count }) => `${cause} ${String(count)}`).join(", ");
-}
-function reason_row(reason, waits2) {
-  const of_reason = waits2.filter((wait) => wait.reason === reason);
-  const ended = of_reason.map((wait) => wait.wait_ms).filter((value) => is_number(value));
-  return lane_stats.to_row([
-    reason,
-    lane_stage_stats.cell(lane_stats.median(ended)),
-    lane_stage_stats.cell(lane_stats.peak(ended)),
-    lane_stage_stats.cell(total(ended)),
-    String(ended.length),
-    String(of_reason.length - ended.length),
-    causes_cell(of_reason)
-  ]);
-}
-function waits_in(entries, window, events = []) {
-  const ends = ends_of(entries, parks_of(events));
-  return waits_of(lane_stats.in_window(entries, window), ends, notices_of(entries));
-}
-function table(entries, window, events = []) {
-  const waits2 = waits_in(entries, window, events);
-  return [
-    lane_stats.to_row(COLUMNS),
-    lane_stats.to_row(COLUMNS.map(() => "---")),
-    ...REASONS.map((reason) => reason_row(reason, waits2))
-  ].join("\n");
-}
-var lane_stop_stats = {
-  REASONS,
-  dispatches_of,
-  ends_of,
-  events_of,
-  issue_of,
-  table,
-  total,
-  wait_ms,
-  waits_in
-};
-
-// scripts/lane/lane-stage-events.ts
-var { EVENT_KIND } = run_event_stream;
-var { PHASE, STAGE: STAGE2 } = run_ship_stage;
-var SHIP_STAGES = /* @__PURE__ */ new Set([
-  ...Object.values(STAGE2),
-  lane_ledger.PRE_DETACH_STAGE
-]);
-function is_ship(entry, issue) {
-  return entry.kind === lane_ledger.KIND.STAGE && entry.issue === issue && SHIP_STAGES.has(entry.stage);
-}
-function event_at(at_ms, issue, words) {
-  return {
-    pos: 0,
-    at: new Date(at_ms).toISOString(),
-    kind: EVENT_KIND.SHIP_STAGE,
-    text: `${issue_cite.plain_for("program", issue)} ${words}`
-  };
-}
-function interval_events(entry, issue) {
-  const end_ms = Date.parse(entry.at);
-  if (!Number.isFinite(end_ms) || entry.elapsed_ms <= 0) return [];
-  return [
-    event_at(end_ms - entry.elapsed_ms, issue, `${entry.stage} ${PHASE.START}`),
-    event_at(end_ms, issue, `${entry.stage} ${PHASE.DONE}`)
-  ];
-}
-function is_lane_ship(event, issue) {
-  return event.kind === EVENT_KIND.SHIP_STAGE && lane_stop_stats.issue_of(event) === issue;
-}
-function change(active, event) {
-  if (event.kind === EVENT_KIND.STOP) {
-    active.clear();
-    return;
-  }
-  const { stage, phase } = run_ship_stage.words_of(event.text);
-  if (phase === PHASE.SKIPPED) return;
-  if (phase === PHASE.START) active.set(stage, event);
-  else active.delete(stage);
-}
-function exclusive(events, issue) {
-  const active = /* @__PURE__ */ new Map();
-  return events.map((event) => {
-    change(active, event);
-    const latest = [...active.values()].at(-1);
-    if (latest === void 0) return event;
-    const { stage } = run_ship_stage.words_of(latest.text);
-    return event_at(Date.parse(event.at), issue, `${stage} ${PHASE.START}`);
-  });
-}
-function stop_events(entries, issue) {
-  return entries.flatMap(
-    (entry) => entry.kind === lane_ledger.KIND.STOP && entry.issue === issue ? { ...event_at(Date.parse(entry.at), issue, entry.reason), kind: EVENT_KIND.STOP } : []
-  );
-}
-function of(entries, events, issue) {
-  const restored = entries.filter((entry) => is_ship(entry, issue)).flatMap((entry) => interval_events(entry, issue));
-  const ship = [
-    ...events.filter((event) => is_lane_ship(event, issue)),
-    ...restored,
-    ...stop_events(entries, issue)
-  ].toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
-  return [
-    ...events.filter((event) => !is_lane_ship(event, issue)),
-    ...exclusive(ship, issue)
-  ].toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
-}
-var lane_stage_events = { of };
-
-// scripts/lane/lane-net-time.ts
-var { EVENT_KIND: EVENT_KIND2 } = run_event_stream;
-var { PHASE: PHASE2, STAGE: STAGE3 } = run_ship_stage;
-function entries_of(entries, issue) {
-  return entries.filter((entry) => "issue" in entry && entry.issue === issue);
-}
-function span_of(entries, issue) {
-  const of_issue = entries_of(entries, issue).toSorted(
-    (left, right) => Date.parse(left.at) - Date.parse(right.at)
-  );
-  const from = of_issue.find((entry) => lane_stage_stats.is_dispatch(entry));
-  const to = of_issue.findLast((entry) => lane_stage_stats.is_merge(entry));
-  if (from === void 0 || to === void 0) return void 0;
-  const span = { from_ms: Date.parse(from.at), to_ms: Date.parse(to.at) };
-  return span.to_ms < span.from_ms ? void 0 : span;
-}
-function holds_of(events) {
-  return [
-    ...lane_stop_stats.events_of(events, EVENT_KIND2.PARK),
-    ...lane_stop_stats.events_of(events, EVENT_KIND2.OUTAGE),
-    ...lane_stop_stats.events_of(events, EVENT_KIND2.USAGE_LIMIT)
-  ];
-}
-function held_ms(hold, ends, to_ms) {
-  const left_ms = to_ms - hold.at_ms;
-  return Math.min(lane_stop_stats.wait_ms(hold, ends) ?? left_ms, left_ms);
-}
-function hold_waits(entries, events, issue, span) {
-  const holds = holds_of(events);
-  const inside = holds.filter(
-    (hold) => hold.issue === issue && hold.at_ms >= span.from_ms && hold.at_ms < span.to_ms
-  );
-  return inside.map((hold) => {
-    const ends = lane_stop_stats.ends_of(
-      entries,
-      holds.filter((other) => other.at_ms > hold.at_ms)
-    );
-    return { from_ms: hold.at_ms, to_ms: hold.at_ms + held_ms(hold, ends, span.to_ms) };
-  });
-}
-function joined(spans) {
-  const sorted = spans.toSorted((left, right) => left.from_ms - right.from_ms);
-  const kept = [];
-  for (const next of sorted) {
-    const last = kept.at(-1);
-    if (last === void 0 || next.from_ms > last.to_ms) kept.push({ ...next });
-    else last.to_ms = Math.max(last.to_ms, next.to_ms);
-  }
-  return kept;
-}
-function slept(events, span) {
-  const cut = lane_sleep.spans(events).map((sleep) => ({
-    from_ms: Math.max(sleep.from_ms, span.from_ms),
-    to_ms: Math.min(sleep.to_ms, span.to_ms)
-  }));
-  return joined(cut.filter((sleep) => sleep.to_ms > sleep.from_ms));
-}
-function yield_spans(entries, events) {
-  const yields = lane_stop_stats.events_of(
-    events.filter((event) => lane_yield.is_yield_note(event)),
-    EVENT_KIND2.NOTE
-  );
-  return lane_spans.issue_spans({
-    starts: yields,
-    bounds: yields,
-    ends: lane_stop_stats.dispatches_of(entries)
-  });
-}
-function run_start_ms(dispatches, split) {
-  const start = dispatches.findLast(
-    (entry) => entry.issue === split.issue && entry.at_ms <= split.at_ms
-  );
-  return start?.at_ms ?? split.at_ms;
-}
-function split_spans(entries, events) {
-  const splits = lane_stop_stats.events_of(events, EVENT_KIND2.SPLIT);
-  const dispatches = lane_stop_stats.dispatches_of(entries);
-  const spans = lane_spans.issue_spans({ starts: splits, bounds: splits, ends: dispatches });
-  return splits.map((split, index) => ({
-    from_ms: run_start_ms(dispatches, split),
-    end_ms: spans[index]?.end_ms
-  })).filter((wait) => wait.end_ms !== void 0);
-}
-function cut_inside(spans, span) {
-  const inside = spans.filter((wait) => wait.from_ms >= span.from_ms && wait.from_ms < span.to_ms);
-  return inside.map((wait) => ({
-    from_ms: wait.from_ms,
-    to_ms: Math.min(wait.end_ms ?? span.to_ms, span.to_ms)
-  }));
-}
-function events_of_issue(events, issue) {
-  return events.filter((event) => lane_stop_stats.issue_of(event) === issue);
-}
-function yielded(entries, events, issue, span) {
-  return cut_inside(yield_spans(entries, events_of_issue(events, issue)), span);
-}
-function split_waits(entries, events, issue, span) {
-  return cut_inside(split_spans(entries, events_of_issue(events, issue)), span);
-}
-function waiting(entries, events, issue, span) {
-  return joined([
-    ...hold_waits(entries, events, issue, span),
-    ...yielded(entries, events, issue, span),
-    ...slept(events, span)
-  ]);
-}
-function waits(entries, events, issue, span) {
-  return joined([
-    ...waiting(entries, events, issue, span),
-    ...split_waits(entries, events, issue, span)
-  ]);
-}
-function is_followup_start(event) {
-  const { stage, phase } = run_ship_stage.words_of(event.text);
-  return stage === STAGE3.FOLLOWUP && phase === PHASE2.START;
-}
-function followed(events, issue, span) {
-  const lines = events.filter((event) => event.kind === EVENT_KIND2.SHIP_STAGE).filter((event) => lane_stop_stats.issue_of(event) === issue).map((event) => ({ event, at_ms: Date.parse(event.at) })).filter((line) => line.at_ms >= span.from_ms && line.at_ms < span.to_ms).toSorted((left, right) => left.at_ms - right.at_ms);
-  return lines.map((line, index) => ({ line, to_ms: lines[index + 1]?.at_ms ?? span.to_ms })).filter(({ line }) => is_followup_start(line.event)).map(({ line, to_ms }) => ({ from_ms: line.at_ms, to_ms }));
-}
-function automatic_waits(entries, events, issue, span) {
-  const stages = lane_stage_events.of(entries, events, issue);
-  return joined([...waiting(entries, events, issue, span), ...followed(stages, issue, span)]);
-}
-function outside(entries, events, issue, span) {
-  return joined([
-    ...automatic_waits(entries, events, issue, span),
-    ...split_waits(entries, events, issue, span)
-  ]);
-}
-function net_ms(entries, events, issue) {
-  const span = span_of(entries, issue);
-  if (span === void 0) return void 0;
-  return outside(entries, events, issue, span).reduce(
-    (left, wait) => left - (wait.to_ms - wait.from_ms),
-    span.to_ms - span.from_ms
-  );
-}
-function net_minutes(entries, events, issue) {
-  const net = net_ms(entries, events, issue);
-  return net === void 0 ? void 0 : Math.ceil(net / MS_PER_MINUTE);
-}
-function missing_reason(entries, issue) {
-  const of_issue = entries_of(entries, issue);
-  if (of_issue.every((entry) => !lane_stage_stats.is_dispatch(entry))) return "no dispatch";
-  if (of_issue.every((entry) => !lane_stage_stats.is_merge(entry))) return "no merge";
-  return "cause unknown";
-}
-var lane_net_time = {
-  automatic_waits,
-  hold_waits,
-  missing_reason,
-  net_minutes,
-  net_ms,
-  outside,
-  slept,
-  span_of,
-  waits,
-  yield_spans,
-  yielded
-};
-
-export {
-  lane_stop_stats,
-  lane_stage_events,
-  lane_net_time
-};

package/dist/commands/chunk-MXC4IBZ7.js

@@ -1,104 +0,0 @@
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  lane_paths
-} from "./chunk-YIA6FC3K.js";
-import {
-  PROBE_TIMEOUT_MS
-} from "./chunk-WPAQUMHC.js";
-
-// scripts/lane/process-directories.ts
-import { spawnSync } from "node:child_process";
-import path2 from "node:path";
-
-// scripts/lane/process-linux.ts
-import { readdirSync, readFileSync, readlinkSync, statSync } from "node:fs";
-import path from "node:path";
-var GONE_CODES = /* @__PURE__ */ new Set(["ENOENT", "ESRCH"]);
-var PID_DIRECTORY = /^\d+$/u;
-var MARK_PREFIX = `${lane_child_marker.KEY}=`;
-function is_gone(error) {
-  return error instanceof Error && "code" in error && GONE_CODES.has(String(error.code));
-}
-function marked_issue(content) {
-  const assignment = content.split("\0").find((entry) => entry.startsWith(MARK_PREFIX));
-  const value = assignment?.slice(MARK_PREFIX.length);
-  return lane_child_marker.marked_issue({ [lane_child_marker.KEY]: value });
-}
-function read_process(root, pid, uid) {
-  const directory = path.join(root, pid);
-  try {
-    if (statSync(directory).uid !== uid) return { kind: "skip" };
-    const cwd = readlinkSync(path.join(directory, "cwd"));
-    const issue = marked_issue(readFileSync(path.join(directory, "environ"), "utf8"));
-    return { kind: "read", process: { pid: Number(pid), directory: cwd, issue } };
-  } catch (error) {
-    return { kind: is_gone(error) ? "skip" : "unknown" };
-  }
-}
-function processes(readings) {
-  return readings.flatMap((reading) => reading.kind === "read" ? [reading.process] : []);
-}
-function read_owned(root, uid) {
-  try {
-    const pids = readdirSync(root).filter((entry) => PID_DIRECTORY.test(entry));
-    const readings = pids.map((pid) => read_process(root, pid, uid));
-    if (readings.some((reading) => reading.kind === "unknown")) return void 0;
-    return processes(readings);
-  } catch {
-    return void 0;
-  }
-}
-function read_processes(root = "/proc", uid = process.getuid?.()) {
-  return uid === void 0 ? void 0 : read_owned(root, uid);
-}
-function directories() {
-  const read = read_processes();
-  return read === void 0 ? void 0 : new Map(read.map((entry) => [entry.pid, entry.directory]));
-}
-function marks() {
-  const marked = read_processes()?.filter((entry) => entry.issue !== void 0);
-  return marked === void 0 ? void 0 : new Map(
-    marked.flatMap((entry) => entry.issue === void 0 ? [] : [[entry.pid, entry.issue]])
-  );
-}
-var process_linux = { directories, marks, read_processes };
-
-// scripts/lane/process-directories.ts
-var LSOF_COMMAND = "lsof";
-var CWD_ARGUMENTS = ["-a", "-d", "cwd", "-Fn"];
-var LSOF_PROCESS = /^(?=p)/mu;
-var LSOF_NAME = "n";
-var LISTING_PLATFORMS = /* @__PURE__ */ new Set(["darwin"]);
-function lsof_block(block) {
-  const [process_line = "", ...rest] = block.trim().split("\n");
-  const name = rest.find((line) => line.startsWith(LSOF_NAME));
-  return name === void 0 ? void 0 : [Number(process_line.slice(1)), name.slice(1)];
-}
-function parse(output) {
-  const blocks = output.split(LSOF_PROCESS).map((block) => lsof_block(block));
-  return new Map(blocks.filter((block) => block !== void 0));
-}
-function list_all(platform = process.platform) {
-  if (platform === "linux") return process_linux.directories();
-  if (!LISTING_PLATFORMS.has(platform)) return /* @__PURE__ */ new Map();
-  const result = spawnSync(LSOF_COMMAND, CWD_ARGUMENTS, {
-    encoding: "utf8",
-    timeout: PROBE_TIMEOUT_MS,
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  return result.error === void 0 ? parse(result.stdout) : void 0;
-}
-function lane_of(directory, root) {
-  const parts = directory.split(path2.sep);
-  const ancestors = parts.map((_, index) => parts.slice(0, index + 1).join(path2.sep)).slice(1);
-  const environment = { [lane_paths.LANE_ROOT_KEY]: root };
-  return ancestors.map((ancestor) => lane_paths.lane_issue_of(ancestor, environment)).find(Boolean);
-}
-var process_directories = { CWD_ARGUMENTS, lane_of, list_all, parse };
-
-export {
-  process_linux,
-  process_directories
-};

package/dist/commands/chunk-N7QTMTST.js

@@ -1,210 +0,0 @@
-import {
-  time_bundle_call,
-  time_bundles,
-  time_spans
-} from "./chunk-7HAGC6SW.js";
-import {
-  time_transcript_line
-} from "./chunk-OJ65BZBV.js";
-import {
-  time_shell
-} from "./chunk-LHKXJD6L.js";
-
-// scripts/time-runtime/time-command-key.ts
-var UNNAMED_KEY = "";
-function command_key(span) {
-  if (span.label === time_spans.UNKNOWN_TOOL) return UNNAMED_KEY;
-  return span.josh_command === "" ? span.label : span.josh_command;
-}
-var time_command_key = { UNNAMED_KEY, command_key };
-
-// scripts/time-runtime/time-call-identity.ts
-var IDENTITY_SEPARATOR = "\0";
-function identity_of(call) {
-  return [
-    time_command_key.command_key(call),
-    call.check_key,
-    [...call.targets].toSorted((left, right) => left.localeCompare(right)).join(",")
-  ].join(IDENTITY_SEPARATOR);
-}
-var time_call_identity = { identity_of };
-
-// scripts/time-runtime/time-search-call.ts
-var SEARCH_COMMANDS = ["fd", "find", "grep", "rg"];
-var SEARCH_LABELS = new Set(
-  SEARCH_COMMANDS.map((command) => time_shell.bash_label(command))
-);
-var CHAIN_COMMANDS = [...SEARCH_COMMANDS, "sed"];
-var CHAIN_LABELS = new Set(
-  CHAIN_COMMANDS.map((command) => time_shell.bash_label(command))
-);
-function is_read_only_search(call) {
-  return SEARCH_LABELS.has(call.label) && call.is_bundleable && !call.may_write;
-}
-function is_search_chain_call(call) {
-  return CHAIN_LABELS.has(call.label) && call.is_bundleable && !call.is_writing;
-}
-var time_search_call = {
-  is_read_only_search,
-  is_search_chain_call
-};
-
-// scripts/time-runtime/time-batch-guard.ts
-var CONSECUTIVE_LIMIT = 3;
-var REFIRE_EVERY = CONSECUTIVE_LIMIT;
-var ONE_TURN = 1;
-var NONE = 0;
-var NOTICE_REFIRE_EVERY = ONE_TURN;
-var NAMED_CANDIDATE_COUNT = 3;
-var SEQUENCE_BEFORE_LIMIT = CONSECUTIVE_LIMIT - ONE_TURN;
-var RULE_POINTER = "`prompts/collaboration-workflow/turn-batching.md`";
-var STREAK = `${String(CONSECUTIVE_LIMIT)} single-call turns in a row`;
-var REASON = `\u26D4 batching: ${STREAK}. Reissue this with the calls that do not need its result \u2014 the test is whether a call's input needs another call's result, not what kind of call it is (edits are covered exactly as reads); it never authorizes weakening a verification gate or a review. Nothing to pair? Reissue it unchanged. ${RULE_POINTER}`;
-var NOTICE = `\u{1F4A1} batching: ${STREAK}; the Write proceeds. Issue the writes that do not need its result in one turn, never by weakening a gate or a review. ${RULE_POINTER}`;
-var LANE_NOTICE = `\u{1F4A1} batching: ${STREAK}; the call proceeds. Pair independent calls. ${RULE_POINTER}`;
-var WHOLE_FILE_WRITE_TOOL = "Write";
-var EDIT_TOOL = "Edit";
-function is_guarded_call(call) {
-  if (call.name === WHOLE_FILE_WRITE_TOOL) return false;
-  return time_bundle_call.call_facts(call.name, call.input).is_bundleable;
-}
-function is_notice_call(call) {
-  return call.name === WHOLE_FILE_WRITE_TOOL;
-}
-function is_read_only_call(call) {
-  const facts = time_bundle_call.call_facts(call.name, call.input);
-  return facts.is_bundleable && !facts.may_write;
-}
-function depends_on_sequence(sequence, facts) {
-  return sequence.some((span) => time_bundles.shares_target(span.targets, facts.targets));
-}
-function sequence_started_ms(sequence) {
-  return sequence[0]?.ended_ms ?? NONE;
-}
-function turns_since(sequence, last_fired_ms) {
-  return sequence.filter((span) => span.ended_ms > last_fired_ms).length;
-}
-function is_sequence_at_limit(sequence, facts, last_fired_ms, refire_every) {
-  if (sequence.length < SEQUENCE_BEFORE_LIMIT || depends_on_sequence(sequence, facts)) return false;
-  if (last_fired_ms < sequence_started_ms(sequence)) return true;
-  return turns_since(sequence, last_fired_ms) >= refire_every;
-}
-function is_at_limit(spans, call, last_fired_ms, refire_every) {
-  return is_sequence_at_limit(
-    time_bundles.open_sequence(spans),
-    time_bundle_call.call_facts(call.name, call.input),
-    last_fired_ms,
-    refire_every
-  );
-}
-var GUARD_LABEL = time_transcript_line.guard_from_refusal(REASON);
-function is_reissued_refusal(spans, call) {
-  const identity = time_call_identity.identity_of(
-    time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID)
-  );
-  return spans.some(
-    (span) => span.refusal_guard === GUARD_LABEL && time_call_identity.identity_of(span) === identity
-  );
-}
-function refusable_spans(text, call) {
-  if (!is_guarded_call(call)) return [];
-  const { spans } = time_spans.parse_timeline(text);
-  return is_reissued_refusal(spans, call) ? [] : spans;
-}
-function should_block(text, call, refused_at_ms, refire_every = REFIRE_EVERY) {
-  return is_at_limit(refusable_spans(text, call), call, refused_at_ms, refire_every);
-}
-function as_tool_call(call) {
-  return time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID);
-}
-function is_search_chain_call2(call) {
-  return is_guarded_call(call) && time_search_call.is_search_chain_call(as_tool_call(call));
-}
-function is_search_chain(spans, call) {
-  const recent = time_bundles.open_sequence(spans).slice(-SEQUENCE_BEFORE_LIMIT);
-  return [...recent, as_tool_call(call)].every(
-    (turn) => time_search_call.is_search_chain_call(turn)
-  );
-}
-function should_block_search_chain(text, call, refused_at_ms) {
-  const spans = refusable_spans(text, call);
-  return is_search_chain(spans, call) && is_at_limit(spans, call, refused_at_ms, REFIRE_EVERY);
-}
-function should_notify(text, call, notified_at_ms) {
-  if (!is_notice_call(call)) return false;
-  const { spans } = time_spans.parse_timeline(text);
-  return is_at_limit(spans, call, notified_at_ms, NOTICE_REFIRE_EVERY);
-}
-function describe_span(span) {
-  const target = span.targets[0] ?? "";
-  if (target === "" || span.label.includes(target)) return span.label;
-  return `${span.label} ${target}`;
-}
-var FOLD_MINIMUM = 2;
-function read_targets(sequence) {
-  const paths = sequence.filter((span) => span.is_bundleable && !span.is_writing).map((span) => span.targets[0] ?? "").filter((path) => path !== "" && time_bundle_call.has_extension(path));
-  return [...new Set(paths)];
-}
-function read_fold_directive(sequence) {
-  const paths = read_targets(sequence);
-  if (paths.length < FOLD_MINIMUM) return "";
-  return ` Fold them into one call: \`pnpm josh read:files ${paths.join(" ")}\`.`;
-}
-function write_targets(sequence) {
-  const paths = sequence.filter((span) => span.label === EDIT_TOOL).map((span) => span.targets[0] ?? "").filter((path) => path !== "" && time_bundle_call.has_extension(path));
-  return [...new Set(paths)];
-}
-function write_fold_directive(sequence) {
-  const paths = write_targets(sequence);
-  if (paths.length < FOLD_MINIMUM) return "";
-  return ` Fold them into one \`pnpm josh edit:files\` call with a plan over: ${paths.join(" ")}.`;
-}
-function name_candidates(calls) {
-  if (calls.length === NONE) return "";
-  const named = calls.map((call) => describe_span(call)).join(", ");
-  const folds = `${read_fold_directive(calls)}${write_fold_directive(calls)}`;
-  return ` Just issued one per turn, so at least these could have shared a turn: ${named}.${folds}`;
-}
-function recent_candidates(tail) {
-  return name_candidates(
-    time_bundles.open_sequence(time_spans.parse_timeline(tail).spans).slice(-NAMED_CANDIDATE_COUNT)
-  );
-}
-function pairing_candidates(tail, call) {
-  const sequence = time_bundles.open_sequence(time_spans.parse_timeline(tail).spans);
-  if (call === void 0 || sequence.length === NONE) {
-    return name_candidates(sequence.slice(-NAMED_CANDIDATE_COUNT));
-  }
-  const facts = time_bundle_call.call_facts(call.name, call.input);
-  if (!facts.is_bundleable || depends_on_sequence(sequence, facts)) return "";
-  const current = time_spans.to_tool_call(call.name, call.input, time_spans.NO_MESSAGE_ID);
-  return name_candidates([...sequence.slice(ONE_TURN - NAMED_CANDIDATE_COUNT), current]);
-}
-var STAMP_PREFIX = "josh-batch-guard-";
-var NOTICE_STAMP_PREFIX = "josh-batch-guard-notice-";
-var time_batch_guard = {
-  CONSECUTIVE_LIMIT,
-  GUARD_LABEL,
-  LANE_NOTICE,
-  NOTICE,
-  NOTICE_REFIRE_EVERY,
-  NOTICE_STAMP_PREFIX,
-  REASON,
-  REFIRE_EVERY,
-  SEQUENCE_BEFORE_LIMIT,
-  STAMP_PREFIX,
-  is_guarded_call,
-  is_notice_call,
-  is_read_only_call,
-  is_search_chain_call: is_search_chain_call2,
-  pairing_candidates,
-  recent_candidates,
-  should_block,
-  should_block_search_chain,
-  should_notify
-};
-
-export {
-  time_search_call,
-  time_batch_guard
-};