@bastani/atomic 0.5.34-0 → 0.6.0-0

package/src/commands/cli/workflow.test.ts

@@ -1,317 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import {
-  parsePassthroughArgs,
-  validateInputsAgainstSchema,
-  resolveInputs,
-  renderWorkflowList,
-} from "./workflow.ts";
-import type { WorkflowInput } from "../../sdk/workflows/index.ts";
-import type {
-  DiscoveredWorkflow,
-  WorkflowWithMetadata,
-} from "../../sdk/workflows/index.ts";
-
-// ─── Colour handling ────────────────────────────────────────────────────────
-// The renderer emits ANSI sequences when the host terminal claims truecolor
-// support. Force `NO_COLOR=1` for this file so renderWorkflowList assertions
-// can match on plain-text output rather than brittle SGR escapes. Restore the
-// prior value on teardown so other suites in the same run are unaffected.
-let originalNoColor: string | undefined;
-beforeAll(() => {
-  originalNoColor = process.env.NO_COLOR;
-  process.env.NO_COLOR = "1";
-});
-afterAll(() => {
-  if (originalNoColor === undefined) delete process.env.NO_COLOR;
-  else process.env.NO_COLOR = originalNoColor;
-});
-
-// ─── parsePassthroughArgs ──────────────────────────────────────────────────
-
-describe("parsePassthroughArgs", () => {
-  test("parses --name=value flag pairs", () => {
-    const out = parsePassthroughArgs(["--foo=bar", "--baz=qux"]);
-    expect(out.flags).toEqual({ foo: "bar", baz: "qux" });
-    expect(out.positional).toEqual([]);
-    expect(out.errors).toEqual([]);
-  });
-
-  test("parses --name value flag pairs", () => {
-    const out = parsePassthroughArgs(["--foo", "bar", "--baz", "qux"]);
-    expect(out.flags).toEqual({ foo: "bar", baz: "qux" });
-    expect(out.errors).toEqual([]);
-  });
-
-  test("preserves values containing equals signs", () => {
-    const out = parsePassthroughArgs(["--query=key=value"]);
-    expect(out.flags).toEqual({ query: "key=value" });
-  });
-
-  test("collects positional tokens separately", () => {
-    const out = parsePassthroughArgs(["fix", "the", "bug"]);
-    expect(out.positional).toEqual(["fix", "the", "bug"]);
-    expect(out.flags).toEqual({});
-  });
-
-  test("returns an error when a flag has no value", () => {
-    const out = parsePassthroughArgs(["--foo"]);
-    expect(out.errors.length).toBe(1);
-    expect(out.errors[0]).toContain("--foo");
-  });
-
-  test("flags an empty flag name when `--=value` slips through", () => {
-    // `--=foo` tokenises to body="=foo", splits at the first `=`,
-    // and yields an empty name. The parser rejects this so users see
-    // "did you mean --name=foo?" rather than silently accepting a
-    // nameless entry in the flags record.
-    const out = parsePassthroughArgs(["--=foo"]);
-    expect(out.errors.length).toBe(1);
-    expect(out.errors[0]).toContain("Malformed flag");
-    expect(out.flags).toEqual({});
-  });
-
-  test("treats a trailing --flag --other as a missing value", () => {
-    // Second `--other` looks like a flag so the parser should not
-    // silently consume it as the first flag's value.
-    const out = parsePassthroughArgs(["--foo", "--other=x"]);
-    expect(out.errors.length).toBe(1);
-    expect(out.flags).toEqual({ other: "x" });
-  });
-
-  test("handles mixed positional and flag tokens", () => {
-    const out = parsePassthroughArgs([
-      "run",
-      "--mode=fast",
-      "now",
-      "--retries",
-      "3",
-    ]);
-    expect(out.positional).toEqual(["run", "now"]);
-    expect(out.flags).toEqual({ mode: "fast", retries: "3" });
-    expect(out.errors).toEqual([]);
-  });
-});
-
-// ─── validateInputsAgainstSchema ───────────────────────────────────────────
-
-const schema: WorkflowInput[] = [
-  {
-    name: "research_doc",
-    type: "string",
-    required: true,
-    description: "path",
-  },
-  {
-    name: "focus",
-    type: "enum",
-    required: true,
-    values: ["minimal", "standard", "exhaustive"],
-    default: "standard",
-  },
-  {
-    name: "notes",
-    type: "text",
-  },
-];
-
-describe("validateInputsAgainstSchema", () => {
-  test("passes when all required fields are present", () => {
-    const errors = validateInputsAgainstSchema(
-      { research_doc: "notes.md", focus: "standard" },
-      schema,
-    );
-    expect(errors).toEqual([]);
-  });
-
-  test("accepts an omitted enum with a declared default", () => {
-    // `focus` has a default of "standard", so omission should be OK.
-    const errors = validateInputsAgainstSchema(
-      { research_doc: "notes.md" },
-      schema,
-    );
-    expect(errors).toEqual([]);
-  });
-
-  test("flags a missing required string input", () => {
-    const errors = validateInputsAgainstSchema(
-      { focus: "standard" },
-      schema,
-    );
-    expect(errors.length).toBe(1);
-    expect(errors[0]).toContain("--research_doc");
-  });
-
-  test("rejects required strings that are whitespace only", () => {
-    const errors = validateInputsAgainstSchema(
-      { research_doc: "   ", focus: "standard" },
-      schema,
-    );
-    expect(errors[0]).toContain("--research_doc");
-  });
-
-  test("rejects enum values that are not in the allowed list", () => {
-    const errors = validateInputsAgainstSchema(
-      { research_doc: "notes.md", focus: "bogus" },
-      schema,
-    );
-    expect(errors.length).toBe(1);
-    expect(errors[0]).toContain("bogus");
-    expect(errors[0]).toContain("minimal");
-  });
-
-  test("flags unknown inputs", () => {
-    const errors = validateInputsAgainstSchema(
-      {
-        research_doc: "notes.md",
-        focus: "standard",
-        bogus: "hello",
-      },
-      schema,
-    );
-    expect(errors.length).toBe(1);
-    expect(errors[0]).toContain("--bogus");
-  });
-
-  test("flags a required enum that resolves to empty when no values are declared", () => {
-    // Pathological but reachable: a declared enum with an empty
-    // `values` array and no default falls through to value==="" in the
-    // resolver, which should trip the enum-specific required-input
-    // error branch rather than the generic string-required branch.
-    const brokenSchema: WorkflowInput[] = [
-      { name: "mode", type: "enum", required: true, values: [] },
-    ];
-    const errors = validateInputsAgainstSchema({}, brokenSchema);
-    expect(errors.length).toBe(1);
-    expect(errors[0]).toContain("--mode");
-    expect(errors[0]).toContain("expected one of:");
-  });
-});
-
-// ─── renderWorkflowList ────────────────────────────────────────────────────
-
-function wf(
-  name: string,
-  agent: DiscoveredWorkflow["agent"],
-  source: DiscoveredWorkflow["source"],
-  status: WorkflowWithMetadata["status"] = { kind: "ok" },
-): WorkflowWithMetadata {
-  return {
-    name,
-    agent,
-    source,
-    path: `/tmp/fake/${source}/${name}/${agent}/index.ts`,
-    description: "",
-    inputs: [],
-    status,
-  };
-}
-
-describe("renderWorkflowList", () => {
-  test("renders an empty-state stanza when no workflows are available", () => {
-    const out = renderWorkflowList([]);
-    expect(out).toContain("no workflows found");
-    // Teaches the user where to drop a new workflow.
-    expect(out).toContain(".atomic/workflows/<name>/<agent>/index.ts");
-  });
-
-  test("uses singular 'workflow' for a count of exactly one", () => {
-    const out = renderWorkflowList([wf("only", "claude", "local")]);
-    // Must say "1 workflow", never "1 workflows".
-    expect(out).toMatch(/\b1 workflow\b/);
-    expect(out).not.toMatch(/\b1 workflows\b/);
-    expect(out).toContain("only");
-  });
-
-  test("groups entries by source → provider and sorts names", () => {
-    const workflows: WorkflowWithMetadata[] = [
-      wf("zebra", "claude", "local"),
-      wf("apple", "claude", "local"),
-      wf("middle", "opencode", "local"),
-      wf("personal", "claude", "global"),
-      wf("shipped", "copilot", "builtin"),
-    ];
-    const out = renderWorkflowList(workflows);
-
-    // Count uses plural noun.
-    expect(out).toMatch(/\b5 workflows\b/);
-
-    // Section headings appear with friendly directory hints.
-    expect(out).toContain("local");
-    expect(out).toContain(".atomic/workflows");
-    expect(out).toContain("global");
-    expect(out).toContain("~/.atomic/workflows");
-    expect(out).toContain("builtin");
-    expect(out).toContain("built-in");
-
-    // Provider sub-headings are present with branded names.
-    expect(out).toContain("Claude");
-    expect(out).toContain("OpenCode");
-    expect(out).toContain("Copilot CLI");
-
-    // Run-hint footer is appended.
-    expect(out).toContain("run: atomic workflow -n <name> -a <agent>");
-
-    // Local/Claude names are sorted alphabetically: apple before zebra.
-    const appleIdx = out.indexOf("apple");
-    const zebraIdx = out.indexOf("zebra");
-    expect(appleIdx).toBeGreaterThanOrEqual(0);
-    expect(zebraIdx).toBeGreaterThan(appleIdx);
-
-    // Source ordering: local before global before builtin.
-    const localIdx = out.indexOf("local");
-    const globalIdx = out.indexOf("global");
-    const builtinIdx = out.indexOf("builtin");
-    expect(localIdx).toBeLessThan(globalIdx);
-    expect(globalIdx).toBeLessThan(builtinIdx);
-  });
-
-  test("omits provider sub-groups that have no entries for a given source", () => {
-    // Only a copilot workflow exists, so the local stanza should render a
-    // single "Copilot CLI" sub-heading — never "Claude" or "OpenCode".
-    const out = renderWorkflowList([wf("alone", "copilot", "local")]);
-    expect(out).toContain("Copilot CLI");
-    expect(out).not.toContain("Claude");
-    expect(out).not.toContain("OpenCode");
-    expect(out).toContain("alone");
-  });
-});
-
-// ─── resolveInputs ─────────────────────────────────────────────────────────
-
-describe("resolveInputs", () => {
-  test("fills in declared defaults", () => {
-    const out = resolveInputs({ research_doc: "notes.md" }, schema);
-    expect(out.research_doc).toBe("notes.md");
-    expect(out.focus).toBe("standard");
-    // `notes` has no default — should be absent, not empty-string.
-    expect(out.notes).toBeUndefined();
-  });
-
-  test("prefers provided values over defaults", () => {
-    const out = resolveInputs(
-      { research_doc: "notes.md", focus: "exhaustive" },
-      schema,
-    );
-    expect(out.focus).toBe("exhaustive");
-  });
-
-  test("falls back to the first enum value when no default and no input", () => {
-    const enumOnly: WorkflowInput[] = [
-      {
-        name: "mode",
-        type: "enum",
-        required: true,
-        values: ["a", "b", "c"],
-      },
-    ];
-    expect(resolveInputs({}, enumOnly)).toEqual({ mode: "a" });
-  });
-
-  test("ignores unknown provided keys", () => {
-    const out = resolveInputs(
-      { research_doc: "notes.md", bogus: "hello" },
-      schema,
-    );
-    expect(out.bogus).toBeUndefined();
-  });
-});

package/src/sdk/runtime/discovery.ts

@@ -1,368 +0,0 @@
-/**
- * Workflow discovery — finds workflow definitions from disk.
- *
- * Workflows are discovered from:
- *   1. src/sdk/workflows/builtin/<name>/<agent>/index.ts (SDK-shipped builtins)
- *   2. .atomic/workflows/<name>/<agent>/index.ts (project-local)
- *   3. ~/.atomic/workflows/<name>/<agent>/index.ts (global)
- *
- * All three sources use the same scanning function (`discoverFromBaseDir`)
- * so registration is uniform. Builtin names are reserved — project-local
- * and global workflows with the same name are dropped during merge.
- */
-
-import { join } from "node:path";
-import { readdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import ignore from "ignore";
-import type { AgentType, WorkflowInput } from "../types.ts";
-import { WorkflowLoader } from "./loader.ts";
-import { IncompatibleSDKError } from "../errors.ts";
-
-export interface DiscoveredWorkflow {
-  name: string;
-  agent: AgentType;
-  path: string;
-  source: "local" | "global" | "builtin";
-}
-
-function getLocalWorkflowsDir(projectRoot: string): string {
-  return join(projectRoot, ".atomic", "workflows");
-}
-
-function getGlobalWorkflowsDir(): string {
-  return join(homedir(), ".atomic", "workflows");
-}
-
-export const AGENTS: AgentType[] = ["copilot", "opencode", "claude"];
-const AGENT_SET = new Set<string>(AGENTS);
-
-/**
- * Default `.gitignore` content for a workflows directory.
- * Auto-generated during install; regenerated by discovery if missing.
- */
-export const WORKFLOWS_GITIGNORE = [
-  "node_modules/",
-  "dist/",
-  "build/",
-  "coverage/",
-  ".cache/",
-  "*.log",
-  "*.tsbuildinfo",
-  "",
-].join("\n");
-
-/**
- * Load the `.gitignore` from a workflows directory, regenerating it if absent.
- * The workflows `.gitignore` is always auto-generated so a missing file
- * indicates an incomplete setup rather than an intentional absence.
- */
-async function loadWorkflowsGitignore(workflowsDir: string): Promise<ignore.Ignore> {
-  const gitignorePath = join(workflowsDir, ".gitignore");
-  let content: string;
-  try {
-    content = await Bun.file(gitignorePath).text();
-  } catch {
-    // Missing — regenerate from the canonical template
-    await Bun.write(gitignorePath, WORKFLOWS_GITIGNORE);
-    content = WORKFLOWS_GITIGNORE;
-  }
-  return ignore().add(content);
-}
-
-/**
- * Discover workflows from a base directory by scanning workflow-name
- * directories first, then agent subdirectories within each.
- *
- * Layout: baseDir/<workflow_name>/<agent>/index.ts
- *
- * Entries are filtered against the `.gitignore` that lives inside the
- * workflows directory itself (auto-generated, regenerated if missing).
- */
-async function discoverFromBaseDir(
-  baseDir: string,
-  source: "local" | "global" | "builtin",
-  agentFilter?: AgentType,
-): Promise<DiscoveredWorkflow[]> {
-  const workflows: DiscoveredWorkflow[] = [];
-  const agents = agentFilter ? [agentFilter] : AGENTS;
-  const agentNames = new Set<string>(agents);
-
-  let workflowEntries;
-  try {
-    workflowEntries = await readdir(baseDir, { withFileTypes: true });
-  } catch {
-    return workflows;
-  }
-
-  // Builtin workflows live inside the SDK source tree — skip .gitignore
-  // handling to avoid writing files into node_modules or the SDK dir.
-  const ig = source === "builtin"
-    ? ignore()
-    : await loadWorkflowsGitignore(baseDir);
-
-  for (const wfEntry of workflowEntries) {
-    if (!wfEntry.isDirectory()) continue;
-    if (wfEntry.name.startsWith(".")) continue;
-    // Skip agent-named directories at root (they are not workflow names)
-    if (AGENT_SET.has(wfEntry.name)) continue;
-    // Skip directories matched by the workflows .gitignore.
-    // Append "/" so directory-only patterns (e.g. "build/") match correctly.
-    if (ig.ignores(wfEntry.name + "/")) continue;
-
-    const workflowDir = join(baseDir, wfEntry.name);
-
-    let agentEntries;
-    try {
-      agentEntries = await readdir(workflowDir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-
-    for (const agentEntry of agentEntries) {
-      if (!agentEntry.isDirectory()) continue;
-      if (!agentNames.has(agentEntry.name)) continue;
-
-      const indexPath = join(workflowDir, agentEntry.name, "index.ts");
-      const file = Bun.file(indexPath);
-      if (await file.exists()) {
-        workflows.push({
-          name: wfEntry.name,
-          agent: agentEntry.name as AgentType,
-          path: indexPath,
-          source,
-        });
-      }
-    }
-  }
-
-  return workflows;
-}
-
-/**
- * Absolute path to the `builtin/` directory inside the SDK source tree.
- * Computed from this file's URL so it always resolves correctly regardless
- * of how the package was installed (dev checkout, global, bunx, etc.).
- */
-const BUILTIN_WORKFLOWS_DIR = join(
-  Bun.fileURLToPath(new URL("../workflows/builtin", import.meta.url)),
-);
-
-/**
- * Discover all available workflows from built-in, global, and local sources.
- * Optionally filter by agent.
- *
- * **Merge precedence:** `builtin > local > global`.
- *
- * Builtin names are **strictly reserved** — a user-defined local or
- * global workflow whose name matches any built-in workflow is dropped
- * entirely from discovery. It will not be registered, returned from
- * `findWorkflow`, appear in the interactive picker, or show up in
- * `atomic workflow -l`. This protects SDK-shipped workflows (e.g.
- * `ralph`) from being silently overridden or even visibly "competing
- * with" a user's own definition, which would otherwise be confusing
- * when someone tries to run the canonical version.
- *
- * Reservation is by **name only**, across all agents: if a builtin
- * defines `ralph` for any agent, a local `ralph` for any other agent is
- * also dropped. Local still overrides global for every non-builtin
- * name, so project-scoped customisation of user-scoped workflows
- * continues to work.
- *
- * By default, the result is **merged by precedence** — if a workflow is
- * defined in both local and global sources, only the higher-precedence
- * entry is returned. This is the right shape for `findWorkflow`, which
- * needs the single resolved entry per (name, agent) pair.
- *
- * Pass `{ merge: false }` to get the **unmerged** result — local and
- * global contribute their entries independently, so `--list` can show
- * both a local and a global copy of the same workflow when they coexist
- * on disk. (Builtin reservation still applies in both modes.)
- */
-export async function discoverWorkflows(
-  projectRoot: string = process.cwd(),
-  agentFilter?: AgentType,
-  options: { merge?: boolean } = {},
-): Promise<DiscoveredWorkflow[]> {
-  const { merge = true } = options;
-
-  const localDir = getLocalWorkflowsDir(projectRoot);
-  const globalDir = getGlobalWorkflowsDir();
-
-  // Collect ALL builtin names (ignoring agentFilter) so reservation is
-  // name-based across every agent: a local `ralph` for copilot is still
-  // reserved by a builtin `ralph` for claude, even when the discovery
-  // call was filtered to copilot.
-  const [allBuiltins, globalResults, localResults] = await Promise.all([
-    discoverFromBaseDir(BUILTIN_WORKFLOWS_DIR, "builtin"),
-    discoverFromBaseDir(globalDir, "global", agentFilter),
-    discoverFromBaseDir(localDir, "local", agentFilter),
-  ]);
-  const reservedNames = new Set<string>(allBuiltins.map((w) => w.name));
-  const builtinResults = agentFilter
-    ? allBuiltins.filter((w) => w.agent === agentFilter)
-    : allBuiltins;
-
-  // Drop any local/global workflow whose name matches a reserved
-  // builtin. This happens BEFORE both merge and unmerged code paths so
-  // reserved names never leak into `findWorkflow`, the picker, or
-  // `--list` — there is exactly one canonical entry per reserved name,
-  // the SDK-shipped one.
-  const filteredGlobal = globalResults.filter((w) => !reservedNames.has(w.name));
-  const filteredLocal = localResults.filter((w) => !reservedNames.has(w.name));
-
-  if (!merge) {
-    // Unmerged: keep local and global independent so `--list` can show
-    // both copies of a non-reserved name when they coexist. Order lowest
-    // → highest precedence so callers that want the winning entry can
-    // take the last one by (agent, name).
-    return [...filteredGlobal, ...filteredLocal, ...builtinResults];
-  }
-
-  // Merge with precedence: global (lowest) → local → builtin (highest).
-  // Builtin is layered last as a belt-and-braces guarantee — though
-  // reserved-name filtering above already makes this overwrite
-  // impossible in practice.
-  const byKey = new Map<string, DiscoveredWorkflow>();
-  for (const wf of filteredGlobal) {
-    byKey.set(`${wf.agent}/${wf.name}`, wf);
-  }
-  for (const wf of filteredLocal) {
-    byKey.set(`${wf.agent}/${wf.name}`, wf);
-  }
-  for (const wf of builtinResults) {
-    byKey.set(`${wf.agent}/${wf.name}`, wf);
-  }
-
-  return Array.from(byKey.values());
-}
-
-/**
- * Find a specific workflow by name and agent.
- */
-export async function findWorkflow(
-  name: string,
-  agent: AgentType,
-  projectRoot: string = process.cwd()
-): Promise<DiscoveredWorkflow | null> {
-  const all = await discoverWorkflows(projectRoot, agent);
-  return all.find((w) => w.name === name) ?? null;
-}
-
-/**
- * Load status for a {@link WorkflowWithMetadata} entry.
- *
- * - `ok`            — the workflow compiled cleanly and is ready to run.
- * - `incompatible`  — the workflow declared a `minSDKVersion` newer
- *                     than the bundled CLI. The CLI renders it with an
- *                     "update required" badge so users see the mismatch
- *                     rather than a silent disappearance.
- * - `error`         — any other load failure (syntax error, missing
- *                     `.compile()`, invalid default export, etc.).
- *                     Rendered with a "failed to load" badge plus the
- *                     underlying message.
- */
-export type WorkflowMetadataStatus =
-  | { kind: "ok" }
-  | {
-      kind: "incompatible";
-      requiredVersion: string;
-      currentVersion: string;
-      message: string;
-    }
-  | {
-      kind: "error";
-      stage: "resolve" | "validate" | "load";
-      message: string;
-    };
-
-/**
- * A discovered workflow enriched with the metadata the picker needs to
- * render it: the human description, the declared input schema, and the
- * load status.
- *
- * Populated by {@link loadWorkflowsMetadata}, which runs each discovered
- * workflow through {@link WorkflowLoader.loadWorkflow} and extracts the
- * display-relevant fields — the full compiled definition is discarded
- * after extraction so re-imports during execution are cheap.
- *
- * Broken entries still materialise with empty `description` / `inputs`
- * and a non-`ok` {@link status}, so the picker can render them as
- * visible "update required" / "failed to load" rows instead of
- * silently omitting them (the previous behaviour, which made user and
- * global workflows vanish whenever the base SDK shape drifted between
- * releases).
- */
-export interface WorkflowWithMetadata extends DiscoveredWorkflow {
-  /** Workflow description, empty string when none was declared or the workflow failed to load. */
-  description: string;
-  /** Picker-ready input schema; empty for free-form or failed-to-load workflows. */
-  inputs: readonly WorkflowInput[];
-  /** Load outcome — non-`ok` entries are rendered as visible diagnostics in the picker/list. */
-  status: WorkflowMetadataStatus;
-}
-
-/**
- * Load metadata (description + picker-ready inputs + status) for a batch
- * of discovered workflows.
- *
- * **Failed workflows are kept in the returned list**, not dropped. Each
- * broken entry carries a {@link WorkflowMetadataStatus} explaining the
- * failure so the picker and `atomic workflow -l` can surface it as an
- * actionable diagnostic. This is the only way end users discover that a
- * workflow from an older SDK release has gone incompatible after an
- * `atomic` upgrade — silent filtering would leave them with a missing
- * entry and no breadcrumb.
- *
- * Callers that want to execute a workflow should still route through
- * {@link WorkflowLoader.loadWorkflow} — this function throws away the
- * compiled definition so re-running the loader on a confirmed pick is
- * unavoidable.
- */
-export async function loadWorkflowsMetadata(
-  discovered: DiscoveredWorkflow[],
-): Promise<WorkflowWithMetadata[]> {
-  return Promise.all(
-    discovered.map(async (wf): Promise<WorkflowWithMetadata> => {
-      const loaded = await WorkflowLoader.loadWorkflow(wf);
-      if (loaded.ok) {
-        return {
-          ...wf,
-          description: loaded.value.definition.description,
-          inputs: loaded.value.definition.inputs,
-          status: { kind: "ok" },
-        };
-      }
-
-      // Incompatible SDK version is a first-class status so the UI can
-      // show a dedicated "update required" hint. Every other failure
-      // maps to a generic `error` variant — the picker renders the
-      // message but doesn't try to interpret it further.
-      if (loaded.error instanceof IncompatibleSDKError) {
-        return {
-          ...wf,
-          description: "",
-          inputs: [],
-          status: {
-            kind: "incompatible",
-            requiredVersion: loaded.error.requiredVersion,
-            currentVersion: loaded.error.currentVersion,
-            message: loaded.message,
-          },
-        };
-      }
-
-      return {
-        ...wf,
-        description: "",
-        inputs: [],
-        status: {
-          kind: "error",
-          stage: loaded.stage,
-          message: loaded.message,
-        },
-      };
-    }),
-  );
-}
-