@joshuafolkken/kit 1.3041.0 → 1.3092.0

package/dist/commands/chunk-4MGTNY2L.js

@@ -0,0 +1,347 @@
+import {
+  lane_session_action
+} from "./chunk-VXE3V3OC.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
+};

package/dist/commands/chunk-4NSIW3UB.js

@@ -0,0 +1,104 @@
+import {
+  observation_ledger_home
+} from "./chunk-QXBOECGL.js";
+import {
+  git_branch
+} from "./chunk-YEQFAEVW.js";
+import {
+  time_transcript_line
+} from "./chunk-YSLGWRQN.js";
+import {
+  hook_context
+} from "./chunk-CUWT6UQO.js";
+import {
+  agent_session_role
+} from "./chunk-DURHGVRC.js";
+import {
+  git_common_directory
+} from "./chunk-JPMAW2VZ.js";
+import {
+  git_spawn
+} from "./chunk-B5HP6T4L.js";
+import {
+  json_value
+} from "./chunk-HIU2WXB6.js";
+
+// scripts/hooks/hook-ledger.ts
+import { appendFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+var LEDGER_DIRECTORY = "hook-ledger";
+var LEDGER_EXTENSION = ".jsonl";
+var COMMAND_HEAD = 80;
+var RULE_HEAD = 48;
+var STOP_TOOL = "Stop";
+var COMMAND_FIELDS = ["command", "file_path", "pattern", "url", "prompt"];
+var input_schema = z.record(z.string(), z.unknown());
+var payload_schema = z.object({
+  tool_name: z.string().catch(STOP_TOOL),
+  tool_input: z.unknown().optional(),
+  transcript_path: z.string().catch("")
+});
+var EMPTY_PAYLOAD = payload_schema.parse({});
+var block_schema = z.object({ decision: z.literal("block"), reason: z.string() });
+function rule_of(reason) {
+  const guard = time_transcript_line.guard_from_refusal(reason);
+  return guard === "" ? reason.trim().slice(0, RULE_HEAD) : guard;
+}
+function command_of(input) {
+  const fields = input_schema.safeParse(input).data ?? {};
+  const value = COMMAND_FIELDS.map((key) => fields[key]).find((field) => typeof field === "string");
+  return typeof value === "string" ? value.slice(0, COMMAND_HEAD) : "";
+}
+function entry_of(refusal, branch, now, environment) {
+  const payload = json_value.parse_with(refusal.raw_payload, payload_schema) ?? EMPTY_PAYLOAD;
+  return {
+    at: now.toISOString(),
+    hook: refusal.hook,
+    rule: rule_of(refusal.reason),
+    tool: payload.tool_name,
+    role: environment[agent_session_role.KEY] ?? "",
+    issue: git_branch.issue_from_branch(branch),
+    session: payload.transcript_path,
+    command: command_of(payload.tool_input)
+  };
+}
+function ledger_directory(context = hook_context.from_process()) {
+  if (context.env["VITEST"] !== void 0) return void 0;
+  const common = git_common_directory.repository(context.cwd);
+  return common === void 0 ? void 0 : path.join(common, git_common_directory.STATE_DIRECTORY, LEDGER_DIRECTORY);
+}
+async function append(entry, directory) {
+  const day = observation_ledger_home.ledger_date(new Date(entry.at));
+  await mkdir(directory, { recursive: true });
+  await appendFile(path.join(directory, `${day}${LEDGER_EXTENSION}`), `${JSON.stringify(entry)}
+`);
+}
+async function record(refusal, directory = ledger_directory(), context = hook_context.from_process()) {
+  if (directory === void 0) return;
+  try {
+    const branch = await git_spawn.read(["-C", context.cwd, "rev-parse", "--abbrev-ref", "HEAD"]);
+    await append(entry_of(refusal, branch, /* @__PURE__ */ new Date(), context.env), directory);
+  } catch {
+  }
+}
+async function record_reason(hook, reason, raw_payload, context = hook_context.from_process()) {
+  if (reason !== void 0) {
+    await record({ hook, reason, raw_payload }, ledger_directory(context), context);
+  }
+}
+function blocked_reason(envelope) {
+  return json_value.parse_with(envelope, block_schema)?.reason;
+}
+var hook_ledger = {
+  blocked_reason,
+  command_of,
+  ledger_directory,
+  record,
+  record_reason,
+  rule_of
+};
+
+export {
+  hook_ledger
+};

package/dist/commands/chunk-4YTKV6WV.js

@@ -0,0 +1,37 @@
+import {
+  run_retrospective
+} from "./chunk-IAB6LCJL.js";
+import {
+  doctor_consumer
+} from "./chunk-S4OZJIXD.js";
+import {
+  find_package_directory
+} from "./chunk-LR22UK5W.js";
+
+// scripts/backlog/backlog-drive-retrospective.ts
+var STOP_VERDICT = "stop";
+var EXHAUSTED_ANSWER = "exhausted";
+var RETROSPECTIVE_REASON = "retrospective";
+function is_owed(carry) {
+  const root = find_package_directory(process.cwd());
+  return run_retrospective.is_owed({
+    is_retrospective_enabled: run_retrospective.is_enabled(),
+    is_lane_child: false,
+    is_retrospective_done: carry.retrospective === true,
+    is_consumer: doctor_consumer.is_kit_consumer(root)
+  });
+}
+function is_drain_owed(read, state, verdict) {
+  return read.verdict === verdict && read.answer === EXHAUSTED_ANSWER && state.in_flight.length === 0 && read.is_retrospective_owed === true;
+}
+async function ran(result, read, ports) {
+  if (result.kind === "end" || !is_drain_owed(read, result.state, STOP_VERDICT)) return result;
+  if (await ports.retrospective()) return result;
+  const end = { reason: RETROSPECTIVE_REASON, token: RETROSPECTIVE_REASON, issue: void 0 };
+  return { kind: "end", end, state: result.state };
+}
+var backlog_drive_retrospective = { is_drain_owed, is_owed, ran };
+
+export {
+  backlog_drive_retrospective
+};