@joshuafolkken/kit 1.872.0 → 1.879.0

package/dist/hooks/chunk-BODUSXKK.js

@@ -1,410 +0,0 @@
-import {
-  lane_child_marker
-} from "./chunk-GX4HO7SJ.js";
-import {
-  time_bundle_call,
-  time_format,
-  time_round_trips,
-  time_spans,
-  time_transcript_line
-} from "./chunk-ECXVCCVD.js";
-
-// scripts/lane/lane-guard-policy.ts
-var LANE_GUARD_POLICY = [
-  {
-    id: "investigation",
-    fires_in_lane_child: false,
-    because: "the child is itself the delegated unit the refusal asks for \u2014 it cannot dispatch a sub-unit to read its own edit targets, and the remedy the reason names does not exist for it, the same exemption a subagent transcript already gets in `should_block`"
-  },
-  {
-    id: "batching",
-    fires_in_lane_child: false,
-    because: "the reissue-in-one-turn correction presumes a main line that reshapes its next turn; a child doing dependent single reads of the files it is about to edit is not batching wrongly, and the refusal ends its turn instead of guiding it"
-  },
-  {
-    id: "rule",
-    fires_in_lane_child: true,
-    because: "it carries the lane-only rules a child depends on (`pre-gate-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"
-  }
-];
-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 fires_in_lane_child(id) {
-  return entry_for(id)?.fires_in_lane_child ?? true;
-}
-function is_suppressed_here(id, directory = process.cwd(), source = process.env) {
-  if (fires_in_lane_child(id)) return false;
-  return lane_child_marker.is_child_of(directory, source);
-}
-var lane_guard_policy = {
-  LANE_GUARD_POLICY,
-  KNOWN_GUARD_IDS,
-  entry_for,
-  fires_in_lane_child,
-  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 ONE_TURN = 1;
-var NONE3 = 0;
-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 fires once per run of single-call turns.`;
-var WHOLE_FILE_WRITE_TOOL = "Write";
-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 is_sequence_at_limit(sequence, facts, refused_at_ms) {
-  if (sequence.length < SEQUENCE_BEFORE_LIMIT || depends_on_sequence(sequence, facts)) return false;
-  return sequence_started_ms(sequence) > refused_at_ms;
-}
-function is_at_limit(spans, call, last_fired_ms) {
-  return is_sequence_at_limit(
-    time_bundles.open_sequence(spans),
-    time_bundle_call.call_facts(call.name, call.input),
-    last_fired_ms
-  );
-}
-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) {
-  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);
-}
-function should_notify(text, call, notified_at_ms) {
-  if (!is_notice_call(call)) return false;
-  return is_at_limit(time_spans.parse_timeline(text).spans, call, notified_at_ms);
-}
-var STAMP_PREFIX = "josh-batch-guard-";
-var NOTICE_STAMP_PREFIX = "josh-batch-guard-notice-";
-var time_batch_guard = {
-  CONSECUTIVE_LIMIT,
-  GUARD_LABEL,
-  NOTICE,
-  NOTICE_STAMP_PREFIX,
-  REASON,
-  SEQUENCE_BEFORE_LIMIT,
-  STAMP_PREFIX,
-  is_guarded_call,
-  is_notice_call,
-  is_read_only_call,
-  should_block,
-  should_notify
-};
-
-export {
-  lane_guard_policy,
-  time_batch_guard
-};