@joshuafolkken/kit 1.3101.0 → 1.3125.0

package/dist/commands/chunk-CFLCZ2WO.js

@@ -0,0 +1,63 @@
+import {
+  durable_state
+} from "./chunk-JSJS3OT7.js";
+import {
+  agent_provider
+} from "./chunk-DDZVMXZD.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/run/carry/run-carry-ended.ts
+import path from "node:path";
+import { z } from "zod";
+var ENDED_PREFIX = durable_state.PREFIX.ENDED;
+var TRANSCRIPT_SUFFIX = ".jsonl";
+var ended_run_schema = z.object({
+  scheduler_provider: agent_provider.PROVIDER_SCHEMA.optional(),
+  invocation: z.string(),
+  started_at: z.string(),
+  ended_at: z.string(),
+  stopped: z.string().optional(),
+  session: z.string().optional()
+});
+function ended_path(git_directory) {
+  return durable_state.path(ENDED_PREFIX, git_directory);
+}
+function session_of(transcript) {
+  return transcript === void 0 ? void 0 : path.basename(transcript, TRANSCRIPT_SUFFIX);
+}
+function stop_of(transcript, stopped) {
+  return stopped === void 0 ? {} : { stopped, session: session_of(transcript) };
+}
+function record_ended(target, read, now = /* @__PURE__ */ new Date(), stopped) {
+  if (read.kind !== "carried") return;
+  const { invocation, started_at, owner_transcript } = read.carry;
+  const ended_at = now.toISOString();
+  stamp_file.replace_stamp(target, {
+    ...read.carry.scheduler_provider && { scheduler_provider: read.carry.scheduler_provider },
+    invocation,
+    started_at,
+    ended_at,
+    ...stop_of(owner_transcript, stopped)
+  });
+}
+function parse_ended(raw) {
+  return json_value.parse_with(raw, ended_run_schema);
+}
+function read_ended(target) {
+  const raw = stamp_file.read_stamp_text(target);
+  return raw === void 0 ? void 0 : parse_ended(raw);
+}
+function has_ended(target, started_at) {
+  const ended = read_ended(target);
+  return ended !== void 0 && ended.started_at === started_at;
+}
+var run_carry_ended = { ended_path, has_ended, read_ended, record_ended };
+
+export {
+  run_carry_ended
+};

package/dist/commands/chunk-CGA2K3XV.js

@@ -0,0 +1,137 @@
+import {
+  lane_implement_signals
+} from "./chunk-CXFN5W7O.js";
+import {
+  run_event_step
+} from "./chunk-NQFQVSHV.js";
+import {
+  run_hold_cli
+} from "./chunk-IQMMYORJ.js";
+import {
+  lane_breakdown_implement,
+  lane_transcript_stats
+} from "./chunk-UWLANGIR.js";
+import {
+  lane_plan
+} from "./chunk-JUQN3OXG.js";
+import {
+  run_stage
+} from "./chunk-UWLLZQJB.js";
+import {
+  run_step
+} from "./chunk-C3V6H6TW.js";
+import {
+  run_event_stream_emit
+} from "./chunk-XO7S2BTY.js";
+import {
+  run_event_stream
+} from "./chunk-373P5MM2.js";
+
+// scripts/run/entry/run-entry.ts
+var SUMMARY_PREFIX = "entry #";
+var SUMMARY_DASH = " \u2014 ";
+var FIELD_SEPARATOR = " \xB7 ";
+var HOLD_LABEL = "hold: ";
+var COST_LABEL = "cost: ";
+var VERDICT_LABEL = "verdict: ";
+var SECTION_SEPARATOR = "\n\n";
+var COST_UNDER = "under";
+var COST_OVER = "over";
+var COST_SKIPPED = "skipped";
+var NO_VERDICT = "-";
+var GATE_VERDICT = "gate";
+var SUCCESS_EXIT_CODE = 0;
+var FAILURE_EXIT_CODE = 1;
+function summary(parts) {
+  const fields = [
+    `${HOLD_LABEL}${parts.hold}`,
+    `${COST_LABEL}${parts.cost}`,
+    `${VERDICT_LABEL}${parts.verdict}`
+  ];
+  return `${SUMMARY_PREFIX}${parts.issue_number}${SUMMARY_DASH}${fields.join(FIELD_SEPARATOR)}`;
+}
+function format_report(parts) {
+  return [summary(parts), parts.report].join(SECTION_SEPARATOR);
+}
+function can_proceed(hold, cost) {
+  return hold === run_hold_cli.HOLD_VERDICT && cost !== COST_OVER;
+}
+function exit_code(parts) {
+  const is_ok = can_proceed(parts.hold, parts.cost) && parts.verdict !== run_step.UNKNOWN;
+  return is_ok ? SUCCESS_EXIT_CODE : FAILURE_EXIT_CODE;
+}
+function stage_verdict(state, verdict) {
+  return state === run_stage.PR_OPEN && verdict === run_step.IMPLEMENT ? GATE_VERDICT : verdict;
+}
+var run_entry = {
+  COST_OVER,
+  COST_SKIPPED,
+  COST_UNDER,
+  GATE_VERDICT,
+  NO_VERDICT,
+  exit_code,
+  format_report,
+  can_proceed,
+  summary,
+  stage_verdict
+};
+
+// scripts/lane/lane-implement-signals-record.ts
+function lane_calls(issue) {
+  const directories = lane_breakdown_implement.transcript_directories(issue);
+  return lane_transcript_stats.read_calls(directories, { since_ms: 0, until_ms: Date.now() });
+}
+function planned_paths(issue) {
+  const plan = lane_plan.read(issue, process.cwd());
+  return [...plan?.paths ?? [], ...plan?.cleared_paths ?? []];
+}
+var STREAM_IO = {
+  read: run_event_stream_emit.all_events,
+  emit: run_event_stream_emit.emit,
+  calls: lane_calls,
+  planned: planned_paths,
+  root: process.cwd()
+};
+async function record(issue, io = STREAM_IO) {
+  const number = Number(issue);
+  const events = await io.read();
+  if (events.some((event) => lane_implement_signals.is_signals_of(event, number))) return;
+  const signals = lane_implement_signals.counts_of(io.calls(number), io.planned(number), io.root);
+  await io.emit(lane_implement_signals.KIND, lane_implement_signals.text_of(issue, signals));
+}
+var lane_implement_signals_record = { record };
+
+// scripts/run/run-step-progress.ts
+var { STEP } = run_event_step;
+var KIND = run_event_stream.EVENT_KIND;
+var VERDICT_STEPS = {
+  [run_step.UPDATE_DEPS]: STEP.UPDATE_DEPS,
+  [run_step.IMPLEMENT]: STEP.IMPLEMENT,
+  [run_step.HUMAN_REVIEW]: STEP.IMPLEMENT,
+  [run_entry.GATE_VERDICT]: STEP.GATE
+};
+var EVENT_STEPS = {
+  [KIND.REVIEW_ROUND]: STEP.GATE,
+  [KIND.PR_OPENED]: STEP.FOLLOWUP
+};
+function step_of(line, last_event = "") {
+  return VERDICT_STEPS[line] ?? EVENT_STEPS[last_event];
+}
+var STREAM_IO2 = {
+  step: async (issue, step) => {
+    await run_event_step.record(issue, step);
+  },
+  signals: lane_implement_signals_record.record
+};
+async function record2(issue, line, last_event, io = STREAM_IO2) {
+  const step = step_of(line, last_event);
+  if (step === void 0) return;
+  await io.step(issue, step);
+  if (step === STEP.GATE) await io.signals(issue);
+}
+var run_step_progress = { record: record2, step_of };
+
+export {
+  run_entry,
+  run_step_progress
+};

package/dist/commands/chunk-CHQQ3VTL.js

@@ -0,0 +1,184 @@
+import {
+  lane_instructions
+} from "./chunk-SCCUBRDO.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+
+// scripts/agent/agent-diagnostics.ts
+import { spawnSync } from "node:child_process";
+import semver from "semver";
+var DIAGNOSTIC_TIMEOUT_MS = 1e4;
+var AUTH_ARGS = ["login", "status"];
+var VERSION_ARGS = ["--version"];
+var PROVIDER_CLI_TABLE = {
+  anthropic: { command: "claude", name: "Claude Code", update: "claude update" },
+  openai: { command: "codex", name: "Codex CLI", update: "npm install -g @openai/codex@latest" }
+};
+var MODEL_CLI_FLOORS = /* @__PURE__ */ new Map([
+  ["claude-opus-5-5", "2.1.280"],
+  ["gpt-6-sol", "0.155.0"],
+  ["gpt-6.1-sol", "0.159.1"]
+]);
+var default_ports = {
+  run(command, args) {
+    const outcome = spawnSync(command, [...args], {
+      encoding: "utf8",
+      timeout: DIAGNOSTIC_TIMEOUT_MS
+    });
+    return { ...outcome, status: outcome.status ?? void 0 };
+  }
+};
+function nonempty(value) {
+  const trimmed = value?.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function note_of(outcome) {
+  if (outcome.error !== void 0) return outcome.error.message;
+  return nonempty(outcome.stderr) ?? nonempty(outcome.stdout) ?? "unknown error";
+}
+function rejected(note) {
+  return { kind: "rejected", note };
+}
+function version_of(outcome) {
+  if (outcome.error !== void 0 || outcome.status !== 0) return void 0;
+  return semver.coerce(outcome.stdout ?? "", { includePrerelease: true })?.version;
+}
+function version_note(cli, model, floor, found) {
+  return `${cli.name} ${found} cannot run ${model}; it needs ${floor} or later \u2014 run \`${cli.update}\`, then retry`;
+}
+function check_version(model, cli, ports) {
+  const floor = MODEL_CLI_FLOORS.get(model);
+  if (floor === void 0) return { kind: "ready" };
+  const outcome = ports.run(cli.command, VERSION_ARGS);
+  const found = version_of(outcome);
+  if (found === void 0) {
+    return rejected(`${cli.name} version could not be read: ${note_of(outcome)}`);
+  }
+  return semver.gte(found, floor) ? { kind: "ready" } : rejected(version_note(cli, model, floor, found));
+}
+function check_auth(cli, ports) {
+  const outcome = ports.run(cli.command, AUTH_ARGS);
+  if (outcome.error !== void 0) {
+    return rejected(`${cli.name} is unavailable: ${note_of(outcome)}`);
+  }
+  return outcome.status === 0 ? { kind: "ready" } : rejected(`Codex authentication is unavailable: ${note_of(outcome)}`);
+}
+function check(profile, ports = default_ports) {
+  const cli = PROVIDER_CLI_TABLE[profile.provider];
+  const version = check_version(profile.model, cli, ports);
+  if (version.kind === "rejected" || profile.provider === "anthropic") return version;
+  return check_auth(cli, ports);
+}
+var agent_diagnostics = { check };
+
+// scripts/agent/claude-agent-argv.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+var AGENT_COMMAND = "claude";
+var PERMISSION_FLAGS = ["--permission-mode", "bypassPermissions"];
+var AGENT_FLAGS = [
+  "-p",
+  "--verbose",
+  "--output-format",
+  "stream-json",
+  ...PERMISSION_FLAGS
+];
+var MODEL_FLAG = "--model";
+var EFFORT_FLAG = "--effort";
+var RESUME_FLAG = "--resume";
+var SESSION_ID_FLAG = "--session-id";
+var LAUNCHED_TOOLS = [
+  "Bash",
+  "Read",
+  "Edit",
+  "Write",
+  "Agent",
+  "Skill",
+  "ToolSearch",
+  "SendMessage",
+  "TaskStop",
+  "Monitor",
+  "TodoWrite"
+];
+var DROPPED_TOOLS = {
+  scheduler: /* @__PURE__ */ new Set(),
+  worker: /* @__PURE__ */ new Set(["Skill"]),
+  reviewer: /* @__PURE__ */ new Set(["Agent", "Skill"])
+};
+var TOOLS_FLAG = "--tools";
+var STRICT_MCP_FLAG = "--strict-mcp-config";
+var MCP_CONFIG_FLAG = "--mcp-config";
+var PROJECT_MCP_FILE = ".mcp.json";
+function session_id_flags(session_id) {
+  return session_id === void 0 ? [] : [SESSION_ID_FLAG, session_id];
+}
+function launched_tools(role) {
+  const dropped = DROPPED_TOOLS[role];
+  return LAUNCHED_TOOLS.filter((tool) => !dropped.has(tool));
+}
+function tool_flags(role, cwd = process.cwd()) {
+  const mcp_config = path.join(cwd, PROJECT_MCP_FILE);
+  const mcp_flags = existsSync(mcp_config) ? [STRICT_MCP_FLAG, MCP_CONFIG_FLAG, mcp_config] : [STRICT_MCP_FLAG];
+  return [TOOLS_FLAG, launched_tools(role).join(","), ...mcp_flags];
+}
+function instruction_flags(profile, cwd) {
+  if (profile.role === agent_role_profile.SCHEDULER) return [];
+  return lane_instructions.flags(cwd, profile.role === agent_role_profile.WORKER);
+}
+function build(invocation, profile, session_id, cwd) {
+  return {
+    command: AGENT_COMMAND,
+    args: [
+      ...AGENT_FLAGS,
+      ...tool_flags(profile.role, cwd),
+      ...instruction_flags(profile, cwd),
+      ...session_id_flags(session_id),
+      MODEL_FLAG,
+      profile.model,
+      EFFORT_FLAG,
+      profile.effort,
+      invocation
+    ],
+    ends_with_prompt: true
+  };
+}
+function build_resume(invocation, profile, session_id, cwd) {
+  return {
+    command: AGENT_COMMAND,
+    args: [
+      ...AGENT_FLAGS,
+      ...tool_flags(profile.role, cwd),
+      ...instruction_flags(profile, cwd),
+      RESUME_FLAG,
+      session_id,
+      MODEL_FLAG,
+      profile.model,
+      EFFORT_FLAG,
+      profile.effort,
+      invocation
+    ],
+    ends_with_prompt: true
+  };
+}
+function with_profile(invocation, profile) {
+  return { kind: "argv", argv: build(invocation, profile), profile };
+}
+function resolve(invocation, role, environment = process.env) {
+  const result = agent_role_profile.resolve(role, environment);
+  if (result.kind === "rejected") return result;
+  return with_profile(invocation, result.profile);
+}
+var claude_agent_argv = {
+  AGENT_COMMAND,
+  AGENT_FLAGS,
+  LAUNCHED_TOOLS,
+  build,
+  build_resume,
+  resolve
+};
+
+export {
+  agent_diagnostics,
+  claude_agent_argv
+};

package/dist/commands/chunk-CKD2G35M.js

@@ -0,0 +1,86 @@
+import {
+  parse_json_array_or_undefined
+} from "./chunk-NAZ753DE.js";
+
+// scripts/gh/git-gh-pr-rollup.ts
+import { z } from "zod";
+var STATUS_CONTEXT_TYPE_NAME = "StatusContext";
+var TYPE_NAME_KEY = "__typename";
+var rollup_element_schema = z.looseObject({});
+var check_runs_page_schema = z.looseObject({
+  // Required, not optional: GitHub always names the key, and accepting a page without one would
+  // answer an empty rollup — which `git-pr-followup.ts` reports as "this branch has no checks".
+  check_runs: z.array(rollup_element_schema)
+});
+var id_holder_schema = z.object({ id: z.number() });
+var status_page_schema = z.looseObject({
+  statuses: z.array(rollup_element_schema)
+});
+var NOT_A_CHECK_RUNS_LISTING = "gh api answered something other than a check run listing";
+var NOT_A_STATUS_LISTING = "gh api answered something other than a commit status listing";
+function read_pages(raw_json, schema, message) {
+  const pages = parse_json_array_or_undefined(raw_json, schema);
+  if (pages === void 0) throw new Error(message);
+  return pages;
+}
+var NO_SUITE = -1;
+function read_id(value) {
+  const parsed = id_holder_schema.safeParse(value);
+  return parsed.success ? parsed.data.id : void 0;
+}
+function check_run_group_key(run) {
+  const { name, app } = run;
+  if (typeof name !== "string") return void 0;
+  return JSON.stringify([name, read_id(app)]);
+}
+function read_rank(run) {
+  const id = read_id(run);
+  if (id === void 0) return void 0;
+  return { suite: read_id(run["check_suite"]) ?? NO_SUITE, run: id };
+}
+function is_ranked_above(candidate, current) {
+  if (candidate.suite !== current.suite) return candidate.suite > current.suite;
+  return candidate.run > current.run;
+}
+function should_replace(previous, rank) {
+  const previous_rank = previous === void 0 ? void 0 : read_rank(previous);
+  return previous_rank === void 0 || is_ranked_above(rank, previous_rank);
+}
+function remember_newest_run(run, newest) {
+  const key = check_run_group_key(run);
+  const rank = read_rank(run);
+  if (key === void 0 || rank === void 0) return;
+  if (should_replace(newest.get(key), rank)) newest.set(key, run);
+}
+function is_newest_run(run, newest) {
+  const key = check_run_group_key(run);
+  if (key === void 0 || read_rank(run) === void 0) return true;
+  return newest.get(key) === run;
+}
+function newest_check_runs(runs) {
+  const newest = /* @__PURE__ */ new Map();
+  for (const run of runs) remember_newest_run(run, newest);
+  return runs.filter((run) => is_newest_run(run, newest));
+}
+function to_check_run_items(check_runs_json) {
+  const pages = read_pages(check_runs_json, check_runs_page_schema, NOT_A_CHECK_RUNS_LISTING);
+  return newest_check_runs(pages.flatMap((page) => page.check_runs));
+}
+function to_status_context_items(status_json) {
+  const pages = read_pages(status_json, status_page_schema, NOT_A_STATUS_LISTING);
+  return pages.flatMap((page) => page.statuses).map((status) => ({ ...status, [TYPE_NAME_KEY]: STATUS_CONTEXT_TYPE_NAME }));
+}
+function to_status_check_rollup(input) {
+  return [
+    ...to_check_run_items(input.check_runs_json),
+    ...to_status_context_items(input.status_json)
+  ];
+}
+var git_gh_pr_rollup = {
+  newest_check_runs,
+  to_status_check_rollup
+};
+
+export {
+  git_gh_pr_rollup
+};

package/dist/commands/chunk-CMTTDS7F.js

@@ -0,0 +1,77 @@
+import {
+  issue_priority
+} from "./chunk-FBWNL3UA.js";
+import {
+  git_gh_command
+} from "./chunk-VJNE7W7O.js";
+import {
+  issue_label_schema
+} from "./chunk-34DND4BA.js";
+import {
+  has_label_name,
+  label_name_of
+} from "./chunk-QQBMVC5W.js";
+import {
+  parse_json_object_or_undefined
+} from "./chunk-NAZ753DE.js";
+
+// scripts/issue/issue-priority-raise.ts
+import { z } from "zod";
+var read_schema = z.object({
+  labels: z.array(issue_label_schema).optional(),
+  body: z.string().nullish()
+});
+async function read_issue(issue_number) {
+  const raw = await git_gh_command.issue_get_labels_and_body(issue_number);
+  const parsed = raw === void 0 ? void 0 : parse_json_object_or_undefined(raw, read_schema);
+  if (parsed === void 0) return void 0;
+  return { labels: (parsed.labels ?? []).map((label) => label.name), body: parsed.body ?? "" };
+}
+function decision(labels) {
+  return issue_priority.is_typed(labels) ? "labelled" : "below";
+}
+var PRIORITY_LABELS = Object.values(issue_priority.LABELS).filter(
+  (label) => label !== void 0
+);
+function priority_labels_of(labels) {
+  return PRIORITY_LABELS.map((label) => label_name_of(labels, label)).filter(
+    (name) => name !== void 0
+  );
+}
+function is_only(labels, label) {
+  const present = priority_labels_of(labels);
+  if (label === void 0) return present.length === 0;
+  return present.length === 1 && has_label_name(present, label);
+}
+async function replace(issue_number, labels, label) {
+  const kept = label === void 0 ? void 0 : label_name_of(labels, label);
+  const is_added = label === void 0 || kept !== void 0 || await git_gh_command.issue_add_label(issue_number, label);
+  if (!is_added) return false;
+  const stale = priority_labels_of(labels).filter((name) => name !== kept);
+  const cleared = await Promise.all(
+    stale.map(async (name) => await git_gh_command.issue_clear_label(issue_number, name))
+  );
+  return cleared.every(Boolean);
+}
+async function settle(issue_number, labels) {
+  const [top] = priority_labels_of(labels);
+  if (top === void 0 || is_only(labels, top)) return decision(labels);
+  return await replace(issue_number, labels, top) ? "labelled" : "failed";
+}
+async function raise(issue_number) {
+  const read = await read_issue(issue_number);
+  if (read === void 0) return "unreadable";
+  const label = issue_priority.raise_label(read.labels, read.body);
+  if (label === void 0) return await settle(issue_number, read.labels);
+  const is_applied = await replace(issue_number, read.labels, label);
+  return is_applied ? "raised" : "failed";
+}
+var FAILURES = /* @__PURE__ */ new Set(["unreadable", "failed"]);
+function is_failure(result) {
+  return FAILURES.has(result);
+}
+var issue_priority_raise = { read_issue, is_only, replace, raise, is_failure };
+
+export {
+  issue_priority_raise
+};

package/dist/commands/chunk-CRCQOA4Z.js

@@ -0,0 +1,77 @@
+import {
+  backlogrun_launch
+} from "./chunk-3IXIYDC3.js";
+import {
+  agent_argv
+} from "./chunk-IV6ETHVB.js";
+import {
+  run_headless
+} from "./chunk-UACWDTJ5.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  agent_safe_text
+} from "./chunk-3LZXX5GL.js";
+import {
+  durable_state
+} from "./chunk-JSJS3OT7.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
+};