@akagilnc/pi-workflow-roles 0.1.1941 → 0.1.2004

package/src/public-cli/invocation.ts

@@ -334,6 +334,50 @@ export type ParseMergerArgvResult = {
   project?: string;
 };
 
+/**
+ * #336/#337/#338 taishi public argv — four faces on one registration seam.
+ * - issue (default): ticket N and/or project-root P
+ * - sweep (#337): optional positional `sweep` and/or --attach paths;
+ *   sweep payload rides exactly one typed JSON attachment (not argv/stdin)
+ * - cohort: two labeled issue-number groups
+ * - model-groups: one or more project-root scope keys
+ */
+export type ParseTaishiIssueArgv = {
+  readonly query: "issue";
+  /** Caller ticket / issue number face (#176 numbering space). */
+  readonly ticket?: number;
+  /** Direct projectRoot mechanical key (ADR 0068). */
+  readonly projectRoot?: string;
+};
+
+export type ParseTaishiSweepArgv = {
+  readonly query: "sweep";
+  /**
+   * Public CLI attachment paths (--attach). Sweep mode only (#337).
+   * Cardinality validated on the sweep run path (exactly one).
+   */
+  readonly attachmentPaths: readonly string[];
+};
+
+export type ParseTaishiCohortArgv = {
+  readonly query: "cohort";
+  readonly groups: readonly [
+    { readonly groupLabel: string; readonly issues: readonly number[] },
+    { readonly groupLabel: string; readonly issues: readonly number[] },
+  ];
+};
+
+export type ParseTaishiModelGroupsArgv = {
+  readonly query: "model-groups";
+  readonly projectRoots: readonly string[];
+};
+
+export type ParseTaishiArgvResult =
+  | ParseTaishiIssueArgv
+  | ParseTaishiSweepArgv
+  | ParseTaishiCohortArgv
+  | ParseTaishiModelGroupsArgv;
+
 /** Honest activation-class failure while deriving the active-merge envelope. */
 export class MergerEnvelopeDerivationError extends Error {
   readonly code = "merger-envelope-derivation" as const;
@@ -347,7 +391,13 @@ export class MergerEnvelopeDerivationError extends Error {
 
 /** Reject missing/blank path values so empty overrides cannot silently degrade. */
 function requireOptionPath(
-  flag: "--project" | "--attach" | "--prerequisites" | "--request-manifest" | "--base",
+  flag:
+    | "--project"
+    | "--attach"
+    | "--prerequisites"
+    | "--request-manifest"
+    | "--base"
+    | "--project-root",
   value: string | undefined,
 ): string {
   if (value === undefined || value.trim() === "") {
@@ -2041,3 +2091,304 @@ export function buildMergerTransportPrompt(
   }
   return lines.join("\n");
 }
+
+const TAISHI_TICKET_NUMBER_PATTERN = /^[1-9]\d*$/;
+
+/**
+ * Parse a positive ticket / issue number for public taishi admission.
+ * Leading zeros and non-integers are structural rejects (same face as #176).
+ * `flag` names the actual argv face in diagnostics (cohort group lists reuse this).
+ */
+export function parseTaishiTicketNumber(
+  raw: string,
+  flag: string = "--ticket",
+): number {
+  const trimmed = raw.trim();
+  if (!TAISHI_TICKET_NUMBER_PATTERN.test(trimmed)) {
+    throw new CliUsageError(
+      `taishi ${flag} must be a positive integer, got ${raw}`,
+    );
+  }
+  const value = Number(trimmed);
+  // Digit-only strings beyond MAX_SAFE_INTEGER round or become Infinity — reject.
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new CliUsageError(
+      `taishi ${flag} must be a positive integer, got ${raw}`,
+    );
+  }
+  return value;
+}
+
+function parseTaishiIssueNumberList(raw: string, flag: string): number[] {
+  const trimmed = raw.trim();
+  if (trimmed === "") {
+    throw new CliUsageError(`${flag} requires a comma-separated positive integer list`);
+  }
+  const parts = trimmed.split(",").map((part) => part.trim());
+  if (parts.some((part) => part === "")) {
+    throw new CliUsageError(`${flag} requires a comma-separated positive integer list`);
+  }
+  // Same numeric rule as --ticket; diagnostic names the actual group flag.
+  return parts.map((part) => parseTaishiTicketNumber(part, flag));
+}
+
+function requireOptionValue(
+  flag: string,
+  value: string | undefined,
+  what: string,
+): string {
+  if (value === undefined || value.trim() === "") {
+    throw new CliUsageError(`${flag} requires ${what}`);
+  }
+  return value;
+}
+
+/**
+ * Parse taishi-specific argv after the `taishi` token (#336/#337/#338).
+ * Issue: at least one of --ticket / --project-root.
+ * Sweep: positional `sweep` and/or --attach; payload is the attachment body only.
+ * Cohort / model-groups: explicit query flags with their own required faces.
+ * Faces are mutually exclusive.
+ */
+export function parseTaishiArgv(args: readonly string[]): ParseTaishiArgvResult {
+  let query: "issue" | "cohort" | "model-groups" = "issue";
+  let ticketRaw: string | undefined;
+  const projectRoots: string[] = [];
+  let groupALabel: string | undefined;
+  let groupAIssuesRaw: string | undefined;
+  let groupBLabel: string | undefined;
+  let groupBIssuesRaw: string | undefined;
+  let sweepToken = false;
+  const attachmentPaths: string[] = [];
+  const tokens = [...args];
+
+  while (tokens.length > 0) {
+    const token = tokens.shift()!;
+    if (token === "--") {
+      if (tokens.length > 0) {
+        throw new CliUsageError(`unexpected taishi argument: ${tokens[0]}`);
+      }
+      break;
+    }
+    if (token === "--cohort") {
+      if (query !== "issue") {
+        throw new CliUsageError("taishi accepts only one of --cohort / --model-groups");
+      }
+      query = "cohort";
+      continue;
+    }
+    if (token === "--model-groups") {
+      if (query !== "issue") {
+        throw new CliUsageError("taishi accepts only one of --cohort / --model-groups");
+      }
+      query = "model-groups";
+      continue;
+    }
+    if (token === "--ticket") {
+      const value = tokens.shift();
+      if (value === undefined || value.trim() === "") {
+        throw new CliUsageError("taishi --ticket requires a positive integer");
+      }
+      ticketRaw = value;
+      continue;
+    }
+    if (token.startsWith("--ticket=")) {
+      ticketRaw = token.slice("--ticket=".length);
+      if (ticketRaw.trim() === "") {
+        throw new CliUsageError("taishi --ticket requires a positive integer");
+      }
+      continue;
+    }
+    if (token === "--project-root") {
+      projectRoots.push(requireOptionPath("--project-root", tokens.shift()));
+      continue;
+    }
+    if (token.startsWith("--project-root=")) {
+      projectRoots.push(
+        requireOptionPath("--project-root", token.slice("--project-root=".length)),
+      );
+      continue;
+    }
+    if (token === "--group-a-label") {
+      groupALabel = requireOptionValue("--group-a-label", tokens.shift(), "a label");
+      continue;
+    }
+    if (token.startsWith("--group-a-label=")) {
+      groupALabel = requireOptionValue(
+        "--group-a-label",
+        token.slice("--group-a-label=".length),
+        "a label",
+      );
+      continue;
+    }
+    if (token === "--group-a-issues") {
+      groupAIssuesRaw = requireOptionValue(
+        "--group-a-issues",
+        tokens.shift(),
+        "a comma-separated positive integer list",
+      );
+      continue;
+    }
+    if (token.startsWith("--group-a-issues=")) {
+      groupAIssuesRaw = requireOptionValue(
+        "--group-a-issues",
+        token.slice("--group-a-issues=".length),
+        "a comma-separated positive integer list",
+      );
+      continue;
+    }
+    if (token === "--group-b-label") {
+      groupBLabel = requireOptionValue("--group-b-label", tokens.shift(), "a label");
+      continue;
+    }
+    if (token.startsWith("--group-b-label=")) {
+      groupBLabel = requireOptionValue(
+        "--group-b-label",
+        token.slice("--group-b-label=".length),
+        "a label",
+      );
+      continue;
+    }
+    if (token === "--group-b-issues") {
+      groupBIssuesRaw = requireOptionValue(
+        "--group-b-issues",
+        tokens.shift(),
+        "a comma-separated positive integer list",
+      );
+      continue;
+    }
+    if (token.startsWith("--group-b-issues=")) {
+      groupBIssuesRaw = requireOptionValue(
+        "--group-b-issues",
+        token.slice("--group-b-issues=".length),
+        "a comma-separated positive integer list",
+      );
+      continue;
+    }
+    if (token === "--attach") {
+      attachmentPaths.push(requireOptionPath("--attach", tokens.shift()));
+      continue;
+    }
+    if (token.startsWith("--attach=")) {
+      attachmentPaths.push(
+        requireOptionPath("--attach", token.slice("--attach=".length)),
+      );
+      continue;
+    }
+    if (token.startsWith("-") && token !== "-") {
+      throw new CliUsageError(`unknown taishi option: ${token}`);
+    }
+    // Optional sweep mode token (like coder plan/apply); only once, no other positionals.
+    if (token === "sweep") {
+      if (sweepToken) {
+        throw new CliUsageError("unexpected taishi argument: sweep");
+      }
+      sweepToken = true;
+      continue;
+    }
+    throw new CliUsageError(`unexpected taishi argument: ${token}`);
+  }
+
+  const hasSweepFace = sweepToken || attachmentPaths.length > 0;
+  const hasCohortFlags =
+    groupALabel !== undefined
+    || groupAIssuesRaw !== undefined
+    || groupBLabel !== undefined
+    || groupBIssuesRaw !== undefined;
+
+  if (query === "cohort") {
+    if (
+      groupALabel === undefined
+      || groupAIssuesRaw === undefined
+      || groupBLabel === undefined
+      || groupBIssuesRaw === undefined
+    ) {
+      throw new CliUsageError(
+        "usage: ak-role taishi --cohort --group-a-label <L> --group-a-issues <N[,N...]> --group-b-label <L> --group-b-issues <N[,N...]>",
+      );
+    }
+    if (ticketRaw !== undefined || projectRoots.length > 0) {
+      throw new CliUsageError(
+        "taishi --cohort does not accept --ticket or --project-root",
+      );
+    }
+    if (hasSweepFace) {
+      throw new CliUsageError(
+        "taishi --cohort does not accept sweep --attach",
+      );
+    }
+    return {
+      query: "cohort",
+      groups: [
+        {
+          groupLabel: groupALabel,
+          issues: parseTaishiIssueNumberList(groupAIssuesRaw, "--group-a-issues"),
+        },
+        {
+          groupLabel: groupBLabel,
+          issues: parseTaishiIssueNumberList(groupBIssuesRaw, "--group-b-issues"),
+        },
+      ],
+    };
+  }
+
+  if (query === "model-groups") {
+    if (projectRoots.length === 0) {
+      throw new CliUsageError(
+        "usage: ak-role taishi --model-groups --project-root <P> [--project-root <P> ...]",
+      );
+    }
+    if (ticketRaw !== undefined) {
+      throw new CliUsageError("taishi --model-groups does not accept --ticket");
+    }
+    if (hasCohortFlags) {
+      throw new CliUsageError("taishi --model-groups does not accept cohort group flags");
+    }
+    if (hasSweepFace) {
+      throw new CliUsageError(
+        "taishi --model-groups does not accept sweep --attach",
+      );
+    }
+    return {
+      query: "model-groups",
+      projectRoots,
+    };
+  }
+
+  // default issue or sweep (#336/#337 faces)
+  if (hasCohortFlags) {
+    throw new CliUsageError("taishi issue query does not accept cohort group flags");
+  }
+
+  if (hasSweepFace) {
+    if (ticketRaw !== undefined || projectRoots.length > 0) {
+      throw new CliUsageError(
+        "taishi sweep --attach cannot combine with --ticket or --project-root",
+      );
+    }
+    return {
+      query: "sweep",
+      attachmentPaths,
+    };
+  }
+
+  if (projectRoots.length > 1) {
+    throw new CliUsageError(
+      "taishi issue query accepts at most one --project-root (use --model-groups for many)",
+    );
+  }
+  const projectRoot = projectRoots[0];
+  if (ticketRaw === undefined && projectRoot === undefined) {
+    throw new CliUsageError(
+      "usage: ak-role taishi ((--ticket <N> | --project-root <P>) | [sweep] --attach <sweep.json> | --cohort ... | --model-groups ...)",
+    );
+  }
+
+  return {
+    query: "issue",
+    ...(ticketRaw === undefined
+      ? {}
+      : { ticket: parseTaishiTicketNumber(ticketRaw) }),
+    ...(projectRoot === undefined ? {} : { projectRoot }),
+  };
+}

package/src/public-cli/main.ts

@@ -1,11 +1,30 @@
+import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { ensureHostPiRuntimeResolvable } from "./host-pi-runtime.ts";
 
 const here = dirname(fileURLToPath(import.meta.url));
-// dist/public-cli/main.js → package root is ../..
-const packageRoot = join(here, "..", "..");
+
+/**
+ * Resolve install package root from the public bin location.
+ *
+ * Shipped layout is `<packageRoot>/dist/public-cli/main.js` → two levels up when
+ * that ancestor owns package.json. A relocated single-file bundle (no package
+ * tree beside the bin) must NOT keep climbing: `join("/tmp/<bin>","..","..")`
+ * is `"/"` on Linux CI, and host-pi linking then does
+ * `mkdir('/node_modules/@earendil-works')` → EACCES. Fall back to the bin
+ * directory so links stay on the ESM ancestor walk and remain writable.
+ */
+function resolvePackageRoot(binDir: string): string {
+  const canonical = join(binDir, "..", "..");
+  if (existsSync(join(canonical, "package.json"))) {
+    return canonical;
+  }
+  return binDir;
+}
+
+const packageRoot = resolvePackageRoot(here);
 
 // The host-provided runtime must be resolvable before the CLI module graph loads it.
 ensureHostPiRuntimeResolvable(packageRoot);

package/src/public-cli/registry.ts

@@ -97,6 +97,12 @@ export function publicStartupCandidates(
   return STARTUP_CANDIDATES[seat];
 }
 
+/** Deterministic public commands — discoverable, never LLM-configurable seats. */
+export const PUBLIC_DETERMINISTIC_COMMANDS = ["taishi"] as const;
+
+export type PublicDeterministicCommand =
+  (typeof PUBLIC_DETERMINISTIC_COMMANDS)[number];
+
 export type HelpCapability =
   | {
       kind: "support";
@@ -107,11 +113,16 @@ export type HelpCapability =
       name: PublicCallableRole;
       phases: readonly (string | null)[];
       defaultPhase: string | null;
+    }
+  | {
+      kind: "deterministic";
+      name: PublicDeterministicCommand;
     };
 
 /**
  * Typed help surface. Presentation formats these facts; tests must not assert
  * exact help prose or layout (锚定宪法 / ADR 0016 / #105 AC).
+ * taishi is a deterministic analysis command on the public CLI — not an LLM seat.
  */
 export function listHelpCapabilities(): readonly HelpCapability[] {
   const support: HelpCapability[] = PUBLIC_CLI_SUPPORT_COMMANDS.map((name) => ({
@@ -133,7 +144,13 @@ export function listHelpCapabilities(): readonly HelpCapability[] {
       defaultPhase,
     };
   });
-  return [...support, ...roles];
+  const deterministic: HelpCapability[] = PUBLIC_DETERMINISTIC_COMMANDS.map(
+    (name) => ({
+      kind: "deterministic" as const,
+      name,
+    }),
+  );
+  return [...support, ...roles, ...deterministic];
 }
 
 export function isPublicCallableRole(value: string): value is PublicCallableRole {

package/src/public-cli/settlement.ts

@@ -242,6 +242,15 @@ export function presentStructuralRejection(
   io.stderr(formatCliDiagnostic(error.message));
 }
 
+/** ControlledFailure face without admitted-run Terminal (stdout body + stderr line). */
+export function presentControlledFailure(
+  failure: ControlledFailure,
+  io: { stdout: (text: string) => void; stderr: (text: string) => void },
+): void {
+  io.stdout(`${JSON.stringify(failure, null, 2)}\n`);
+  io.stderr(formatFailureStderrDiagnostic(failure));
+}
+
 /** Session readiness after an admitted activation attempt. */
 export type SessionReadiness =
   | { readonly state: "missing" }

package/src/public-cli/taishi-run.ts

@@ -0,0 +1,235 @@
+/**
+ * Public taishi adapter (#336/#337/#338): argv → typed query → runTaishi family.
+ * Deterministic analysis seat — no Pi runner, no admission lease.
+ * Reuses existing CLI failure envelope (CliUsageError + structural reject +
+ * ControlledFailure).
+ * Index read reuses readTaishiLibraryIndexPage / findTaishiLibraryIndexRow.
+ * #337 sweep: exactly one typed JSON attachment → TaishiSweepModeInput → #329 kernel.
+ * #338: three query faces; sync compute-if-missing; whole-compute failure →
+ * ControlledFailure terminal (code/projectRoot/issueNumber/real cause).
+ * "Unobtrusive" binds #337 merge auto-trigger only, not this user-initiated query.
+ */
+import { readFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { Value } from "typebox/value";
+
+import {
+  errnoCode,
+  physicalPathIdentity,
+  resolveActivationLedgerHome,
+} from "../activation-ledger-topology.ts";
+import { exactUtf8 } from "../exact-utf8.ts";
+import {
+  findTaishiLibraryIndexRow,
+  readTaishiLibraryIndexPage,
+} from "../taishi-index.ts";
+import {
+  readOrComputeTaishiIssuePage,
+  runTaishi,
+  taishiSweepModeInputSchema,
+  TaishiIssueComputeError,
+  type TaishiIssueModeInput,
+  type TaishiSweepModeInput,
+} from "../taishi-entry.ts";
+import { CliUsageError } from "./cli-errors.ts";
+import type { CliIo } from "./cli-io.ts";
+import type {
+  ParseTaishiArgvResult,
+  ParseTaishiIssueArgv,
+} from "./invocation.ts";
+import { presentControlledFailure, presentStructuralRejection } from "./settlement.ts";
+
+export type TaishiRunEnv = {
+  readonly home: string;
+};
+
+/**
+ * Build the sole library issue-mode input from public argv faces.
+ * - ticket N → issueNumber = ticketNumber = N; projectRoot from index (or project-root fallback).
+ * - project-root P → direct mechanical key.
+ * - both + index hit → index projectRoot wins; when direct root differs, retain it as
+ *   conflictingProjectRoot so runTaishi records the C4 dual-param conflict fact on the page.
+ * - both + index miss → project-root fallback.
+ * Bare both-missing is owned by parseTaishiArgv — no second reject here.
+ */
+export async function buildTaishiIssueModeInputFromPublicArgv(
+  parsed: ParseTaishiIssueArgv,
+  ledgerHome: string,
+): Promise<TaishiIssueModeInput> {
+  const ticket = parsed.ticket;
+  const directRoot = parsed.projectRoot;
+
+  if (ticket === undefined) {
+    return {
+      mode: "issue",
+      projectRoot: directRoot!,
+    };
+  }
+
+  // ticket N = issueNumber (no conversion); also the C4 typed ticket face.
+  const index = await readTaishiLibraryIndexPage(ledgerHome);
+  const row = findTaishiLibraryIndexRow(index, ticket);
+
+  let projectRoot: string;
+  if (row !== undefined) {
+    // Ticket-resolved index projectRoot wins over any concurrent --project-root.
+    projectRoot = row.projectRoot;
+  } else if (directRoot !== undefined) {
+    // Index miss with project-root fallback (ticket faces still set for C4).
+    projectRoot = directRoot;
+  } else {
+    throw new CliUsageError(
+      `taishi library index has no row for ticket ${ticket}`,
+    );
+  }
+
+  // Dual-param conflict: index root won, but caller also supplied a distinct --project-root.
+  // Carry the losing root so the metrics page records the call-face conflict fact.
+  const dualParamConflict =
+    row !== undefined
+    && directRoot !== undefined
+    && physicalPathIdentity(directRoot) !== physicalPathIdentity(projectRoot);
+
+  return {
+    mode: "issue",
+    projectRoot,
+    ticketNumber: ticket,
+    issueNumber: ticket,
+    ...(dualParamConflict ? { conflictingProjectRoot: directRoot } : {}),
+  };
+}
+
+/**
+ * Attachment JSON → library TaishiSweepModeInput via the sole schema (#337).
+ * No parallel hand shape; rejects missing/extra/wrong-type fields only.
+ */
+export function parseTaishiSweepModeInputFromJsonValue(
+  value: unknown,
+): TaishiSweepModeInput {
+  if (!Value.Check(taishiSweepModeInputSchema, value)) {
+    throw new CliUsageError(
+      "taishi sweep attachment must match TaishiSweepModeInput",
+    );
+  }
+  return value;
+}
+
+/**
+ * Load sweep typed input from exactly one public CLI attachment path.
+ * Rejects: wrong cardinality, unreadable path, non-UTF-8, JSON fail, field contract.
+ * Zero ledger writes — read-only path resolve + parse.
+ */
+export async function buildTaishiSweepModeInputFromAttachmentPaths(
+  attachmentPaths: readonly string[],
+): Promise<TaishiSweepModeInput> {
+  if (attachmentPaths.length !== 1) {
+    throw new CliUsageError(
+      "taishi sweep requires exactly one --attach typed JSON attachment",
+    );
+  }
+
+  const sourcePath = attachmentPaths[0]!;
+  const absolute = isAbsolute(sourcePath) ? sourcePath : resolve(sourcePath);
+
+  let bytes: Buffer;
+  try {
+    bytes = await readFile(absolute);
+  } catch (error) {
+    throw new CliUsageError(
+      `taishi sweep attachment is not a readable regular file: ${sourcePath}`,
+      { cause: error },
+    );
+  }
+
+  let text: string;
+  try {
+    text = exactUtf8(bytes, "taishi sweep attachment");
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new CliUsageError(detail, { cause: error });
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new CliUsageError(
+      "taishi sweep attachment is not valid JSON",
+      { cause: error },
+    );
+  }
+
+  return parseTaishiSweepModeInputFromJsonValue(parsed);
+}
+
+/**
+ * Public taishi run path — parse → resolve → query → typed receipt on stdout.
+ * Issue (#336/#338 compute-if-missing), sweep (#337), cohort/model-groups (#338).
+ */
+export async function runPublicTaishi(
+  argv: readonly string[],
+  _env: TaishiRunEnv,
+  io: CliIo,
+  parseTaishiArgv: (args: readonly string[]) => ParseTaishiArgvResult,
+): Promise<{ exitCode: number }> {
+  try {
+    const parsed = parseTaishiArgv(argv);
+    // Machine home is package-owned (ADR 0048) — same primitive runTaishi uses.
+    const ledgerHome = resolveActivationLedgerHome();
+
+    if (parsed.query === "sweep") {
+      const input = await buildTaishiSweepModeInputFromAttachmentPaths(
+        parsed.attachmentPaths,
+      );
+      const result = await runTaishi(input);
+      io.stdout(`${JSON.stringify(result, null, 2)}\n`);
+      return { exitCode: 0 };
+    }
+
+    if (parsed.query === "cohort") {
+      const result = await runTaishi({
+        mode: "cohort",
+        groups: parsed.groups,
+      });
+      io.stdout(`${JSON.stringify(result, null, 2)}\n`);
+      return { exitCode: 0 };
+    }
+
+    if (parsed.query === "model-groups") {
+      const result = await runTaishi({
+        mode: "model-groups",
+        projectRoots: parsed.projectRoots,
+      });
+      io.stdout(`${JSON.stringify(result, null, 2)}\n`);
+      return { exitCode: 0 };
+    }
+
+    // issue query — compute-if-missing (#338); sole kernel on miss.
+    const input = await buildTaishiIssueModeInputFromPublicArgv(parsed, ledgerHome);
+    const result = await readOrComputeTaishiIssuePage(input);
+    io.stdout(`${JSON.stringify(result, null, 2)}\n`);
+    return { exitCode: 0 };
+  } catch (error) {
+    if (error instanceof CliUsageError) {
+      presentStructuralRejection(error, io);
+      return { exitCode: 2 };
+    }
+    if (error instanceof TaishiIssueComputeError) {
+      // Existing ControlledFailure: details carry code/projectRoot/issueNumber;
+      // identity.code carries distinguishable real cause (errno). No parallel schema.
+      const code = errnoCode(error.cause);
+      presentControlledFailure({
+        cause: "output",
+        diagnostic: error.message,
+        ...(code === undefined ? {} : { identity: { code } }),
+        details: {
+          code: error.code,
+          projectRoot: error.projectRoot,
+          ...(error.issueNumber === undefined ? {} : { issueNumber: error.issueNumber }),
+        },
+      }, io);
+      return { exitCode: 1 };
+    }
+    throw error;
+  }
+}