@pi-harness/pi-harness 0.1.2 → 0.1.3

package/packages/cli/src/main.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import type { Readable, Writable } from "node:stream";
-import { bootHarness, provideLaunchContext, provideStdioContext, resolveProfileConfig, type BootedHarness } from "@pi-harness/core";
+import { BUILTIN_PROFILES, bootHarness, provideLaunchContext, provideStdioContext, resolveProfileConfig, type BootedHarness } from "@pi-harness/core";
 import { CliUsageError, parseLauncherArgs } from "./args.js";
 import { NodeStdio } from "./node-stdio.js";
 import { PI_HARNESS_RESTART_EXIT_CODE } from "./relaunch.js";
@@ -13,6 +13,7 @@ export interface CliEnvironment {
   readonly stdout: Writable;
   readonly stderr: Writable;
   readonly shutdownTimeoutMs: number;
+  readonly supervised?: boolean;
   forceExit(code: number): void;
   onSignal(listener: (signal: NodeJS.Signals) => void): () => void;
 }
@@ -29,6 +30,23 @@ async function settleWithin<T>(promise: Promise<T>, timeoutMs: number): Promise<
   return result;
 }
 
+const HELP_TEXT = `Usage: pih [--profile <name> | --config <path>] [--dump-config] [--] [--prompt <text> | <prompt>]
+
+Launcher options (recognized before the first application argument):
+  --profile <name>   Built-in profile to boot; one of ${BUILTIN_PROFILES.join(", ")} (default: default)
+  --config <path>    Cordis entry-tree YAML or JSON to boot instead of a built-in profile
+  --dump-config      Print the resolved profile file and exit without importing any plugin
+  -h, --help         Print this message and exit
+  -v, --version      Print the launcher version and exit
+
+Every remaining argument, including a \`--\` separator, is passed unchanged to the active
+application plugin. The bundled stdio application reads its prompt from --prompt <text>,
+--prompt=<text>, a positional prompt, or stdin, and needs \`--\` before a prompt that starts
+with a dash.
+`;
+
+const FLUSH_TIMEOUT_MS = 2_000;
+
 function signalExitCode(signal: NodeJS.Signals): number {
   return signal === "SIGINT" ? 130 : signal === "SIGHUP" ? 129 : 143;
 }
@@ -44,7 +62,7 @@ export async function runCli(_args: readonly string[], _environment: CliEnvironm
     return error instanceof CliUsageError ? 2 : 1;
   }
   if (invocation.mode === "help") {
-    environment.stdout.write("Usage: pih [--profile <name> | --config <path>] [--dump-config] [--] [--prompt <text> | <prompt>]\n");
+    environment.stdout.write(HELP_TEXT);
     return 0;
   }
   if (invocation.mode === "version") {
@@ -69,9 +87,12 @@ export async function runCli(_args: readonly string[], _environment: CliEnvironm
   let harness: BootedHarness | undefined;
   let resultCode: number | undefined;
   let forcedExit = false;
-  const forceExit = (code: number) => {
+  const forceExit = async (code: number, flush = true) => {
     if (forcedExit) return;
     forcedExit = true;
+    // process.exit discards whatever is still buffered for a pipe, so the answer is flushed first.
+    // A repeated signal is the user asking to leave now, so that path skips the wait.
+    if (flush) await settleWithin(stdio.flush(), FLUSH_TIMEOUT_MS);
     environment.forceExit(code);
   };
   let requestedExit: ((code: number) => void) | undefined;
@@ -83,17 +104,29 @@ export async function runCli(_args: readonly string[], _environment: CliEnvironm
     signalledExit = resolve;
   });
   const startupAbort = new AbortController();
+  const stdio = new NodeStdio(environment.stdin, environment.stdout, environment.stderr);
+  let signalCount = 0;
   const removeSignals = environment.onSignal((signal) => {
     const code = signalExitCode(signal);
+    signalCount += 1;
+    if (signalCount > 1) {
+      environment.stderr.write(`Received ${signal} again; exiting immediately\n`);
+      void forceExit(code, false);
+      return;
+    }
     signalledExit?.(code);
+    stdio.close();
     startupAbort.abort(new Error(`Received ${signal}`));
   });
   try {
-    const stdio = new NodeStdio(environment.stdin, environment.stdout, environment.stderr);
     const bootOutcome: Promise<BootOutcome> = bootHarness({
       configPath,
       signal: startupAbort.signal,
       onFullReload() {
+        if (environment.supervised !== true) {
+          environment.stderr.write("Cordis requested a full reload but this process is not supervised; restart the CLI to apply the change\n");
+          return;
+        }
         requestedExit?.(PI_HARNESS_RESTART_EXIT_CODE);
       },
       prepare(context) {
@@ -107,13 +140,16 @@ export async function runCli(_args: readonly string[], _environment: CliEnvironm
         });
         provideStdioContext(context, stdio);
       },
-    }).then((booted): BootOutcome => ({ kind: "ready", harness: booted }), (error: unknown): BootOutcome => ({ kind: "error", error }));
+    }).then(
+      (booted): BootOutcome => ({ kind: "ready", harness: booted }),
+      (error: unknown): BootOutcome => ({ kind: "error", error }),
+    );
     const startup = await Promise.race([bootOutcome, signalPromise.then((code) => ({ kind: "signal" as const, code }))]);
     if (startup.kind === "signal") {
       resultCode = startup.code;
       const settled = await settleWithin(bootOutcome, environment.shutdownTimeoutMs);
       if (!settled.settled) {
-        forceExit(startup.code);
+        await forceExit(startup.code);
         return startup.code;
       }
       if (settled.value.kind === "ready") harness = settled.value.harness;
@@ -123,33 +159,41 @@ export async function runCli(_args: readonly string[], _environment: CliEnvironm
     harness = startup.harness;
     const application = harness.context.get("piApplication");
     if (application === undefined) throw new Error("Cordis profile did not provide a piApplication service");
+    const shutdownAbort = new AbortController();
+    const applicationRun = application.run(shutdownAbort.signal).then((code) => ({ source: "application" as const, code }));
     const result = await Promise.race([
-      application.run().then((code) => ({ source: "application" as const, code })),
+      applicationRun,
       requestedExitPromise.then((code) => ({ source: "request" as const, code })),
       signalPromise.then((code) => ({ source: "signal" as const, code })),
     ]);
     resultCode = result.code;
     if (result.source !== "application") {
+      shutdownAbort.abort(new Error("Pi Harness is shutting down"));
       const runtime = harness.context.get("piRuntime");
       if (runtime !== undefined) {
         const aborted = await settleWithin(runtime.abort().then(() => undefined, (error: unknown) => {
           environment.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
         }), environment.shutdownTimeoutMs);
-        if (!aborted.settled) forceExit(result.code);
+        if (!aborted.settled) await forceExit(result.code);
       }
+      // The application surface outlives the runtime abort unless it honours the signal, and
+      // Node waits for it before exiting, so it gets the same deadline as everything else.
+      const finished = await settleWithin(applicationRun.then(() => undefined, () => undefined), environment.shutdownTimeoutMs);
+      if (!finished.settled) await forceExit(result.code);
     }
     return result.code;
   } catch (error) {
-    environment.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    environment.stderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
     resultCode = 1;
     return 1;
   } finally {
     removeSignals();
+    stdio.close();
     if (harness !== undefined) {
       const disposed = await settleWithin(harness.dispose().then(() => undefined, (error: unknown) => {
         environment.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
       }), environment.shutdownTimeoutMs);
-      if (!disposed.settled) forceExit(resultCode ?? 1);
+      if (!disposed.settled) await forceExit(resultCode ?? 1);
     }
   }
 }

package/packages/cli/src/node-stdio.ts

@@ -1,6 +1,6 @@
-import { createInterface } from "node:readline/promises";
+import { createInterface, type Interface } from "node:readline/promises";
 import type { Readable, Writable } from "node:stream";
-import type { PiHarnessStdio } from "@pi-harness/core";
+import { PiHarnessStdioCancelledError, type PiHarnessStdio } from "@pi-harness/core";
 
 type TerminalReadable = Readable & { isTTY?: boolean };
 
@@ -8,33 +8,105 @@ export class NodeStdio implements PiHarnessStdio {
   readonly #input: TerminalReadable;
   readonly #output: Writable;
   readonly #error: Writable;
+  readonly #abort = new AbortController();
+  #readline: Interface | undefined;
+  readonly #broken = new WeakSet<Writable>();
 
   constructor(input: Readable, output: Writable, error: Writable) {
     this.#input = input;
     this.#output = output;
     this.#error = error;
+    output.on("error", () => this.#broken.add(output));
+    error.on("error", () => this.#broken.add(error));
   }
 
   async readPrompt(): Promise<string> {
-    if (this.#input.isTTY === true) {
-      const readline = createInterface({ input: this.#input, output: this.#output });
-      try {
-        return await readline.question("> ");
-      } finally {
-        readline.close();
-      }
-    }
+    if (this.#abort.signal.aborted) throw new PiHarnessStdioCancelledError();
+    if (this.#input.isTTY === true) return await this.#question();
     this.#input.setEncoding("utf8");
     let content = "";
-    for await (const chunk of this.#input) content += String(chunk);
+    await new Promise<void>((resolve, reject) => {
+      const onData = (chunk: unknown) => { content += String(chunk); };
+      const settle = (error?: Error) => {
+        this.#input.off("data", onData);
+        this.#input.off("end", onEnd);
+        this.#input.off("error", onError);
+        this.#abort.signal.removeEventListener("abort", onAbort);
+        if (error === undefined) resolve(); else reject(error);
+      };
+      const onEnd = () => settle();
+      const onError = (error: Error) => settle(error);
+      const onAbort = () => {
+        this.#input.pause();
+        settle(new PiHarnessStdioCancelledError());
+      };
+      this.#input.on("data", onData);
+      this.#input.once("end", onEnd);
+      this.#input.once("error", onError);
+      this.#abort.signal.addEventListener("abort", onAbort, { once: true });
+    });
     return content.trimEnd();
   }
 
+  async #question(): Promise<string> {
+    const readline = createInterface({ input: this.#input, output: this.#output });
+    this.#readline = readline;
+    readline.on("SIGINT", () => this.close());
+    try {
+      return await Promise.race([
+        readline.question("> ", { signal: this.#abort.signal }),
+        new Promise<string>((_, reject) => readline.once("close", () => reject(new PiHarnessStdioCancelledError()))),
+      ]);
+    } catch (cause) {
+      throw this.#abort.signal.aborted || cause instanceof PiHarnessStdioCancelledError ? new PiHarnessStdioCancelledError() : cause;
+    } finally {
+      this.#readline = undefined;
+      readline.close();
+    }
+  }
+
   writeOutput(text: string): void {
-    this.#output.write(text);
+    this.#write(this.#output, text);
   }
 
   writeError(text: string): void {
-    this.#error.write(text);
+    this.#write(this.#error, text);
+  }
+
+  #write(stream: Writable, text: string): void {
+    if (this.#broken.has(stream) || stream.destroyed || stream.writableEnded) return;
+    try {
+      stream.write(text, (error) => {
+        if (error !== null && error !== undefined) this.#broken.add(stream);
+      });
+    } catch {
+      this.#broken.add(stream);
+    }
+  }
+
+  async flush(): Promise<void> {
+    await Promise.all([this.#drain(this.#output), this.#drain(this.#error)]);
+  }
+
+  async #drain(stream: Writable): Promise<void> {
+    if (this.#broken.has(stream) || stream.destroyed || stream.writableEnded || stream.writableLength === 0) return;
+    await new Promise<void>((resolve) => {
+      const done = () => {
+        stream.off("drain", done);
+        stream.off("error", done);
+        stream.off("close", done);
+        resolve();
+      };
+      stream.once("drain", done);
+      stream.once("error", done);
+      stream.once("close", done);
+    });
+  }
+
+  close(): void {
+    if (this.#abort.signal.aborted) return;
+    this.#abort.abort(new PiHarnessStdioCancelledError());
+    this.#readline?.close();
+    this.#input.pause();
   }
 }

package/packages/cli/src/relaunch.ts

@@ -1,16 +1,21 @@
 import { spawn, type SpawnOptions } from "node:child_process";
+import { constants } from "node:os";
+import { setTimeout as delay } from "node:timers/promises";
 import { parseLauncherArgs } from "./args.js";
 
 export const PI_HARNESS_RESTART_EXIT_CODE = 75;
+const RESTART_WINDOW_MS = 10_000;
+const RESTART_WINDOW_LIMIT = 5;
+const RESTART_BACKOFF_MS = 250;
 
 function signalExitCode(signal: NodeJS.Signals | null): number {
-  if (signal === "SIGINT") return 130;
-  if (signal === "SIGHUP") return 129;
-  if (signal === "SIGTERM") return 143;
-  return 1;
+  if (signal === null) return 1;
+  const number = constants.signals[signal];
+  return number === undefined ? 1 : 128 + number;
 }
 
 export async function superviseDevelopmentProcess(command: string, args: readonly string[], options: SpawnOptions = {}): Promise<number> {
+  const restarts: number[] = [];
   while (true) {
     const result = await new Promise<{ code: number | null; signal: NodeJS.Signals | null }>((resolve, reject) => {
       const child = spawn(command, [...args], options);
@@ -25,6 +30,7 @@ export async function superviseDevelopmentProcess(command: string, args: readonl
       };
       child.once("error", (error) => {
         cleanup();
+        if (child.pid !== undefined) child.kill("SIGKILL");
         reject(error);
       });
       child.once("exit", (code, signal) => {
@@ -32,8 +38,15 @@ export async function superviseDevelopmentProcess(command: string, args: readonl
         resolve({ code, signal });
       });
     });
-    if (result.code === PI_HARNESS_RESTART_EXIT_CODE) continue;
-    return result.code ?? signalExitCode(result.signal);
+    if (result.code !== PI_HARNESS_RESTART_EXIT_CODE) return result.code ?? signalExitCode(result.signal);
+    const startedAt = Date.now();
+    while (restarts.length > 0 && startedAt - (restarts[0] ?? 0) > RESTART_WINDOW_MS) restarts.shift();
+    restarts.push(startedAt);
+    if (restarts.length > RESTART_WINDOW_LIMIT) {
+      process.stderr.write(`Pi Harness development child requested ${restarts.length} restarts within ${RESTART_WINDOW_MS / 1_000}s; giving up\n`);
+      return 1;
+    }
+    await delay(RESTART_BACKOFF_MS);
   }
 }
 

package/packages/cli/test/args.test.ts

@@ -6,15 +6,34 @@ describe("parseLauncherArgs", () => {
     expect(parseLauncherArgs(["--prompt", "hello"])).toEqual({ mode: "run", profile: "default", dumpConfig: false, args: ["--prompt", "hello"] });
   });
 
-  test("parses launcher options without consuming escaped application options", () => {
-    expect(parseLauncherArgs(["--profile", "development", "--", "--profile", "inside", "hello"])).toEqual({ mode: "run", profile: "development", dumpConfig: false, args: ["--profile", "inside", "hello"] });
+  test("forwards the end-of-options separator so the application can take option-shaped prompts literally", () => {
+    expect(parseLauncherArgs(["--profile", "development", "--", "--profile", "inside", "hello"])).toEqual({ mode: "run", profile: "development", dumpConfig: false, args: ["--", "--profile", "inside", "hello"] });
+  });
+
+  test("stops recognizing launcher options at the first application argument", () => {
+    expect(parseLauncherArgs(["--prompt", "--version"])).toEqual({ mode: "run", profile: "default", dumpConfig: false, args: ["--prompt", "--version"] });
+    expect(parseLauncherArgs(["explain", "what", "tar", "-h", "prints"])).toEqual({ mode: "run", profile: "default", dumpConfig: false, args: ["explain", "what", "tar", "-h", "prints"] });
+    expect(parseLauncherArgs(["hello", "--profile", "development"])).toEqual({ mode: "run", profile: "default", dumpConfig: false, args: ["hello", "--profile", "development"] });
+  });
+
+  test("accepts the inline form of launcher options", () => {
+    expect(parseLauncherArgs(["--profile=development", "hello"])).toEqual({ mode: "run", profile: "development", dumpConfig: false, args: ["hello"] });
+    expect(parseLauncherArgs(["--config=./custom.yml", "--dump-config"])).toEqual({ mode: "run", configPath: "./custom.yml", dumpConfig: true, args: [] });
+    expect(() => parseLauncherArgs(["--profile="])).toThrow(/--profile requires a value/);
+    expect(() => parseLauncherArgs(["--config="])).toThrow(/--config requires a value/);
+    expect(() => parseLauncherArgs(["--profile=a", "--profile=b"])).toThrow(/may only be specified once/);
   });
 
   test("accepts an explicit config instead of a profile", () => {
     expect(parseLauncherArgs(["--config", "./custom.yml", "--dump-config"])).toEqual({ mode: "run", configPath: "./custom.yml", dumpConfig: true, args: [] });
   });
 
-  test.each([["--help", "help"], ["-h", "help"], ["--version", "version"], ["-v", "version"]] as const)("maps %s to %s mode", (flag, mode) => {
+  test.each([
+    ["--help", "help"],
+    ["-h", "help"],
+    ["--version", "version"],
+    ["-v", "version"],
+  ] as const)("maps %s to %s mode", (flag, mode) => {
     expect(parseLauncherArgs([flag])).toEqual({ mode });
   });
 

package/packages/cli/test/binary.test.ts

@@ -0,0 +1,58 @@
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { describe, expect, test } from "vitest";
+
+const run = promisify(execFile);
+const BIN = join(import.meta.dirname, "..", "dist", "bin.js");
+
+async function pih(args: string[], cwd: string, agentDir: string): Promise<{ stdout: string; stderr: string; code: number }> {
+  try {
+    const result = await run(process.execPath, [BIN, ...args], { cwd, env: { ...process.env, PI_AGENT_DIR: agentDir }, timeout: 30_000 });
+    return { ...result, code: 0 };
+  } catch (error) {
+    const failure = error as { stdout?: string; stderr?: string; code?: number };
+    return { stdout: failure.stdout ?? "", stderr: failure.stderr ?? "", code: failure.code ?? 1 };
+  }
+}
+
+describe("published binary", () => {
+  test("runs through the package export map without Node internals exposed", async () => {
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-bin-"));
+
+    const version = await pih(["--version"], directory, directory);
+    const dump = await pih(["--profile", "default", "--dump-config"], directory, directory);
+
+    expect(version.code).toBe(0);
+    expect(version.stdout.trim()).toMatch(/^\d+\.\d+\.\d+/);
+    expect(dump.code).toBe(0);
+    expect(dump.stdout).toContain("@pi-harness/core/plugins/models");
+  });
+
+  test("loads a bare plugin specifier installed next to the user's own profile", async () => {
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-bin-resolve-"));
+    const packageDir = join(directory, "node_modules", "@acme", "pi-probe");
+    await mkdir(packageDir, { recursive: true });
+    await writeFile(join(packageDir, "package.json"), JSON.stringify({ name: "@acme/pi-probe", version: "1.0.0", type: "module", exports: { ".": "./index.mjs" } }), "utf8");
+    await writeFile(join(packageDir, "index.mjs"), `export default { apply(ctx) { ctx.provide("piApplication", { async run() { ctx.piHarnessStdio.writeOutput("probe ran\\n"); return 0; } }); }, inject: ["piHarnessStdio"] };`, "utf8");
+    await writeFile(join(directory, "cordis.yml"), JSON.stringify([{ id: "probe", name: "@acme/pi-probe" }]), "utf8");
+
+    const result = await pih(["--config", join(directory, "cordis.yml"), "--prompt", "hi"], directory, directory);
+
+    expect(result.stderr).not.toContain("Cannot find package");
+    expect(result.code).toBe(0);
+    expect(result.stdout).toBe("probe ran\n");
+  }, 40_000);
+
+  test("reports an unresolvable bare plugin specifier", async () => {
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-bin-missing-"));
+    await writeFile(join(directory, "cordis.yml"), JSON.stringify([{ id: "probe", name: "@acme/definitely-not-installed" }]), "utf8");
+
+    const result = await pih(["--config", join(directory, "cordis.yml"), "--prompt", "hi"], directory, directory);
+
+    expect(result.code).toBe(1);
+    expect(result.stderr).toContain("@acme/definitely-not-installed");
+  }, 40_000);
+});

package/packages/cli/test/broken-pipe.test.ts

@@ -0,0 +1,32 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { describe, expect, test } from "vitest";
+
+const BIN = join(import.meta.dirname, "..", "dist", "bin.js");
+
+describe("broken output pipe", () => {
+  test("finishes the run and disposes the tree when the reader closes the pipe mid-stream", async () => {
+    const directory = await mkdtemp(join(tmpdir(), "pi-harness-epipe-"));
+    const markerPath = join(directory, "marker.txt");
+    const pluginPath = join(directory, "application.mjs");
+    const configPath = join(directory, "cordis.yml");
+    await writeFile(pluginPath, `import { appendFileSync } from "node:fs"; export default { inject: ["piHarnessStdio"], apply(ctx, config) { ctx.effect(() => () => appendFileSync(config.markerPath, "disposed\\n")); ctx.provide("piApplication", { async run() { for (let i = 0; i < 200; i += 1) { ctx.piHarnessStdio.writeOutput("line " + i + " " + "-".repeat(200) + "\\n"); await new Promise((resolve) => setTimeout(resolve, 5)); } appendFileSync(config.markerPath, "completed\\n"); return 0; } }); } };`, "utf8");
+    await writeFile(configPath, JSON.stringify([{ name: pathToFileURL(pluginPath).href, config: { markerPath } }]), "utf8");
+
+    const producer = spawn(process.execPath, [BIN, "--config", configPath, "--prompt", "hi"], { stdio: ["ignore", "pipe", "pipe"], env: { ...process.env, PI_AGENT_DIR: directory } });
+    let stderr = "";
+    producer.stderr.setEncoding("utf8");
+    producer.stderr.on("data", (chunk: string) => { stderr += chunk; });
+    producer.stdout.once("data", () => { producer.stdout.destroy(); });
+
+    const code = await new Promise<number | null>((resolve) => producer.once("exit", resolve));
+
+    expect(stderr).not.toContain("EPIPE");
+    expect(code).toBe(0);
+    const { readFile } = await import("node:fs/promises");
+    await expect(readFile(markerPath, "utf8")).resolves.toBe("completed\ndisposed\n");
+  }, 30_000);
+});

package/packages/cli/test/cli.test.ts

@@ -7,22 +7,28 @@ import { describe, expect, test } from "vitest";
 import { runCli, type CliEnvironment } from "../src/main.js";
 
 interface TestEnvironment extends CliEnvironment {
+  readonly stdin: Readable;
   readonly output: string[];
   readonly errors: string[];
   readonly forcedExitCodes: number[];
   emitSignal(signal: NodeJS.Signals): void;
 }
 
-function createEnvironment(cwd = process.cwd(), input = "", shutdownTimeoutMs = 5_000): TestEnvironment {
+function createEnvironment(cwd = process.cwd(), input: string | null = "", shutdownTimeoutMs = 5_000): TestEnvironment {
   const output: string[] = [];
   const errors: string[] = [];
   const forcedExitCodes: number[] = [];
   const signals = new Set<(signal: NodeJS.Signals) => void>();
+  const stdin = new Readable({ read() {} });
+  if (input !== null) {
+    if (input.length > 0) stdin.push(input);
+    stdin.push(null);
+  }
   return {
     cwd,
     agentDir: join(cwd, ".pi-agent-test"),
     version: "0.1.0-test",
-    stdin: Readable.from([input]),
+    stdin,
     stdout: new Writable({ write(chunk, _encoding, callback) { output.push(String(chunk)); callback(); } }),
     stderr: new Writable({ write(chunk, _encoding, callback) { errors.push(String(chunk)); callback(); } }),
     output,
@@ -55,7 +61,7 @@ async function waitForFileContent(path: string, expected: string, timeoutMs = 5_
   const startedAt = Date.now();
   while (true) {
     try {
-      if (await readFile(path, "utf8") === expected) return;
+      if ((await readFile(path, "utf8")) === expected) return;
     } catch {
       // The producer has not created the marker yet.
     }
@@ -97,7 +103,9 @@ describe("runCli", () => {
   });
 
   test("runs the application plugin and disposes the Cordis tree", async () => {
-    const profile = await createApplicationProfile(`import { appendFileSync, writeFileSync } from "node:fs"; export default { apply(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.effect(() => () => appendFileSync(config.markerPath, ":disposed")); ctx.provide("piApplication", { async run() { appendFileSync(config.markerPath, ":run"); return 7; } }); } };`);
+    const profile = await createApplicationProfile(
+      `import { appendFileSync, writeFileSync } from "node:fs"; export default { apply(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.effect(() => () => appendFileSync(config.markerPath, ":disposed")); ctx.provide("piApplication", { async run() { appendFileSync(config.markerPath, ":run"); return 7; } }); } };`,
+    );
     const environment = createEnvironment(profile.directory);
 
     const exitCode = await runCli(["--config", profile.configPath], environment);
@@ -107,7 +115,7 @@ describe("runCli", () => {
   });
 
   test("aborts and disposes a running application on SIGINT", async () => {
-    const profile = await createApplicationProfile(`import { appendFileSync, writeFileSync } from "node:fs"; export default { apply(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.effect(() => () => appendFileSync(config.markerPath, ":disposed")); ctx.provide("piApplication", { async run() { appendFileSync(config.markerPath, ":run"); return new Promise(() => {}); } }); } };`);
+    const profile = await createApplicationProfile(`import { appendFileSync, writeFileSync } from "node:fs"; export default { apply(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.effect(() => () => appendFileSync(config.markerPath, ":disposed")); ctx.provide("piApplication", { async run(signal) { appendFileSync(config.markerPath, ":run"); await new Promise((resolve) => signal.addEventListener("abort", resolve, { once: true })); appendFileSync(config.markerPath, ":aborted"); return 0; } }); } };`);
     const environment = createEnvironment(profile.directory);
     const result = runCli(["--config", profile.configPath], environment);
     const markerPath = join(profile.directory, "marker.txt");
@@ -116,11 +124,26 @@ describe("runCli", () => {
     environment.emitSignal("SIGINT");
 
     await expect(result).resolves.toBe(130);
-    await expect(readFile(markerPath, "utf8")).resolves.toBe("started:run:disposed");
+    await expect(readFile(markerPath, "utf8")).resolves.toBe("started:run:aborted:disposed");
+    expect(environment.forcedExitCodes).toEqual([]);
+  });
+
+  test("forces the bin exit when an application ignores the shutdown signal", async () => {
+    const profile = await createApplicationProfile(`import { writeFileSync } from "node:fs"; export default { apply(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.provide("piApplication", { async run() { return new Promise(() => {}); } }); } };`);
+    const environment = createEnvironment(profile.directory, "", 25);
+    const result = runCli(["--config", profile.configPath], environment);
+    await waitForFileContent(join(profile.directory, "marker.txt"), "started");
+
+    environment.emitSignal("SIGINT");
+
+    await expect(result).resolves.toBe(130);
+    expect(environment.forcedExitCodes).toEqual([130]);
   });
 
   test("handles SIGTERM while the Cordis plugin tree is still starting", async () => {
-    const profile = await createApplicationProfile(`import { writeFileSync } from "node:fs"; export default { async apply(_ctx, config) { writeFileSync(config.markerPath, "starting"); await new Promise(() => {}); } };`);
+    const profile = await createApplicationProfile(
+      `import { writeFileSync } from "node:fs"; export default { async apply(_ctx, config) { writeFileSync(config.markerPath, "starting"); await new Promise(() => {}); } };`,
+    );
     const environment = createEnvironment(profile.directory, "", 50);
     const result = runCli(["--config", profile.configPath], environment);
     await waitForFileContent(join(profile.directory, "marker.txt"), "starting");
@@ -131,7 +154,9 @@ describe("runCli", () => {
   });
 
   test("forces the bin exit when a Cordis disposer exceeds the shutdown deadline", async () => {
-    const profile = await createApplicationProfile(`import { writeFileSync } from "node:fs"; export default { apply(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.effect(() => async () => new Promise(() => {})); ctx.provide("piApplication", { async run() { return new Promise(() => {}); } }); } };`);
+    const profile = await createApplicationProfile(
+      `import { writeFileSync } from "node:fs"; export default { apply(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.effect(() => async () => new Promise(() => {})); ctx.provide("piApplication", { async run() { return new Promise(() => {}); } }); } };`,
+    );
     const environment = createEnvironment(profile.directory, "", 25);
     const result = runCli(["--config", profile.configPath], environment);
     await waitForFileContent(join(profile.directory, "marker.txt"), "started");
@@ -142,6 +167,30 @@ describe("runCli", () => {
     expect(environment.forcedExitCodes).toEqual([143]);
   });
 
+  test("forces the bin exit on a repeated signal instead of waiting for the shutdown deadline", async () => {
+    const profile = await createApplicationProfile(`import { writeFileSync } from "node:fs"; export default { apply(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.provide("piRuntime", { async abort() { return new Promise(() => {}); }, async dispose() {} }); ctx.provide("piApplication", { async run() { return new Promise(() => {}); } }); } };`);
+    const environment = createEnvironment(profile.directory, "", 60_000);
+    const result = runCli(["--config", profile.configPath], environment);
+    await waitForFileContent(join(profile.directory, "marker.txt"), "started");
+
+    environment.emitSignal("SIGINT");
+    environment.emitSignal("SIGINT");
+
+    expect(environment.forcedExitCodes).toEqual([130]);
+    expect(environment.errors.join("")).toContain("Received SIGINT again");
+    await expect(Promise.race([result, new Promise((resolve) => setTimeout(() => resolve("pending"), 200))])).resolves.toBe("pending");
+  });
+
+  test("does not exit with the restart code when the process is not supervised", async () => {
+    const profile = await createApplicationProfile(`import { writeFileSync } from "node:fs"; export default { inject: ["piHarnessLaunch"], apply(ctx, config) { writeFileSync(config.markerPath, "started"); ctx.provide("piApplication", { async run() { ctx.loader.exit(); return 0; } }); } };`);
+    const environment = createEnvironment(profile.directory);
+
+    const exitCode = await runCli(["--config", profile.configPath], environment);
+
+    expect(exitCode).toBe(0);
+    expect(environment.errors.join("")).toContain("not supervised");
+  });
+
   test("returns a usage error for a missing config", async () => {
     const environment = createEnvironment();