@joshuafolkken/kit 1.872.0 → 1.881.0

package/dist/hooks/chunk-GIMRTKFU.js

@@ -1,566 +0,0 @@
-import {
-  stamp_file,
-  time_bundle_call,
-  time_density_hook,
-  time_format,
-  time_hook_transcript,
-  time_round_trips,
-  time_spans,
-  time_transcript_line
-} from "./chunk-QVCRG34O.js";
-import {
-  josh_environment_file
-} from "./chunk-ITVJ2MKQ.js";
-
-// scripts/josh/hook-decision.ts
-import { z } from "zod";
-var payload_schema = z.object({
-  transcript_path: z.string().min(1),
-  // **`nullish`, not `optional`.** A payload spelling the absent agent as `null` has to read as "no
-  // fork"; rejected, it would fail `safeParse` for the whole payload and take the guard off every
-  // call of the main line, in silence — the failure every other path here is written to avoid.
-  agent_id: z.string().nullish(),
-  tool_name: z.string().min(1),
-  tool_input: z.unknown()
-});
-var refusal_schema = z.object({ refused_at_ms: z.number() });
-var HOOK_EVENT_NAME = "PreToolUse";
-var DENY_DECISION = "deny";
-var NEVER_MS = 0;
-var MISSING_FILE = "ENOENT";
-var DISABLED_VALUES = ["off", "0", "false", "no"];
-function is_switch_enabled(key) {
-  return !DISABLED_VALUES.includes((process.env[key] ?? "").trim().toLowerCase());
-}
-function parse_hook_payload(raw_payload) {
-  const parsed = payload_schema.safeParse(JSON.parse(raw_payload));
-  return parsed.success ? parsed.data : void 0;
-}
-function deny_envelope(reason) {
-  return JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: HOOK_EVENT_NAME,
-      permissionDecision: DENY_DECISION,
-      permissionDecisionReason: reason
-    }
-  });
-}
-function notice_envelope(notice) {
-  return JSON.stringify({
-    systemMessage: notice,
-    hookSpecificOutput: { hookEventName: HOOK_EVENT_NAME, additionalContext: notice }
-  });
-}
-function stamp_fault(switch_key) {
-  return `\u26A0 ${switch_key}: the run is past the limit but the refusal stamp could not be written, so this call was allowed rather than refused. Without the stamp a refusal could repeat and wedge the run. Batch the calls that do not need each other anyway, and check the temp directory is writable.`;
-}
-function is_missing_file(error) {
-  if (!(error instanceof Error) || !("code" in error)) return false;
-  return typeof error.code === "string" && error.code === MISSING_FILE;
-}
-function error_text(error) {
-  if (error instanceof Error) return error.message;
-  return typeof error === "string" ? error : "a value that is not an error";
-}
-function fault_notice(switch_key, error) {
-  if (is_missing_file(error)) return void 0;
-  const detail = error_text(error);
-  return `\u26A0 ${switch_key}: the guard could not read the run's history, so this call was allowed without being checked \u2014 silence here is not evidence that the run is batching. Cause: ${detail}`;
-}
-function last_refusal_ms(target) {
-  const raw = stamp_file.read_stamp_text(target);
-  if (raw === void 0) return NEVER_MS;
-  try {
-    return refusal_schema.parse(JSON.parse(raw)).refused_at_ms;
-  } catch {
-    return NEVER_MS;
-  }
-}
-function record_refusal(target, now_ms) {
-  try {
-    stamp_file.write_stamp(target, { refused_at_ms: now_ms });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function create_refusal_stamp(prefix) {
-  function path(transcript_path) {
-    return stamp_file.stamp_path(prefix, transcript_path);
-  }
-  return { path, last_ms: last_refusal_ms, record: record_refusal };
-}
-var { load_environment_file } = josh_environment_file;
-var NO_OUTCOME = { reason: void 0, notice: void 0, fault: void 0 };
-function fire_once(stamp, run, should_fire, switch_key) {
-  const target = stamp.path(run.transcript);
-  if (!should_fire(stamp.last_ms(target))) return { fired: false, fault: void 0 };
-  if (!stamp.record(target, run.now_ms)) return { fired: false, fault: stamp_fault(switch_key) };
-  return { fired: true, fault: void 0 };
-}
-function block_outcome(context) {
-  const { spec, stamp, tail, call, run } = context;
-  const result = fire_once(
-    stamp,
-    run,
-    (last_fired_ms) => spec.should_block(tail, call, last_fired_ms, run),
-    spec.switch_key
-  );
-  if (result.fired) return { reason: spec.reason, notice: void 0, fault: void 0 };
-  return { reason: void 0, notice: void 0, fault: result.fault };
-}
-function notify_outcome(context) {
-  const { spec, notify_stamp, tail, call, run } = context;
-  if (notify_stamp === void 0 || spec.notify === void 0) return NO_OUTCOME;
-  const { notify } = spec;
-  const result = fire_once(
-    notify_stamp,
-    run,
-    (last_fired_ms) => notify.should_notify(tail, call, last_fired_ms, run),
-    spec.switch_key
-  );
-  if (result.fired) return { reason: void 0, notice: notify.text, fault: void 0 };
-  return { reason: void 0, notice: void 0, fault: result.fault };
-}
-function is_clear(outcome) {
-  return outcome.reason === void 0 && outcome.notice === void 0 && outcome.fault === void 0;
-}
-function guard_reason_for_payload(parts, payload, now_ms) {
-  const call = { name: payload.tool_name, input: payload.tool_input };
-  if (!parts.spec.is_candidate(call)) return NO_OUTCOME;
-  const transcript = time_hook_transcript.transcript_of(payload.transcript_path, payload.agent_id);
-  const tail = time_density_hook.read_tail(transcript);
-  const context = { ...parts, tail, call, run: { transcript, now_ms } };
-  const blocked = block_outcome(context);
-  if (!is_clear(blocked)) return blocked;
-  return notify_outcome(context);
-}
-function guard_outcome(parts, raw_payload, now_ms) {
-  const payload = parse_hook_payload(raw_payload);
-  if (payload === void 0 || !is_switch_enabled(parts.spec.switch_key)) return NO_OUTCOME;
-  return guard_reason_for_payload(parts, payload, now_ms);
-}
-function create_transcript_guard(spec) {
-  const stamp = create_refusal_stamp(spec.prefix);
-  const notify_stamp = spec.notify ? create_refusal_stamp(spec.notify.prefix) : void 0;
-  const parts = { spec, stamp, notify_stamp };
-  function is_enabled() {
-    return is_switch_enabled(spec.switch_key);
-  }
-  function refusal_path(transcript_path) {
-    return stamp.path(transcript_path);
-  }
-  function outcome(raw_payload, now_ms = Date.now()) {
-    try {
-      return guard_outcome(parts, raw_payload, now_ms);
-    } catch (error) {
-      return { reason: void 0, notice: void 0, fault: fault_notice(spec.switch_key, error) };
-    }
-  }
-  function refusal(raw_payload, now_ms = Date.now()) {
-    return outcome(raw_payload, now_ms).reason;
-  }
-  return { is_enabled, outcome, refusal, refusal_path };
-}
-function write_outcome(raw_payload, outcome) {
-  load_environment_file();
-  const { reason, notice, fault } = outcome(raw_payload);
-  if (reason !== void 0) process.stdout.write(`${deny_envelope(reason)}
-`);
-  else if (notice !== void 0) process.stdout.write(`${notice_envelope(notice)}
-`);
-  else if (fault !== void 0) process.stdout.write(`${notice_envelope(fault)}
-`);
-}
-function write_decision(raw_payload, refusal) {
-  write_outcome(raw_payload, (raw) => ({
-    reason: refusal(raw),
-    notice: void 0,
-    fault: void 0
-  }));
-}
-function report_no_payload(command) {
-  process.stderr.write(
-    `${command} reads a Claude Code PreToolUse payload on stdin; it is not run by hand.
-`
-  );
-}
-var hook_decision = {
-  DISABLED_VALUES,
-  NEVER_MS,
-  create_refusal_stamp,
-  create_transcript_guard,
-  deny_envelope,
-  fault_notice,
-  is_switch_enabled,
-  load_environment_file,
-  notice_envelope,
-  parse_hook_payload,
-  report_no_payload,
-  stamp_fault,
-  write_decision,
-  write_outcome
-};
-
-// 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) return false;
-  if (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) return false;
-  if (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 {
-  hook_decision,
-  time_batch_guard
-};