@joshuafolkken/kit 1.3101.0 → 1.3125.0

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

@@ -1,46 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,462 +0,0 @@
-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
-};