@edgehero/pi-dispatch 2.1.0 → 3.0.0

package/src/queue.mjs

@@ -1,6 +1,7 @@
+import { randomUUID } from "node:crypto";
 import { Queue } from "bullmq";
 import { assertJudgedConnection, onValkeyError } from "./connection.mjs";
-import { chainedJobId, localJobId, deliveryJobId, gitlabDeliveryJobId, forgeDeliveryJobId } from "./job-id.mjs";
+import { chainedJobId, localJobId, deliveryJobId, gitlabDeliveryJobId, forgeDeliveryJobId, manualTriggerJobId } from "./job-id.mjs";
 import { targetSeparator } from "./forges.mjs";
 import { PR_CLOSE_ACTIONS } from "./triggers.mjs";
 
@@ -62,7 +63,7 @@ export function fleetQueueNames(hosts) {
 /** The name charset, duplicated from `config.mjs` deliberately: this module imports nothing. */
 const WORKER_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 
-export { chainedJobId, localJobId, deliveryJobId, gitlabDeliveryJobId, forgeDeliveryJobId };
+export { chainedJobId, localJobId, deliveryJobId, gitlabDeliveryJobId, forgeDeliveryJobId, manualTriggerJobId };
 
 /**
  * A queue handle. `name` defaults to the shared queue, so every existing caller is unchanged and a
@@ -84,7 +85,98 @@ export function makeQueue(connection, { name = QUEUE } = {}) {
  * removeOnComplete keeps the dedup window ~= the retention. Unlike webhooks, local jobs are not
  * redelivered, so a modest window is enough.
  */
-export async function enqueueLocalJob(queue, { folder, flow, task, command, provider, model, maxTurns, image, backend, excludeTools, skillsDir, secrets, secretsProfile, chainDepth, parentJobId, jobId, now = new Date() }) {
+export async function enqueueLocalJob(queue, fields) {
+	return (await addLocalJob(queue, fields)).id;
+}
+
+/**
+ * `enqueueLocalJob` for a caller that must SAY whether anything was queued (issue #524): the operator's
+ * `pi-dispatch run`. Returns `{ id, existing }`, where `existing` is null for a job this call created, and
+ * `{ queuedAt, state }` when the one-minute dedup answered with a job an identical earlier call made.
+ *
+ * The CLI printed "queued <id>" either way, so a second `run` inside the same minute announced a job while
+ * running nothing, under the id of one that had already finished. The dedup itself is deliberate and stays.
+ *
+ * How a duplicate is told apart, and why not by asking first. BullMQ answers a jobId that already exists by
+ * returning the existing id inside a Job object it built LOCALLY for this call, so the return value says nothing
+ * about whether anything was stored. Each call therefore puts a random nonce of its own on the job's data
+ * (`enqueueNonce`) and reads the stored job back AFTER the add: the stored nonce is this call's exactly when
+ * this call's add is the one BullMQ kept. Exactly one of any number of concurrent identical calls finds its own.
+ * The first version compared the add's timestamp instead, and PR #528's review refuted it: calls in the same
+ * millisecond share a timestamp, and ten in parallel all reported "created" while one job existed. A lookup
+ * BEFORE the add has the same flaw by construction, since every concurrent caller can see nothing.
+ *
+ * The nonce is on job data, never inside `trigger`, which is the object copied into /job/event.json: it is the
+ * producer's bookkeeping and the agent has no use for it. Only the two reporting producers add it (this one and
+ * `enqueueTriggerRunReporting`), so a job from the outbox collector or a cron tick keeps exactly the data it had.
+ *
+ * A separate function rather than a change to `enqueueLocalJob`'s return, because the outbox collector consumes
+ * that as a bare id and prints nothing to a person. It also keeps its one Valkey round trip: only this function
+ * pays for the read back.
+ *
+ * `state` is BullMQ's own word for where the job is (`waiting`, `active`, `completed`, `failed`, `delayed`
+ * and the rest), or null when the state could not be read; the caller then says it is already queued or
+ * done rather than inventing one. A read that fails outright returns `existing: undefined`: whether this
+ * call queued anything is then unknown, and the caller says so instead of guessing either way.
+ */
+export async function enqueueLocalJobReporting(queue, fields) {
+	return addReporting(queue, (enqueueNonce) => addLocalJob(queue, { ...fields, enqueueNonce }));
+}
+
+/**
+ * Fire one cron trigger by hand (`pi-dispatch run --trigger <id>`, issue #505), reporting like
+ * `enqueueLocalJobReporting` and through the same nonce and read back, so a second call in the same minute says
+ * the first job was already queued instead of announcing one it did not make.
+ *
+ * `schedule` is the trigger's own scheduler entry from `loadSchedules`, and its `data` is passed through WHOLE, with
+ * only the nonce added: the folder, the flow or command, the task, `github`, `packages`, `resume`, the model fields,
+ * `trigger: { id, pattern }` and a job-level `portfolio`. Field by field through `addLocalJob` was the other way, and
+ * it is the one that drops a field the next issue adds to the schedule. The options are the schedule's too, so the
+ * job is not retried, as a scheduled tick is not (a scheduler job carries no `attempts`). The id is
+ * `manualTriggerJobId`'s, so `localEventContext` reports `source: "cron"` with `scheduledFor: null`.
+ */
+export async function enqueueTriggerRunReporting(queue, schedule, { now = new Date() } = {}) {
+	const jobId = manualTriggerJobId({ triggerId: schedule.schedulerId, now });
+	return addReporting(queue, async (enqueueNonce) => {
+		await queue.add(schedule.name, { ...schedule.data, enqueueNonce }, { ...schedule.opts, jobId });
+		return { id: jobId };
+	});
+}
+
+/** The add, then the read back that says whether THIS call's add is the one stored (see `enqueueLocalJobReporting`). */
+async function addReporting(queue, add) {
+	const enqueueNonce = randomUUID();
+	const { id } = await add(enqueueNonce);
+	let stored;
+	try {
+		stored = await queue.getJob(id);
+	} catch {
+		return { id, existing: undefined };
+	}
+	// No stored job: it was removed between the add and this read (a `cancel` racing it). Nothing says it was
+	// a duplicate, so it reads as created, which is what the add itself answered.
+	if (!stored || stored.data?.enqueueNonce === enqueueNonce) return { id, existing: null };
+	let state = null;
+	try {
+		const s = await stored.getState();
+		state = typeof s === "string" && s !== "unknown" ? s : null;
+	} catch {}
+	return { id, existing: { queuedAt: Number.isFinite(stored.timestamp) ? stored.timestamp : null, state } };
+}
+
+/**
+ * The one sentence for a swallowed local enqueue (issue #524), shared by `pi-dispatch run` and the admin's
+ * `/dispatch run` so the two producers an operator types cannot drift apart. `existing` is
+ * `enqueueLocalJobReporting`'s: the time is the first job's own, in this process's local time, and a state the
+ * queue could not give is said as "already queued or done" rather than guessed.
+ */
+export function swallowedRunSentence(jobId, existing) {
+	const at = Number.isFinite(existing?.queuedAt) ? new Date(existing.queuedAt) : null;
+	const hhmm = at ? ` at ${String(at.getHours()).padStart(2, "0")}:${String(at.getMinutes()).padStart(2, "0")}` : "";
+	return `an identical run was queued${hhmm} as ${jobId} (${existing?.state ?? "already queued or done"}); nothing new was queued.`;
+}
+
+async function addLocalJob(queue, { folder, flow, task, command, provider, model, maxTurns, models, maxCostUsd, image, backend, excludeTools, skillsDir, secrets, secretsProfile, chainDepth, parentJobId, jobId, enqueueNonce, now = new Date() }) {
 	const minute = now.toISOString().slice(0, 16); // YYYY-MM-DDTHH:MM -- the dedup window
 	// A caller-supplied jobId (the outbox collector's retry-idempotent chainedJobId) wins; otherwise the
 	// minute-windowed localJobId is the dedup key. A command job (issue #189) fills the flow slot with
@@ -93,7 +185,7 @@ export async function enqueueLocalJob(queue, { folder, flow, task, command, prov
 	// vanish silently -- and the `cmd:` prefix keeps a command named X from colliding with a flow named X
 	// (`:` is outside the skill-name charset, so no real flow can spell the prefixed form). A flow job's
 	// key is byte-identical to before the feature.
-	const id = jobId ?? localJobId({ folder, flow: command !== undefined ? `cmd:${command}` : flow, task, minute });
+	const id = jobId ?? localJobId({ folder, flow: command !== undefined ? `cmd:${command}` : flow, task, minute, provider, model, models });
 	// image/chainDepth/parentJobId land on `data` only when present, so a plain non-chained job's data is
 	// byte-identical. `image` is the container image this job runs in (INT-TRIGGERS-FILE-CONTRACT); absent
 	// resolves the deployment default at job start, never a value frozen here.
@@ -109,6 +201,11 @@ export async function enqueueLocalJob(queue, { folder, flow, task, command, prov
 		provider,
 		model,
 		maxTurns,
+		// Issue #502: the allowed-model list, conditional like `image`, so a job whose trigger named none keeps its
+		// data byte-identical. An outbox child carries its parent's (outbox.mjs), never one its request file names.
+		...(models !== undefined && { models }),
+		// Issue #501: the per-job dollar cap, passed through for the outbox child that inherits its parent's.
+		...(maxCostUsd !== undefined && { maxCostUsd }),
 		...(image !== undefined && { image }),
 		// #227. WHERE this job's container is built. Conditional like `image`, so a trigger that named no
 		// venue produces byte-identical job data -- and at JOB level, never inside `trigger`, for the reason
@@ -132,6 +229,8 @@ export async function enqueueLocalJob(queue, { folder, flow, task, command, prov
 		...(secretsProfile !== undefined && { secretsProfile }),
 		...(chainDepth !== undefined && { chainDepth }),
 		...(parentJobId !== undefined && { parentJobId }),
+		// Issue #524: `enqueueLocalJobReporting`'s own mark, so it can tell whether ITS add is the one stored.
+		...(enqueueNonce !== undefined && { enqueueNonce }),
 	};
 	await queue.add("local", data, {
 		jobId: id,
@@ -140,7 +239,7 @@ export async function enqueueLocalJob(queue, { folder, flow, task, command, prov
 		removeOnComplete: { age: 24 * 3600 },
 		removeOnFail: { age: 7 * 24 * 3600 },
 	});
-	return id;
+	return { id };
 }
 
 // Coalesces rapid re-label spam; the GUID jobId + 31d retention handle exact redelivery, so this
@@ -211,7 +310,7 @@ export async function enqueueGitLabJob(queue, fields) {
  * window, replicas never coalesce against each other, and an unflagged job's dedup id is the same string it
  * has always been.
  */
-export async function enqueueForgeJob(queue, kind, { repo, projectId, azure, target, flow, command, trigger, provider, model, maxTurns, packages, image, backend, excludeTools, skillsDir, instructions, resume, secrets, secretsProfile, waitFor, replica, replicas }) {
+export async function enqueueForgeJob(queue, kind, { repo, projectId, azure, target, flow, command, trigger, provider, model, maxTurns, models, maxCostUsd, packages, image, backend, excludeTools, skillsDir, instructions, resume, secrets, secretsProfile, waitFor, replica, replicas }) {
 	const jobId = forgeDeliveryJobId(kind, trigger?.deliveryId, replica);
 	// `packages` (whether to load the operator-staged pi packages) and `image` (which container image to run)
 	// come off the MATCHED trigger (INT-TRIGGERS-FILE-CONTRACT / REQ-GLOBAL-PI-OVERLAY) and land on `data`
@@ -237,6 +336,9 @@ export async function enqueueForgeJob(queue, kind, { repo, projectId, azure, tar
 		provider,
 		model,
 		maxTurns,
+		// Issue #502: the allowed-model list, conditional like `packages` below so an unflagged trigger's job data is
+		// byte-identical, and at JOB level, never inside `trigger` (copied verbatim into /job/event.json).
+		...(models !== undefined && { models }),
 		...(packages !== undefined && { packages }),
 		...(image !== undefined && { image }),
 		// #227. WHERE this job's container is built. Conditional like `image`, so a trigger that named no
@@ -249,6 +351,9 @@ export async function enqueueForgeJob(queue, kind, { repo, projectId, azure, tar
 		// same reason: `trigger` is copied verbatim into /job/event.json, and a permission boundary is the
 		// worker's business, never agent-visible input to reason about.
 		...(excludeTools !== undefined && { excludeTools }),
+		// #501. The trigger's per-job dollar cap, as written. Conditional like `excludeTools`, at JOB level for its
+		// reason, and a narrowing like it: the worker runs the job under the smaller of this and the deployment cap.
+		...(maxCostUsd !== undefined && { maxCostUsd }),
 		// The host directory of operator-authored skills this trigger injects (REQ-PER-TRIGGER-SKILLS).
 		// Conditional like `image`, so an unflagged job's data stays byte-identical, and at JOB level rather
 		// than inside `trigger` because a worker-host path is an execution knob, not a fact about the

package/src/reserved-env.mjs

@@ -1,3 +1,12 @@
+/**
+ * Issue #503: the variable a keyless provider's `models.json` key names (`"apiKey": "$PI_DISPATCH_KEYLESS"`), so pi
+ * composes the provider. `buildContainerEnv` writes it, with the fixed, non-secret value `keyless`, only when the
+ * credential gate passed the job's provider keyless (env-allowlist.mjs, `resolveProviderCredential`): a provider pi does
+ * not know, served by keyless model endpoints alone. Reserved in the set below, so neither `run.secrets` nor
+ * `PI_FORWARD_ENV` can set it.
+ */
+export const KEYLESS_ENV_NAME = "PI_DISPATCH_KEYLESS";
+
 /**
  * The environment variable names `buildContainerEnv` writes itself, spelled once (issue #225).
  *
@@ -34,6 +43,14 @@ export const CONTAINER_ENV_NAMES = new Set([
 	"PI_FLOW",
 	"PI_COMMAND",
 	"PI_EXCLUDE_TOOLS",
+	// Issues #501, #502: the per-job dollar cap (written by the worker since #501, from the trigger's and the
+	// deployment's caps) and the allowed-model list (reserved until #502 writes it). Neither can be bound through
+	// `run.secrets`: a trigger setting its own cap, or its own list, would be the policy choosing itself.
+	"PI_MAX_COST_MICROS",
+	"PI_ALLOWED_MODELS",
+	// Issue #545: tells the runner the exit line's key waits on stdin. A trigger setting it would block its own runner
+	// on a stdin no one writes, or turn the signed line off.
+	"PI_EXIT_AUTH",
 	"PI_OFFLINE",
 	"PLAYWRIGHT_BROWSERS_PATH",
 	"PLAYWRIGHT_MCP_BROWSER",
@@ -41,4 +58,17 @@ export const CONTAINER_ENV_NAMES = new Set([
 	// Issue #341: set beside `--user` so a uid with no passwd entry has a writable home. A new reservation, so a
 	// triggers file binding a secret named HOME is now refused at parse (worker, receiver and admin alike).
 	"HOME",
+	// Issue #503: written only on the keyless branch of the credential gate (see KEYLESS_ENV_NAME at the top).
+	KEYLESS_ENV_NAME,
 ]);
+
+/**
+ * Issue #500: the names the RUNNER sets in its own environment inside the container, for its descendants: the child
+ * ledger directory and the runner's pid (image/runner/src/usage-meter.mjs, openChildLedger). The worker never writes
+ * them, so they are not in the set above (which a test pins to what buildContainerEnv emits). They are reserved all the
+ * same: a trigger binding one through `run.secrets`, or a host value forwarded through `PI_FORWARD_ENV`, would arrive in
+ * the runner's environment before the runner sets its own, and a value the runner then failed to replace would point
+ * every pi child's ledger at a directory the agent chose. Refused at load in both lists, and deleted by
+ * buildContainerEnv after both loops as the backstop.
+ */
+export const RUNNER_ENV_NAMES = new Set(["PI_DISPATCH_CHILD_LEDGER", "PI_DISPATCH_RUNNER_PID"]);

package/src/run-container.mjs

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import { readFileSync, rmSync } from "node:fs";
 import { DOCKER_NEVER_STARTED_EXITS } from "./backends.mjs";
 import { CONTAINER_HOME } from "./container-spec.mjs";
@@ -61,14 +62,24 @@ export function makeRunContainer({
 	// `log` names a teardown the gate refused, which leaves the job's network for the boot reaper.
 	teardownRuntime = null,
 	log = () => {},
+	// Issue #545: the per-job exit-line key, 32 random bytes as hex. A seam so a test can name the key it verifies with.
+	mintExitKey = () => randomBytes(32).toString("hex"),
 }) {
 	// async so a synchronous throw (e.g. buildContainerEnv on an unconfigured provider) surfaces as
 	// a rejection, uniformly awaitable by the processor and by tests.
 	// `relabel` (issue #355) is the processor's, off the same job-user answer as `user`: true where the daemon confines
 	// containers with SELinux, so the worker's own per-job mounts carry `:Z`. Defaults off, so a caller that predates it
 	// builds exactly the argv it always did.
-	return async function runContainer({ job, token, prepared, secrets = {}, name, signal, user = null, home = null, relabel = false }) {
+	// `modelEndpoints` (issue #503) is the pickup's endpoint snapshot, the one the free credential gate decided on, so a
+	// keyless provider's PI_DISPATCH_KEYLESS is written from the same declaration and never from a second read.
+	// `exitAuth` (issue #545) is the processor's, off the image preflight: true when the job image declares `exitAuth`, so
+	// its runner reads a key from stdin and signs its exit line with it. Defaults off, so a caller that predates it, and
+	// every image that does not declare it, runs exactly as before and is read exactly as before.
+	return async function runContainer({ job, token, prepared, secrets = {}, name, signal, user = null, home = null, relabel = false, modelEndpoints = null, exitAuth = false }) {
 		if (signal?.aborted) return { code: 137, aborted: true, turns: null, tokens: null, session: null, usage: null, context: null, exitReason: null }; // killed before it could start
+		// Minted per attempt, held in this closure and the sink's, and handed to the container on its stdin only: never in
+		// the argv (a host `ps` shows it), never in the env (the container's /proc/1/environ shows it), never logged.
+		const exitKey = exitAuth === true ? mintExitKey() : null;
 		// Issue #341. `user` and `home` travel as a PAIR: a uid with no passwd entry in the image gets `HOME=/` from
 		// Docker and `HOME=/workspace` from Podman (measured), so a `--user` without this HOME is refused here rather
 		// than started. The builder does not insist, because `doctor --live`'s probes run `--user` with no environment.
@@ -87,6 +98,7 @@ export function makeRunContainer({
 			model: job.model,
 			maxTurns: job.maxTurns,
 			maxTokens: job.maxTokens, // optional per-job token budget (issue #25); undefined => runner meter only
+			maxCostMicros: job.maxCostMicros ?? null, // issue #501: effectiveJobOf's min of trigger and deployment; null => no cap
 			jobId: name,
 			githubToken: token ?? undefined,
 			// Which forge minted it, so the token lands in that forge's own variable names and no other.
@@ -121,12 +133,17 @@ export function makeRunContainer({
 			// non-empty validated array; the guard is the same defensive shape `flow` above wears, so a
 			// hand-built job with junk in the field emits no variable rather than an empty one.
 			excludeTools: Array.isArray(job.excludeTools) && job.excludeTools.length > 0 ? job.excludeTools : undefined,
+			// Issue #502: the effective allowed-model list, off `job` like excludeTools. index.mjs `effectiveJobOf` folds
+			// the deployment's PI_ALLOWED_MODELS in under the trigger's own, so `job.models` is already the one list.
+			allowedModels: Array.isArray(job.models) && job.models.length > 0 ? job.models : null,
 			authFromPi, // source the provider key from pi's auth.json when the env has none
 			// REQ-TRIGGER-SECRETS: this trigger's resolved secrets, fetched by the processor BEFORE anything
 			// spent. Off the call bag rather than off `job` or the closure: it is neither a per-job fact the
 			// record may carry nor a deployment setting, it is a live credential, and `token` is its precedent.
 			secrets,
 			home: user !== null ? home : null, // issue #341: HOME only beside --user, assigned after the forward loops
+			modelEndpoints, // issue #503: the keyless branch of the credential, from the gate's own snapshot
+			exitAuth: exitKey !== null, // issue #545: PI_EXIT_AUTH=stdin, only when a key is actually handed over below
 		});
 
 		// `-net` on this container's own name (egress.mjs). null when no policy is armed, and docker-run's
@@ -168,6 +185,9 @@ export function makeRunContainer({
 			// Both facts, the kind the preparers branch on AND containment in this job's own directory, so a kind added later
 			// that works on a folder in place fails closed rather than relabelling it.
 			workspaceOwned: job?.kind !== "local" && insideDir(prepared.jobDir, prepared.workspace),
+			// Issue #545: `-i`, so the container's stdin is the pipe the key is written to. Absent otherwise, and the argv is
+			// byte-identical to one built before the signed exit line.
+			...(exitKey !== null ? { extraFlags: ["-i"] } : {}),
 		});
 
 		// REQ-EGRESS-ALLOWLIST. This job's own --internal network, created here rather than at boot because
@@ -184,10 +204,17 @@ export function makeRunContainer({
 
 		// Host-side per-job log sink, teed off `onOutput`. `name` is `pi-job-<jobId>`; the sink
 		// sanitizes internally. No container mount, no env var -- the sink lives on this side only.
-		const sink = openJobLog(name);
+		const sink = openJobLog(name, { exitKey });
 
 		const run = new Promise((resolve, reject) => {
-			const child = spawnFn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+			const child = spawnFn(bin, args, { stdio: [exitKey !== null ? "pipe" : "ignore", "pipe", "pipe"] });
+			if (exitKey !== null) {
+				// Written and closed at once: the runner drains stdin to EOF before anything else runs, so the key is out of
+				// the pipe before any tool exists. A CLI that died first makes this EPIPE, which is the run failing, reported
+				// by `error` or `close` below; the listener only keeps the write's own error from crashing the worker.
+				child.stdin?.on("error", () => {});
+				child.stdin?.end(`${exitKey}\n`);
+			}
 			// A throwing sink.write is swallowed so a misbehaving sink cannot break the tee or hang the run.
 			const tee = (chunk) => {
 				onOutput(chunk);
@@ -216,12 +243,19 @@ export function makeRunContainer({
 				// RUNNER_POLICY_REASONS set and to a line that itself said code 2. The processor still decides
 				// the retry class from `code` alone; this only picks the label inside exit 2.
 				let exitReason = null;
+				// Issue #501 (PR #542's review, round 3): the LAST exit line's own `code`, which the dollar settlement
+				// compares with the container's real exit code before it trusts that line's cost.
+				let exitLineCode = null;
+				// Issue #507: the cost guard's rule on a `cost-cap` line, already filtered by parseExitWhy to COST_CAP_WHYS.
+				let exitWhy = null;
+				// Issue #545: null (no key issued), "verified" or "unverified" (a key, and no exit line carried it).
+				let exitAuthResult = null;
 				try {
 					// `context = null` is a DEFAULT rather than a plain destructure: an injected sink that
 					// predates the field returns no such key, and `undefined` would then reach the record's
 					// shape where every other absence is spelled `null`.
 					// `exitReason` defaults the same way, for the same reason.
-					({ turns, tokens, session, usage, context = null, exitReason = null } = await sink.close());
+					({ turns, tokens, session, usage, context = null, exitReason = null, exitLineCode = null, exitWhy = null, exitAuth: exitAuthResult = null } = await sink.close());
 				} catch {
 					turns = null;
 					tokens = null;
@@ -229,8 +263,28 @@ export function makeRunContainer({
 					usage = null;
 					context = null;
 					exitReason = null;
+					exitLineCode = null;
+					exitWhy = null;
+					// The sink could not say, and a key was issued: nothing it returned was verified.
+					exitAuthResult = exitKey !== null ? "unverified" : null;
+				}
+				// A sink that predates the field returned none; with a key issued, that is still nothing verified.
+				if (exitKey !== null && exitAuthResult !== "verified") {
+					exitAuthResult = "unverified";
+					turns = null;
+					tokens = null;
+					session = null;
+					usage = null;
+					context = null;
+					exitReason = null;
+					exitLineCode = null;
+					exitWhy = null;
 				}
-				resolve(aborted ? { code: code ?? 137, aborted: true, turns, tokens, session, usage, context, exitReason } : { code: code ?? 1, aborted: false, turns, tokens, session, usage, context, exitReason });
+				// Spread only when a key was issued, so a run without one resolves the very object it always did.
+				const auth = exitKey !== null ? { exitAuth: exitAuthResult } : {};
+				// `exitWhy` only when the line named one, so every other run resolves the object it always did.
+				const why = exitWhy !== null ? { exitWhy } : {};
+				resolve(aborted ? { code: code ?? 137, aborted: true, turns, tokens, session, usage, context, exitReason, exitLineCode, ...why, ...auth } : { code: code ?? 1, aborted: false, turns, tokens, session, usage, context, exitReason, exitLineCode, ...why, ...auth });
 			});
 		});