@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-6YURRFRU.js

@@ -1,461 +0,0 @@
-import {
-  lane_value_missing
-} from "./chunk-AJWR7D3H.js";
-import {
-  lane_launch_cli
-} from "./chunk-LB557AHJ.js";
-import {
-  run_handoff_launch
-} from "./chunk-KODXWMBX.js";
-import {
-  lane_vacant
-} from "./chunk-VV4TQYGD.js";
-import {
-  issue_measured_close
-} from "./chunk-BTZJDHQT.js";
-import {
-  epic_validate
-} from "./chunk-OP2RFVLS.js";
-import {
-  trusted_measure
-} from "./chunk-M6JDU5EK.js";
-import {
-  run_carry_ended
-} from "./chunk-ZVAIIHBE.js";
-import {
-  measure_declaration
-} from "./chunk-34JJYCIY.js";
-import {
-  size_estimate
-} from "./chunk-FDS65XOJ.js";
-import {
-  lane_implement_rate_read
-} from "./chunk-FURNDIT3.js";
-import {
-  split_assess
-} from "./chunk-D7JRJI44.js";
-import {
-  git_gh_command
-} from "./chunk-YGFOGA7C.js";
-import {
-  git_stash
-} from "./chunk-K64EIHD2.js";
-import {
-  run_event_setup
-} from "./chunk-I2KCGKJI.js";
-import {
-  agent_role_profile
-} from "./chunk-6UCWAFQY.js";
-import {
-  backlog_budget
-} from "./chunk-BYSPYVLD.js";
-import {
-  lane_registry
-} from "./chunk-452HWOJ7.js";
-import {
-  detached_launch
-} from "./chunk-C2SEDMZ3.js";
-import {
-  run_event_stream_emit
-} from "./chunk-OKZWEVR4.js";
-import {
-  run_event_stream
-} from "./chunk-NSAVEXVR.js";
-import {
-  EPIC_LABEL
-} from "./chunk-QQBMVC5W.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-import {
-  durable_state,
-  run_carry
-} from "./chunk-MPGJ4ONJ.js";
-import {
-  agent_provider
-} from "./chunk-JQXPLMCO.js";
-import {
-  poll
-} from "./chunk-SBGTCT2C.js";
-import {
-  error_text
-} from "./chunk-CDY4NFQG.js";
-
-// scripts/backlog/backlog-drive-seats.ts
-async function seated(issues, ports) {
-  const kept = await Promise.all(issues.map(async (issue) => await ports.has_lane(issue)));
-  const room = await ports.limit_room();
-  const available = Math.min(await ports.free_lanes(), room);
-  const resumed = issues.filter((_issue, index) => kept[index] === true).slice(0, available);
-  const fresh_room = available - resumed.length;
-  return [
-    ...resumed,
-    ...issues.filter((_issue, index) => kept[index] !== true).slice(0, fresh_room)
-  ];
-}
-async function has_kept_lane(issue) {
-  const lane = await lane_registry.find_open_lane(issue);
-  if (lane?.output === void 0) return false;
-  return !await lane_vacant.is_vacant(lane);
-}
-var backlog_drive_seats = { has_kept_lane, seated };
-
-// scripts/backlog/backlog-drive-owner.ts
-import { existsSync } from "node:fs";
-var READ_ATTEMPTS = 6;
-var ENDED_MESSAGE = "The carry record is no longer active.";
-var seen = {};
-function owns_record(carry, owner) {
-  const current = run_carry.owner_of(Number(owner));
-  const has_owner = carry.owner_pid === current.pid && carry.owner_start === current.start;
-  return has_owner && run_carry.is_owner_live(carry) && !carry.is_handed_off;
-}
-function is_ended(directory) {
-  return run_carry_ended.has_ended(run_carry_ended.ended_path(directory), seen.started_at);
-}
-function unread_note(read, directory) {
-  const presence = existsSync(run_carry.carry_path(directory)) ? "present" : "absent";
-  return `The carry record read \`${read.kind}\` with its file ${presence}`;
-}
-function is_settled(read, directory) {
-  if (read.kind === "carried" || is_ended(directory)) return true;
-  console.error(`${unread_note(read, directory)}; reading it again.`);
-  return false;
-}
-async function read_record(directory) {
-  const target = run_carry.carry_path(directory);
-  let read = { kind: "none" };
-  await poll.poll_until(
-    async () => {
-      read = run_carry.read_carry(target);
-      return is_settled(read, directory);
-    },
-    {
-      attempts: READ_ATTEMPTS,
-      interval_ms: backlog_budget.OFFER_INTERVAL_MS,
-      sleeper: async (duration_ms) => {
-        await poll.sleep(duration_ms);
-      }
-    }
-  );
-  return read;
-}
-function unread_message(read, directory) {
-  if (is_ended(directory)) return ENDED_MESSAGE;
-  return `${unread_note(read, directory)}, ${String(READ_ATTEMPTS)} times in a row.`;
-}
-async function assert_current(owner) {
-  const directory = await run_carry.repository_directory();
-  if (directory === void 0) throw new Error("The carry record cannot be located.");
-  const read = await read_record(directory);
-  if (read.kind !== "carried") throw new Error(unread_message(read, directory));
-  if (!owns_record(read.carry, owner)) {
-    throw new Error("The driver no longer owns the carry record.");
-  }
-  seen.started_at = read.carry.started_at;
-  return read.carry;
-}
-var backlog_drive_owner = { READ_ATTEMPTS, assert_current };
-
-// scripts/backlog/backlog-drive-launch-pass.ts
-var NO_FREE_LANES = 0;
-var LAUNCHED = "launched";
-var UNOPENED = "unopened";
-var MEASURED_LAUNCH = "measured";
-var UNSAMPLED_LAUNCH = "unsampled";
-var SPLIT_LAUNCH = "split";
-async function handed_back(issue, outcome2, state, ports) {
-  await ports.stall(issue, outcome2);
-  return { kind: "end", end: { reason: "launch", token: void 0, issue }, state };
-}
-async function refused(issue, outcome2, state, ports) {
-  if (outcome2 === "waiting") return { kind: "continue", state };
-  if (outcome2 !== UNOPENED) return await handed_back(issue, outcome2, state, ports);
-  if (await ports.free_lanes() <= NO_FREE_LANES) return { kind: "continue", state };
-  return await handed_back(issue, outcome2, state, ports);
-}
-function launched(state, settled, ports) {
-  const { in_flight, measured: measured3, unsampled } = settled;
-  const exclude = [...state.exclude, ...measured3];
-  const waiting = [...state.waiting ?? [], ...unsampled];
-  if (in_flight.length === state.in_flight.length && measured3.length === 0) {
-    return { ...state, in_flight, exclude, waiting };
-  }
-  return { ...state, in_flight, exclude, waiting, active: ports.now().toISOString() };
-}
-var SETTLED = /* @__PURE__ */ new Set([
-  MEASURED_LAUNCH,
-  LAUNCHED,
-  UNSAMPLED_LAUNCH,
-  SPLIT_LAUNCH
-]);
-function is_settled2(outcome2) {
-  return SETTLED.has(outcome2);
-}
-function settle(settled, issue, outcome2) {
-  if (outcome2 === MEASURED_LAUNCH || outcome2 === SPLIT_LAUNCH) settled.measured.push(issue);
-  if (outcome2 === UNSAMPLED_LAUNCH) settled.unsampled.push(issue);
-  if (outcome2 === LAUNCHED) settled.in_flight.push(issue);
-}
-async function launch_each(issues, ports) {
-  const results = await Promise.allSettled(
-    issues.map(async (issue) => ({ issue, outcome: await ports.launch(issue) }))
-  );
-  const failure = results.find((result) => result.status === "rejected");
-  if (failure !== void 0) throw failure.reason;
-  return results.flatMap((result) => result.status === "fulfilled" ? [result.value] : []);
-}
-async function launch_all(issues, state, ports) {
-  const settled = { in_flight: [...state.in_flight], measured: [], unsampled: [] };
-  const launching = await backlog_drive_seats.seated(issues, ports);
-  const outcomes = await launch_each(launching, ports);
-  for (const { issue, outcome: outcome2 } of outcomes) settle(settled, issue, outcome2);
-  const refusal = outcomes.find(({ outcome: outcome2 }) => !is_settled2(outcome2));
-  const next = launched(state, settled, ports);
-  if (refusal === void 0) return { kind: "continue", state: next };
-  return await refused(refusal.issue, refusal.outcome, next, ports);
-}
-var backlog_drive_launch_pass = { MEASURED_LAUNCH, SPLIT_LAUNCH, UNSAMPLED_LAUNCH, launch_all };
-
-// 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, launch2, log) {
-  const selected = agent_provider.resolve_provider(launch2.environment);
-  if (selected.kind === "rejected") return void 0;
-  const child = {
-    prompt,
-    role: agent_role_profile.SCHEDULER,
-    provider: selected.provider,
-    cwd: launch2.cwd
-  };
-  const built = run_handoff_launch.argv_of(child, launch2.environment);
-  if (built.kind === "rejected") return void 0;
-  return run_handoff_launch.request_of(built, launch2.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 };
-
-// scripts/backlog/backlog-drive-split-unit.ts
-function brief_of(issue) {
-  return [
-    `Split-only unit for ${issue_cite.plain_for("program", issue)}: its declared size is over the size bar. Implement nothing.`,
-    `Read it with \`pnpm josh issue:read ${issue}\` and answer only question 1 of`,
-    `\`pnpm josh doc:section .claude/skills/workflow-commands/split-assessment.md "${split_assess.QUESTION_SECTION}"\`.`,
-    `Separately-mergeable parts \u2192 file each child k with \`pnpm josh issue:file "<title>" --body-file .josh/tmp/split-${issue}-<k>.md --route split\`, then`,
-    `\`pnpm josh epic --promote ${issue} <N1> <N2> ... [--ordered]\`.`,
-    `One deliverable \u2192 add \`${split_assess.REASON_PREFIX} <\u7406\u7531>\` under \u80CC\u666F with \`pnpm josh issue:body ${issue} --body-file -\`.`,
-    "Nobody answers this session: end it once either is written."
-  ].join(" ");
-}
-function is_over_bar(subject, measured3) {
-  const { implement_rate, growth } = measured3;
-  return size_estimate.over_budget(subject.body ?? "", implement_rate, growth) !== void 0;
-}
-function is_split(subject) {
-  if (subject === void 0) return false;
-  return subject.state?.toUpperCase() === "CLOSED" || subject.labels.includes(EPIC_LABEL);
-}
-function production_ports() {
-  return {
-    read: async (issue) => epic_validate.parse_epic_subject(await git_gh_command.issue_get_labels_and_body(issue)),
-    measurements: async () => await lane_implement_rate_read.measurements(),
-    repository_directory: run_carry.repository_directory,
-    launch_attached: backlog_drive_unit.launch_attached,
-    environment: process.env,
-    cwd: process.cwd(),
-    now: () => Date.now()
-  };
-}
-async function request_of2(issue, ports) {
-  const git_directory = await ports.repository_directory();
-  if (git_directory === void 0) return void 0;
-  const log = backlog_drive_unit.log_path(git_directory, `split-${issue}`, ports.now());
-  return backlog_drive_unit.request_of(brief_of(issue), ports, log);
-}
-async function is_due(issue, ports) {
-  const subject = await ports.read(issue);
-  return subject !== void 0 && is_over_bar(subject, await ports.measurements());
-}
-async function run(issue, ports = production_ports()) {
-  if (!await is_due(issue, ports)) return "launch";
-  const request = await request_of2(issue, ports);
-  if (request === void 0) return "launch";
-  await ports.launch_attached(request);
-  return is_split(await ports.read(issue)) ? "split" : "launch";
-}
-var backlog_drive_split_unit = { run };
-
-// scripts/backlog/backlog-drive-trace.ts
-var STEP = { COLLECT: "collect", LAUNCH: "launch" };
-var EDGE = { START: "start", DONE: "done", FAILED: "failed" };
-function text_of(issue, step, edge) {
-  return `${issue_cite.plain_for("program", issue)} ${step} ${edge}`;
-}
-async function mark(issue, step, edge) {
-  await run_event_stream_emit.emit(
-    run_event_stream.EVENT_KIND.LANE_PHASE,
-    text_of(issue, step, edge)
-  );
-}
-async function traced(issue, step, run2) {
-  await mark(issue, step, EDGE.START);
-  try {
-    const value = await run2();
-    await mark(issue, step, EDGE.DONE);
-    return value;
-  } catch (error) {
-    await mark(issue, step, EDGE.FAILED);
-    throw error;
-  }
-}
-var backlog_drive_trace = { STEP, traced };
-
-// scripts/backlog/backlog-measure-close.ts
-var FENCE = "```";
-var VERDICT_WORDS = {
-  pass: "within the bound, so the issue is closed without a lane.",
-  fail: "out of the bound, so the issue goes to a lane.",
-  unreadable: "no value could be read from the output, so the issue goes to a lane.",
-  unsampled: "sample condition not met \u2014 no sample to read yet, so the issue waits without a lane."
-};
-function verdict_of(declaration, run2) {
-  if (run2.kind === "ok") return measure_declaration.judge(declaration, run2.output);
-  return lane_value_missing.is_unsampled(run2.message) ? { kind: "unsampled" } : { kind: "unreadable" };
-}
-function measured(declaration, source) {
-  const run2 = trusted_measure.run_command(declaration.command, source);
-  return { declaration, run: run2, verdict: verdict_of(declaration, run2) };
-}
-async function declared(issue) {
-  const read = await trusted_measure.read_trusted_body(issue);
-  if (read.kind === "refused") return void 0;
-  const declaration = measure_declaration.parse(read.body);
-  return declaration === void 0 ? void 0 : measured(declaration, read);
-}
-function value_words(verdict) {
-  return "value" in verdict ? String(verdict.value) : verdict.kind;
-}
-function report(measurement) {
-  const { declaration, run: run2, verdict } = measurement;
-  return [
-    "`backlog:drive` ran the measurement declaration.",
-    "",
-    `- Declaration: ${measure_declaration.format(declaration)}`,
-    `- Value: ${value_words(verdict)}`,
-    `- Verdict: ${VERDICT_WORDS[verdict.kind]}`,
-    "",
-    FENCE,
-    trusted_measure.text_of(run2),
-    FENCE
-  ].join("\n");
-}
-async function close_passed(issue, measurement) {
-  const is_closed = await issue_measured_close.close(issue, report(measurement));
-  const value = value_words(measurement.verdict);
-  const bound = `${measurement.declaration.operator} ${String(measurement.declaration.threshold)}`;
-  if (is_closed) {
-    await run_event_stream_emit.emit(
-      run_event_stream.EVENT_KIND.MEASURED,
-      `${issue_cite.plain_for("program", issue)} measured by backlog:drive: ${value} ${bound}`
-    );
-  }
-  return is_closed;
-}
-async function waited(issue) {
-  await run_event_stream_emit.emit(
-    run_event_stream.EVENT_KIND.SAMPLE_WAIT,
-    `${issue_cite.plain_for("program", issue)} waiting: sample condition not met`
-  );
-  return "wait";
-}
-async function hand_over(issue, measurement) {
-  try {
-    await git_gh_command.issue_comment(issue, report(measurement));
-  } catch (error) {
-    console.error(`Measurement result not posted: ${error_text.message_of(error)}`);
-  }
-  return measurement.verdict.kind === "unsampled" ? await waited(issue) : "launch";
-}
-async function outcome(issue) {
-  const measurement = await declared(issue);
-  if (measurement === void 0) return "launch";
-  if (measurement.verdict.kind !== "pass") return await hand_over(issue, measurement);
-  return await close_passed(issue, measurement) ? "closed" : "launch";
-}
-var backlog_measure_close = { outcome };
-
-// scripts/backlog/backlog-drive-launch.ts
-var { MEASURED_LAUNCH: MEASURED_LAUNCH2, SPLIT_LAUNCH: SPLIT_LAUNCH2, UNSAMPLED_LAUNCH: UNSAMPLED_LAUNCH2 } = backlog_drive_launch_pass;
-var LATEST_STASH_MESSAGE = "backlogrun: josh latest before lanes";
-async function latest_stash() {
-  const selection = git_stash.select(await git_stash.list(), LATEST_STASH_MESSAGE);
-  if (selection.kind === "ambiguous") {
-    console.error(
-      `Launching without the "${LATEST_STASH_MESSAGE}" stash: ${selection.selectors.join(", ")} all match \u2014 keep one.`
-    );
-  }
-  return selection.kind === "match" ? LATEST_STASH_MESSAGE : void 0;
-}
-var stash_holders = /* @__PURE__ */ new Set();
-async function launch_ready(issue) {
-  const { launch_ready_lane } = lane_launch_cli;
-  if (stash_holders.size > 0) return await launch_ready_lane({ issue, stash: void 0 });
-  stash_holders.add(issue);
-  try {
-    return await launch_ready_lane({ issue, stash: await latest_stash() });
-  } finally {
-    stash_holders.delete(issue);
-  }
-}
-var DETAIL_LIMIT = 200;
-function no_child(issue, detail) {
-  const event = run_event_setup.no_child(issue);
-  if (detail === void 0) return event;
-  const folded = detail.replaceAll(/\s+/gu, " ");
-  const capped = folded.length > DETAIL_LIMIT ? `${folded.slice(0, DETAIL_LIMIT)}\u2026` : folded;
-  return `${event}: ${capped}`;
-}
-async function measured2(issue) {
-  const outcome2 = await backlog_measure_close.outcome(issue);
-  if (outcome2 === "closed") return MEASURED_LAUNCH2;
-  return outcome2 === "wait" ? UNSAMPLED_LAUNCH2 : void 0;
-}
-async function opened(issue, owner) {
-  await backlog_drive_owner.assert_current(owner);
-  const settled = await measured2(issue);
-  if (settled !== void 0) return settled;
-  if (await backlog_drive_split_unit.run(issue) === "split") return SPLIT_LAUNCH2;
-  await backlog_drive_owner.assert_current(owner);
-  await run_event_setup.emit(run_event_setup.opening_lane(issue));
-  const outcome2 = await launch_ready(issue);
-  if (outcome2.kind !== "launched" && outcome2.kind !== "waiting") {
-    await run_event_setup.emit(no_child(issue, outcome2.detail));
-  }
-  return outcome2.kind;
-}
-async function launch(issue, owner) {
-  return await backlog_drive_trace.traced(
-    issue,
-    backlog_drive_trace.STEP.LAUNCH,
-    async () => await opened(issue, owner)
-  );
-}
-var backlog_drive_launch = { LATEST_STASH_MESSAGE, launch };
-
-export {
-  backlog_drive_seats,
-  backlog_drive_launch_pass,
-  backlog_drive_owner,
-  backlog_drive_trace,
-  backlog_drive_unit,
-  backlog_drive_launch
-};