@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-J22PSIXR.js

@@ -1,418 +0,0 @@
-import {
-  lane_session_broker
-} from "./chunk-L7DAL54N.js";
-import {
-  ts_entry_loader
-} from "./chunk-VHRNXWVP.js";
-import {
-  lane_dispatch_log
-} from "./chunk-AC26ZUG5.js";
-import {
-  agent_argv
-} from "./chunk-NU7W6QGT.js";
-import {
-  run_cut
-} from "./chunk-DYZOOWVW.js";
-import {
-  run_ship_detach
-} from "./chunk-G4E4M2P4.js";
-import {
-  detached_launch
-} from "./chunk-C2SEDMZ3.js";
-import {
-  lane_child_marker
-} from "./chunk-QAHFPCFR.js";
-import {
-  lane_child_invocation
-} from "./chunk-EW4NPUMQ.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  process_owner_schema
-} from "./chunk-HLUS2M3D.js";
-import {
-  poll
-} from "./chunk-SBGTCT2C.js";
-import {
-  process_identity
-} from "./chunk-AKK56GNX.js";
-import {
-  git_common_directory
-} from "./chunk-FFHEGWPK.js";
-import {
-  stamp_file
-} from "./chunk-QWWTC3XR.js";
-import {
-  json_value
-} from "./chunk-HIU2WXB6.js";
-
-// scripts/lane/openai-lane-supervisor.ts
-import { dirname as __josh_dirname } from "node:path";
-import { fileURLToPath as __josh_file_path } from "node:url";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { fileURLToPath } from "node:url";
-
-// scripts/lane/openai-lane-ship.ts
-var POLL_MS = 250;
-async function current(issue) {
-  const repository = await git_common_directory.read_repository();
-  return repository === void 0 ? void 0 : run_ship_detach.read_result(repository, issue);
-}
-async function settled(issue) {
-  const read3 = await current(issue);
-  if (read3 === void 0) return "abnormal";
-  return read3.result === "running" ? void 0 : read3.result;
-}
-async function wait_for_ship(issue, prior_launch) {
-  const read3 = await current(issue);
-  if (read3 === void 0 || read3.launch_id === prior_launch) return "none";
-  if (read3.result !== "running") return read3.result;
-  return await poll.wait_for(async () => await settled(issue), { interval_ms: POLL_MS });
-}
-var openai_lane_ship = { current, wait_for_ship };
-
-// scripts/lane/openai-lane-supervisor-decision.ts
-import { z } from "zod";
-var DECISION_PREFIX = "josh-openai-lane-supervisor-decision-";
-var APPROVAL_POLL_MS = 50;
-var APPROVAL_POLL_LIMIT = 200;
-var schema = z.object({
-  nonce: z.string(),
-  decision: z.enum(["approved", "cancelled"])
-});
-function target(lane_directory, nonce) {
-  return stamp_file.stamp_path(`${DECISION_PREFIX}${nonce}-`, lane_directory);
-}
-function read(lane_directory, nonce) {
-  const raw = stamp_file.read_stamp_text(target(lane_directory, nonce)) ?? "";
-  return json_value.parse_with(raw, schema);
-}
-function decide(lane_directory, nonce, decision) {
-  const value = { nonce, decision };
-  return stamp_file.create_stamp(target(lane_directory, nonce), value) || read(lane_directory, nonce)?.decision === decision;
-}
-function approve(lane_directory, nonce) {
-  return decide(lane_directory, nonce, "approved");
-}
-function cancel(lane_directory, nonce) {
-  return decide(lane_directory, nonce, "cancelled");
-}
-async function wait_for_decision(lane_directory, nonce) {
-  return await poll.poll_for(() => read(lane_directory, nonce)?.decision, {
-    attempts: APPROVAL_POLL_LIMIT,
-    interval_ms: APPROVAL_POLL_MS
-  });
-}
-async function is_approved(lane_directory, nonce) {
-  return await wait_for_decision(lane_directory, nonce) === "approved";
-}
-function remove(lane_directory, nonce) {
-  stamp_file.remove_stamp(target(lane_directory, nonce));
-}
-var openai_lane_supervisor_decision = { approve, cancel, is_approved, remove, wait_for_decision };
-
-// scripts/lane/openai-lane-supervisor-owner.ts
-import { randomUUID } from "node:crypto";
-import { linkSync, statSync, unlinkSync } from "node:fs";
-import { z as z2 } from "zod";
-var OWNER_PREFIX = "josh-openai-lane-supervisor-";
-var STATE_PREFIX = "josh-openai-lane-supervisor-state-";
-var CLAIM_POLL_MS = 50;
-var CLAIM_POLL_LIMIT = 600;
-var owner_schema = process_owner_schema.extend({
-  issue: z2.string(),
-  nonce: z2.string(),
-  pid: z2.number().int().positive()
-});
-var state_schema = z2.object({
-  owner_nonce: z2.string(),
-  child_pid: z2.number().int().positive().optional(),
-  child_process_start: z2.string().optional(),
-  resume_cut: z2.string().optional(),
-  epoch: z2.number().int().nonnegative()
-});
-function marker_path(lane_directory) {
-  return stamp_file.stamp_path(OWNER_PREFIX, lane_directory);
-}
-function state_path(lane_directory) {
-  return stamp_file.stamp_path(STATE_PREFIX, lane_directory);
-}
-function parsed_stamp(target2, schema2) {
-  return json_value.parse_with(stamp_file.read_stamp_text(target2) ?? "", schema2);
-}
-function read2(lane_directory) {
-  return parsed_stamp(marker_path(lane_directory), owner_schema);
-}
-function read_state(lane_directory, nonce) {
-  const state = parsed_stamp(state_path(lane_directory), state_schema);
-  return state?.owner_nonce === nonce ? state : void 0;
-}
-function is_live(owner) {
-  return process_identity.is_same_process(owner.pid, owner.process_start) !== false;
-}
-function active(lane_directory) {
-  const owner = read2(lane_directory);
-  return owner !== void 0 && is_live(owner) ? owner : void 0;
-}
-function claim_status(lane_directory, pid) {
-  const owner = active(lane_directory);
-  if (owner !== void 0) return { owner };
-  if (pid !== void 0 && !process_identity.is_present_pid(pid)) return { owner: void 0 };
-  return void 0;
-}
-async function wait_for_active(lane_directory, pid) {
-  const owner = await poll.poll_for(() => claim_status(lane_directory, pid), {
-    attempts: CLAIM_POLL_LIMIT,
-    interval_ms: CLAIM_POLL_MS
-  });
-  return owner?.owner;
-}
-function remove_if_unchanged(target2) {
-  const snapshot = `${target2}.${String(process.pid)}.${randomUUID()}`;
-  try {
-    linkSync(target2, snapshot);
-    const current2 = statSync(target2);
-    const linked = statSync(snapshot);
-    if (current2.dev === linked.dev && current2.ino === linked.ino) unlinkSync(target2);
-  } catch {
-  } finally {
-    stamp_file.remove_stamp(snapshot);
-  }
-}
-function live_child(state) {
-  if (state?.child_pid === void 0) return void 0;
-  const { child_pid, child_process_start } = state;
-  if (process_identity.is_same_process(child_pid, child_process_start) === false) return void 0;
-  return {
-    pid: child_pid,
-    ...child_process_start !== void 0 && { process_start: child_process_start }
-  };
-}
-function carried_child(lane_directory, owner) {
-  if (owner === void 0) return void 0;
-  return live_child(read_state(lane_directory, owner.nonce));
-}
-function remove_stale_owner(target2, previous) {
-  if (previous !== void 0 && is_live(previous)) return false;
-  if (stamp_file.read_stamp_text(target2) !== void 0) remove_if_unchanged(target2);
-  return true;
-}
-function previous_resume(lane_directory, owner) {
-  if (owner === void 0) return void 0;
-  return read_state(lane_directory, owner.nonce)?.resume_cut;
-}
-function claim(issue, lane_directory, nonce) {
-  const target2 = marker_path(lane_directory);
-  const previous = read2(lane_directory);
-  if (!remove_stale_owner(target2, previous)) return void 0;
-  const child = carried_child(lane_directory, previous);
-  const resume_cut = previous_resume(lane_directory, previous);
-  const owner = { issue, nonce, ...process_identity.own_fields() };
-  if (!stamp_file.create_stamp(target2, owner)) return void 0;
-  stamp_file.replace_stamp(state_path(lane_directory), {
-    owner_nonce: nonce,
-    resume_cut,
-    epoch: 0,
-    ...child !== void 0 && {
-      child_pid: child.pid,
-      ...child.process_start !== void 0 && {
-        child_process_start: child.process_start
-      }
-    }
-  });
-  return owner;
-}
-function update(lane_directory, owner, state) {
-  if (read2(lane_directory)?.nonce !== owner.nonce) return;
-  stamp_file.replace_stamp(state_path(lane_directory), state);
-}
-function release(lane_directory, nonce) {
-  if (read2(lane_directory)?.nonce !== nonce) return;
-  stamp_file.remove_stamp(state_path(lane_directory));
-  stamp_file.remove_stamp(marker_path(lane_directory));
-  openai_lane_supervisor_decision.remove(lane_directory, nonce);
-}
-var openai_lane_supervisor_owner = {
-  active,
-  claim,
-  marker_path,
-  read_state,
-  release,
-  state_path,
-  update,
-  wait_for_active
-};
-
-// scripts/lane/openai-lane-supervisor.ts
-var __josh_meta = import.meta;
-var __josh_source_url = new URL("../../scripts/lane/openai-lane-supervisor.ts", __josh_meta.url).href;
-var __josh_source_filename = __josh_file_path(__josh_source_url);
-var __josh_source_dirname = __josh_dirname(__josh_source_filename);
-var { claim: claim2, read_state: read_state2, release: release2, update: update2 } = openai_lane_supervisor_owner;
-var CHILD_POLL_MS = 250;
-var SUPERVISOR_SCRIPT = fileURLToPath(new URL("openai-lane-supervisor-entry.ts", __josh_source_url));
-function handed_off(cut, issue) {
-  return cut?.is_handed_off === true && cut.issue === issue && cut.invocation === run_cut.invocation_for(issue);
-}
-async function standing_cut(issue) {
-  const git_directory = await run_cut.worktree_directory();
-  if (git_directory === void 0) return void 0;
-  const read_cut = run_cut.read_cut(run_cut.cut_path(git_directory));
-  return read_cut.kind === "carried" && handed_off(read_cut.cut, issue) ? read_cut.cut : void 0;
-}
-function child_argv(lane, profile, is_resume, override) {
-  const invocation = override ?? (is_resume ? lane_child_invocation.resume_invocation(lane.issue) : lane_child_invocation.child_invocation(lane.issue));
-  const built = agent_argv.with_profile_in(invocation, profile, lane.directory);
-  if (built.kind === "rejected") throw new Error(built.note);
-  return built.argv;
-}
-var LAUNCH_FAILED_KIND = "launch-failed";
-function completion_code(result, ship) {
-  return ship === "abnormal" || result.kind === "abnormal" ? 1 : 0;
-}
-function record_child(generation, child_pid) {
-  const { lane, owner, epoch } = generation;
-  const child_process_start = process_identity.read_start(child_pid);
-  update2(lane.directory, owner, {
-    owner_nonce: owner.nonce,
-    epoch,
-    child_pid,
-    resume_cut: generation.resume_cut,
-    ...child_process_start !== void 0 && { child_process_start }
-  });
-}
-function child_result(result) {
-  if (result.kind === "failed") return { kind: LAUNCH_FAILED_KIND, note: result.note };
-  if (result.exit_code === 0) return { kind: "completed" };
-  const note = `OpenAI lane child exited abnormally (${String(result.exit_code)})`;
-  console.error(note);
-  return { kind: "abnormal", note };
-}
-async function prepare_generation(generation) {
-  const { lane, owner } = generation;
-  const cut = await standing_cut(lane.issue);
-  if (cut === void 0) return { ...generation, resume_cut: void 0 };
-  const resume_cut = JSON.stringify(cut);
-  if (read_state2(lane.directory, owner.nonce)?.resume_cut === resume_cut) {
-    console.error(
-      `OpenAI supervisor ${session_cite.issue(lane.issue)}: resume did not adopt cut ${cut.cut_at}; stopping with work and cut preserved`
-    );
-    return void 0;
-  }
-  return { ...generation, resume_cut };
-}
-async function launch_child(generation) {
-  const { lane, profile, is_resume } = generation;
-  update2(lane.directory, generation.owner, {
-    owner_nonce: generation.owner.nonce,
-    epoch: generation.epoch,
-    resume_cut: generation.resume_cut
-  });
-  const result = await detached_launch.launch_attached(
-    {
-      argv: child_argv(lane, profile, is_resume, generation.invocation),
-      cwd: lane.directory,
-      log_path: lane_dispatch_log.default_log_path(lane),
-      profile,
-      env: lane_child_marker.env_for(lane.issue)
-    },
-    (note) => {
-      console.error(`OpenAI lane child launch: ${note}`);
-    },
-    (child_pid) => {
-      record_child(generation, child_pid);
-    }
-  );
-  return child_result(result);
-}
-async function stop_invocation(issue) {
-  const current2 = await openai_lane_ship.current(issue);
-  return current2?.stop_invocation ?? lane_child_invocation.ship_stop_invocation(issue);
-}
-async function run_child(generation) {
-  const ready = await prepare_generation(generation);
-  if (ready === void 0) return { kind: LAUNCH_FAILED_KIND, note: "cut resume failed" };
-  return await launch_child(ready);
-}
-async function run_generations(generation) {
-  const prior = await openai_lane_ship.current(generation.lane.issue);
-  const result = await run_child(generation);
-  if (result.kind === LAUNCH_FAILED_KIND) return 1;
-  if (await standing_cut(generation.lane.issue) !== void 0) {
-    return await run_generations({ ...generation, epoch: generation.epoch + 1, is_resume: true });
-  }
-  const ship = await openai_lane_ship.wait_for_ship(generation.lane.issue, prior?.launch_id);
-  if (ship === "failed") {
-    return await run_generations({
-      ...generation,
-      epoch: generation.epoch + 1,
-      is_resume: false,
-      invocation: await stop_invocation(generation.lane.issue)
-    });
-  }
-  return completion_code(result, ship);
-}
-async function wait_for_inherited_child(child_pid, child_process_start) {
-  await poll.wait_for(
-    () => process_identity.is_same_process(child_pid, child_process_start) === false || void 0,
-    { interval_ms: CHILD_POLL_MS }
-  );
-}
-async function recovered_resume(lane, nonce) {
-  const child_pid = read_state2(lane.directory, nonce)?.child_pid;
-  if (child_pid === void 0) return false;
-  await wait_for_inherited_child(child_pid, read_state2(lane.directory, nonce)?.child_process_start);
-  if (await standing_cut(lane.issue) === void 0) return void 0;
-  return true;
-}
-async function run_claimed(lane, profile, owner) {
-  const is_recovered = await recovered_resume(lane, owner.nonce);
-  if (is_recovered === void 0) return 0;
-  const is_resume = is_recovered || await standing_cut(lane.issue) !== void 0;
-  const epoch = (read_state2(lane.directory, owner.nonce)?.epoch ?? 0) + 1;
-  return await run_generations({ lane, profile, owner, is_resume, epoch });
-}
-async function is_approved2(lane, nonce) {
-  const decision = await openai_lane_supervisor_decision.wait_for_decision(lane.directory, nonce);
-  if (decision === "approved") return true;
-  const reason = decision === "cancelled" ? "late claim \u2014 dispatcher cancelled" : "approval timed out";
-  console.error(`OpenAI supervisor ${session_cite.issue(lane.issue)}: ${reason}; exiting`);
-  return false;
-}
-async function supervise(lane, profile, nonce) {
-  const owner = claim2(lane.issue, lane.directory, nonce);
-  if (owner === void 0) return 0;
-  try {
-    if (!await is_approved2(lane, nonce)) return 0;
-    return await lane_session_broker.with_server(
-      lane,
-      async () => await run_claimed(lane, profile, owner)
-    );
-  } finally {
-    release2(lane.directory, nonce);
-  }
-}
-function supervisor_argv(issue, nonce) {
-  return {
-    command: process.execPath,
-    args: [...ts_entry_loader.loader_argv(process.execArgv), SUPERVISOR_SCRIPT, issue, nonce]
-  };
-}
-var openai_lane_supervisor = {
-  active: openai_lane_supervisor_owner.active,
-  approve: openai_lane_supervisor_decision.approve,
-  cancel: openai_lane_supervisor_decision.cancel,
-  claim: claim2,
-  marker_path: openai_lane_supervisor_owner.marker_path,
-  new_nonce: randomUUID2,
-  release: release2,
-  state_path: openai_lane_supervisor_owner.state_path,
-  supervise,
-  supervisor_argv,
-  wait_for_active: openai_lane_supervisor_owner.wait_for_active
-};
-
-export {
-  openai_lane_supervisor
-};

package/dist/commands/chunk-J66YBAAM.js

@@ -1,161 +0,0 @@
-import {
-  run_cut,
-  run_cut_handoff
-} from "./chunk-DYZOOWVW.js";
-import {
-  session_cite
-} from "./chunk-22DVQCP6.js";
-import {
-  issue_cite
-} from "./chunk-HQ2HSZBN.js";
-
-// scripts/run/cut/run-cut-report.ts
-var SUCCESS_EXIT_CODE = 0;
-var FAILURE_EXIT_CODE = 1;
-var CUT_VERDICT = "cut";
-var RESUME_VERDICT = "resume";
-var RESUME_IMPL_VERDICT = "resume-impl";
-var FRESH_VERDICT = "fresh";
-var UNDER_THRESHOLD_VERDICT = "under-threshold";
-var STALE_VERDICT = "stale";
-var INCOMPLETE_VERDICT = "incomplete";
-var BAD_HANDOFF_VERDICT = "bad-handoff";
-var HANDED_OFF_VERDICT = "handed-off";
-var BUSY_VERDICT = "busy";
-var NOT_A_LANE_VERDICT = "not-a-lane";
-var UNREADY_VERDICT = "unready";
-var FAILED_VERDICT = "failed";
-var ENDED_VERDICT = "ended";
-var UNREADABLE_VERDICT = "unreadable";
-var UNKNOWN_VERDICT = "unknown";
-var OVER_VERDICT = "over";
-var printed = { verdict: "" };
-function report(verdict, code) {
-  printed.verdict = verdict;
-  console.info(verdict);
-  return code;
-}
-function last_verdict() {
-  return printed.verdict;
-}
-function report_stale(cut_record) {
-  console.error(run_cut.stale_message(cut_record));
-  return report(STALE_VERDICT, FAILURE_EXIT_CODE);
-}
-function report_busy(cut_record) {
-  console.error(run_cut.busy_message(cut_record));
-  return report(BUSY_VERDICT, FAILURE_EXIT_CODE);
-}
-function report_incomplete(cut_record) {
-  console.error(run_cut.incomplete_message(cut_record));
-  return report(INCOMPLETE_VERDICT, FAILURE_EXIT_CODE);
-}
-var HANDOFF_OVERFLOW_NOTE = "--handoff <path> would grow the cut record past its byte bound";
-var HANDOFF_MISSING_NOTE = "this cut resumes into implementation and needs --handoff <path>";
-function report_bad_handoff(note) {
-  console.error(
-    `${note}. Nothing was cut; write the handoff file at ${run_cut_handoff.HANDOFF_PATH} and reissue.`
-  );
-  return report(BAD_HANDOFF_VERDICT, FAILURE_EXIT_CODE);
-}
-function report_handed_off(cut_record) {
-  console.error(run_cut.handed_off_message(cut_record));
-  return report(HANDED_OFF_VERDICT, SUCCESS_EXIT_CODE);
-}
-function report_unreadable() {
-  console.error(run_cut.unreadable_message());
-  return report(UNREADABLE_VERDICT, FAILURE_EXIT_CODE);
-}
-function report_fault(message) {
-  console.error(message);
-  return report(UNKNOWN_VERDICT, FAILURE_EXIT_CODE);
-}
-function report_unknown() {
-  return report_fault(run_cut.unknown_message());
-}
-function refuse_unready(state) {
-  console.error(
-    `Not ready to cut on ${state.branch} (dirty: ${String(state.is_dirty)}); a cut needs an uncommitted lane branch. Nothing was cut.`
-  );
-  return report(UNREADY_VERDICT, FAILURE_EXIT_CODE);
-}
-function report_under_threshold() {
-  console.error(
-    "The current context is under the shared cut threshold, so nothing was cut; a resume would cost more than the accumulation it would drop. Continue to the gate."
-  );
-  return report(UNDER_THRESHOLD_VERDICT, SUCCESS_EXIT_CODE);
-}
-function report_reviewer() {
-  console.error(
-    "This session is a ship reviewer, which its supervisor is waiting on, so nothing was cut and nothing was relaunched. Finish the review in this process and submit its findings the way your review prompt says."
-  );
-  return report(NOT_A_LANE_VERDICT, SUCCESS_EXIT_CODE);
-}
-function report_held_cut(issue) {
-  console.error(
-    `The cut is recorded for ${session_cite.issue(issue)} outside a lane, so nothing was relaunched. Keep the hold, send a \`confirmation\` Telegram whose body names the resume command \`fullrun ${issue_cite.plain_for("terminal", issue)}\`, and end the turn; the fresh session's \`pnpm josh run:cut --resume ${issue}\` answers \`resume-impl\` with the handoff.`
-  );
-  return report(CUT_VERDICT, SUCCESS_EXIT_CODE);
-}
-var RELAUNCHED_CUT_MARKER = "cut-relaunched";
-function report_relaunched_cut() {
-  console.error(RELAUNCHED_CUT_MARKER);
-  return report(CUT_VERDICT, SUCCESS_EXIT_CODE);
-}
-function report_over() {
-  console.error(
-    "This session is over the shared context-cut threshold (`pnpm josh cost --cut` answers `over`), so the implementation cut was not resumed here and its record is kept. End this conversation and type the invocation again in a fresh session."
-  );
-  return report(OVER_VERDICT, FAILURE_EXIT_CODE);
-}
-function report_missing_supervisor(issue) {
-  console.error(
-    `The OpenAI supervisor for ${session_cite.issue(issue)} is not live, so this nested process was not cut and can continue. Re-dispatch the lane to recover the supervisor.`
-  );
-  return report(FAILED_VERDICT, FAILURE_EXIT_CODE);
-}
-var run_cut_report = {
-  BAD_HANDOFF_VERDICT,
-  BUSY_VERDICT,
-  CUT_VERDICT,
-  ENDED_VERDICT,
-  FAILED_VERDICT,
-  FAILURE_EXIT_CODE,
-  FRESH_VERDICT,
-  HANDED_OFF_VERDICT,
-  HANDOFF_MISSING_NOTE,
-  HANDOFF_OVERFLOW_NOTE,
-  INCOMPLETE_VERDICT,
-  NOT_A_LANE_VERDICT,
-  OVER_VERDICT,
-  RELAUNCHED_CUT_MARKER,
-  RESUME_IMPL_VERDICT,
-  RESUME_VERDICT,
-  STALE_VERDICT,
-  SUCCESS_EXIT_CODE,
-  UNDER_THRESHOLD_VERDICT,
-  UNKNOWN_VERDICT,
-  UNREADABLE_VERDICT,
-  UNREADY_VERDICT,
-  refuse_unready,
-  last_verdict,
-  report,
-  report_bad_handoff,
-  report_busy,
-  report_fault,
-  report_handed_off,
-  report_held_cut,
-  report_incomplete,
-  report_missing_supervisor,
-  report_over,
-  report_relaunched_cut,
-  report_reviewer,
-  report_stale,
-  report_under_threshold,
-  report_unknown,
-  report_unreadable
-};
-
-export {
-  run_cut_report
-};