@edgehero/pi-dispatch 4.3.0 → 5.0.0

package/src/checkpoint-paths.mjs

@@ -0,0 +1,113 @@
+/**
+ * Path rules for a workspace checkpoint (issue #645), shared by the SNAPSHOT walk and the RESTORE write.
+ *
+ * ONE MODULE FOR BOTH SIDES because the two must agree to the byte. A rule the snapshot applies and the
+ * restore does not is the tamper path: the store sits on the worker host, and a restore that trusts what a
+ * snapshot "would never have written" trusts a directory, not a rule. So the restore re-validates every
+ * path with these same functions, and a single disagreement refuses the whole restore.
+ *
+ * A LEAF that imports only node builtins, on `git-hardening.mjs`'s precedent: both the checkpointer and
+ * any future reader (doctor, an admin view) need it, and a leaf cannot grow an import cycle.
+ *
+ * Every function takes a `Buffer` or a `string`. The walk reads names as BUFFERS (`readdir` with
+ * `encoding: "buffer"`), because the default UTF-8 decode replaces an invalid byte with U+FFFD, and a name
+ * that decodes to something it is not is exactly the disagreement described above.
+ */
+
+const MAX_SEGMENT_BYTES = 255;
+export const MAX_PATH_BYTES = 4096;
+export const MAX_DEPTH = 64;
+
+const utf8 = new TextDecoder("utf-8", { fatal: true });
+
+/**
+ * The codepoints HFS+ ignores when it compares names (git's `is_hfs_dotgit` list): ZWNJ/ZWJ and the
+ * directional marks, the bidi embeddings, the deprecated format characters and the BOM. `.g‌it` IS
+ * `.git` to a Mac's filesystem, so it must be `.git` to us too.
+ */
+const HFS_IGNORABLE = /[‌-‏‪-‮-]/g;
+
+function asBuffer(seg) {
+	return Buffer.isBuffer(seg) ? seg : Buffer.from(String(seg), "utf8");
+}
+
+/** Decode strictly, or `null` for bytes that are not UTF-8. */
+function decode(buf) {
+	try {
+		return utf8.decode(buf);
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * True when `seg` names git's own directory on ANY filesystem a restore could land on, after the folding
+ * git itself applies under `core.protectHFS` and `core.protectNTFS`: case-insensitive, HFS ignorables
+ * removed, trailing dots and spaces stripped (NTFS drops them), and the 8.3 short name `git~1`.
+ *
+ * Over-inclusive on purpose in one place: everything from the first `:` is cut, so `.git::$INDEX_ALLOCATION`
+ * (an NTFS stream spelling of the directory) matches. A real file called `.git:notes` is then excluded too,
+ * which costs a checkpoint one oddly named file; the opposite mistake writes into a repository's config.
+ *
+ * Bytes that are not UTF-8 return false: no filesystem folds them to `.git`, and `validSegment` refuses
+ * them separately, so they are counted as a bad name rather than as a dotgit.
+ */
+export function isDotGitSegment(seg) {
+	const s = decode(asBuffer(seg));
+	if (s === null) return false;
+	let folded = s.replace(HFS_IGNORABLE, "").toLowerCase();
+	const colon = folded.indexOf(":");
+	if (colon !== -1) folded = folded.slice(0, colon);
+	folded = folded.replace(/[. ]+$/, "");
+	return folded === ".git" || folded === "git~1";
+}
+
+/**
+ * One path component: non-empty, not `.`/`..`, no `/`, no NUL or other control byte (C0 and DEL), valid
+ * UTF-8, at most 255 bytes (the common NAME_MAX). Control bytes are refused rather than escaped because a
+ * name carrying a newline or an escape sequence would reach an operator's terminal through any listing,
+ * and nothing legitimate in a repository needs one.
+ */
+export function validSegment(seg) {
+	const buf = asBuffer(seg);
+	if (buf.length === 0 || buf.length > MAX_SEGMENT_BYTES) return false;
+	if (buf.length === 1 && buf[0] === 0x2e) return false;
+	if (buf.length === 2 && buf[0] === 0x2e && buf[1] === 0x2e) return false;
+	for (const b of buf) {
+		if (b === 0x2f || b < 0x20 || b === 0x7f) return false;
+	}
+	return decode(buf) !== null;
+}
+
+/**
+ * A whole relative path: no leading `/`, every segment valid and none a dotgit, at most 4096 bytes and 64
+ * segments deep. The depth cap is the walk's own recursion bound, so a restore can never be handed a path
+ * the snapshot could not have produced.
+ */
+export function validPath(p) {
+	const buf = asBuffer(p);
+	if (buf.length === 0 || buf.length > MAX_PATH_BYTES) return false;
+	if (buf[0] === 0x2f) return false;
+	const segments = [];
+	let start = 0;
+	for (let i = 0; i <= buf.length; i++) {
+		if (i === buf.length || buf[i] === 0x2f) {
+			segments.push(buf.subarray(start, i));
+			start = i + 1;
+		}
+	}
+	if (segments.length > MAX_DEPTH) return false;
+	return segments.every((seg) => validSegment(seg) && !isDotGitSegment(seg));
+}
+
+/**
+ * The key two paths collide under on a case-insensitive, normalising filesystem (APFS, HFS+, NTFS): NFC,
+ * lower case, HFS ignorables removed. Used only to DETECT a collision and refuse; it never names a file.
+ * Not the full Unicode case-folding table, which no filesystem uses either: each implements its own, and
+ * this one errs towards calling more pairs a collision, which refuses a restore rather than letting one
+ * file silently overwrite another.
+ */
+export function foldCase(p) {
+	const s = Buffer.isBuffer(p) ? p.toString("utf8") : String(p);
+	return s.replace(HFS_IGNORABLE, "").normalize("NFC").toLowerCase();
+}

package/src/cli.mjs

@@ -1,13 +1,18 @@
 #!/usr/bin/env node
 import { existsSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { resolve } from "node:path";
 import { parseArgs } from "node:util";
 import { loadConfig } from "./config.mjs";
 import { EXIT_POLICY, installRejectionPrinter, installStdoutPipeGuard } from "./exit-code.mjs";
 import { isEntryModule } from "./entry.mjs";
 import { gitDirty, localRepoProblem } from "./git-dirty.mjs";
 import { imageRefProblem } from "./image-ref.mjs";
-import { resolveServiceEnv, serviceEnvFileOf, serviceEnvLoader } from "./service-env.mjs";
+import { modelIdProblem, providerIdProblem } from "./model-ref.mjs";
+import { cliDeploymentEnv } from "./service-env.mjs";
+
+// Issue #804: `cliDeploymentEnv` lives in service-env.mjs, where `service restart --drain` reads it too (service.mjs
+// must not import this entry module). Re-exported so every caller that took it from here keeps working.
+export { cliDeploymentEnv };
 
 /** How long the kill switch waits on the host registry before acting on the shared queue alone. */
 const FLEET_READ_TIMEOUT_MS = 2_000;
@@ -15,13 +20,20 @@ const FLEET_READ_TIMEOUT_MS = 2_000;
 const USAGE = `pi-dispatch — run pi coding-agent flows on your own folders
 
   pi-dispatch init         scaffold .env + triggers.json + pause-windows.json + pi-packages.json + subscriptions.json here
-  pi-dispatch doctor [--fix] [--live]
+  pi-dispatch doctor [--json] [--fix] [--live] [--openshell] [--secrets] [--no-publish]
                            preflight Docker, Valkey, the job image, and your provider key; --fix offers to run each fix (y/N per action);
-                           --live reads the backend declarations back off short-lived real containers (shown in docker ps while they run)
-  pi-dispatch up [--yes]   one consented pass: pull+tag the job image, start Valkey, init, doctor
+                           --live reads the backend declarations back off short-lived real containers (shown in docker ps while they run);
+                           --openshell says whether this host is ready for the openshell venue (run anyway once PI_BACKENDS names it);
+                           --secrets resolves each project secret bundle here and prints its variable names, never values;
+                           every run publishes its checks to Valkey for the console and the panel (labels with paths
+                           and secret values redacted, kept 7 days), and --no-publish skips that
+  pi-dispatch up [--console] [--yes] [--adopt-volume] [--restart-proxy] [--refresh-proxy-rules]
+                           one consented pass: pull+tag the job image, start Valkey, init, doctor
   pi-dispatch setup github mint GitHub App credentials in one browser click (App Manifest flow);
                            every write shown first and individually consented — no --yes here
                            (--webhook-url <URL> | --no-webhook) [--org <org>] [--name <appName>]
+  pi-dispatch auth <status|login CONNECTION|logout CONNECTION|usage CONNECTION|trial CONNECTION>
+                           manage host-owned subscription authentication, see docs/subscription-auth.md
   pi-dispatch import-pi    stage your host pi setup (models/skills/persona) into a global overlay
                            [--no-extensions] [--with-packages] [--no-host-packages]
                            [--packages-file <path>] [--from <agentDir>] [--to <overlayDir>]
@@ -37,15 +49,24 @@ const USAGE = `pi-dispatch — run pi coding-agent flows on your own folders
   pi-dispatch sandbox <jobId>
                            re-open a finished run's sandbox as a shell — same image, same workspace,
                            no credentials  [--publish <port>[:<containerPort>]] [--pin]
+  pi-dispatch sandbox <id> --attach
+                           return to the tracked shell on its original runtime
+  pi-dispatch sandbox --new <repo> --ref <branch|pr:N|sha> --as <trigger-index> [--pin]
+                           prepare a kept workspace without an agent, container, reservation or run slot
+  pi-dispatch opener install --config <approved Fleet export.json>
+                           register pi-dispatch-open for this account; terminal commands wait for Enter
   pi-dispatch sandbox --list
                            what is still re-openable, for how long, and what is running now
+  pi-dispatch canary --role <role> --model <provider/model> --flow <flow> --cap-usd <amount>
+                           replay up to three retained recent jobs in disposable workspaces with forge
+                           access blocked, under one experiment cap [--count 1..10] [--json]
 
   pi-dispatch worker       drain the queue (run this in another terminal, or as a service)
   pi-dispatch-receiver     webhook receiver for forge triggers, its own bin (see docs/github.md)
-  pi-dispatch service <render|install|uninstall|status|start|stop|restart> [--receiver] [--user|--system] [--force]
-                           run the worker (or --receiver) as an OS service — the deploy/ templates
+  pi-dispatch service <render|install|uninstall|status|start|stop|restart> [--receiver|--console] [--user|--system] [--force]
+                           run the worker (or --receiver, or --console) as an OS service — the deploy/ templates
                            rendered with this host's real paths, installed user-level;
-                           \`service restart --drain\` lets the in-flight job finish first
+                           \`service restart --drain\` lets this host's running jobs finish first
   pi-dispatch egress render
                            write model-endpoints.conf here from model-endpoints.json (in place), then print
                            the command that reloads the egress proxy; it never reloads the proxy itself
@@ -58,6 +79,21 @@ const USAGE = `pi-dispatch — run pi coding-agent flows on your own folders
   pi-dispatch cancel <jobId>  stop one job: a queued or held job is removed (the line says whether it had
                            made attempts; cancel records nothing), a running one is aborted on whichever
                            host owns it (its record says operator-cancel)
+  pi-dispatch steer <jobId> [--later] <text…|->
+                           send a message to a running job whose trigger has run.steer: the agent reads it
+                           after its current tool calls, or with --later once it would otherwise stop;
+                           - reads the text from stdin. Prints the message id and its state, never the text
+  pi-dispatch steer --withdraw <jobId> <msgId>
+                           take a message back: guaranteed while it is queued, best effort once written
+  pi-dispatch chat <run-id | issue-url> --fork-as-job [--entry <id>] [--position before|at] [--provider <id>] [--model <id>] [--thinking <level>] [--message <text>] [--yes]
+  pi-dispatch chat <run-id | issue-or-PR-url | session-key> [--fork] [--force] [--tools] [--pi <path>] [--console <addr>] [--yes]
+                           open a run's chat here, through the operator console (PI_CONSOLE_TOKEN, else a prompt):
+                           a running job is followed live and steered (Enter; /later <text>; /withdraw <id>;
+                           Ctrl+C detaches), a parked one is answered, and a finished one (or a session key, or
+                           --fork) opens in your own pi as a fork of its stored transcript, on the host that keeps
+                           the sessions, with tools off unless --tools; the stored transcript is never changed.
+                           A console that is not loopback is asked about first (the token goes over plain HTTP);
+                           --yes answers that question
 
 Config comes from the environment (see .env.example); flags override it per run.
 Prefer being walked through all of this? The operator panel's /dispatch setup does every step
@@ -67,8 +103,14 @@ with a consent per action:  pi install npm:@edgehero/pi-dispatch-admin`;
 	// injects a collector instead of reassigning `process.stdout.write`. That matters because `node --test`
 	// runs each file in a child process that serialises its own results over that same stdout, so a test
 	// holding a replacement across an `await` swallows the runner's result frames (issue #266).
-export async function main(argv = process.argv.slice(2), env = process.env, { write = (chunk) => process.stdout.write(chunk), valkeyRefusal = valkeyRefusalAtStart, now = () => new Date() } = {}) {
+export async function main(argv = process.argv.slice(2), env = process.env, { write = (chunk) => process.stdout.write(chunk), writeErr = (chunk) => process.stderr.write(chunk), valkeyRefusal = valkeyRefusalAtStart, now = () => new Date() } = {}) {
 	const cmd = argv[0];
+	if (cmd === "auth") {
+		const { runAuth } = await import("./auth-cli.mjs");
+		const deployment = cliDeploymentEnv(env, ["PI_AUTH_CONNECTIONS_FILE", "PI_AUTH_STORE_DIR", "PI_WORKER_NAME", "PI_SETTINGS_FILE", "PI_GLOBAL_PI_DIR", "VALKEY_URL"]);
+		if (deployment.problem) { writeErr(`${deployment.problem}\n`); return 2; }
+		return runAuth(argv.slice(1), { env: deployment.env, write, writeErr, now: () => Number(now()) });
+	}
 
 	if (cmd === "init") {
 		const { runInit } = await import("./init.mjs");
@@ -76,11 +118,42 @@ export async function main(argv = process.argv.slice(2), env = process.env, { wr
 		// the podman ladder.
 		return runInit(process.cwd(), { env });
 	}
+	if (cmd === "setup-host") {
+		if (argv.length !== 1) return 2;
+		const { runSetupHostCli } = await import("./setup-host.mjs");
+		return runSetupHostCli({ env });
+	}
 
 	if (cmd === "doctor") {
 		const { runDoctor } = await import("./doctor.mjs");
 		// `fix` and `live` ride in the deps position (runDoctor(env, depsOrOpts)) — one options bag, no third arg.
-		return runDoctor(env, { fix: argv.slice(1).includes("--fix"), live: argv.slice(1).includes("--live") });
+		// `--openshell` (issue #683): the openshell venue's lines, before PI_BACKENDS blesses it (issue #684 made it blessable).
+		// `--secrets` (issue #704): resolve each project secret bundle on this host, printing variable names and a count only.
+		// Publishing (issue #712) is ON unless `--no-publish`; `--publish` says it explicitly (the worker's own runs pass it),
+		// and the two together are refused rather than one silently winning.
+		const flags = argv.slice(1);
+		if (flags.includes("--publish") && flags.includes("--no-publish")) {
+			writeErr("pi-dispatch doctor: --publish and --no-publish contradict each other; pass one\n");
+			return 2;
+		}
+		// `--by-worker=<hours>` is the worker's own spawn saying so (doctor-spawner.mjs), with the interval it runs at, so
+		// the record names who ran it and carries the real interval. Not in the usage: an operator has no reason to type it,
+		// and one who does only mislabels their own run.
+		// Held to the worker's own range (1 to DOCTOR_INTERVAL_MAX_HOURS: a worker at 0 spawns no doctor at all), refused
+		// otherwise, as a mistyped flag is.
+		const byWorkerFlag = flags.find((f) => f.startsWith("--by-worker"));
+		let publishBy = null;
+		if (byWorkerFlag !== undefined) {
+			const { DOCTOR_INTERVAL_MAX_HOURS } = await import("./doctor-spawner.mjs");
+			const m = /^--by-worker=(\d{1,3})$/.exec(byWorkerFlag);
+			const hours = m ? Number(m[1]) : NaN;
+			if (!(hours >= 1 && hours <= DOCTOR_INTERVAL_MAX_HOURS)) {
+				writeErr(`pi-dispatch doctor: --by-worker takes the worker's doctor interval in hours, 1 to ${DOCTOR_INTERVAL_MAX_HOURS}\n`);
+				return 2;
+			}
+			publishBy = { worker: true, every: hours };
+		}
+		return runDoctor(env, { json: flags.includes("--json"), fix: flags.includes("--fix"), live: flags.includes("--live"), openshell: flags.includes("--openshell"), secrets: flags.includes("--secrets"), publish: !flags.includes("--no-publish"), publishBy });
 	}
 
 	if (cmd === "up") {
@@ -104,10 +177,23 @@ export async function main(argv = process.argv.slice(2), env = process.env, { wr
 		return runImportPi(argv.slice(1), { env });
 	}
 
+	if (cmd === "updates") {
+		const { runUpdatesCli } = await import("./updates-cli.mjs");
+		return runUpdatesCli(argv.slice(1), { env });
+	}
+
 	if (cmd === "sandbox") {
 		const { runSandbox } = await import("./sandbox-cli.mjs");
 		return runSandbox(argv.slice(1), { env });
 	}
+	if (cmd === "opener") {
+		const { runOpener } = await import("./opener-cli.mjs");
+		return runOpener(argv.slice(1), { env });
+	}
+	if (cmd === "canary") {
+		const { runCanary } = await import("./canary-cli.mjs");
+		return runCanary(argv.slice(1), { env, write, deploymentEnv: cliDeploymentEnv });
+	}
 
 	if (cmd === "worker") {
 		const { startWorker } = await import("./start.mjs");
@@ -150,6 +236,15 @@ export async function main(argv = process.argv.slice(2), env = process.env, { wr
 			const problem = imageRefProblem(values.image);
 			if (problem) return fail(`--image ${problem.reason} (got ${JSON.stringify(values.image)})`);
 		}
+		// The one model-id and provider-id rule (model-ref.mjs, issue #673), before anything is queued, so a local run's
+		// model is one the console's runs filter can find, as a trigger's, PI_MODEL's and the overlay's are. An empty
+		// flag is refused too, never read as absent: it used to be enqueued as "" and run on a model named "". The
+		// value is not echoed, as no other refusal of this rule echoes it.
+		for (const [flag, judge] of [["provider", providerIdProblem], ["model", modelIdProblem]]) {
+			if (values[flag] === undefined) continue;
+			const problem = judge(values[flag]);
+			if (problem) return fail(`--${flag} ${problem}. Nothing was queued.`);
+		}
 
 		// The worker's folder rule, before anything is queued (issue #524): `.git` at the folder itself and a commit at
 		// HEAD. A folder that fails it used to be queued anyway and refused at pickup as a generic `config-refused`.
@@ -257,6 +352,24 @@ export async function main(argv = process.argv.slice(2), env = process.env, { wr
 		return runCancel(jobId, picked.urls[0], { write });
 	}
 
+	if (cmd === "steer") {
+		// cancel's footing (issue #646): VALKEY_URL only, the kill switch's resolver, and a refusal on a shell/.env
+		// disagreement, since a job id belongs to one Valkey. parseArgs is strict, so a word of the message that looks
+		// like a flag is refused rather than silently dropped from the text; `--` or stdin is the way to send one.
+		const picked = await killSwitchUrls(argv.slice(1), env, { later: { type: "boolean", default: false }, withdraw: { type: "boolean", default: false } });
+		if (picked.error) return fail(/^Unknown option|^Option '/.test(picked.error) ? `${picked.error}\n  A message word that starts with a dash needs -- before the text, or pass - and pipe the text on stdin. Nothing was sent` : picked.error);
+		if (picked.urls.length > 1) return fail(`${picked.disagreement}: a job lives in one of them. Say which: pi-dispatch steer ${picked.positionals[0] ?? "<jobId>"} --valkey-url <url> ...`);
+		const { runSteer } = await import("./steer-cli.mjs");
+		return runSteer({ positionals: picked.positionals, later: picked.values.later, withdraw: picked.values.withdraw }, picked.urls[0], { write });
+	}
+
+	if (cmd === "chat") {
+		// Through the operator console (issue #647): its cookie login, its run lookup and its actions, never Valkey, so a
+		// terminal behind an SSH tunnel needs nothing else. The fork mode reads this host's session store directly.
+		const { runChat } = await import("./chat-cli.mjs");
+		return runChat(argv.slice(1), { env, out: (line) => write(`${line}\n`), err: (line) => writeErr(`${line}\n`), deploymentEnv: cliDeploymentEnv });
+	}
+
 	write(`${USAGE}\n`);
 	return cmd && cmd !== "--help" && cmd !== "-h" ? 1 : 0; // asked-for help is success; a typo is not (the receiver's rule)
 }
@@ -264,13 +377,14 @@ export async function main(argv = process.argv.slice(2), env = process.env, { wr
 /**
  * The Valkey(s) a kill-switch verb acts on: the one rule of `killSwitchValkeyUrls` (valkey-endpoint.mjs), shared with the
  * panel. The verb's own flags are parsed with parseArgs over what follows the verb (PR #475's review, round 3: a hand
- * scan took `--valkey-url` for the job id in `cancel --valkey-url URL j1`). `{ urls, disagreement, positionals }` or
+ * scan took `--valkey-url` for the job id in `cancel --valkey-url URL j1`). `extraOptions` adds a verb's own parseArgs
+ * flags (steer's `--later` and `--withdraw`), returned in `values`. `{ urls, disagreement, positionals, values }` or
  * `{ error }`; a note (a URL that matches neither side) is written to stderr.
  */
-async function killSwitchUrls(args, env) {
+async function killSwitchUrls(args, env, extraOptions = {}) {
 	let parsed;
 	try {
-		parsed = parseArgs({ args, allowPositionals: true, options: { "valkey-url": { type: "string" } } });
+		parsed = parseArgs({ args, allowPositionals: true, options: { ...extraOptions, "valkey-url": { type: "string" } } });
 	} catch (error) {
 		return { error: error.message };
 	}
@@ -278,7 +392,7 @@ async function killSwitchUrls(args, env) {
 	const picked = killSwitchValkeyUrls({ env, flagUrl: parsed.values["valkey-url"] ?? null });
 	if (picked.error) return picked;
 	if (picked.note) process.stderr.write(`warning: ${picked.note}\n`);
-	return { ...picked, positionals: parsed.positionals };
+	return { ...picked, positionals: parsed.positionals, values: parsed.values };
 }
 
 /**
@@ -368,33 +482,6 @@ async function runTrigger(values, positionals, env, { write, valkeyRefusal, now
  */
 export const TRIGGER_LOADER_ENV_KEYS = Object.freeze(["PI_TRIGGERS_FILE", "PI_WORKER_NAME", "PI_MAX_COST_USD"]);
 
-/**
- * Deployment keys for a CLI verb that acts for the deployment (review of PR #575): `keys` resolved by issue #471's rule
- * (`resolveServiceEnv`, service-env.mjs), the one doctor and `up` read the service's keys by. This shell's value where
- * it sets the key, else the `.env` in `cwd` from a line the service's loader reads as written. Where the two disagree,
- * or a line naming the key cannot be read as the loader reads it, or the file cannot be read and this shell sets none,
- * the answer is unknown and the verb refuses (`problem`), as `up` refuses on a PI_JOB_IMAGE disagreement: a job queued
- * on a queue no worker drains, or from a triggers file the worker does not read, is a silent no-op. Returns
- * `{ env }` (this shell's with the file's values filled in) or `{ problem }`.
- */
-export function cliDeploymentEnv(env, keys, { cwd = process.cwd(), platform = process.platform, readFile = (p) => readFileSync(p) } = {}) {
-	const envPath = join(cwd, ".env");
-	let file;
-	try {
-		file = serviceEnvFileOf(readFile(envPath), envPath, serviceEnvLoader(platform));
-	} catch (error) {
-		const unset = keys.filter((k) => typeof env[k] !== "string");
-		if (error?.code !== "ENOENT" && unset.length > 0) return { problem: `${envPath} could not be read (${error?.code ?? "error"}), so ${unset.join(" and ")} cannot be told` };
-		return { env };
-	}
-	const read = resolveServiceEnv({ env, file, keys });
-	const [d] = read.disagreements;
-	if (d) return { problem: `${d.key} is ${JSON.stringify(d.shell)} in this shell and ${JSON.stringify(d.file)} in ${envPath}: make them agree (the service runs the file's)` };
-	const unread = [...read.unread.map((u) => u.key), ...read.hazardSkipped];
-	if (unread.length > 0) return { problem: `${envPath} has a line for ${unread.join(" and ")} that the service's loader may read differently, so it cannot be told (pi-dispatch doctor names the line)` };
-	return { env: read.env };
-}
-
 /** `workerHint`'s line when the queue cannot say, true whether or not a worker runs. */
 export const WORKER_HINT_UNKNOWN = "a worker picks it up; start one with `pi-dispatch worker` if none is running.";