@joshuafolkken/kit 1.3044.0 → 1.3099.0

package/dist/commands/chunk-OKBZGLD5.js

@@ -0,0 +1,393 @@
+import {
+  openai_lane_supervisor
+} from "./chunk-YANDBVAT.js";
+import {
+  api_outage,
+  run_ending
+} from "./chunk-NHEBKL7X.js";
+import {
+  lane_dispatch_log,
+  lane_seat_start
+} from "./chunk-ZV6BZZJ2.js";
+import {
+  lane_dispatch_dependency
+} from "./chunk-NDQIJBRQ.js";
+import {
+  run_label
+} from "./chunk-KN46UC77.js";
+import {
+  telegram_notify
+} from "./chunk-MDKRTUE4.js";
+import {
+  run_park
+} from "./chunk-BPDNGJXY.js";
+import {
+  agent_argv
+} from "./chunk-L7MDU6D7.js";
+import {
+  agent_worker_profile
+} from "./chunk-LL6G34MF.js";
+import {
+  git_gh_issue_write
+} from "./chunk-4F4KARQN.js";
+import {
+  agent_role_profile
+} from "./chunk-O5JGV7NA.js";
+import {
+  lane_registry
+} from "./chunk-NEOCCN6D.js";
+import {
+  run_liveness
+} from "./chunk-DHJRFBKO.js";
+import {
+  lane_environment
+} from "./chunk-CVRDJCOE.js";
+import {
+  detached_launch
+} from "./chunk-HDVSZ6CZ.js";
+import {
+  run_event_stream_emit
+} from "./chunk-26JL4UU4.js";
+import {
+  run_event_stream
+} from "./chunk-KGSEWOKI.js";
+import {
+  lane_state
+} from "./chunk-7EAYFMDN.js";
+import {
+  IN_PROGRESS_LABEL
+} from "./chunk-QQBMVC5W.js";
+import {
+  lane_child_invocation,
+  lane_reap
+} from "./chunk-ON4IKRGS.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  issue_cite
+} from "./chunk-HQ2HSZBN.js";
+import {
+  ENV_FILE_NAME
+} from "./chunk-IGD6QJPH.js";
+import {
+  run_startup
+} from "./chunk-RV7EQIE4.js";
+import {
+  lane_ledger_write
+} from "./chunk-KIS7JFNP.js";
+import {
+  lane_child_marker
+} from "./chunk-XXPDFJRI.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+
+// scripts/lane/lane-output.ts
+var NO_OUTPUT = "This lane records no output path yet.";
+var FORBIDDEN_CHARACTERS = /["\n\r]/u;
+function invalid_reason(output) {
+  if (FORBIDDEN_CHARACTERS.test(output)) return "the path cannot hold a quote or a line break";
+  return run_liveness.to_safe_path(output) === void 0 ? "the path has to be one `run:liveness` can read: absolute, and under the home or temp directory" : void 0;
+}
+async function record_output(issue, output, profile) {
+  const reason = invalid_reason(output);
+  if (reason !== void 0) return { kind: "invalid", reason };
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return { kind: "no-lane" };
+  const content = lane_registry.read_environment(lane.directory);
+  if (content === void 0) return { kind: "unreadable", lane };
+  lane_registry.write_environment(
+    lane.directory,
+    lane_environment.with_lane_output(content, output, profile)
+  );
+  return { kind: "recorded", lane, output };
+}
+async function read_output(issue) {
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return { kind: "no-lane" };
+  const { output } = lane;
+  if (output === void 0) return { kind: "none", lane };
+  return { kind: "read", lane, output };
+}
+function describe_refusal(refusal, issue) {
+  if (refusal.kind === "invalid") {
+    return `That output path cannot be recorded: ${refusal.reason}. \`pnpm josh run:liveness\` reads only an absolute path, so a record it cannot use would be worse than none.`;
+  }
+  if (refusal.kind === "unreadable") {
+    return `The lane for ${session_cite.issue(issue)} has a ${ENV_FILE_NAME} that cannot be read at ${refusal.lane.directory}. Fix it and run this again \u2014 writing a new one would drop the lane's port seat with it.`;
+  }
+  return `No lane is open for ${session_cite.issue(issue)}. Run \`pnpm josh lane:list\` to see what is open.`;
+}
+var lane_output = {
+  NO_OUTPUT,
+  describe_refusal,
+  read_output,
+  record_output
+};
+
+// scripts/lane/lane-resume.ts
+var ANTHROPIC = "anthropic";
+function fresh_plan(issue) {
+  return { kind: "fresh", invocation: lane_child_invocation.child_invocation(issue) };
+}
+function resumable_session(record, provider) {
+  if (provider !== ANTHROPIC || record === void 0) return void 0;
+  return api_outage.is_outage(record) ? record.session_id : void 0;
+}
+function plan(issue, record, provider) {
+  const session_id = resumable_session(record, provider);
+  if (session_id === void 0) return fresh_plan(issue);
+  return {
+    kind: "resume",
+    session_id,
+    invocation: lane_child_invocation.outage_resume_invocation(issue)
+  };
+}
+var lane_resume = { plan };
+
+// scripts/lane/lane-dispatch-prepare.ts
+function built_for(plan2, profile, lane) {
+  if (plan2.kind === "resume") {
+    return agent_argv.with_resume_in(plan2.invocation, profile, plan2.session_id, lane.directory);
+  }
+  return agent_argv.with_profile_in(plan2.invocation, profile, lane.directory);
+}
+async function worker_profile(lane) {
+  const worker = await agent_worker_profile.resolve(
+    lane.directory,
+    async () => await git_gh_issue_write.read_label_names(lane.issue)
+  );
+  if (worker.kind === "unset") return agent_role_profile.resolve(agent_role_profile.WORKER);
+  return worker.kind === "rejected" ? worker : { kind: "profile", profile: worker.worker.agent };
+}
+async function prepared(lane, is_fresh) {
+  const resolved = await worker_profile(lane);
+  if (resolved.kind === "rejected") return resolved;
+  const record = is_fresh ? void 0 : run_ending.read_exit(lane_dispatch_log.default_log_path(lane));
+  const plan2 = lane_resume.plan(lane.issue, record, resolved.profile.provider);
+  const built = built_for(plan2, resolved.profile, lane);
+  if (built.kind === "rejected") return built;
+  const resumed_from = plan2.kind === "resume" ? plan2.session_id : void 0;
+  return {
+    kind: "prepared",
+    invocation: plan2.invocation,
+    argv: built.argv,
+    profile: built.profile,
+    resumed_from
+  };
+}
+var lane_dispatch_prepare = { prepared };
+
+// scripts/lane/lane-dispatch.ts
+var NOTE_SEPARATOR = "; ";
+var WARNING_RECOVERY = "Check the lane with `pnpm josh lane:list`, then run `pnpm josh lane:dispatch <issue-number>` again.";
+var LABEL_UNSET_KIND = "label-unset";
+var RESTART_START = "restart";
+var DEPENDENCY_WAIT = "dependency-wait";
+function child_invocation(issue) {
+  return lane_child_invocation.child_invocation(issue);
+}
+function resume_invocation(issue) {
+  return lane_child_invocation.resume_invocation(issue);
+}
+function default_log_path(lane) {
+  return lane_dispatch_log.default_log_path(lane);
+}
+async function resolved_log(lane, profile) {
+  const outcome = await lane_output.record_output(lane.issue, default_log_path(lane), profile);
+  if (outcome.kind === "recorded") return { kind: "ready", path: outcome.output };
+  return { kind: "unrecordable", reason: lane_output.describe_refusal(outcome, lane.issue) };
+}
+function failed_start(request, note, notes) {
+  return {
+    kind: "failed",
+    lane: request.lane,
+    log_path: request.log_path,
+    note: [note, ...notes].join(NOTE_SEPARATOR)
+  };
+}
+function dispatched_of(request, pid, notes) {
+  return { ...request, pid, notes, kind: "dispatched" };
+}
+function existing_dispatch(request) {
+  if (request.profile.provider !== "openai") return void 0;
+  const active = openai_lane_supervisor.active(request.lane.directory);
+  if (active?.issue !== request.lane.issue) return void 0;
+  if (!openai_lane_supervisor.approve(request.lane.directory, active.nonce)) {
+    return failed_start(
+      request,
+      `the OpenAI supervisor for lane ${session_cite.issue(request.lane.issue)} was cancelled`,
+      []
+    );
+  }
+  return dispatched_of(request, active.pid, []);
+}
+function launch_argv(request, nonce) {
+  if (request.profile.provider !== "openai") return request.argv;
+  if (nonce === void 0) throw new Error("OpenAI supervisor nonce is missing");
+  return openai_lane_supervisor.supervisor_argv(request.lane.issue, nonce);
+}
+async function openai_dispatched_start(request, notes, nonce, pid) {
+  const owner = await openai_lane_supervisor.wait_for_active(request.lane.directory, pid);
+  if (owner?.issue !== request.lane.issue) {
+    if (nonce !== void 0) openai_lane_supervisor.cancel(request.lane.directory, nonce);
+    return failed_start(
+      request,
+      `the OpenAI supervisor did not claim lane ${session_cite.issue(request.lane.issue)}`,
+      notes
+    );
+  }
+  if (!openai_lane_supervisor.approve(request.lane.directory, owner.nonce)) {
+    return failed_start(
+      request,
+      `the OpenAI supervisor for lane ${session_cite.issue(request.lane.issue)} was cancelled`,
+      notes
+    );
+  }
+  return dispatched_of(request, owner.pid, notes);
+}
+async function dispatched_start(request, pid, notes, nonce) {
+  return request.profile.provider === "openai" ? await openai_dispatched_start(request, notes, nonce, pid) : dispatched_of(request, pid, notes);
+}
+function worker_environment(lane) {
+  return {
+    ...lane_child_marker.env_for(lane.issue),
+    ...lane_seat_start.environment(lane),
+    [run_startup.ENVIRONMENT_KEY]: ""
+  };
+}
+async function started(request) {
+  const notes = [];
+  const existing = existing_dispatch(request);
+  if (existing !== void 0) return existing;
+  run_park.clear(request.lane.issue, request.lane.directory);
+  const nonce = request.profile.provider === "openai" ? openai_lane_supervisor.new_nonce() : void 0;
+  const result = detached_launch.launch(
+    {
+      argv: launch_argv(request, nonce),
+      cwd: request.lane.directory,
+      log_path: request.log_path,
+      profile: request.profile,
+      env: worker_environment(request.lane)
+    },
+    (note) => {
+      notes.push(note);
+    }
+  );
+  if (result.kind !== "launched") return failed_start(request, result.note, notes);
+  return await dispatched_start(request, result.pid, notes, nonce);
+}
+async function mark_in_progress(issue) {
+  return await run_label.claim(issue);
+}
+async function record_started(issue, start) {
+  const now = /* @__PURE__ */ new Date();
+  await run_event_stream_emit.emit(
+    run_event_stream.EVENT_KIND.CHILD_LAUNCH,
+    `${issue_cite.plain_for("program", issue)} dispatched`,
+    now
+  );
+  await lane_ledger_write.record_dispatch(Number(issue));
+  await lane_state.record_change(
+    {
+      issue,
+      state: "running",
+      command: start === RESTART_START ? "lane:restart" : "lane:dispatch",
+      is_launch: true
+    },
+    { now }
+  );
+}
+async function claimed(issue, start) {
+  if (start === RESTART_START) return { is_applied: true };
+  return await mark_in_progress(issue);
+}
+async function start_wait(issue, request, start) {
+  if (request.profile.provider !== "openai" && lane_reap.is_child_running(issue)) {
+    return { kind: DEPENDENCY_WAIT, reason: "child is already running" };
+  }
+  const wait = await lane_dispatch_dependency.check(issue);
+  if (wait !== void 0 && start === RESTART_START) await lane_dispatch_dependency.defer(issue);
+  return wait;
+}
+async function finish_dispatch(issue, request, start) {
+  const wait = await start_wait(issue, request, start);
+  if (wait !== void 0) return wait;
+  const mark = await claimed(issue, start);
+  if (!mark.is_applied) return { kind: LABEL_UNSET_KIND, reason: mark.reason };
+  await lane_dispatch_dependency.begin(issue);
+  const outcome = await started(request);
+  const is_failed = outcome.kind === "failed";
+  await (is_failed ? run_label.unmark(issue) : record_started(issue, start));
+  return outcome;
+}
+async function dispatch_child(issue, start = "resumable") {
+  issue_number_shape.require_issue_number(issue);
+  const lane = await lane_registry.find_open_lane(issue);
+  if (lane === void 0) return { kind: "no-lane" };
+  const built = await lane_dispatch_prepare.prepared(lane, start === RESTART_START);
+  const log_path = default_log_path(lane);
+  if (built.kind === "rejected") return { kind: "failed", lane, log_path, note: built.note };
+  const log = await resolved_log(lane, built.profile);
+  if (log.kind !== "ready") return log;
+  return await lane_seat_start.start(
+    lane,
+    async (seated) => await finish_dispatch(issue, { lane: seated, log_path: log.path, ...built }, start)
+  );
+}
+function log_sentence(outcome, issue) {
+  const poll = `run \`pnpm josh run:liveness ${issue} --output ${outcome.log_path}\` \u2014 it reads the child's process for itself`;
+  if (outcome.notes.length > 0) {
+    return ` Its output is NOT being kept \u2014 ${outcome.notes.join(NOTE_SEPARATOR)} \u2014 so ${outcome.log_path} will not grow and the process trace is the only answer: ${poll}.`;
+  }
+  return ` It writes to ${outcome.log_path}. Wait on it with \`pnpm josh lane:await ${issue}\` in the background and end the turn; once that output falls silent, ${poll}.`;
+}
+function resume_sentence(outcome) {
+  if (outcome.resumed_from === void 0) {
+    return " Started fresh \u2014 no resumable session was found in the lane record.";
+  }
+  return ` Resumed session ${outcome.resumed_from} \u2014 the disconnected child's context was recovered.`;
+}
+function describe_dispatch(outcome, issue) {
+  if (outcome.kind === "no-lane") {
+    return `No lane is open for ${session_cite.issue(issue)}. Run \`pnpm josh lane:open ${issue}\` first, then dispatch into it.`;
+  }
+  if (outcome.kind === "unrecordable") return outcome.reason;
+  if (outcome.kind === LABEL_UNSET_KIND) {
+    return `The child for ${session_cite.issue(issue)} was not started: the \`${IN_PROGRESS_LABEL}\` label could not be applied (${outcome.reason}), so the lane would be counted as empty. Nothing was launched.`;
+  }
+  if (outcome.kind === "failed") {
+    return `The child for ${session_cite.issue(issue)} did not start: ${outcome.note}.${agent_role_profile.default_notice()} Its log is at ${outcome.log_path}.`;
+  }
+  return `Dispatched \`${outcome.invocation}\` as process ${String(outcome.pid)} in ${outcome.lane.directory} with ${agent_role_profile.describe(outcome.profile)}.${agent_role_profile.default_notice()}${resume_sentence(outcome)}${log_sentence(outcome, issue)}`;
+}
+function describe(outcome, issue) {
+  return outcome.kind === DEPENDENCY_WAIT ? outcome.reason : describe_dispatch(outcome, issue);
+}
+function is_worth_warning(outcome) {
+  if (outcome.kind === DEPENDENCY_WAIT) return false;
+  return outcome.kind !== "dispatched" || outcome.notes.length > 0;
+}
+async function warn_of_problem(outcome, issue) {
+  await telegram_notify.warn({
+    issue_title: `lane child dispatch ${issue_cite.plain_for("telegram", issue)}`,
+    body: describe(outcome, issue),
+    recovery: WARNING_RECOVERY
+  });
+}
+var lane_dispatch = {
+  child_invocation,
+  claim_marker: mark_in_progress,
+  default_log_path,
+  describe,
+  dispatch_child,
+  is_worth_warning,
+  resume_invocation,
+  warn_of_problem
+};
+
+export {
+  lane_output,
+  lane_dispatch
+};

package/dist/commands/chunk-OKN63ZH5.js

@@ -0,0 +1,109 @@
+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 {
+  error_text
+} from "./chunk-CDY4NFQG.js";
+
+// scripts/run/event/run-event-setup.ts
+var STAGE = {
+  // `josh backlogrun` started the parent session, which is reading its procedure.
+  STARTING: "starting session",
+  // `run:carry --begin` claimed the run, and the parent is planning it.
+  PLANNING: "planning",
+  // The supervisor took the run over from the parent and is asking for the first offer.
+  HANDING_OFF: "handing off",
+  // No child is runnable; maintenance may still be finishing before the replaceable drain.
+  WATCHING: "watching",
+  // The driver answered something only a session can act on — an untriaged child, an epic left to a
+  // person — and the supervisor is waking one. The next hand-off replaces it.
+  JUDGING: "waiting on judgment",
+  // The supervisor started that session, which is now acting on the driver's answer. It is detached, so
+  // its end is the supervisor's next hand-off, which replaces this.
+  SESSION: "judgment session running",
+  // The driver read a drain owing the retrospective and is waiting on the retrospective unit it
+  // started (joshuafolkken/kit#6745). The unit's end is the driver's next stage, which replaces this.
+  RETROSPECTIVE: "retrospective",
+  // The driver's launch of a lane returned without a child: no lane was free to open, or a step after
+  // the open failed. Written through `no_child`, naming its issue, so it ends that lane's stage alone
+  // while the pass's other launches run on (joshuafolkken/kit#5519).
+  NO_CHILD: "no child launched"
+};
+var OPENING = "opening lane";
+var INSTALLING = "installing dependencies";
+var DISPATCHING = "dispatching";
+var LANE_STAGE = { OPENING, INSTALLING, DISPATCHING };
+function opening_lane(issue) {
+  return `${OPENING} ${issue_cite.plain_for("program", issue)}`;
+}
+function installing(issue) {
+  return `${INSTALLING} ${issue_cite.plain_for("program", issue)}`;
+}
+function dispatching(issue) {
+  return `${DISPATCHING} ${issue_cite.plain_for("program", issue)}`;
+}
+function no_child(issue) {
+  return `${STAGE.NO_CHILD} ${issue_cite.plain_for("program", issue)}`;
+}
+async function emit(text) {
+  await run_event_stream_emit.emit(run_event_stream.EVENT_KIND.SETUP, text);
+}
+function append_stage(resolve_target, text, at) {
+  try {
+    const { SETUP } = run_event_stream.EVENT_KIND;
+    run_event_stream.append(resolve_target(), SETUP, text, at.toISOString());
+  } catch (error) {
+    error_text.trace_swallowed("run_event_setup.append_stage", error);
+  }
+}
+function emit_in(repository, text, at) {
+  append_stage(() => run_event_stream.target_of(repository), text, at);
+}
+function emit_to(target, text, at) {
+  append_stage(() => target, text, at);
+}
+function is_stage(event, prefix) {
+  return event.kind === run_event_stream.EVENT_KIND.SETUP && event.text.startsWith(prefix);
+}
+function first_lane_span(start, later) {
+  const next_start = later.findIndex((event) => is_stage(event, STAGE.STARTING));
+  const session = next_start === -1 ? later : later.slice(0, next_start);
+  const opening = session.find((event) => is_stage(event, OPENING));
+  return {
+    from_ms: Date.parse(start.at),
+    end_ms: opening === void 0 ? void 0 : Date.parse(opening.at)
+  };
+}
+function first_lane_spans(events) {
+  return events.flatMap(
+    (event, index) => is_stage(event, STAGE.STARTING) ? [first_lane_span(event, events.slice(index + 1))] : []
+  );
+}
+function first_lane_ms(events) {
+  const span = first_lane_spans(events).at(-1);
+  return span?.end_ms === void 0 ? void 0 : span.end_ms - span.from_ms;
+}
+var run_event_setup = {
+  LANE_STAGE,
+  STAGE,
+  dispatching,
+  emit,
+  emit_in,
+  emit_to,
+  first_lane_ms,
+  first_lane_spans,
+  installing,
+  is_stage,
+  no_child,
+  opening_lane
+};
+
+export {
+  run_event_setup
+};