@agentswf/engine 0.1.0-beta.2 → 0.1.0-beta.4

package/src/operator-cli.ts

@@ -7,13 +7,7 @@ import type { JsonObject, JsonValue } from "@agentswf/contract/workflow";
 import { type Harness, handBack, type RunProcess } from "@agentswf/harness";
 import manifest from "../package.json" with { type: "json" };
 import { stageFigures } from "./accounting/format";
-import {
-  type AllowanceCommand,
-  allowanceUsage,
-  describeReport,
-  parseAllowanceCommand,
-  readReport,
-} from "./allowance-command";
+import { allowanceCommand } from "./allowance-command";
 import {
   type AttemptEnd,
   cleanupFailed,
@@ -25,11 +19,23 @@ import {
 } from "./attempt-ending";
 import { type Kept, keepRecords } from "./attempt-output";
 import { continueCommand, printEnding, toldOf } from "./attempt-view";
+import { type CommandName, helpOf, index, isCommand, reference, unknownCommand } from "./commands";
+import {
+  type LineReader,
+  promptCoordinator,
+  replyHints,
+  terminalReader,
+} from "./coordinator-prompt";
+import { coordinatorSocket, prepareCoordinatorDir } from "./coordinator-socket";
+import { EmitError, emitEvent, openEventRun } from "./emit";
+import { emitCommand } from "./emit-command";
 import { messageOf } from "./errors";
 import { type Caller, showOwnTab, startHere, takeCaller } from "./here";
-import { type InitCommand, initUsage, parseInitCommand, runInit } from "./init-command";
+import { holderCommand } from "./holder-command";
+import { inboxCommand } from "./inbox-command";
+import { initCommand } from "./init-command";
 import { logsCommand } from "./logs-command";
-import { machinePaths, sandboxesDirOf } from "./machine";
+import { coordinatorDir, machinePaths, sandboxesDirOf } from "./machine";
 import {
   allowanceReader,
   herdrConfig,
@@ -39,13 +45,17 @@ import {
 } from "./operator-runtime";
 import { ANSI, describeRunSession, type Terminal, watchProgress } from "./progress-view";
 import { parseCommand, type RunCommand, usage } from "./run-command";
-import { shellLine, startedLine } from "./run-commands";
+import { placeFlags, shellLine, startedLine } from "./run-commands";
+import { runLockFile, withRunLock } from "./run-lock";
 import { claimNext, loadAndPrepare, type PreparedRun, workspaceLabel } from "./run-prepare";
 import { findRun } from "./run-state";
-import { type Attempt, createRun, discardRun, type Run, RunRefused } from "./runs";
+import { type Attempt, createRun, discardRun, endAttempt, type Run, RunRefused } from "./runs";
 import { runsCommand } from "./runs-command";
-import { parseTestCommand, runWorkflowTests, type TestCommand, testUsage } from "./test-command";
-import type { LoadedWorkflow } from "./workflow-loader";
+import { stopCrashed } from "./stop-crashed";
+import { testCommand } from "./test-command";
+import { tickCommand } from "./tick-command";
+import type { Launch } from "./wake";
+import type { EventWorkflow, LoadedWorkflow } from "./workflow-loader";
 import {
   type RunWorkflowOptions,
   startWorkflow,
@@ -60,7 +70,7 @@ export type OperatorEnvironment = {
   stdout?: (text: string) => void;
   stderr?: (text: string) => void;
   installRuntime?: (
-    timeoutMilliseconds: number,
+    timeoutMilliseconds: number | undefined,
     options: {
       watchSandboxes: boolean;
       caller?: Caller;
@@ -84,11 +94,22 @@ export type OperatorEnvironment = {
   install?: (dir: string) => Promise<number>;
   /** How `awf allowance` reads a harness's plan. */
   readAllowance?: (harness: Harness) => Promise<HarnessAllowance>;
+  /** Starts or continues an event run's attempt for `awf emit`; absent, a detached `awf run`. */
+  launch?: Launch;
   /**
    * Where agents may `--await-reply`, past the engine's list: for the live checks that decide
    * what goes on it (story 029's M2 gate).
    */
   awaitReply?: RunWorkflowOptions["awaitReply"];
+  /** Answers for the run's coordinators in place of a person: for the live checks of story 032. */
+  coordinators?: RunWorkflowOptions["coordinators"];
+  /**
+   * Given, stdin is a terminal and these are the lines typed at it: `awf run` asks a coordinator's
+   * questions there. Absent, it is so when stdin and stderr are both terminals.
+   */
+  lines?: LineReader;
+  /** What `awf reply` and `awf send` read their text from without an argument; stdin otherwise. */
+  stdin?: () => Promise<string>;
 };
 
 type Output = {
@@ -124,28 +145,156 @@ export async function runOperatorCli(
     stderr(`awf: ${tooOld}`);
     return 1;
   }
-  if (argv.length === 1 && argv[0] === "--version") {
+  const cwd = environment.cwd ?? process.cwd();
+  const holder = () =>
+    holderCommand(argv, cwd, {
+      stdout,
+      stderr,
+      stdin: environment.stdin ?? (() => new Response(Bun.stdin.stream()).text()),
+      ...(environment.stdin ? {} : { stdinIsTerminal: process.stdin.isTTY === true }),
+      ...(environment.environment ? { environment: environment.environment } : {}),
+      ...(environment.home ? { home: environment.home } : {}),
+    });
+  const wakes = {
+    home: environment.home ?? homedir(),
+    environment: environment.environment ?? process.env,
+    ...(environment.launch ? { launch: environment.launch } : {}),
+  };
+  const handlers = {
+    run: () => runCommand(argv, environment, { stdout, stderr, notice, terminal, now }),
+    test: () => {
+      const captured = environment.stdout || environment.stderr ? { stdout, stderr } : undefined;
+      return testCommand(argv.slice(1), cwd, {
+        stdout,
+        stderr,
+        ...(captured ? { output: captured } : {}),
+        ...(environment.signal ? { signal: environment.signal } : {}),
+      });
+    },
+    init: () =>
+      initCommand(argv.slice(1), cwd, {
+        stdout,
+        stderr,
+        ...(environment.install ? { install: environment.install } : {}),
+      }),
+    emit: () => emitCommand(argv.slice(1), cwd, { stdout, stderr }, wakes),
+    tick: () => tickCommand(argv.slice(1), cwd, { stdout, stderr }, wakes),
+    runs: () => runsCommand(argv.slice(1), cwd, { stdout, stderr }, Date.now(), wakes.home),
+    logs: () => logsCommand(argv.slice(1), cwd, { stdout, stderr }, undefined, wakes.home),
+    inbox: () =>
+      inboxCommand(
+        argv.slice(1),
+        cwd,
+        { stdout, stderr },
+        { home: wakes.home, ...(environment.signal ? { signal: environment.signal } : {}) },
+      ),
+    reply: () => holder(),
+    send: () => holder(),
+    allowance: () =>
+      allowanceCommand(argv.slice(1), {
+        stdout,
+        stderr,
+        read:
+          environment.readAllowance ??
+          allowanceReader(
+            environment.environment ?? process.env,
+            undefined,
+            environment.signal,
+            environment.home ?? homedir(),
+          ),
+        now,
+      }),
+  } satisfies Record<CommandName, () => Promise<number>>;
+  const [word, ...rest] = argv;
+  if (word === undefined) {
+    stdout(index());
+    return 0;
+  }
+  if (word === "--version") {
+    if (rest.length > 0) {
+      stderr("awf: --version takes nothing after it; awf -h lists the commands");
+      return 2;
+    }
     stdout(describeVersion());
     return 0;
   }
-  if (argv[0] === "test") return testCommand(argv.slice(1), environment, stdout, stderr);
-  if (argv[0] === "init") return initCommand(argv.slice(1), environment, stdout, stderr);
-  if (argv[0] === "logs") {
-    return logsCommand(argv.slice(1), environment.cwd ?? process.cwd(), { stdout, stderr });
+  if (word === "help" || word === "-h" || word === "--help") return help(rest, stdout, stderr);
+  if (isCommand(word)) return handlers[word]();
+  stderr(unknownCommand(word));
+  return 2;
+}
+
+/** `awf help`, `awf help {command}` and `awf help reference`; `-h` and `--help` are `help`. */
+function help(
+  words: readonly string[],
+  stdout: (text: string) => void,
+  stderr: (text: string) => void,
+): number {
+  const [word] = words;
+  if (words.length > 1) {
+    stderr("awf: help takes one command; awf -h lists the commands");
+    return 2;
   }
-  if (argv[0] === "runs") {
-    return runsCommand(argv.slice(1), environment.cwd ?? process.cwd(), { stdout, stderr });
+  if (word === undefined || word === "help" || word === "-h" || word === "--help") {
+    stdout(index());
+  } else if (word === "reference") {
+    stdout(reference());
+  } else if (isCommand(word)) {
+    stdout(helpOf(word));
+  } else {
+    stderr(unknownCommand(word));
+    return 2;
   }
-  if (argv[0] === "allowance") {
-    return allowanceCommand(argv.slice(1), environment, stdout, stderr);
+  return 0;
+}
+
+/** `awf run`: parses it, then starts or continues the run, here or in a tab. */
+/**
+ * `awf run --id` for a workflow with events: the run is made with no event and started detached, as
+ * an event starts one, so it runs to its first wait and parks; one already there is only woken.
+ */
+async function openRun(
+  { loaded, id, argv }: { loaded: LoadedWorkflow; id: string; argv: readonly string[] },
+  environment: OperatorEnvironment,
+  { stdout, stderr }: Output,
+): Promise<number> {
+  try {
+    const opened = await openEventRun(loaded.workflow as EventWorkflow, id, argv, {
+      home: environment.home ?? homedir(),
+      environment: environment.environment ?? process.env,
+      ...(environment.launch ? { launch: environment.launch } : {}),
+    });
+    const did = opened.did === "none" ? opened.why : opened.did;
+    stdout(
+      `${opened.run}${opened.created ? "" : " was there"}${did === undefined ? "" : `: ${did}`}`,
+    );
+    if (opened.why !== "launch-failed") return 0;
+    stderr(`awf: the run's attempt did not start: ${opened.error}`);
+    return 1;
+  } catch (error) {
+    stderr(`awf: ${messageOf(error)}`);
+    return error instanceof EmitError ? 2 : 1;
   }
-  let command: RunCommand;
+}
+
+async function runCommand(
+  argv: readonly string[],
+  environment: OperatorEnvironment,
+  output: Output,
+): Promise<number> {
+  const { stdout, stderr, notice, terminal, now } = output;
+  let parsed: RunCommand | "help";
   try {
-    command = parseCommand(argv, environment.cwd ?? process.cwd());
+    parsed = parseCommand(argv, environment.cwd ?? process.cwd());
   } catch (error) {
     stderr(`awf: ${messageOf(error)}\n\n${usage}`);
     return 2;
   }
+  if (parsed === "help") {
+    stdout(usage);
+    return 0;
+  }
+  let command: RunCommand = parsed;
   const meant = await runNamed(command);
   if (meant) {
     const look = shellLine([
@@ -167,17 +316,20 @@ export async function runOperatorCli(
   };
   const home = environment.home ?? homedir();
   const { sandboxes, callers } = machinePaths(home);
+  const ready = await loadAndPrepare(command, now(), home);
+  if ("refused" in ready) {
+    stderr(`awf: ${ready.refused}`);
+    return unstarted(2);
+  }
+  if ("opens" in ready) return openRun(ready.opens, environment, output);
+  // After loading: an event run's root is its project's, which this checks too.
+  command = ready.command;
   if (!relative(command.runRoot, sandboxes).startsWith("..")) {
     stderr(
       `awf: --run-root ${command.runRoot} holds ${sandboxes}, which every sandbox must reach and none may reach the run root`,
     );
     return unstarted(2);
   }
-  const ready = await loadAndPrepare(command, now());
-  if ("refused" in ready) {
-    stderr(`awf: ${ready.refused}`);
-    return unstarted(2);
-  }
   for (const line of ready.prepared.continued?.warnings ?? []) notice(line);
 
   // Loading the workflow imports operator-supplied code before anything listens to the signal, so
@@ -227,8 +379,8 @@ async function runAttempt(
   output: Output,
 ): Promise<number> {
   const { stdout, stderr, notice, terminal, now } = output;
-  const { executable } = loaded;
-  const { meta } = executable.definition;
+  const { workflow } = loaded;
+  const { meta } = workflow;
   /** The run, once it is claimed. */
   let run: Run | undefined;
   // Once the run has taken the session over, however it ends, the session gets it back.
@@ -251,6 +403,17 @@ async function runAttempt(
     await handOver(`did not start: ${why}`);
     return 2;
   };
+  // The operator's, never where the workflow's agents work.
+  const coordinatorRoot = coordinatorDir(home, environment.environment ?? process.env);
+  try {
+    await prepareCoordinatorDir(
+      coordinatorRoot,
+      command.cwd,
+      Boolean((environment.environment ?? process.env).AWF_COORDINATOR_DIR),
+    );
+  } catch (error) {
+    return refuse(messageOf(error));
+  }
   try {
     run =
       prepared.continued?.run ??
@@ -275,13 +438,33 @@ async function runAttempt(
     return refuse(messageOf(error));
   }
   const { id, cwd } = run.record;
+  const locked = <T>(work: () => Promise<T>) =>
+    withRunLock(runLockFile(run.root, meta.name, id), work);
   const sandbox = run.record.sandbox ?? undefined;
   const n = attempt.record.attempt;
+  // Claimed first, which `wake` waits for holding the run's lock; only then waited on: two
+  // attempts never share an agent's session.
+  const previous = prepared.continued?.attempts.at(-1);
+  // An event run continued after a crash: what that attempt left working is stopped first (Q17).
+  if (run.record.events && previous && previous.ended === undefined)
+    await stopCrashed(previous, workspaceLabel(meta.name, run.record.id, previous.attempt), {
+      home,
+      environment: environment.environment ?? process.env,
+    }).catch((error: unknown) =>
+      notice(
+        `awf: what attempt ${previous.attempt} left running was not all stopped: ${messageOf(error)}`,
+      ),
+    );
   const goOn: GoOn = (stop, entered) => continueCommand(command, id, stop, entered);
-  const records = { attempt, executable, workflow: { name: meta.name, file: loaded.file }, stderr };
+  const records = {
+    attempt,
+    loaded,
+    stderr,
+    ...(!run.record.events ? {} : { locked }),
+  };
   const close = (end: AttemptEnd, kept: Kept, cleanupAlso?: string) =>
     printEnding(end, kept, {
-      executable,
+      workflow,
       run: { id, dir: run.dir },
       n,
       earlier: prepared.continued?.attempts ?? [],
@@ -302,7 +485,10 @@ async function runAttempt(
   // run is over may continue it at once. One that never does is interrupted. A new run that never
   // started is not kept at all, so the same command starts it again, unless another attempt has
   // claimed it since: then its records are kept as a continued run's are.
-  const deadline = { unixMilliseconds: startedAt + command.timeoutMilliseconds };
+  const deadline =
+    command.timeoutMilliseconds === undefined
+      ? undefined
+      : { unixMilliseconds: startedAt + command.timeoutMilliseconds };
   const endUnstarted = async (error: unknown, cleanupAlso?: string) => {
     const end = endedBeforeStart(error, deadline, { runId: id, startedAt, endedAt: now() }, goOn);
     const cancelled = end.ending.kind === "cancelled";
@@ -360,9 +546,33 @@ async function runAttempt(
     const insideHerdr = (environment.environment ?? process.env).HERDR_ENV === "1";
     for (const line of describeRunSession(session, label, insideHerdr)) progress.log(line);
   };
+  // Interactive: a coordinator's questions are asked here, unless the output is for a program.
+  const reader =
+    terminal && !command.json
+      ? (environment.lines ?? (process.stdin.isTTY ? terminalReader() : undefined))
+      : undefined;
+  const prompt = reader && promptCoordinator(reader, progress);
+  // Without a prompt, each question says how to answer it, so the run does not look stuck.
+  const asked =
+    prompt ??
+    replyHints(`${meta.name}/${id}`, placeFlags(command), n, (line) => progress.log(line));
+  progress.showsMessages((message) => asked.shows(message));
+  const { events } = run.record;
+  let nudge: (() => void) | undefined;
+  const socket = coordinatorSocket({
+    dir: coordinatorRoot,
+    runDir: run.dir,
+    attempt: n,
+    ...(events ? { nudged: () => nudge?.() } : {}),
+    failed: (reason) =>
+      progress.log(
+        `awf: the participants' socket did not open, so awf reply and awf send cannot reach this run: ${reason}`,
+      ),
+  });
+  const coordinators = [...(environment.coordinators ?? []), socket, asked];
   let handle: WorkflowRunHandle<JsonValue>;
   try {
-    handle = await startWorkflow(executable.definition, prepared.args, {
+    handle = await startWorkflow(workflow, prepared.args, {
       runRoot: run.root,
       run: {
         dir: run.dir,
@@ -371,24 +581,54 @@ async function runAttempt(
         label: workspaceLabel(meta.name, id, n),
         ...(command.fromStage === undefined ? {} : { fromStage: command.fromStage }),
         ...(command.values === undefined ? {} : { values: command.values.stages }),
+        ...(!events
+          ? {}
+          : {
+              events,
+              locked,
+              listenNudges: (given) => {
+                nudge = given;
+              },
+
+              // After a crash its agents start new sessions: a harness may still count the killed
+              // writer as its session's, as codex's thread store did (story 034, task 6).
+              resumeSessions: previous === undefined || previous.ended !== undefined,
+              park: async () => {
+                await endAttempt(attempt, { outcome: "parked" });
+              },
+            }),
       },
+      emit: async (target, event, from) =>
+        (
+          await emitEvent(target, event, {
+            from,
+            home,
+            environment: environment.environment ?? process.env,
+            ...(environment.launch ? { launch: environment.launch } : {}),
+          })
+        ).outcome,
       runtime: installed.config,
       sandboxes: {
         providers: installed.sandboxes ?? { installed: {} },
         sandboxesDir: sandboxesDirOf(home, run.record),
         machineRoot: machinePaths(home).root,
+        coordinatorRoot,
         ...(sandbox === undefined ? {} : { run: sandbox }),
       },
       ...(installed.decisions ? { decisions: installed.decisions } : {}),
+      ...(installed.allowance ? { allowance: installed.allowance } : {}),
       deadline,
       cwd,
       ...(environment.signal ? { signal: environment.signal } : {}),
       ...(environment.awaitReply ? { awaitReply: environment.awaitReply } : {}),
+      ...(coordinators.length > 0 ? { coordinators } : {}),
       onCallerStopped: () => handOver("stopped using this session", true),
       onLog: (logMessage, fields?: JsonObject) =>
         progress.log(fields ? `${logMessage} ${JSON.stringify(fields)}` : logMessage),
     });
   } catch (error) {
+    prompt?.close();
+    await socket.close();
     progress.stop();
     return endUnstarted(error, await cleanUp());
   }
@@ -399,6 +639,9 @@ async function runAttempt(
   } catch (error) {
     finished = { error };
   }
+  prompt?.close();
+  // Gone with the run: a holder now finds it ended.
+  await socket.close();
 
   let end = decideEnding(finished, deadline, goOn);
   progress.stop(end.settled ? stageFigures(end.settled.accounting) : undefined);
@@ -426,89 +669,6 @@ async function runAttempt(
   return close(end, kept, cleanupAlso);
 }
 
-/** `awf allowance`: what is left of each harness's plan. */
-async function allowanceCommand(
-  argv: readonly string[],
-  environment: OperatorEnvironment,
-  stdout: (text: string) => void,
-  stderr: (text: string) => void,
-): Promise<number> {
-  let command: AllowanceCommand;
-  try {
-    command = parseAllowanceCommand(argv);
-  } catch (error) {
-    stderr(`awf: ${messageOf(error)}\n\n${allowanceUsage}`);
-    return 2;
-  }
-  if (command === "help") {
-    stdout(allowanceUsage);
-    return 0;
-  }
-  const read =
-    environment.readAllowance ??
-    allowanceReader(
-      environment.environment ?? process.env,
-      undefined,
-      environment.signal,
-      environment.home ?? homedir(),
-    );
-  const report = await readReport(command.harnesses, read, (environment.now ?? Date.now)());
-  stdout(command.json ? JSON.stringify(report, null, 2) : describeReport(report));
-  return 0;
-}
-
-/** `awf init`: a folder set up for writing workflows. */
-async function initCommand(
-  argv: readonly string[],
-  environment: OperatorEnvironment,
-  stdout: (text: string) => void,
-  stderr: (text: string) => void,
-): Promise<number> {
-  const cwd = environment.cwd ?? process.cwd();
-  let command: InitCommand | "help";
-  try {
-    command = parseInitCommand(argv, cwd);
-  } catch (error) {
-    stderr(`awf: ${messageOf(error)}\n\n${initUsage}`);
-    return 2;
-  }
-  if (command === "help") {
-    stdout(initUsage);
-    return 0;
-  }
-  try {
-    return await runInit(command, cwd, { stdout, stderr }, environment.install);
-  } catch (error) {
-    stderr(`awf: ${messageOf(error)}`);
-    return 1;
-  }
-}
-
-/** `awf test`: the workflow tests under the given paths, with Bun's test runner. */
-async function testCommand(
-  argv: readonly string[],
-  environment: OperatorEnvironment,
-  stdout: (text: string) => void,
-  stderr: (text: string) => void,
-): Promise<number> {
-  let tests: TestCommand | "help";
-  try {
-    tests = parseTestCommand(argv, environment.cwd ?? process.cwd());
-  } catch (error) {
-    stderr(`awf: ${messageOf(error)}\n\n${testUsage}`);
-    return 2;
-  }
-  if (tests === "help") {
-    stdout(testUsage);
-    return 0;
-  }
-  const captured = environment.stdout || environment.stderr ? { stdout, stderr } : undefined;
-  return runWorkflowTests(tests, environment.cwd ?? process.cwd(), {
-    ...(environment.signal ? { signal: environment.signal } : {}),
-    ...(captured ? { output: captured } : {}),
-  });
-}
-
 /**
  * Not `console.error`, which Bun paints red on a terminal: a workflow's log and the accounting
  * are ordinary lines. Only awf's own problems, which it prefixes `awf: `, are red: their first line.
@@ -557,6 +717,8 @@ function describeVersion(): string {
 
 /** How soon a repeated signal is the copy `bun awf` forwards, not the operator pressing again. */
 const REPEAT_MS = 1_000;
+/** How long a command that has returned and written its output may keep the process. */
+const EXIT_GRACE_MS = 2_000;
 
 /**
  * Cancels `controller` at the first signal that asks the run to stop, and stops the process at
@@ -595,6 +757,15 @@ export async function main(): Promise<void> {
   } finally {
     stop();
   }
+  // A workflow's body can leave a timer or a pending call behind once its run has ended and its
+  // records are written; a woken run, detached, would otherwise live on with nothing to reap it.
+  // Output still queued for a slow reader is written first.
+  await Promise.all(
+    [process.stdout, process.stderr].map(
+      (stream) => new Promise<void>((resolve) => stream.write("", () => resolve())),
+    ),
+  );
+  setTimeout(() => process.exit(), EXIT_GRACE_MS).unref();
 }
 
 if (import.meta.main) await main();

package/src/operator-runtime.ts

@@ -56,6 +56,8 @@ export type OperatorRuntimeInstallation = {
   sandboxes?: SandboxProviders;
   /** The decision models workflows may ask, and their aliases. */
   decisions?: DecisionInstallation;
+  /** How `wf.allowance` reads a harness's plan, as `awf allowance` does. */
+  allowance?: (harness: Harness) => Promise<HarnessAllowance>;
   cleanup(): Promise<void>;
 };
 
@@ -82,7 +84,7 @@ export type OperatorRuntimeOptions = {
  * headless one. `WITHHELD_ENVIRONMENT` is cleared from both.
  */
 export async function installOperatorRuntime(
-  timeoutMilliseconds: number,
+  timeoutMilliseconds: number | undefined,
   options: OperatorRuntimeOptions = {},
 ): Promise<OperatorRuntimeInstallation> {
   const {
@@ -101,7 +103,7 @@ export async function installOperatorRuntime(
   const session = runSessionOnce(() => name, { run, environment, home }, onRunSession);
   const runConfig = (session: string): HerdrConfig => ({
     ...herdrConfig(session),
-    commandTimeoutMs: Math.min(timeoutMilliseconds, 150_000),
+    commandTimeoutMs: Math.min(timeoutMilliseconds ?? Number.POSITIVE_INFINITY, 150_000),
     emptyEnvironment: PANE_WITHHELD_ENVIRONMENT,
     acceptWorkspaceTrust: true,
     watchSandboxes,
@@ -178,7 +180,8 @@ export async function installOperatorRuntime(
     },
     sandboxes: await installSandboxes(environment),
     decisions: installDecisions({ OPENROUTER_API_KEY: await openRouterKey(environment) }),
-    // Nothing to undo: the agent's `wf` is a launcher the control plane installs beside its own
+    allowance: allowanceReader(environment, run, undefined, home),
+    // Nothing to undo: the agent's `wfa` is a launcher the control plane installs beside its own
     // socket, and the control plane removes both when the run closes.
     cleanup: async () => undefined,
   };
@@ -279,9 +282,8 @@ export function herdrConfig(session: string): HerdrConfig {
 
 /**
  * The sandbox providers this machine has: srt when its CLI is on `PATH`, docker when its CLI is;
- * its daemon is first asked when a sandbox opens. srt is the default when installed, as it runs
- * the project's own toolchain, which an image lacks (story 004), and when it is there but cannot
- * be set up: a spec naming none then fails saying why, rather than moving to docker unsaid.
+ * its daemon is first asked when a sandbox opens. There is no default: a spec names its provider,
+ * since the two give agents different machines, the host's toolchain or an image.
  */
 export async function installSandboxes(
   environment: Readonly<Record<string, string | undefined>>,
@@ -301,10 +303,8 @@ export async function installSandboxes(
     ...(srt ? { srt: createSrtProvider(srt) } : {}),
     ...(docker ? { docker: createDockerProvider(docker) } : {}),
   };
-  const fallback = srt || unavailable.srt ? "srt" : docker ? "docker" : undefined;
   return {
     installed,
-    ...(fallback ? { default: fallback } : {}),
     ...(Object.keys(unavailable).length > 0 ? { unavailable } : {}),
   };
 }