@joshuafolkken/kit 1.3099.0 → 1.3125.0

package/dist/commands/chunk-OKBZGLD5.js

@@ -1,393 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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
-};