@joshuafolkken/kit 1.3000.0 → 1.3044.0

package/dist/hooks/stop-guard.js

@@ -1,11 +1,9 @@
 #!/usr/bin/env tsx
 import {
-  JOSH_TMP_DIRECTORY,
   KIT_PACKAGE_NAME,
   MAX_SCANNED,
   OperationCancelledError,
   SUMMARY_FIELDS,
-  backlog_budget,
   backlog_overlap,
   epic_busy,
   gh_spawn,
@@ -13,11 +11,11 @@ import {
   git_error,
   git_gh_blocked_by_graphql,
   git_gh_command,
-  git_gh_issue_write,
   git_gh_pr_read,
   git_gh_pr_too_large,
   git_gh_repo,
   git_stash,
+  hook_launch,
   hook_ledger,
   issue_read,
   lane_background,
@@ -33,29 +31,25 @@ import {
   read_pull,
   review_attest,
   review_checkout,
-  run_cut,
-  run_cut_handoff,
   run_preflight,
   run_stage,
   stop_decision,
   stop_rules,
   tail_commands,
   turn_filings
-} from "./chunk-6RR6JZSB.js";
+} from "./chunk-OV22V63P.js";
 import {
   machine_capacity,
   resolve_tsx_runner,
   run_board_usage_rusage,
   toolchain_inputs
-} from "./chunk-P7BPAU26.js";
+} from "./chunk-IURJANNZ.js";
 import {
   find_local_bin_upwards,
   gate_labels,
-  hook_decision,
   issue_body_keys,
-  test_declared_logic,
-  time_hook_transcript
-} from "./chunk-CICKRHTB.js";
+  test_declared_logic
+} from "./chunk-AO4TOV4V.js";
 import {
   AUTO_OK_LABEL,
   BUGFIX_LABEL,
@@ -66,6 +60,7 @@ import {
   INTERRUPT_ROUTE_LABEL,
   IN_PROGRESS_LABEL,
   ISSUE_FIELDS,
+  JOSH_TMP_DIRECTORY,
   NEEDS_HUMAN_MERGE_LABEL,
   NOT_BEFORE_LABEL,
   NOT_DIRECTLY_RUNNABLE_LABELS,
@@ -82,6 +77,7 @@ import {
   SPLIT_ROUTE_LABEL,
   STATE_AND_RELATIONS_FIELDS,
   agent_headless,
+  backlog_budget,
   bounded_pool,
   detached_launch,
   gh_author_association,
@@ -91,6 +87,7 @@ import {
   git_gh_issue_graphql,
   git_gh_issue_read,
   git_gh_issue_rest,
+  git_gh_issue_write,
   git_gh_transport,
   has_any_label,
   has_label_name,
@@ -109,12 +106,14 @@ import {
   parse_json_object_or_undefined,
   read_json_listing,
   repo_party,
+  run_cut,
+  run_cut_handoff,
   run_headless,
   run_hold,
   run_liveness,
   shared_cache,
   token_shape
-} from "./chunk-LWD43Z3C.js";
+} from "./chunk-5CUXGQT6.js";
 import {
   ESLINT_RELATED_CACHE_FILE,
   ESLINT_RELATED_CACHE_FLAGS,
@@ -126,6 +125,7 @@ import {
   change_base,
   changed_paths,
   epic_issue_schema,
+  hook_decision,
   issue_citation,
   issue_cite,
   issue_label_schema,
@@ -146,8 +146,9 @@ import {
   session_cite,
   session_language,
   shell_quote,
+  time_hook_transcript,
   transcript_tail
-} from "./chunk-NUPVO7RI.js";
+} from "./chunk-G5WSPYJ6.js";
 import {
   timed_fetch
 } from "./chunk-U3ON2GBN.js";
@@ -1032,8 +1033,8 @@ function fence_mask(body) {
   });
 }
 function strip_fenced_blocks(body) {
-  const mask = fence_mask(body);
-  return body.split("\n").filter((_, index) => mask[index] === true).join("\n");
+  const mask2 = fence_mask(body);
+  return body.split("\n").filter((_, index) => mask2[index] === true).join("\n");
 }
 function to_issue_number(match) {
   const [, raw] = match;
@@ -1716,7 +1717,8 @@ var stop_schema = external_exports.object({
   cause: external_exports.string().optional(),
   preconditions: external_exports.array(external_exports.string()).optional(),
   findings: external_exports.array(external_exports.string()).optional(),
-  base: external_exports.string().optional()
+  base: external_exports.string().optional(),
+  checks: external_exports.array(external_exports.string()).optional()
 });
 var chain_schema = external_exports.object({
   kind: external_exports.literal(KIND3.CHAIN),
@@ -2830,11 +2832,14 @@ var BUDGET_MINUTES = {
   ship: 8,
   followup: 5
 };
+var TARGET_MINUTES = 30;
+var INTERNAL_MINUTES = Object.values(BUDGET_MINUTES).reduce((sum, minutes) => sum + minutes, 0);
+var DESCRIPTION = `target ${String(TARGET_MINUTES)} min dispatch to merge (human wait reported separately, included); internal stage budgets ${String(INTERNAL_MINUTES)} min (plan 3 + implement 9 + ship 8 + followup 5)`;
 function over_minutes(stage, elapsed_ms2) {
   const over_ms = elapsed_ms2 - BUDGET_MINUTES[stage] * MS_PER_MINUTE;
   return over_ms > 0 ? Math.ceil(over_ms / MS_PER_MINUTE) : void 0;
 }
-var lane_stage_budget = { BUDGET_MINUTES, over_minutes };
+var lane_stage_budget = { BUDGET_MINUTES, DESCRIPTION, TARGET_MINUTES, over_minutes };
 
 // scripts/split/declared-growth.ts
 var FALLBACK = 2;
@@ -2850,6 +2855,61 @@ function text(ratios2) {
 }
 var declared_growth = { FALLBACK, factor, text };
 
+// scripts/agent/codex-hooks.ts
+var CODEX_EDIT_TOOL = "apply_patch|functions.apply_patch";
+var CODEX_SHELL_TOOLS = "exec_command|functions.exec_command|exec|functions.exec";
+var TOOL_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse"]);
+var UNMATCHED_EVENTS = /* @__PURE__ */ new Set(["UserPromptSubmit"]);
+var JSON_INDENT = "	";
+var CLAUDE_SETTINGS_FILE = ".claude/settings.json";
+var CODEX_HOOKS_FILE = ".codex/hooks.json";
+var GENERATED_SOURCES = /* @__PURE__ */ new Map([
+  [CODEX_HOOKS_FILE, CLAUDE_SETTINGS_FILE]
+]);
+function adapter_command(mode) {
+  return hook_launch.hook_launch_command(`codex-hook-adapter ${mode}`, hook_launch.CODEX_ROOT);
+}
+var ADAPTED_COMMANDS = /* @__PURE__ */ new Map([
+  [hook_launch.hook_launch_command("pretool-guard"), adapter_command("pretool")],
+  [hook_launch.hook_launch_command("format-edited"), adapter_command("posttool")]
+]);
+function codex_handler(handler) {
+  const command = ADAPTED_COMMANDS.get(handler.command) ?? hook_launch.codex_command(handler.command);
+  return { ...handler, command };
+}
+function codex_matcher(event, matcher) {
+  if (UNMATCHED_EVENTS.has(event)) return void 0;
+  if (matcher !== void 0 && TOOL_EVENTS.has(event)) {
+    return `${matcher}|${CODEX_EDIT_TOOL}|${CODEX_SHELL_TOOLS}`;
+  }
+  return matcher;
+}
+function codex_group(event, group) {
+  const matcher = codex_matcher(event, group.matcher);
+  const hooks = group.hooks.map((handler) => codex_handler(handler));
+  return matcher === void 0 ? { hooks } : { matcher, hooks };
+}
+function codex_hook_config(claude) {
+  const events = Object.entries(claude.hooks).map(([event, groups]) => [
+    event,
+    groups.map((group) => codex_group(event, group))
+  ]);
+  return { hooks: Object.fromEntries(events) };
+}
+function codex_hooks_text(claude_settings_text) {
+  const claude = JSON.parse(claude_settings_text);
+  return `${JSON.stringify(codex_hook_config(claude), void 0, JSON_INDENT)}
+`;
+}
+var codex_hooks = {
+  adapter_command,
+  codex_hook_config,
+  codex_hooks_text,
+  CLAUDE_SETTINGS_FILE,
+  CODEX_HOOKS_FILE,
+  GENERATED_SOURCES
+};
+
 // scripts/git/git-path-quoting.ts
 var OCTAL_RADIX = 8;
 var OCTAL_WIDTH = 3;
@@ -2939,10 +2999,10 @@ function parse_row(row2) {
   return { path: path_parts.join("	"), changed_lines: parse_count(added) + parse_count(deleted) };
 }
 function parse_numstat(raw) {
-  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "").map((row2) => parse_row(row2)).filter((change) => change !== void 0);
+  return raw.split("\n").map((line) => line.trim()).filter((line) => line !== "").map((row2) => parse_row(row2)).filter((change2) => change2 !== void 0);
 }
-function is_deliverable(change) {
-  const file = git_path_quoting.unquote(change.path);
+function is_deliverable(change2) {
+  const file = git_path_quoting.unquote(change2.path);
   return !test_declared_logic.is_test_file(file) && !run_record_path.is_run_record(file);
 }
 function is_scripts_module(file) {
@@ -2964,11 +3024,14 @@ function partners_of(files, added) {
   return partners;
 }
 function units_of(files, added) {
-  const partners = partners_of(files, added);
-  return files.flatMap((file) => {
+  const artifacts = codex_hooks.GENERATED_SOURCES;
+  const sources = files.filter((file) => !files.includes(artifacts.get(file) ?? ""));
+  const partners = partners_of(sources, added);
+  return sources.flatMap((file) => {
     const partner = partners.get(file);
-    if (partner === void 0) return [[file]];
-    return files.indexOf(partner) < files.indexOf(file) ? [] : [[file, partner]];
+    const unit = partner === void 0 ? [file] : [file, partner];
+    const generated = files.filter((path15) => unit.includes(artifacts.get(path15) ?? ""));
+    return partner !== void 0 && sources.indexOf(partner) < sources.indexOf(file) ? [] : [[...unit, ...generated]];
   });
 }
 function verdict_for(files, lines2, guide = DEFAULT_GUIDE) {
@@ -2978,9 +3041,9 @@ function is_over_cap(files, lines2, guide = DEFAULT_GUIDE) {
   return files > guide.cap.files || lines2 > guide.cap.lines;
 }
 function measure(changes, guide, added = /* @__PURE__ */ new Set()) {
-  const runtime = changes.filter((change) => is_deliverable(change));
-  const lines2 = runtime.reduce((total2, change) => total2 + change.changed_lines, 0);
-  const paths = runtime.map((change) => git_path_quoting.unquote(change.path));
+  const runtime = changes.filter((change2) => is_deliverable(change2));
+  const lines2 = runtime.reduce((total2, change2) => total2 + change2.changed_lines, 0);
+  const paths = runtime.map((change2) => git_path_quoting.unquote(change2.path));
   const files = units_of(paths, added).length;
   return {
     files,
@@ -3052,8 +3115,10 @@ var split_assess = {
   SINGLE_VERDICT,
   assess,
   guide_for,
+  is_deliverable,
   is_over_cap,
   notice,
+  measure,
   parse_numstat,
   policy_text,
   reason,
@@ -5685,7 +5750,7 @@ function with_label2(labels, body, now = Date.now()) {
   return change_of(body, labels, now) === "add" ? [...labels, NOT_BEFORE_LABEL] : labels;
 }
 function changes_of(issues, now) {
-  return issues.flatMap(function change(issue) {
+  return issues.flatMap(function change2(issue) {
     const names = (issue.labels ?? []).map((label2) => label2.name);
     const owed = change_of(issue.body, names, now);
     return owed === void 0 ? [] : [[issue, owed]];
@@ -6223,6 +6288,7 @@ function causes_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)
@@ -6253,25 +6319,108 @@ function reason_row(reason2, waits2) {
     causes_cell(of_reason)
   ]);
 }
-function table4(entries, window, events = []) {
+function waits_in(entries, window, events = []) {
   const ends = ends_of(entries, parks_of(events));
-  const waits2 = waits_of(lane_stats.in_window(entries, window), ends, notices_of(entries));
+  return waits_of(lane_stats.in_window(entries, window), ends, notices_of(entries));
+}
+function table4(entries, window, events = []) {
+  const waits2 = waits_in(entries, window, events);
   return [
     lane_stats.to_row(COLUMNS5),
     lane_stats.to_row(COLUMNS5.map(() => "---")),
     ...REASONS.map((reason2) => reason_row(reason2, waits2))
   ].join("\n");
 }
-var lane_stop_stats = { REASONS, dispatches_of, ends_of, events_of, issue_of: issue_of2, table: table4, wait_ms };
+var lane_stop_stats = {
+  REASONS,
+  dispatches_of,
+  ends_of,
+  events_of,
+  issue_of: issue_of2,
+  table: table4,
+  total,
+  wait_ms,
+  waits_in
+};
 
-// scripts/lane/lane-net-time.ts
+// scripts/lane/lane-stage-events.ts
 var { EVENT_KIND: EVENT_KIND2 } = run_event_stream;
 var { PHASE, STAGE: STAGE3 } = run_ship_stage;
+var SHIP_STAGES = /* @__PURE__ */ new Set([
+  ...Object.values(STAGE3),
+  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_KIND2.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_KIND2.SHIP_STAGE && lane_stop_stats.issue_of(event) === issue;
+}
+function change(active, event) {
+  if (event.kind === EVENT_KIND2.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_KIND2.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_KIND3 } = run_event_stream;
+var { PHASE: PHASE2, STAGE: STAGE4 } = 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);
+  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;
@@ -6280,9 +6429,9 @@ function span_of(entries, issue) {
 }
 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)
+    ...lane_stop_stats.events_of(events, EVENT_KIND3.PARK),
+    ...lane_stop_stats.events_of(events, EVENT_KIND3.OUTAGE),
+    ...lane_stop_stats.events_of(events, EVENT_KIND3.USAGE_LIMIT)
   ];
 }
 function held_ms(hold, ends, to_ms) {
@@ -6322,7 +6471,7 @@ function slept(events, span) {
 function yield_spans(entries, events) {
   const yields = lane_stop_stats.events_of(
     events.filter((event) => lane_yield.is_yield_note(event)),
-    EVENT_KIND2.NOTE
+    EVENT_KIND3.NOTE
   );
   return lane_spans.issue_spans({
     starts: yields,
@@ -6337,7 +6486,7 @@ function run_start_ms(dispatches, split) {
   return start2?.at_ms ?? split.at_ms;
 }
 function split_spans(entries, events) {
-  const splits = lane_stop_stats.events_of(events, EVENT_KIND2.SPLIT);
+  const splits = lane_stop_stats.events_of(events, EVENT_KIND3.SPLIT);
   const dispatches = lane_stop_stats.dispatches_of(entries);
   const spans2 = lane_spans.issue_spans({ starts: splits, bounds: splits, ends: dispatches });
   return splits.map((split, index) => ({
@@ -6361,24 +6510,36 @@ function yielded(entries, events, issue, span) {
 function split_waits(entries, events, issue, span) {
   return cut_inside(split_spans(entries, events_of_issue(events, issue)), span);
 }
-function waits(entries, events, issue, span) {
+function waiting(entries, events, issue, span) {
   return joined([
     ...hold_waits(entries, events, issue, span),
     ...yielded(entries, events, issue, span),
-    ...split_waits(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 === PHASE.START;
+  return stage === STAGE4.FOLLOWUP && phase === PHASE2.START;
 }
 function followed(events, issue, span) {
-  const lines2 = 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);
+  const lines2 = events.filter((event) => event.kind === EVENT_KIND3.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 lines2.map((line, index) => ({ line, to_ms: lines2[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([...waits(entries, events, issue, span), ...followed(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);
@@ -6399,6 +6560,8 @@ function missing_reason(entries, issue) {
   return "cause unknown";
 }
 var lane_net_time = {
+  automatic_waits,
+  hold_waits,
   missing_reason,
   net_minutes,
   net_ms,
@@ -7128,16 +7291,16 @@ function with_dependants(children, held) {
   return grown2.size === held.size ? held : with_dependants(children, grown2);
 }
 function epic_classification(views, untrusted) {
-  const waiting = views.flatMap((view) => view.result.waiting);
+  const waiting2 = views.flatMap((view) => view.result.waiting);
   const offered = views.flatMap(
     (view) => view.result.candidates.flatMap((bundle) => bundle.children)
   );
-  const held = with_dependants(waiting, untrusted);
+  const held = with_dependants(waiting2, untrusted);
   const human = unique_children([
     ...views.flatMap((view) => view.result.blocked_on_people),
-    ...[...waiting, ...offered].filter((child) => held.has(epic_graph.key_of(child)))
+    ...[...waiting2, ...offered].filter((child) => held.has(epic_graph.key_of(child)))
   ]);
-  const time = without2(unique_children(waiting), keys_of2(human));
+  const time = without2(unique_children(waiting2), keys_of2(human));
   return {
     runnable: without2(unique_children(offered), keys_of2([...human, ...time])),
     time,
@@ -8874,6 +9037,20 @@ async function run_stall_check(ready = backlog_ready.DEFAULT_PORTS) {
 }
 var backlog_stalled_detect = { detect_and_report, observe_offerable, run_stall_check };
 
+// scripts/lib/home-tilde.ts
+import os from "node:os";
+var TILDE = "~";
+var ROOT = "/";
+var SEGMENT_CONTINUES = /^[\w.-]/u;
+function mask(text2) {
+  const home = os.homedir();
+  if (home === "" || home === ROOT) return text2;
+  const [head = "", ...rest] = text2.split(home);
+  const masked = rest.map((part) => `${SEGMENT_CONTINUES.test(part) ? home : TILDE}${part}`);
+  return `${head}${masked.join("")}`;
+}
+var home_tilde = { mask };
+
 // scripts/lib/stdout-on-stderr.ts
 function set_stdout_write(stream_write) {
   process.stdout.write = stream_write;
@@ -12522,7 +12699,7 @@ function notify_values(issue_url, action) {
   const { recommended, alternative } = action.decision;
   const values = {
     "task-type": "confirmation",
-    body: session_cite.text(summary_of(action.message)),
+    body: session_cite.text(summary_of(home_tilde.mask(action.message))),
     recommended,
     ...alternative !== void 0 && { alternative: [alternative] }
   };