@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-2E6PSONB.js

@@ -0,0 +1,46 @@
+import {
+  run_handoff_launch
+} from "./chunk-2GA4775H.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  detached_launch
+} from "./chunk-HDVSZ6CZ.js";
+import {
+  durable_state
+} from "./chunk-DS53UUDH.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.js";
+
+// scripts/backlog/backlog-drive-unit.ts
+function log_path(git_directory, label, now) {
+  return durable_state.path(
+    durable_state.PREFIX.HANDOFF_LOG,
+    git_directory,
+    `-${label}-${String(now)}.log`
+  );
+}
+function request_of(prompt, launch, log) {
+  const selected = agent_provider.resolve_provider(launch.environment);
+  if (selected.kind === "rejected") return void 0;
+  const child = {
+    prompt,
+    role: agent_role_profile.SCHEDULER,
+    provider: selected.provider,
+    cwd: launch.cwd
+  };
+  const built = run_handoff_launch.argv_of(child, launch.environment);
+  if (built.kind === "rejected") return void 0;
+  return run_handoff_launch.request_of(built, launch.cwd, log);
+}
+async function launch_attached(request) {
+  return await detached_launch.launch_attached(request, (note) => process.stderr.write(`${note}
+`));
+}
+var backlog_drive_unit = { log_path, request_of, launch_attached };
+
+export {
+  backlog_drive_unit
+};

package/dist/commands/chunk-2GA4775H.js

@@ -0,0 +1,77 @@
+import {
+  backlogrun_launch
+} from "./chunk-QTQAI2M2.js";
+import {
+  agent_argv
+} from "./chunk-L7MDU6D7.js";
+import {
+  run_headless
+} from "./chunk-Q4ULMZAS.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  agent_safe_text
+} from "./chunk-3LZXX5GL.js";
+import {
+  durable_state
+} from "./chunk-DS53UUDH.js";
+
+// scripts/run/handoff/run-handoff-launch.ts
+var ROLES = {
+  kickoff: agent_role_profile.SCHEDULER,
+  fullrun: agent_role_profile.WORKER,
+  halfrun: agent_role_profile.WORKER,
+  prrun: agent_role_profile.WORKER,
+  retrospective: agent_role_profile.SCHEDULER
+};
+var ORIGIN_MARKER = "through `josh run:handoff`";
+var PREAMBLE = [
+  `Handed over by another session ${ORIGIN_MARKER}; the brief below is the work it hands over.`,
+  "Nobody answers this session: a question for the person ends it, written as the final message.",
+  "End the final message with the URL of every Issue and pull request this run created."
+].join(" ");
+function role_of(keyword) {
+  return ROLES[keyword];
+}
+function prompt_of(handoff, brief) {
+  return agent_safe_text.printable(`${handoff.line}
+
+${PREAMBLE}
+
+${brief.trim()}`);
+}
+function argv_of(child, environment = process.env) {
+  const chosen = backlogrun_launch.chosen_environment(child.provider, environment);
+  const resolved = agent_role_profile.resolve(child.role, chosen);
+  if (resolved.kind === "rejected") return resolved;
+  return agent_argv.with_profile_in(child.prompt, resolved.profile, child.cwd);
+}
+function log_path(git_directory, keyword, now) {
+  const suffix = `-${keyword}-${String(now)}.log`;
+  return durable_state.path(durable_state.PREFIX.HANDOFF_LOG, git_directory, suffix);
+}
+function request_of(built, cwd, log) {
+  const environment = {
+    ...run_headless.handoff_child_environment(),
+    [agent_role_profile.CODEX_SESSION_KEY]: void 0,
+    [agent_role_profile.HANDED_PROVIDER_KEY]: built.profile.provider
+  };
+  return { argv: built.argv, cwd, env: environment, log_path: log, profile: built.profile };
+}
+function is_waited(keyword) {
+  return keyword === "kickoff" || keyword === "retrospective";
+}
+var run_handoff_launch = {
+  ORIGIN_MARKER,
+  argv_of,
+  is_waited,
+  log_path,
+  prompt_of,
+  request_of,
+  role_of
+};
+
+export {
+  run_handoff_launch
+};

package/dist/commands/chunk-2O64H5UJ.js

@@ -0,0 +1,462 @@
+import {
+  lane_ledger_pinned_origin
+} from "./chunk-Y2RNUX4W.js";
+import {
+  run_startup_schema
+} from "./chunk-RV7EQIE4.js";
+import {
+  lane_ledger_kind,
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lane/lane-ledger-tail.ts
+import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
+
+// scripts/lane/lane-ledger-schema.ts
+import { z as z4 } from "zod";
+
+// scripts/lane/lane-ledger-schema-load.ts
+import { z } from "zod";
+var { KIND } = lane_ledger_kind;
+var process_kind_schema = z.object({
+  kind: z.string(),
+  cpu_percent: z.number(),
+  rss_mb: z.number(),
+  footprint_mb: z.number().optional(),
+  count: z.number()
+});
+var load_schema = z.object({
+  kind: z.literal(KIND.LOAD),
+  at: z.string(),
+  load: z.number(),
+  available_mb: z.number().optional(),
+  swapped_mb: z.number().optional(),
+  lanes: z.number().optional(),
+  // The heaviest process kinds at the instant of the sample (`lane-process-load.ts`), so the load the
+  // core budget's ledger does not explain can be read back by what made it (joshuafolkken/kit#3874).
+  processes: z.array(process_kind_schema).optional(),
+  // The resident apps' summed size (`lane_process_load.RESIDENT_APPS`, joshuafolkken/kit#5658).
+  resident_mb: z.number().optional(),
+  // The host's sleep since boot (`lane-load.ts`, joshuafolkken/kit#7026).
+  slept_ms: z.number().optional(),
+  // The boot and last-wake instants, epoch ms (`kern.boottime`, `kern.waketime`).
+  booted_ms: z.number().optional(),
+  woke_ms: z.number().optional()
+});
+var lane_ledger_schema_load = { load_schema };
+
+// scripts/lane/lane-ledger-schema-offer.ts
+import { z as z2 } from "zod";
+var { KIND: KIND2 } = lane_ledger_kind;
+var exclusion_schema = z2.object({ issue: z2.number(), reason: z2.string() });
+var offer_schema = z2.object({
+  kind: z2.literal(KIND2.OFFER),
+  at: z2.string(),
+  verdict: z2.string(),
+  seen: z2.array(z2.number()),
+  started: z2.array(z2.number()),
+  excluded: z2.array(exclusion_schema),
+  is_unchanged: z2.boolean()
+});
+var lane_ledger_schema_offer = { offer_schema };
+
+// scripts/lane/lane-ledger-schema-ship.ts
+import { z as z3 } from "zod";
+var { KIND: KIND3 } = lane_ledger_kind;
+var early_push_schema = z3.object({
+  kind: z3.literal(KIND3.EARLY_PUSH),
+  at: z3.string(),
+  issue: z3.number().optional(),
+  source: z3.enum(["review", "ship"]),
+  result: z3.string(),
+  head: z3.string().optional(),
+  slots: z3.number().optional()
+});
+var stop_schema = z3.object({
+  kind: z3.literal(KIND3.STOP),
+  at: z3.string(),
+  issue: z3.number(),
+  reason: z3.string(),
+  cause: z3.string().optional(),
+  preconditions: z3.array(z3.string()).optional(),
+  findings: z3.array(z3.string()).optional(),
+  base: z3.string().optional(),
+  checks: z3.array(z3.string()).optional()
+});
+var chain_schema = z3.object({
+  kind: z3.literal(KIND3.CHAIN),
+  at: z3.string(),
+  issue: z3.number(),
+  elapsed_ms: z3.number(),
+  join: z3.boolean(),
+  stage: z3.string().optional(),
+  reason: z3.enum(["exit", "hold"]).optional()
+});
+var unplanned_notice_schema = z3.object({
+  kind: z3.literal(KIND3.UNPLANNED_NOTICE),
+  at: z3.string(),
+  issue: z3.number(),
+  files: z3.array(z3.string())
+});
+var ship_lap_schema = z3.object({
+  kind: z3.literal(KIND3.SHIP_LAP),
+  at: z3.string(),
+  issue: z3.number(),
+  stage: z3.string(),
+  step: z3.string(),
+  elapsed_ms: z3.number(),
+  fallback: z3.string().optional(),
+  runs: z3.number().optional(),
+  rerun: z3.string().optional(),
+  reused_tree: z3.string().optional(),
+  is_reused: z3.boolean().optional(),
+  named: z3.number().optional(),
+  unsplit: z3.string().optional()
+});
+var counts_schema = z3.object({ files: z3.number(), lines: z3.number() });
+var size_schema = z3.object({
+  kind: z3.literal(KIND3.SIZE),
+  at: z3.string(),
+  issue: z3.number(),
+  declared: counts_schema,
+  actual: counts_schema,
+  missed: z3.boolean().optional()
+});
+var lane_ledger_schema_ship = {
+  chain_schema,
+  early_push_schema,
+  ship_lap_schema,
+  size_schema,
+  stop_schema,
+  unplanned_notice_schema
+};
+
+// scripts/lane/lane-ledger-schema.ts
+var { KIND: KIND4 } = lane_ledger_kind;
+var { early_push_schema: early_push_schema2, ship_lap_schema: ship_lap_schema2, size_schema: size_schema2, stop_schema: stop_schema2, unplanned_notice_schema: unplanned_notice_schema2 } = lane_ledger_schema_ship;
+var { pinned_origin_schema } = lane_ledger_pinned_origin;
+var { load_schema: load_schema2 } = lane_ledger_schema_load;
+var merge_schema = z4.object({ kind: z4.literal(KIND4.MERGE), at: z4.string(), issue: z4.number() });
+var check_schema = z4.object({
+  label: z4.string(),
+  elapsed_ms: z4.number(),
+  is_passed: z4.boolean(),
+  is_reused: z4.boolean().optional(),
+  // The CPU milliseconds the check's process tree spent, so a core weight can be re-measured from
+  // the ledger (joshuafolkken/kit#4362). Absent where the gate could not read it (off macOS).
+  cpu_ms: z4.number().optional(),
+  // Why the unit leg ran the whole suite instead of the related tests — a stable kind, never the
+  // file it names (joshuafolkken/kit#4397). Absent when it narrowed, and on every other check.
+  fallback: z4.string().optional(),
+  // The unit leg's since-green no-op: nothing moved, so it ran no test (joshuafolkken/kit#4457).
+  is_unmoved: z4.boolean().optional(),
+  // The width the check asked the core budget for, the width it ran at and how long it waited, so a
+  // unit claim's wait for room is read per run (joshuafolkken/kit#4451). Absent on a check that
+  // claimed none — a reused one, or one inside another gate's claim.
+  claim: z4.object({ requested: z4.number(), granted: z4.number(), waited_ms: z4.number() }).optional()
+});
+var gate_schema = z4.object({
+  kind: z4.literal(KIND4.GATE),
+  at: z4.string(),
+  elapsed_ms: z4.number(),
+  is_passed: z4.boolean(),
+  // The unit suite's own duration, present when this gate ran it — the one
+  // record of a full vitest run `josh metrics` reads, so the suite is never timed twice.
+  unit_ms: z4.number().optional(),
+  // The whole cores busy outside this gate, beyond the machine's baseline, at its start or its end —
+  // whichever was higher. Absent when the machine could not be read.
+  external_cores: z4.number().optional(),
+  // Each check's own duration and verdict, so `josh lane:stats` can name the check a slow gate waited
+  // on. A reused check started no process: its row says so, and its zero is no timing.
+  checks: z4.array(check_schema).optional(),
+  // A gate that reused a green record for this tree and base and started no check: counted, never
+  // timed (joshuafolkken/kit#4397).
+  is_reused: z4.boolean().optional(),
+  // The lane the gate ran in, so `josh lane:breakdown` puts its checks under the lane's ship gate;
+  // absent outside a lane and on a row written before it (joshuafolkken/kit#5319).
+  issue: z4.number().optional()
+});
+var dispatch_schema = z4.object({
+  kind: z4.literal(KIND4.DISPATCH),
+  at: z4.string(),
+  issue: z4.number()
+});
+var stage_schema = z4.object({
+  kind: z4.literal(KIND4.STAGE),
+  at: z4.string(),
+  stage: z4.string(),
+  elapsed_ms: z4.number(),
+  issue: z4.number().optional(),
+  last_check: z4.string().optional(),
+  check_ms: z4.record(z4.string(), z4.number()).optional(),
+  has_rerun: z4.literal(true).optional()
+});
+var overlap_schema = z4.object({
+  kind: z4.literal(KIND4.OVERLAP),
+  at: z4.string(),
+  issue: z4.number(),
+  lanes: z4.array(z4.number()),
+  paths: z4.array(z4.string()),
+  waited_ms: z4.number(),
+  is_cleared: z4.boolean()
+});
+var held_schema = z4.object({
+  kind: z4.literal(KIND4.HELD),
+  at: z4.string(),
+  reason: z4.string(),
+  waiting: z4.array(z4.number()).optional()
+});
+var released_schema = z4.object({ kind: z4.literal(KIND4.RELEASED), at: z4.string() });
+var lane_state_schema = z4.object({
+  kind: z4.literal(KIND4.LANE_STATE),
+  at: z4.string(),
+  issue: z4.number(),
+  state: z4.enum(["paused", "running"])
+});
+var round_one_schema = z4.object({
+  kind: z4.literal(KIND4.ROUND_ONE),
+  at: z4.string(),
+  issue: z4.number(),
+  verdict: z4.string()
+});
+var round_two_schema = z4.object({
+  kind: z4.literal(KIND4.ROUND_TWO),
+  at: z4.string(),
+  issue: z4.number(),
+  verdict: z4.string(),
+  code: z4.string()
+});
+var offerable_schema = z4.object({
+  kind: z4.literal(KIND4.OFFERABLE),
+  at: z4.string(),
+  is_offerable: z4.boolean()
+});
+var core_wait_schema = z4.object({
+  kind: z4.enum([KIND4.CORE_WAIT, KIND4.CORE_ADMISSION]),
+  at: z4.string(),
+  command: z4.string(),
+  waited_ms: z4.number(),
+  issue: z4.number().optional(),
+  admission_reason: z4.string().optional(),
+  overflow: z4.boolean().optional(),
+  budget_cores: z4.number().optional(),
+  budget_memory_mb: z4.number().optional(),
+  available_mb: z4.number().optional(),
+  busy_cores: z4.number().optional(),
+  requested_cores: z4.number().optional(),
+  granted_cores: z4.number().optional(),
+  memory_mb: z4.number().optional(),
+  wait_reason: z4.string().optional(),
+  admission_waited_ms: z4.number().optional(),
+  memory_pressured: z4.boolean().optional()
+});
+var unit_file_schema = z4.object({ file: z4.string(), elapsed_ms: z4.number() });
+var unit_files_schema = z4.object({
+  kind: z4.literal(KIND4.UNIT_FILES),
+  at: z4.string(),
+  files: z4.array(unit_file_schema)
+});
+var test_related_schema = z4.object({
+  reused: z4.number().optional(),
+  reuse_missed: z4.number().optional(),
+  reuse_reason: z4.string().optional(),
+  reuse_elapsed_ms: z4.number().optional(),
+  select_elapsed_ms: z4.number().optional(),
+  kind: z4.literal(KIND4.TEST_RELATED),
+  at: z4.string(),
+  issue: z4.number().optional(),
+  scope: z4.string(),
+  changed: z4.number(),
+  synced: z4.number(),
+  since_map: z4.number(),
+  readers: z4.number(),
+  test_files: z4.number().optional(),
+  trigger_files: z4.array(z4.string()).optional(),
+  // The changed files past the reach cap, run by their direct importers alone (joshuafolkken/kit#5532).
+  over_cap: z4.number().optional(),
+  // The widest of them in the run's own change, the hub that put the run past the cap
+  // (joshuafolkken/kit#5699); absent when main or the map's tree brought them all (joshuafolkken/kit#5756).
+  over_cap_hub: z4.string().optional(),
+  // The branch change read beside the run, by half and by base (joshuafolkken/kit#6982).
+  branch_tracked: z4.number().optional(),
+  branch_untracked: z4.number().optional(),
+  branch_base: z4.enum(["merge_base", "fallback"]).optional(),
+  // `changed` split by whether that branch change holds the file (joshuafolkken/kit#7066).
+  changed_in_branch: z4.number().optional(),
+  changed_off_branch: z4.number().optional(),
+  elapsed_ms: z4.number()
+});
+var test_pinned_probe_schema = z4.object({
+  file: z4.string(),
+  tests: z4.number().optional(),
+  elapsed_ms: z4.number(),
+  pinned_by: z4.literal("type-check").optional()
+});
+var test_pinned_schema = z4.object({
+  kind: z4.literal(KIND4.TEST_PINNED),
+  at: z4.string(),
+  issue: z4.number().optional(),
+  held: z4.number(),
+  rewired: z4.number().optional(),
+  over_cap: z4.number().optional(),
+  probes: z4.array(test_pinned_probe_schema),
+  elapsed_ms: z4.number(),
+  origin: pinned_origin_schema.optional(),
+  discarded: z4.boolean().optional()
+});
+var split_notice_schema = z4.object({
+  kind: z4.literal(KIND4.SPLIT_NOTICE),
+  at: z4.string(),
+  issue: z4.number(),
+  files: z4.number(),
+  lines: z4.number(),
+  reason: z4.enum(["files", "hunks", "lines", "hub", "budget"]).optional()
+});
+var split_filed_schema = z4.object({
+  kind: z4.literal(KIND4.SPLIT_FILED),
+  at: z4.string(),
+  issue: z4.number(),
+  child: z4.string()
+});
+var push_miss_schema = z4.object({
+  kind: z4.literal(KIND4.PUSH_MISS),
+  at: z4.string(),
+  scope: z4.enum(["whole", "related"]),
+  reason: z4.string()
+});
+var limit_schema = z4.object({ kind: z4.literal(KIND4.LIMIT), at: z4.string(), limit: z4.number() });
+var entry_schema = z4.discriminatedUnion("kind", [
+  early_push_schema2,
+  run_startup_schema.entry_schema,
+  merge_schema,
+  gate_schema,
+  load_schema2,
+  dispatch_schema,
+  stage_schema,
+  stop_schema2,
+  lane_ledger_schema_ship.chain_schema,
+  overlap_schema,
+  held_schema,
+  released_schema,
+  round_one_schema,
+  round_two_schema,
+  offerable_schema,
+  lane_ledger_schema_offer.offer_schema,
+  core_wait_schema,
+  unit_files_schema,
+  test_related_schema,
+  test_pinned_schema,
+  split_notice_schema,
+  split_filed_schema,
+  unplanned_notice_schema2,
+  lane_state_schema,
+  push_miss_schema,
+  ship_lap_schema2,
+  size_schema2,
+  limit_schema
+]);
+var lane_ledger_schema = { entry_schema };
+
+// scripts/lane/lane-ledger-tail.ts
+var { entry_schema: entry_schema2 } = lane_ledger_schema;
+var { LINE_SEPARATOR } = lane_ledger_write;
+var EMPTY = [];
+var { O_NOFOLLOW, O_RDONLY } = constants;
+var READ_FLAGS = O_RDONLY | O_NOFOLLOW;
+function parse_line(line) {
+  return entry_schema2.safeParse(json_value.parse_or_undefined(line)).data;
+}
+function is_present(entry) {
+  return entry !== void 0;
+}
+function parse_text(text) {
+  return text.split(LINE_SEPARATOR).map((line) => parse_line(line.trim())).filter(is_present);
+}
+function snapshot_of(stat) {
+  return { ino: stat.ino, size: stat.size, mtime_ms: stat.mtimeMs };
+}
+function is_unchanged(previous, snapshot) {
+  const { ino, size, mtime_ms } = snapshot;
+  return previous.ino === ino && previous.size === size && previous.mtime_ms === mtime_ms;
+}
+function base_of(previous, snapshot) {
+  if (previous === void 0) return void 0;
+  return previous.ino === snapshot.ino && previous.size < snapshot.size ? previous : void 0;
+}
+function grow(base, snapshot, from, bytes) {
+  const end = bytes.lastIndexOf(LINE_SEPARATOR) + 1;
+  const lines = [...base?.lines ?? EMPTY, ...parse_text(bytes.toString("utf8", 0, end))];
+  const fragment = parse_text(bytes.toString("utf8", end));
+  const entries = fragment.length === 0 ? lines : [...lines, ...fragment];
+  return { ...snapshot, size: from + bytes.length, offset: from + end, lines, entries };
+}
+function next_tail(descriptor, snapshot, previous) {
+  if (previous !== void 0 && is_unchanged(previous, snapshot)) return previous;
+  const base = base_of(previous, snapshot);
+  const from = base?.offset ?? 0;
+  const bytes = Buffer.alloc(snapshot.size - from);
+  const length = readSync(descriptor, bytes, 0, bytes.length, from);
+  return grow(base, snapshot, from, bytes.subarray(0, length));
+}
+function read_tail(path, previous) {
+  try {
+    if (!stamp_file.is_own_regular_file(path)) return void 0;
+    const descriptor = openSync(path, READ_FLAGS);
+    try {
+      return next_tail(descriptor, snapshot_of(fstatSync(descriptor)), previous);
+    } finally {
+      closeSync(descriptor);
+    }
+  } catch {
+    return void 0;
+  }
+}
+var tails = /* @__PURE__ */ new Map();
+function read(path) {
+  const tail = read_tail(path, tails.get(path));
+  if (tail === void 0) {
+    tails.delete(path);
+    return EMPTY;
+  }
+  tails.set(path, tail);
+  return tail.entries;
+}
+var lane_ledger_tail = { read };
+
+// scripts/lane/lane-ledger.ts
+function read_entries(path) {
+  return lane_ledger_tail.read(path);
+}
+var {
+  CI_WAIT_STAGE,
+  CODERABBIT_RATE_LIMIT_STAGE,
+  CODERABBIT_RETRIGGER_STAGE,
+  CODERABBIT_WAIT_STAGE,
+  KIND: KIND5,
+  PRE_DETACH_STAGE,
+  ROUND_ONE_REUSED,
+  target,
+  target_of
+} = lane_ledger_write;
+var lane_ledger = {
+  CI_WAIT_STAGE,
+  CODERABBIT_RATE_LIMIT_STAGE,
+  CODERABBIT_RETRIGGER_STAGE,
+  CODERABBIT_WAIT_STAGE,
+  KIND: KIND5,
+  PRE_DETACH_STAGE,
+  ROUND_ONE_REUSED,
+  read_entries,
+  target,
+  target_of
+};
+
+export {
+  lane_ledger
+};