@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-ZHSNQ2F7.js

@@ -0,0 +1,161 @@
+import {
+  run_cut,
+  run_cut_handoff
+} from "./chunk-TFDVTU6O.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
+};

package/dist/commands/chunk-ZI3SABMH.js

@@ -0,0 +1,347 @@
+import {
+  lane_session_action
+} from "./chunk-2CNVIA35.js";
+import {
+  ts_entry_loader
+} from "./chunk-VHRNXWVP.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  process_identity
+} from "./chunk-F2RDEF2J.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  atomic_write
+} from "./chunk-KSR23NYN.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/lane/lane-session-broker.ts
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync as readFileSync2, rmSync, unlinkSync } from "node:fs";
+import path from "node:path";
+import { z as z3 } from "zod";
+
+// scripts/lane/lane-broker-server.ts
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+var SERVER_SUFFIX = ".server";
+var server_schema = z.object({
+  session: z.uuid(),
+  pid: z.number().int().positive(),
+  process_start: z.string().optional()
+}).strict();
+function server_path(response) {
+  return `${response}${SERVER_SUFFIX}`;
+}
+function write(response, session) {
+  stamp_file.replace_stamp(server_path(response), { session, ...process_identity.own_fields() });
+}
+function remove(response) {
+  stamp_file.remove_stamp(server_path(response));
+}
+function read(response, session) {
+  try {
+    const server = json_value.parse_with(readFileSync(server_path(response), "utf8"), server_schema);
+    return server?.session === session ? server : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function is_serving_process(server) {
+  return process_identity.is_present_process(server.pid, server.process_start) !== false;
+}
+function is_running(server) {
+  return process_identity.is_present_pid(server.pid);
+}
+var lane_broker_server = { is_running, is_serving_process, read, remove, server_path, write };
+
+// scripts/lane/lane-session-reread.ts
+import { dirname as __josh_dirname } from "node:path";
+import { fileURLToPath as __josh_file_path } from "node:url";
+import { fileURLToPath } from "node:url";
+import { execa } from "execa";
+import { z as z2 } from "zod";
+var __josh_meta = import.meta;
+var __josh_source_url = new URL("../../scripts/lane/lane-session-reread.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 ENTRY = fileURLToPath(new URL("lane-session-reread-main.ts", __josh_source_url));
+var answer_schema = z2.discriminatedUnion("is_success", [
+  z2.object({ is_success: z2.literal(true) }).strict(),
+  z2.object({ is_success: z2.literal(false), reason: z2.string() }).strict()
+]);
+async function answer_text(issue, text) {
+  const request2 = json_value.parse_with(text, lane_session_action.request_schema);
+  if (request2 === void 0) return void 0;
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return void 0;
+  return await lane_session_action.answer(lane, request2.action);
+}
+function last_line(text) {
+  return text.trimEnd().split("\n").at(-1) ?? "";
+}
+async function reread(issue, received) {
+  const result = await execa(
+    process.execPath,
+    [...ts_entry_loader.loader_argv(process.execArgv), ENTRY, issue, JSON.stringify(received)],
+    { reject: false, stderr: "inherit" }
+  );
+  if (result.exitCode !== 0) return void 0;
+  return json_value.parse_with(last_line(result.stdout), answer_schema);
+}
+var lane_session_reread = { answer_text, reread };
+
+// scripts/lane/lane-session-broker.ts
+var REQUEST_PREFIX = ".josh-review-request-";
+var RESPONSE_PREFIX = ".josh-review-response-";
+var CACHE_DIRECTORY = ["node_modules", ".cache"];
+var POLL_MS = 100;
+var LEGACY_HEARTBEAT_MS = 500;
+var LEGACY_HEARTBEAT_LIMIT_MS = 3e3;
+var MINUTE_MS = 6e4;
+var REQUEST_LIMIT_MINUTES = {
+  review: 30,
+  relaunch: 2
+};
+var { request_schema } = lane_session_action;
+var envelope_schema = z3.looseObject({ session: z3.uuid(), nonce: z3.uuid() });
+var UNREADABLE_REASON = "the broker could not read the request";
+var VERSION_NOTE = "the broker's code differs from the ship's; a run:wake supervisor re-checks its code at its next pass";
+var refusal = { is_pending: false };
+var response_schema = z3.object({
+  session: z3.uuid(),
+  nonce: z3.string(),
+  is_success: z3.boolean(),
+  heartbeat_at: z3.number().int().positive()
+}).strict();
+var reason_schema = z3.object({ nonce: z3.string(), reason: z3.string() }).strict();
+var { failure } = lane_session_action;
+function request_path(directory, issue) {
+  return path.join(directory, ...CACHE_DIRECTORY, `${REQUEST_PREFIX}${issue}.json`);
+}
+function response_path(directory, issue) {
+  const common = git_common_directory.resolve(directory);
+  if (common === void 0 || path.basename(common) !== ".git") return void 0;
+  return path.join(path.dirname(common), ...CACHE_DIRECTORY, `${RESPONSE_PREFIX}${issue}.json`);
+}
+function reason_path(response) {
+  return `${response}.reason`;
+}
+function read_record(target, schema) {
+  try {
+    return json_value.parse_with(readFileSync2(target, "utf8"), schema);
+  } catch {
+    return void 0;
+  }
+}
+function write_record(target, body) {
+  atomic_write.replace_file(target, JSON.stringify(body));
+}
+function refused_field(issue) {
+  const at = issue.path.map(String);
+  if (issue.code !== "unrecognized_keys") return [`${at.join(".")}: ${issue.message}`];
+  return issue.keys.map((key) => `unrecognized key: ${[...at, key].join(".")}`);
+}
+function unreadable(error) {
+  const fields = error.issues.flatMap((issue) => refused_field(issue));
+  return failure(`${UNREADABLE_REASON} \u2014 ${VERSION_NOTE} \u2014 ${fields.join("; ")}`);
+}
+function is_unreadable(answer) {
+  return !answer.is_success && answer.reason.includes(UNREADABLE_REASON);
+}
+async function answer_request(lane, received) {
+  const parsed = request_schema.safeParse(received);
+  if (parsed.success) return await lane_session_action.answer(lane, parsed.data.action);
+  refusal.is_pending = true;
+  return await lane_session_reread.reread(lane.issue, received) ?? unreadable(parsed.error);
+}
+function take_refusal() {
+  const { is_pending } = refusal;
+  refusal.is_pending = false;
+  return is_pending;
+}
+var answering = { count: 0 };
+function is_answering() {
+  return answering.count > 0;
+}
+async function answer_counted(lane, received) {
+  answering.count += 1;
+  try {
+    return await answer_request(lane, received);
+  } finally {
+    answering.count -= 1;
+  }
+}
+async function process_request(lane, response, received, state) {
+  const answer = await answer_counted(lane, received);
+  const { session, nonce } = received;
+  if (!answer.is_success) write_record(reason_path(response), { nonce, reason: answer.reason });
+  state.current = { session, nonce, is_success: answer.is_success, heartbeat_at: Date.now() };
+  write_record(response, state.current);
+}
+async function serve(lane, session, response, state) {
+  const served = { nonce: "" };
+  const target = request_path(lane.directory, lane.issue);
+  async function serve_pass() {
+    if (!state.is_running) return true;
+    const received = read_record(target, envelope_schema);
+    if (received?.session === session && received.nonce !== served.nonce) {
+      served.nonce = received.nonce;
+      await process_request(lane, response, received, state);
+    }
+    return void 0;
+  }
+  await poll.wait_for(serve_pass, { interval_ms: POLL_MS });
+}
+function prepare(lane) {
+  const response = response_path(lane.directory, lane.issue);
+  if (response === void 0) throw new Error("review broker has no trusted response location");
+  const session = randomUUID();
+  mkdirSync(path.dirname(response), { recursive: true });
+  mkdirSync(path.dirname(request_path(lane.directory, lane.issue)), { recursive: true });
+  lane_broker_server.write(response, session);
+  const current = {
+    session,
+    nonce: "",
+    is_success: false,
+    heartbeat_at: Date.now()
+  };
+  write_record(response, current);
+  return { response, current };
+}
+function start_heartbeat(state, response) {
+  const heartbeat = setInterval(() => {
+    state.current = { ...state.current, heartbeat_at: Date.now() };
+    write_record(response, state.current);
+  }, LEGACY_HEARTBEAT_MS);
+  heartbeat.unref();
+  return heartbeat;
+}
+async function stop_server(state, heartbeat, serving, response) {
+  state.is_running = false;
+  await serving;
+  clearInterval(heartbeat);
+  unlinkSync(response);
+  rmSync(reason_path(response), { force: true });
+  lane_broker_server.remove(response);
+}
+async function with_server(lane, run) {
+  const { response, current } = prepare(lane);
+  const state = { is_running: true, current };
+  const heartbeat = start_heartbeat(state, response);
+  const serving = serve(lane, current.session, response, state);
+  try {
+    return await run();
+  } finally {
+    await stop_server(state, heartbeat, serving, response);
+  }
+}
+function is_fresh_heartbeat(heartbeat_at) {
+  const now = Date.now();
+  return heartbeat_at <= now && heartbeat_at >= now - LEGACY_HEARTBEAT_LIMIT_MS;
+}
+function is_live_response(target, response, is_live) {
+  if (response === void 0) return false;
+  const server = lane_broker_server.read(target, response.session);
+  return server === void 0 ? is_fresh_heartbeat(response.heartbeat_at) : is_live(server);
+}
+function session_response(target, session) {
+  const response = read_record(target, response_schema);
+  return response?.session === session ? response : void 0;
+}
+function answer_of(target, response) {
+  if (response.is_success) return lane_session_action.SUCCESS;
+  const record = read_record(reason_path(target), reason_schema);
+  const reason = record?.nonce === response.nonce ? record.reason : "it gave no reason";
+  return failure(`the broker answered a failure: ${reason}`);
+}
+function response_verdict(target, session, nonce) {
+  const response = session_response(target, session);
+  if (!is_live_response(target, response, lane_broker_server.is_running)) {
+    return failure("the broker stopped serving before it answered");
+  }
+  return response.nonce === nonce ? answer_of(target, response) : void 0;
+}
+async function wait_response(target, session, nonce, kind) {
+  const limit_minutes = REQUEST_LIMIT_MINUTES[kind];
+  const deadline = Date.now() + limit_minutes * MINUTE_MS;
+  function verdict_by_deadline() {
+    if (Date.now() >= deadline) {
+      return failure(`the broker gave no answer within ${String(limit_minutes)} minutes`);
+    }
+    return response_verdict(target, session, nonce);
+  }
+  return await poll.wait_for(verdict_by_deadline, { interval_ms: POLL_MS });
+}
+function live_response(target) {
+  const response = read_record(target, response_schema);
+  return is_live_response(target, response, lane_broker_server.is_serving_process) ? response : void 0;
+}
+function serving_session(directory, issue) {
+  const target = response_path(directory, issue);
+  return target === void 0 ? void 0 : live_response(target)?.session;
+}
+function is_serving(directory, issue) {
+  return serving_session(directory, issue) !== void 0;
+}
+function withdraw(pending, nonce) {
+  if (read_record(pending, request_schema)?.nonce === nonce) stamp_file.remove_stamp(pending);
+}
+async function record_failure(issue, answer) {
+  if (answer.is_success) return;
+  const text = `${issue_cite.plain_for("program", issue)} lane broker: ${answer.reason}`;
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.NOTE, text);
+}
+async function send(directory, issue, action) {
+  const target = response_path(directory, issue);
+  const response = target === void 0 ? void 0 : live_response(target);
+  if (target === void 0 || response === void 0) return failure("no broker serves this lane");
+  const nonce = randomUUID();
+  const body = { session: response.session, nonce, action };
+  const pending = request_path(directory, issue);
+  stamp_file.replace_stamp(pending, body);
+  const answer = await wait_response(target, response.session, nonce, action.kind);
+  withdraw(pending, nonce);
+  return answer;
+}
+async function request(directory, issue, action) {
+  const answer = await send(directory, issue, action);
+  await record_failure(issue, answer);
+  return answer;
+}
+var lane_session_broker = {
+  is_answering,
+  is_serving,
+  is_unreadable,
+  request,
+  request_path,
+  response_path,
+  review_paths: lane_session_action.review_paths,
+  serving_session,
+  take_refusal,
+  with_server
+};
+
+export {
+  lane_session_broker
+};