@joshuafolkken/kit 1.872.0 → 1.879.0

package/dist/hooks/chunk-4LFQEZS4.js

@@ -1,137 +0,0 @@
-import {
-  investigation_reads
-} from "./chunk-B4HPNY2I.js";
-import {
-  lane_guard_policy
-} from "./chunk-O46HMMLJ.js";
-import {
-  hook_decision
-} from "./chunk-HOFEWH6H.js";
-import {
-  json_value,
-  time_spans
-} from "./chunk-USLFAFOI.js";
-
-// scripts/delegation/duplicate-read-guard.ts
-import { statSync } from "node:fs";
-import { text } from "node:stream/consumers";
-import { fileURLToPath } from "node:url";
-var SWITCH_ENV_KEY = "JOSH_DUPLICATE_READ_GUARD";
-var LANE_GUARD_ID = "duplicate-read";
-var STAMP_PREFIX = "josh-duplicate-read-guard-";
-var NOTICE_STAMP_PREFIX = "josh-duplicate-read-notice-";
-var READ_TOOL = "Read";
-var GLOB_CHARACTERS = /[*?]/u;
-var REASON = `\u26D4 duplicate read: this file was already read in this session and has not changed since (its mtime predates that read), so reading it again returns nothing new. Scroll up to the earlier result instead of re-reading it. A read with a new offset/limit, or of a file that has since changed, is allowed; set \`JOSH_DUPLICATE_READ_GUARD=off\` to disable this guard.`;
-var NOTICE = `\u26A0 duplicate read: this file was already read in this session and has not changed since, so re-reading it returns nothing new \u2014 scroll up to the earlier result instead of re-reading it. Set \`JOSH_DUPLICATE_READ_GUARD=off\` to silence this.`;
-function is_paginated(input) {
-  return input["offset"] !== void 0 || input["limit"] !== void 0;
-}
-function names_one_file(file_path) {
-  return typeof file_path === "string" && file_path !== "" && !GLOB_CHARACTERS.test(file_path);
-}
-function read_target(call) {
-  if (call.name !== READ_TOOL || !json_value.is_record(call.input)) return void 0;
-  const { input } = call;
-  if (is_paginated(input) || !names_one_file(input["file_path"])) return void 0;
-  return investigation_reads.resolved(input["file_path"]);
-}
-function is_refusable_call(call) {
-  return read_target(call) !== void 0;
-}
-function is_successful_read(span) {
-  const is_read = investigation_reads.READ_TOOLS.has(span.label);
-  return is_read && span.outcome !== time_spans.FAILED_OUTCOME;
-}
-function reads_target(span, target) {
-  return span.targets.some((one) => investigation_reads.resolved(one) === target);
-}
-function last_read_ms(spans, target) {
-  const times = spans.filter((span) => is_successful_read(span) && reads_target(span, target)).map((span) => span.ended_ms);
-  return times.length === 0 ? hook_decision.NEVER_MS : Math.max(...times);
-}
-function file_mtime_ms(target) {
-  try {
-    return statSync(target).mtimeMs;
-  } catch {
-    return void 0;
-  }
-}
-function read_window(tail, target) {
-  const { spans, started_ms } = time_spans.parse_timeline(tail);
-  return { last_ms: last_read_ms(spans, target), window_start_ms: started_ms };
-}
-function is_unchanged_reread(last_ms, mtime) {
-  if (mtime === void 0 || last_ms === hook_decision.NEVER_MS) return false;
-  return mtime < last_ms;
-}
-function is_rearmed(window, fired_at_ms) {
-  if (fired_at_ms === hook_decision.NEVER_MS || fired_at_ms < window.window_start_ms) return true;
-  return window.last_ms > fired_at_ms;
-}
-function is_redundant_reread(tail, call, fired_at_ms) {
-  const target = read_target(call);
-  if (target === void 0) return false;
-  const window = read_window(tail, target);
-  if (!is_unchanged_reread(window.last_ms, file_mtime_ms(target))) return false;
-  return is_rearmed(window, fired_at_ms);
-}
-function duplicate_mode() {
-  return lane_guard_policy.mode_here(LANE_GUARD_ID);
-}
-function is_candidate(call) {
-  return is_refusable_call(call) && duplicate_mode() !== "off";
-}
-function should_block_here(tail, call, refused_at_ms) {
-  if (duplicate_mode() !== "refuse") return false;
-  return is_redundant_reread(tail, call, refused_at_ms);
-}
-function should_notify_here(tail, call, notified_at_ms) {
-  if (duplicate_mode() !== "notice") return false;
-  return is_redundant_reread(tail, call, notified_at_ms);
-}
-var GUARD = hook_decision.create_transcript_guard({
-  prefix: STAMP_PREFIX,
-  switch_key: SWITCH_ENV_KEY,
-  is_candidate,
-  should_block: should_block_here,
-  reason: REASON,
-  notify: {
-    prefix: NOTICE_STAMP_PREFIX,
-    should_notify: should_notify_here,
-    text: () => NOTICE
-  }
-});
-var duplicate_read_refusal = GUARD.refusal;
-var duplicate_read_outcome = GUARD.outcome;
-var { is_enabled, refusal_path } = GUARD;
-var notice_refusal_path = hook_decision.create_refusal_stamp(NOTICE_STAMP_PREFIX).path;
-var { deny_envelope, DISABLED_VALUES } = hook_decision;
-var duplicate_reads = {
-  REASON,
-  NOTICE,
-  SWITCH_ENV_KEY,
-  is_candidate,
-  is_rearmed,
-  is_redundant_reread,
-  is_refusable_call,
-  is_unchanged_reread,
-  last_read_ms,
-  read_target
-};
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("duplicate-read:guard");
-  else hook_decision.write_outcome(await text(process.stdin), duplicate_read_outcome);
-}
-
-export {
-  SWITCH_ENV_KEY,
-  duplicate_read_refusal,
-  duplicate_read_outcome,
-  is_enabled,
-  refusal_path,
-  notice_refusal_path,
-  deny_envelope,
-  DISABLED_VALUES,
-  duplicate_reads
-};

package/dist/hooks/chunk-4OCX3V2T.js

@@ -1,469 +0,0 @@
-import {
-  lane_child_marker
-} from "./chunk-OFJGH2L4.js";
-import {
-  time_bundle_call,
-  time_format,
-  time_round_trips,
-  time_spans,
-  time_transcript_line
-} from "./chunk-ZVPPBQ3L.js";
-
-// scripts/lane/lane-guard-policy.ts
-var DEFAULT_MODE = "refuse";
-var OFF_MODE = "off";
-var LANE_GUARD_POLICY = [
-  {
-    id: "investigation",
-    mode_in_lane_child: "notice",
-    because: 'a refusal ends a child turn so it cannot fire as one (kit#2138), which is why it was `off` from #2138 to #2382. The exemption reason \u2014 "the child is itself the delegated unit, so it cannot dispatch a sub-unit to read its own edit targets" \u2014 did not hold in measurement: kit#2382 re-measured the six lane children after #2347 (#2366 #2370 #2371 #2372 #2374 #2375) and every one dispatched sub-agents (10 launches, 2 of them investigation fan-outs) and read 4\u201317 files it never edited, all six over the threshold of 3. So the reading the guard exists to send out was there to send. It takes `notice`, not `off`: the child is nudged to delegate rather than killed, on the `additionalContext` path batching and duplicate-read already use, and the notice names the concrete unedited files this run read (the #2276 precedent) rather than the generic "delegate" #2164 \u2192 #2178 measured not to move the number. The density is a genuine experiment \u2014 re-measured on the next backlogrun, and a notice that still does not move it is redesigned rather than kept'
-  },
-  {
-    id: "batching",
-    mode_in_lane_child: "notice",
-    because: 'a refusal ends a child turn so it cannot fire as one (kit#2138); kit#2164 replaced it with a notice, kit#2178 took that notice off after it did not move the density (1.00 calls per turn on both sides of it, transcript f39efeb5), and kit#2276 restores it as a notice \u2014 but a different one. #2178 turned the notice fully off, so across the 2026-09-21 backlogrun 13 runs it fired zero times and the measured 1.147 is the rate with no guidance at all, not guidance that failed. #2276 re-enables it with the two things #2164 lacked: it names the concrete recent calls the run issued one-per-turn (not just "batch more"), and it recurs every single-call turn rather than every three, so the pressure arrives as often as the mistake. The density is to be re-measured on the next backlogrun; if it still does not reach 1.40 the notice is redesigned rather than kept, per the issue'
-  },
-  {
-    id: "duplicate-read",
-    mode_in_lane_child: "notice",
-    because: "a refusal ends a child turn so it cannot fire as one (kit#2138), and the unchanged re-reads the guard catches are measured in lane children above all (kit#2298 baseline: 8.0 per lane run) \u2014 so silencing it there (`off`) would neuter it exactly where the count lives. It takes `notice` instead: the child is nudged to scroll up to the earlier read rather than killed. The mode is a genuine experiment, as the batching notice is \u2014 a notice that does not reduce the duplicate reads on the next backlogrun is redesigned rather than kept"
-  },
-  {
-    id: "rule",
-    mode_in_lane_child: "refuse",
-    because: "it carries the lane-only rules a child depends on (`pre-gate-cut`, `implementation-cut`, `lane-park`) and the safety rules a child must still obey (`shell-body`, `piped-verification`); a blanket suppression would disarm exactly the guards written for the child. `implementation-cut` (joshuafolkken/kit#2310) needs `refuse` for the same reason the pre-gate cut does \u2014 kit#1864 and kit#2310 both measured a cut carried as prose firing 0 times, so a notice, being prose in front of the run, would drop enforcement without a procedural replacement. The pre-gate-cut refusal does collateral a sibling call batched in the same turn \u2014 a `PreToolUse` deny cancels the turn's other parallel calls, which is the harness behavior kit#2177 measured on #2160 (gate refused, its batched `review:brief` cancelled) \u2014 and that collateral is not avoidable at the guard level. `notice` was considered for the pre-gate-cut point and rejected: kit#1864 measured the cut taken 0 times while it was carried as prose, and a notice is prose in front of the run (kit#2178 measured a lane-child notice not moving the number), so a notice would drop enforcement without a procedural replacement. kit#2177 supplies that replacement in the procedure instead \u2014 the chain orders the cut before the gate, so the cut is issued on its own (its `cut` verdict ends the turn, batching with nothing) and the gate runs in the fresh process where the carried cut keeps this guard silent; the refusal therefore stays `refuse` as insurance and the collateral is gone from the default path rather than from the guard"
-  }
-];
-var KNOWN_GUARD_IDS = LANE_GUARD_POLICY.map((entry) => entry.id);
-function entry_for(id) {
-  return LANE_GUARD_POLICY.find((entry) => entry.id === id.trim());
-}
-function mode_in_lane_child(id) {
-  return entry_for(id)?.mode_in_lane_child ?? DEFAULT_MODE;
-}
-function mode_here(id, directory = process.cwd(), source = process.env) {
-  const lane_mode = mode_in_lane_child(id);
-  if (lane_mode === DEFAULT_MODE) return DEFAULT_MODE;
-  return lane_child_marker.is_child_of(directory, source) ? lane_mode : DEFAULT_MODE;
-}
-function is_suppressed_here(id, directory = process.cwd(), source = process.env) {
-  return mode_here(id, directory, source) === OFF_MODE;
-}
-var lane_guard_policy = {
-  LANE_GUARD_POLICY,
-  KNOWN_GUARD_IDS,
-  entry_for,
-  mode_in_lane_child,
-  mode_here,
-  is_suppressed_here
-};
-
-// scripts/time-runtime/time-agent-bundles.ts
-var NONE = 0;
-var ONE = 1;
-var MIN_GROUP = 2;
-function is_launch(span) {
-  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation && time_bundle_call.is_launch_tool(span.label);
-}
-function new_walk() {
-  return { closed: [], open: NONE, wrote_since: false, turn_id: time_spans.NO_MESSAGE_ID };
-}
-function close_group(walk) {
-  if (walk.open >= MIN_GROUP) walk.closed.push(walk.open);
-  walk.open = NONE;
-}
-function is_same_turn(walk, span) {
-  return span.message_id !== time_spans.NO_MESSAGE_ID && span.message_id === walk.turn_id;
-}
-function open_turn(walk, span) {
-  if (walk.wrote_since || span.has_prior_reference) close_group(walk);
-  walk.open += ONE;
-  walk.turn_id = span.message_id;
-  walk.wrote_since = false;
-}
-function step(walk, span) {
-  if (span.is_writing) {
-    walk.wrote_since = true;
-    return;
-  }
-  if (!is_launch(span) || is_same_turn(walk, span)) return;
-  open_turn(walk, span);
-}
-function agent_bundles(spans) {
-  const walk = new_walk();
-  for (const span of time_round_trips.in_time_order(spans)) step(walk, span);
-  close_group(walk);
-  return walk.closed;
-}
-var time_agent_bundles = { agent_bundles };
-
-// scripts/time-runtime/time-bundles.ts
-var { unmeasured_row } = time_format;
-var HEADING = "Bundling:";
-var SEQUENCE_LABEL = "bundleable sequences";
-var RECOVERABLE_LABEL = "recoverable round trips";
-var SAVING_LABEL = "recoverable wait";
-var BY_TOOL_LABEL = "recoverable by tool";
-var AGENT_ROW_LABEL = "Agent";
-var ROW_INDENT = "  ";
-var MIN_SEQUENCE = 2;
-var ONE_CALL = 1;
-var NONE2 = 0;
-var PATH_SEPARATOR = "/";
-var FIRST_CALL = 1;
-var NO_LABEL = "";
-var NO_BUNDLES = {
-  sequence_count: 0,
-  longest_sequence: 0,
-  recoverable_round_trips: 0,
-  by_tool: [],
-  unattributed_round_trips: 0,
-  is_measured: false
-};
-function contains_segments(whole, part) {
-  if (whole.startsWith(`${part}${PATH_SEPARATOR}`)) return true;
-  return whole.endsWith(`${PATH_SEPARATOR}${part}`) || whole.includes(`${PATH_SEPARATOR}${part}${PATH_SEPARATOR}`);
-}
-function is_related(left, right) {
-  if (left === right) return true;
-  return contains_segments(left, right) || contains_segments(right, left);
-}
-function shares_target(left, right) {
-  return left.some((one) => right.some((other) => is_related(one, other)));
-}
-function is_dependent(earlier, later) {
-  if (earlier.is_writing && later.is_writing) return false;
-  return shares_target(earlier.targets, later.targets);
-}
-function conflicts(span, sequence) {
-  return sequence.some((earlier) => is_dependent(earlier, span));
-}
-function is_call(span) {
-  return span.category === time_spans.TOOL_CATEGORY && !span.is_continuation;
-}
-function is_turn_boundary(span) {
-  return span.category === time_spans.MODEL_CATEGORY;
-}
-function new_walk2() {
-  return { pending: [], sequence: [], closed: [] };
-}
-function flush(walk) {
-  if (walk.sequence.length >= MIN_SEQUENCE) walk.closed.push(walk.sequence);
-  walk.sequence = [];
-}
-function extend(walk, span) {
-  if (conflicts(span, walk.sequence)) flush(walk);
-  walk.sequence.push(span);
-}
-function close_trip(walk) {
-  const [only] = walk.pending;
-  if (walk.pending.length === ONE_CALL && only?.is_bundleable === true) extend(walk, only);
-  else if (walk.pending.length > NONE2) flush(walk);
-  walk.pending = [];
-}
-function is_same_turn2(span, pending) {
-  const [first] = pending;
-  if (first === void 0 || span.is_continuation || span.message_id === time_spans.NO_MESSAGE_ID) {
-    return false;
-  }
-  return span.message_id === first.message_id;
-}
-function step2(walk, span) {
-  if (is_call(span)) {
-    walk.pending.push(span);
-    return;
-  }
-  if (is_same_turn2(span, walk.pending)) return;
-  close_trip(walk);
-  if (!is_turn_boundary(span)) flush(walk);
-}
-function longest_of(sizes) {
-  return sizes.length === NONE2 ? NONE2 : Math.max(...sizes);
-}
-function recoverable_of(sizes) {
-  return sizes.reduce((sum, size) => sum + size - ONE_CALL, NONE2);
-}
-function sizes_of(closed) {
-  return closed.map((sequence) => sequence.length);
-}
-function tally_for(tallies, label) {
-  const found = tallies.get(label);
-  if (found !== void 0) return found;
-  const created = { sequence_count: NONE2, recoverable_round_trips: NONE2 };
-  tallies.set(label, created);
-  return created;
-}
-function count_trip(tallies, counted, label) {
-  const tally = tally_for(tallies, label);
-  tally.recoverable_round_trips += ONE_CALL;
-  if (!counted.has(label)) tally.sequence_count += ONE_CALL;
-  counted.add(label);
-}
-function tally_sequence(tallies, sequence) {
-  const counted = /* @__PURE__ */ new Set();
-  for (const span of sequence.slice(FIRST_CALL)) {
-    if (span.label !== NO_LABEL) count_trip(tallies, counted, span.label);
-  }
-}
-function by_weight(left, right) {
-  if (left.recoverable_round_trips !== right.recoverable_round_trips) {
-    return right.recoverable_round_trips - left.recoverable_round_trips;
-  }
-  return left.label.localeCompare(right.label);
-}
-function tool_rows(closed) {
-  const tallies = /* @__PURE__ */ new Map();
-  for (const sequence of closed) tally_sequence(tallies, sequence);
-  return [...tallies].map(([label, tally]) => ({ label, ...tally })).toSorted(by_weight);
-}
-function attributed_of(rows) {
-  return rows.reduce((sum, row) => sum + row.recoverable_round_trips, NONE2);
-}
-function with_agent_row(rows, agent_sizes) {
-  const recoverable_round_trips = recoverable_of(agent_sizes);
-  if (recoverable_round_trips === NONE2) return [...rows];
-  const row = {
-    label: AGENT_ROW_LABEL,
-    sequence_count: agent_sizes.length,
-    recoverable_round_trips
-  };
-  return [...rows, row].toSorted(by_weight);
-}
-function build_bundles(spans) {
-  const walk = new_walk2();
-  for (const span of time_round_trips.in_time_order(spans)) step2(walk, span);
-  close_trip(walk);
-  flush(walk);
-  const sizes = sizes_of(walk.closed);
-  const agent_sizes = time_agent_bundles.agent_bundles(spans);
-  const by_tool = with_agent_row(tool_rows(walk.closed), agent_sizes);
-  const recoverable_round_trips = recoverable_of(sizes) + recoverable_of(agent_sizes);
-  return {
-    sequence_count: sizes.length + agent_sizes.length,
-    longest_sequence: Math.max(longest_of(sizes), longest_of(agent_sizes)),
-    recoverable_round_trips,
-    by_tool,
-    unattributed_round_trips: recoverable_round_trips - attributed_of(by_tool),
-    is_measured: time_spans.has_transcript_data(spans.length)
-  };
-}
-function open_sequence(spans) {
-  const walk = new_walk2();
-  for (const span of time_round_trips.in_time_order(spans)) step2(walk, span);
-  return walk.sequence;
-}
-function sequence_suffix(totals) {
-  return `longest ${String(totals.longest_sequence)} turn(s)`;
-}
-function recoverable_suffix(totals, round_trip_count) {
-  const share = time_format.format_share(totals.recoverable_round_trips, round_trip_count);
-  return `${share} of ${String(round_trip_count)} round trip(s)`;
-}
-function saving_line(totals, model_ms_per_round_trip) {
-  const saved_ms = totals.recoverable_round_trips * model_ms_per_round_trip;
-  const rate = `at ${time_format.format_seconds(model_ms_per_round_trip)} model time per round trip`;
-  return time_format.format_row(SAVING_LABEL, saved_ms, rate);
-}
-function by_tool_suffix(totals) {
-  const attributed = totals.recoverable_round_trips - totals.unattributed_round_trips;
-  return `${String(attributed)} of ${String(totals.recoverable_round_trips)} attributed`;
-}
-function tool_row(row) {
-  return time_format.format_columns(
-    `${ROW_INDENT}${row.label}`,
-    String(row.recoverable_round_trips),
-    `in ${String(row.sequence_count)} sequence(s)`
-  );
-}
-function by_tool_lines(totals) {
-  const heading = time_format.format_columns(
-    BY_TOOL_LABEL,
-    String(totals.by_tool.length),
-    by_tool_suffix(totals)
-  );
-  const rows = totals.by_tool.slice(NONE2, time_format.MAX_ROWS).map((row) => tool_row(row));
-  return [heading, ...rows, ...time_format.overflow_line(totals.by_tool.length)];
-}
-function measured_lines(totals, price) {
-  return [
-    time_format.format_columns(
-      SEQUENCE_LABEL,
-      String(totals.sequence_count),
-      sequence_suffix(totals)
-    ),
-    time_format.format_columns(
-      RECOVERABLE_LABEL,
-      String(totals.recoverable_round_trips),
-      recoverable_suffix(totals, price.round_trip_count)
-    ),
-    saving_line(totals, price.model_ms_per_round_trip),
-    ...by_tool_lines(totals)
-  ];
-}
-var LABELS = [SEQUENCE_LABEL, RECOVERABLE_LABEL, SAVING_LABEL, BY_TOOL_LABEL];
-function no_divisor_lines() {
-  return LABELS.map((label) => time_format.format_columns(label, "", time_format.NO_CALLS));
-}
-function bundle_lines(totals, price) {
-  const heading = ["", HEADING];
-  if (!totals.is_measured) return [...heading, ...LABELS.map((label) => unmeasured_row(label))];
-  if (price.round_trip_count === NONE2) return [...heading, ...no_divisor_lines()];
-  return [...heading, ...measured_lines(totals, price)];
-}
-var time_bundles = {
-  HEADING,
-  SEQUENCE_LABEL,
-  RECOVERABLE_LABEL,
-  SAVING_LABEL,
-  BY_TOOL_LABEL,
-  MIN_SEQUENCE,
-  NO_BUNDLES,
-  build_bundles,
-  bundle_lines,
-  is_dependent,
-  open_sequence,
-  shares_target
-};
-
-// 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-batch-guard.ts
-var CONSECUTIVE_LIMIT = 3;
-var REFIRE_EVERY = CONSECUTIVE_LIMIT;
-var ONE_TURN = 1;
-var NONE3 = 0;
-var NOTICE_REFIRE_EVERY = ONE_TURN;
-var NAMED_CANDIDATE_COUNT = 3;
-var SEQUENCE_BEFORE_LIMIT = CONSECUTIVE_LIMIT - ONE_TURN;
-var REASON = `\u26D4 batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this one would make ${String(CONSECUTIVE_LIMIT)} in a row. Reissue it in one turn together with the calls meant to follow it that do not need its result. **The criterion is whether this call's input needs another call's result, not what kind of call it is** \u2014 edits are covered exactly as reads are, and it never authorizes weakening a verification gate or a review: fewer turns, never less work. The measured cost and the rejected mechanisms are in \`prompts/collaboration-workflow/turn-batching.md\`. If this turn was already batching, or the call genuinely has nothing to go beside it, reissue it as it was: this fires once per run of single-call turns and cannot repeat on the call in hand.`;
-var NOTICE = `\u{1F4A1} batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this Write makes ${String(CONSECUTIVE_LIMIT)} in a row. This is a notice, not a refusal \u2014 the write proceeds. Where the writes meant to follow it do not need its result, issue them in one turn together. **The criterion is whether a call's input needs another call's result, not what kind of call it is** \u2014 it never authorizes weakening a verification gate or a review: fewer turns, never less work. The measured cost and the rejected mechanisms are in \`prompts/collaboration-workflow/turn-batching.md\`. If this run was already batching, or the write genuinely has nothing to go beside it, carry on: this recurs every ${String(NOTICE_REFIRE_EVERY)} further single-call turn(s).`;
-var LANE_NOTICE = `\u{1F4A1} batching: the last ${String(SEQUENCE_BEFORE_LIMIT)} turns each issued a single tool call, so this one makes ${String(CONSECUTIVE_LIMIT)} in a row. This is a notice, not a refusal \u2014 the call proceeds, because a dispatched lane child ends its turn on a denial. Where the calls meant to follow it do not need its result, issue them in one turn together. **The criterion is whether a call's input needs another call's result, not what kind of call it is** \u2014 it never authorizes weakening a verification gate or a review: fewer turns, never less work. The measured cost and the rejected mechanisms are in \`prompts/collaboration-workflow/turn-batching.md\`. If this run was already batching, or the call genuinely has nothing to go beside it, carry on: this recurs every ${String(NOTICE_REFIRE_EVERY)} further single-call turn(s).`;
-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 ?? NONE3;
-}
-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 should_block(text, call, refused_at_ms, refire_every = REFIRE_EVERY) {
-  if (!is_guarded_call(call)) return false;
-  const { spans } = time_spans.parse_timeline(text);
-  if (is_reissued_refusal(spans, call)) return false;
-  return 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 recent_candidates(tail) {
-  const recent = time_bundles.open_sequence(time_spans.parse_timeline(tail).spans).slice(-NAMED_CANDIDATE_COUNT);
-  if (recent.length === NONE3) return "";
-  const named = recent.map((span) => describe_span(span)).join(", ");
-  const folds = `${read_fold_directive(recent)}${write_fold_directive(recent)}`;
-  return ` Just issued one per turn, so at least these could have shared a turn: ${named}.${folds}`;
-}
-var STAMP_PREFIX = "josh-batch-guard-";
-var NOTICE_STAMP_PREFIX = "josh-batch-guard-notice-";
-var time_batch_guard = {
-  CONSECUTIVE_LIMIT,
-  GUARD_LABEL,
-  LANE_NOTICE,
-  NAMED_CANDIDATE_COUNT,
-  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,
-  recent_candidates,
-  should_block,
-  should_notify
-};
-
-export {
-  lane_guard_policy,
-  time_batch_guard
-};

package/dist/hooks/chunk-4OHA5DE7.js

@@ -1,49 +0,0 @@
-import {
-  hook_decision,
-  time_batch_guard
-} from "./chunk-PXT44QVN.js";
-
-// scripts/hooks/batch-guard.ts
-import { text } from "node:stream/consumers";
-import { fileURLToPath } from "node:url";
-var SWITCH_ENV_KEY = "JOSH_BATCH_GUARD";
-function is_batch_candidate(call) {
-  return time_batch_guard.is_guarded_call(call) || time_batch_guard.is_notice_call(call);
-}
-var GUARD = hook_decision.create_transcript_guard({
-  prefix: time_batch_guard.STAMP_PREFIX,
-  switch_key: SWITCH_ENV_KEY,
-  is_candidate: is_batch_candidate,
-  should_block: time_batch_guard.should_block,
-  reason: time_batch_guard.REASON,
-  // The whole-file write is notified rather than refused, on a record of its own so it never spends
-  // the refusal's stamp (joshuafolkken/kit#1848).
-  notify: {
-    prefix: time_batch_guard.NOTICE_STAMP_PREFIX,
-    should_notify: time_batch_guard.should_notify,
-    text: time_batch_guard.NOTICE
-  }
-});
-var batch_refusal = GUARD.refusal;
-var batch_outcome = GUARD.outcome;
-var { is_enabled, refusal_path } = GUARD;
-var notice_refusal_path = hook_decision.create_refusal_stamp(
-  time_batch_guard.NOTICE_STAMP_PREFIX
-).path;
-var { deny_envelope, load_environment_file, DISABLED_VALUES } = hook_decision;
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  if (process.stdin.isTTY) hook_decision.report_no_payload("batch:guard");
-  else hook_decision.write_outcome(await text(process.stdin), batch_outcome);
-}
-
-export {
-  SWITCH_ENV_KEY,
-  batch_refusal,
-  batch_outcome,
-  is_enabled,
-  refusal_path,
-  notice_refusal_path,
-  deny_envelope,
-  load_environment_file,
-  DISABLED_VALUES
-};