@leonarto/spec-embryo 0.1.0

package/src/backends/subprocess.ts

@@ -0,0 +1,198 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { writeUtf8 } from "../storage.ts";
+import type { BackendName, ExecutionBackendConfig, ResumeContext } from "../domain.ts";
+import type { BackendRunOptions, BackendRunResult, ResumeBackend } from "./base.ts";
+import { buildPromptBundle, renderPromptBundleText } from "./prompt.ts";
+
+function replaceToken(token: string, replacements: Record<string, string>): string {
+  let output = token;
+  for (const [key, value] of Object.entries(replacements)) {
+    output = output.replaceAll(`{${key}}`, value);
+  }
+  return output;
+}
+
+export interface SubprocessLaunchPlan {
+  backend: BackendName;
+  mode: "disabled" | "preview" | "spawned";
+  command: string | null;
+  args: string[];
+  promptBundle: ReturnType<typeof buildPromptBundle>;
+  promptText: string;
+  promptBundleText: string;
+  artifactPaths: {
+    promptTextFile: string;
+    promptBundleFile: string;
+  };
+  env: Record<string, string>;
+}
+
+function buildArtifactPaths(rootDir: string, backend: BackendName): SubprocessLaunchPlan["artifactPaths"] {
+  return {
+    promptTextFile: join(rootDir, ".specpm", "tmp", `${backend}-resume-prompt.txt`),
+    promptBundleFile: join(rootDir, ".specpm", "tmp", `${backend}-resume-prompt.json`),
+  };
+}
+
+export function buildSubprocessLaunchPlan(
+  backend: BackendName,
+  backendConfig: ExecutionBackendConfig,
+  context: ResumeContext,
+  options: BackendRunOptions,
+): SubprocessLaunchPlan {
+  const promptBundle = buildPromptBundle(context);
+  const promptBundleText = JSON.stringify(promptBundle, null, 2);
+  const promptText = renderPromptBundleText(promptBundle);
+  const artifactPaths = buildArtifactPaths(options.rootDir, backend);
+
+  const replacements = {
+    prompt: promptText,
+    prompt_text: promptText,
+    prompt_bundle: promptBundleText,
+    prompt_file: artifactPaths.promptTextFile,
+    prompt_text_file: artifactPaths.promptTextFile,
+    prompt_bundle_file: artifactPaths.promptBundleFile,
+    bundle_file: artifactPaths.promptBundleFile,
+  };
+
+  const command = backendConfig.command ?? null;
+  const args = (backendConfig.args ?? []).map((arg) => replaceToken(arg, replacements));
+  const env = {
+    SPM_BACKEND_NAME: backend,
+    SPM_PROJECT_ROOT: options.rootDir,
+    SPM_PROMPT_FILE: artifactPaths.promptTextFile,
+    SPM_PROMPT_TEXT_FILE: artifactPaths.promptTextFile,
+    SPM_PROMPT_BUNDLE_FILE: artifactPaths.promptBundleFile,
+  };
+
+  return {
+    backend,
+    mode: !backendConfig.enabled || !command ? "disabled" : options.spawn ? "spawned" : "preview",
+    command,
+    args,
+    promptBundle,
+    promptText,
+    promptBundleText,
+    artifactPaths,
+    env,
+  };
+}
+
+function renderPreviewText(plan: SubprocessLaunchPlan): string {
+  const commandLine = plan.command ? [plan.command, ...plan.args].join(" ") : "(not configured)";
+
+  return [
+    `${plan.backend} backend is configured but not spawned.`,
+    "Re-run with --spawn to invoke the subprocess adapter.",
+    "",
+    "Command preview:",
+    commandLine,
+    "",
+    "Prompt contract:",
+    `- prompt text file: ${plan.artifactPaths.promptTextFile}`,
+    `- prompt bundle file: ${plan.artifactPaths.promptBundleFile}`,
+    "- token replacements: {prompt}, {prompt_text}, {prompt_bundle}, {prompt_file}, {prompt_text_file}, {prompt_bundle_file}, {bundle_file}",
+    "- env vars: SPM_BACKEND_NAME, SPM_PROJECT_ROOT, SPM_PROMPT_FILE, SPM_PROMPT_TEXT_FILE, SPM_PROMPT_BUNDLE_FILE",
+    "",
+    "Prompt preview:",
+    plan.promptText,
+  ].join("\n");
+}
+
+export abstract class SubprocessBackend implements ResumeBackend {
+  abstract name: BackendName;
+
+  constructor(private readonly backendConfig: ExecutionBackendConfig) {}
+
+  protected get config(): ExecutionBackendConfig {
+    return this.backendConfig;
+  }
+
+  async run(context: ResumeContext, options: BackendRunOptions): Promise<BackendRunResult> {
+    const plan = buildSubprocessLaunchPlan(this.name, this.config, context, options);
+
+    if (plan.mode === "disabled" || !plan.command) {
+      const payload = {
+        backend: this.name,
+        mode: "disabled" as const,
+        reason: "Backend is disabled or missing a command.",
+        prompt_bundle: plan.promptBundle,
+      };
+      return {
+        text: options.json
+          ? JSON.stringify(payload, null, 2)
+          : `${this.name} backend is disabled. Enable it in .specpm/config.toml or use --backend prompt.`,
+        json: payload,
+      };
+    }
+
+    if (plan.mode === "preview") {
+      const payload = {
+        backend: this.name,
+        mode: "preview" as const,
+        command: plan.command,
+        args: plan.args,
+        env: plan.env,
+        artifact_paths: plan.artifactPaths,
+        prompt_bundle: plan.promptBundle,
+        prompt_text: plan.promptText,
+      };
+
+      return {
+        text: options.json ? JSON.stringify(payload, null, 2) : renderPreviewText(plan),
+        json: payload,
+      };
+    }
+
+    await writeUtf8(plan.artifactPaths.promptBundleFile, plan.promptBundleText);
+    await writeUtf8(plan.artifactPaths.promptTextFile, plan.promptText);
+
+    const child = spawn(plan.command, plan.args, {
+      cwd: options.rootDir,
+      env: {
+        ...process.env,
+        ...plan.env,
+      },
+      stdio: "inherit",
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      child.on("exit", (code) => {
+        if (code === 0) {
+          resolve();
+          return;
+        }
+        reject(new Error(`${this.name} backend exited with code ${code ?? -1}`));
+      });
+      child.on("error", reject);
+    });
+
+    return {
+      text: options.json
+        ? JSON.stringify(
+            {
+              backend: this.name,
+              mode: "spawned",
+              command: plan.command,
+              args: plan.args,
+              env: plan.env,
+              artifact_paths: plan.artifactPaths,
+              prompt_bundle: plan.promptBundle,
+            },
+            null,
+            2,
+          )
+        : `${this.name} backend finished successfully.`,
+      json: {
+        backend: this.name,
+        mode: "spawned" as const,
+        command: plan.command,
+        args: plan.args,
+        env: plan.env,
+        artifact_paths: plan.artifactPaths,
+        prompt_bundle: plan.promptBundle,
+      },
+    };
+  }
+}

package/src/cli.ts

@@ -0,0 +1,111 @@
+import { relative } from "node:path";
+import type { BackendName } from "./domain.ts";
+
+export interface ParsedArgs {
+  command: string | undefined;
+  subcommand: string | undefined;
+  positionals: string[];
+  flags: Map<string, string | boolean>;
+}
+
+export function parseArgs(argv: string[]): ParsedArgs {
+  const flags = new Map<string, string | boolean>();
+  const positionals: string[] = [];
+  let index = 0;
+
+  while (index < argv.length) {
+    const arg = argv[index]!;
+
+    if (arg.startsWith("--")) {
+      const [rawKey, inlineValue] = arg.slice(2).split("=", 2);
+      if (inlineValue !== undefined) {
+        flags.set(rawKey, inlineValue);
+        index += 1;
+        continue;
+      }
+
+      const next = argv[index + 1];
+      if (next && !next.startsWith("--")) {
+        flags.set(rawKey, next);
+        index += 2;
+        continue;
+      }
+
+      flags.set(rawKey, true);
+      index += 1;
+      continue;
+    }
+
+    positionals.push(arg);
+    index += 1;
+  }
+
+  return {
+    command: positionals[0],
+    subcommand: positionals[1],
+    positionals,
+    flags,
+  };
+}
+
+export function flagValue(parsed: ParsedArgs, name: string): string | undefined {
+  const value = parsed.flags.get(name);
+  return typeof value === "string" ? value : undefined;
+}
+
+export function hasFlag(parsed: ParsedArgs, name: string): boolean {
+  return parsed.flags.has(name);
+}
+
+export function backendFlag(parsed: ParsedArgs, fallback: BackendName): BackendName {
+  const value = flagValue(parsed, "backend");
+  if (value === "prompt" || value === "deterministic" || value === "codex" || value === "claude") {
+    return value;
+  }
+
+  return fallback;
+}
+
+export function formatPath(rootDir: string, absolutePath: string): string {
+  const rel = relative(rootDir, absolutePath);
+  return rel.length > 0 ? rel : ".";
+}
+
+export function helpText(): string {
+  return `spec-embryo
+
+Usage:
+  spec-embryo init [--force] [--home docs] [--standalone] [--json]
+  spm init [--force] [--home docs] [--standalone] [--json]
+  spm reshape [--home docs] [--dry-run]
+  spm doctor [--json]
+  spm status [--json]
+  spm current show [--json]
+  spm current set [--focus "..."] [--summary "..."] [--active-spec-ids SPEC-001,SPEC-002] [--active-task-ids TASK-006,TASK-013] [--blocked-task-ids TASK-003] [--next-action-hints "hint one || hint two"] [--clear-active-spec-ids] [--clear-active-task-ids] [--clear-blocked-task-ids] [--clear-next-action-hints] [--json]
+  spm ui [--host 127.0.0.1] [--port 4173]
+  spm resume [--backend deterministic|prompt|codex|claude] [--json] [--spawn]
+  spm handoff [--title "Checkpoint"] [--note "extra note"]
+  spm agents check [--json]
+  spm spec list [--status active]
+  spm spec create --title "..." --summary "..." [--status proposed] [--task-ids TASK-001,TASK-002] [--tags foundation,cli] [--owner human-ai] [--json]
+  spm spec set-status <SPEC-ID> <proposed|active|paused|done|archived> [--json]
+  spm spec import-prompt --source docs/specs [--instructions "..."] [--max-chars-per-file 1800] [--json]
+  spm task list [--status todo] [--spec SPEC-001]
+  spm task create --title "..." --summary "..." --spec-ids SPEC-001[,SPEC-002] [--status todo|in_progress|blocked|review|done|cancelled] [--priority 2] [--depends-on TASK-001] [--blocked-by TASK-002] [--owner-role builder] [--tags cli,self-hosting] [--json]
+  spm task set-status <TASK-ID> <todo|in_progress|blocked|review|done|cancelled> [--json]
+  spm task archive <TASK-ID> [--reason "..."] [--json]
+  spm task archive-done --older-than 7d [--reason "..."] [--json]
+  spm task archive-cancelled --older-than 7d [--reason "..."] [--json]
+  spm task restore <TASK-ID> [--json]
+
+Aliases:
+  - \`spm\` is the primary short command
+  - \`spec-embryo\` is the long-form name
+
+Core ideas:
+  - local-first and file-backed
+  - deterministic-first parsing and status derivation
+  - prompt-return mode for already-running agents
+  - subprocess agent backends as optional adapters
+`;
+}

package/src/commands/agents.ts

@@ -0,0 +1,16 @@
+import type { ParsedArgs } from "../cli.ts";
+import { buildAgentsHealthReport, renderAgentsHealthReport } from "../services/agents.ts";
+
+export async function runAgentsCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  if (parsed.subcommand !== "check") {
+    throw new Error("Only `agents check` is supported in v1.");
+  }
+
+  const report = await buildAgentsHealthReport(rootDir);
+
+  if (parsed.flags.has("json")) {
+    return JSON.stringify(report, null, 2);
+  }
+
+  return renderAgentsHealthReport(report);
+}

package/src/commands/current.ts

@@ -0,0 +1,95 @@
+import type { ParsedArgs } from "../cli.ts";
+import { flagValue } from "../cli.ts";
+import { loadProjectContext, updateCurrentState } from "../repository.ts";
+
+function parseCommaList(value: string | undefined): string[] | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  return value
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function parseHints(value: string | undefined): string[] | undefined {
+  if (!value) {
+    return undefined;
+  }
+
+  return value
+    .split("||")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export async function runCurrentCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  if (!parsed.subcommand || parsed.subcommand === "show") {
+    const context = await loadProjectContext(rootDir);
+
+    if (parsed.flags.has("json")) {
+      return JSON.stringify(context.currentState, null, 2);
+    }
+
+    const lines = [
+      `Current state: ${context.currentState.title}`,
+      `Summary: ${context.currentState.summary}`,
+      `Focus: ${context.currentState.focus}`,
+      "",
+      `Active specs: ${context.currentState.activeSpecIds.join(", ") || "none"}`,
+      `Active tasks: ${context.currentState.activeTaskIds.join(", ") || "none"}`,
+      `Blocked tasks: ${context.currentState.blockedTaskIds.join(", ") || "none"}`,
+      "",
+      "Next action hints:",
+      ...(context.currentState.nextActionHints.length > 0
+        ? context.currentState.nextActionHints.map((hint) => `- ${hint}`)
+        : ["- none"]),
+    ];
+
+    if (context.currentState.lastHandoffId) {
+      lines.push("", `Last handoff: ${context.currentState.lastHandoffId}`);
+    }
+
+    return lines.join("\n");
+  }
+
+  if (parsed.subcommand !== "set") {
+    throw new Error("Supported current commands in v1 are `current show` and `current set`.");
+  }
+
+  const hasMutation =
+    flagValue(parsed, "focus") !== undefined ||
+    flagValue(parsed, "summary") !== undefined ||
+    flagValue(parsed, "active-spec-ids") !== undefined ||
+    flagValue(parsed, "active-task-ids") !== undefined ||
+    flagValue(parsed, "blocked-task-ids") !== undefined ||
+    flagValue(parsed, "next-action-hints") !== undefined ||
+    parsed.flags.has("clear-active-spec-ids") ||
+    parsed.flags.has("clear-active-task-ids") ||
+    parsed.flags.has("clear-blocked-task-ids") ||
+    parsed.flags.has("clear-next-action-hints");
+
+  if (!hasMutation) {
+    throw new Error("`current set` requires at least one field flag or clear flag.");
+  }
+
+  const updated = await updateCurrentState(rootDir, {
+    focus: flagValue(parsed, "focus"),
+    summary: flagValue(parsed, "summary"),
+    activeSpecIds: parseCommaList(flagValue(parsed, "active-spec-ids")),
+    activeTaskIds: parseCommaList(flagValue(parsed, "active-task-ids")),
+    blockedTaskIds: parseCommaList(flagValue(parsed, "blocked-task-ids")),
+    nextActionHints: parseHints(flagValue(parsed, "next-action-hints")),
+    clearActiveSpecIds: parsed.flags.has("clear-active-spec-ids"),
+    clearActiveTaskIds: parsed.flags.has("clear-active-task-ids"),
+    clearBlockedTaskIds: parsed.flags.has("clear-blocked-task-ids"),
+    clearNextActionHints: parsed.flags.has("clear-next-action-hints"),
+  });
+
+  if (parsed.flags.has("json")) {
+    return JSON.stringify(updated, null, 2);
+  }
+
+  return `Updated current state in ${updated.filePath}`;
+}

package/src/commands/doctor.ts

@@ -0,0 +1,12 @@
+import type { ParsedArgs } from "../cli.ts";
+import { buildDoctorReport, renderDoctorReport } from "../services/doctor.ts";
+
+export async function runDoctorCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  const report = await buildDoctorReport(rootDir);
+
+  if (parsed.flags.has("json")) {
+    return JSON.stringify(report, null, 2);
+  }
+
+  return renderDoctorReport(report);
+}

package/src/commands/handoff.ts

@@ -0,0 +1,64 @@
+import type { ParsedArgs } from "../cli.ts";
+import { flagValue } from "../cli.ts";
+import { buildResumeContext } from "../engine.ts";
+import { loadProjectContext, writeHandoff } from "../repository.ts";
+
+function compactTitle(title: string): string {
+  return title.trim().length > 0 ? title.trim() : "Checkpoint";
+}
+
+export async function runHandoffCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  const context = await loadProjectContext(rootDir);
+  const resumeContext = buildResumeContext(context);
+  const createdAt = new Date().toISOString();
+  const title = compactTitle(flagValue(parsed, "title") ?? `Checkpoint ${createdAt.slice(0, 10)}`);
+  const note = flagValue(parsed, "note");
+  const handoffId = `HANDOFF-${createdAt.replace(/[-:]/g, "").replace(/\..+/, "")}`;
+  const summary = resumeContext.nextActions[0] ?? "Checkpoint created.";
+  const bodySections = [
+    "# Summary",
+    "",
+    resumeContext.summary,
+    "",
+    "## Focus",
+    "",
+    resumeContext.focus,
+    "",
+    "## Active Specs",
+    "",
+    ...(resumeContext.activeSpecs.length > 0 ? resumeContext.activeSpecs.map((spec) => `- ${spec.id}: ${spec.title}`) : ["- none"]),
+    "",
+    "## Active Tasks",
+    "",
+    ...(resumeContext.activeTasks.length > 0
+      ? resumeContext.activeTasks.map((entry) => `- ${entry.task.id}: ${entry.task.title}`)
+      : ["- none"]),
+    "",
+    "## Next Actions",
+    "",
+    ...resumeContext.nextActions.map((action) => `- ${action}`),
+    "",
+    "## Blockers",
+    "",
+    ...(resumeContext.blockedTasks.length > 0
+      ? resumeContext.blockedTasks.map((entry) => `- ${entry.task.id}: ${entry.unmetDependencies.join(", ") || "manually blocked"}`)
+      : ["- none"]),
+  ];
+
+  if (note) {
+    bodySections.push("", "## Additional Note", "", note);
+  }
+
+  const filePath = await writeHandoff(rootDir, context.currentState, {
+    id: handoffId,
+    title,
+    summary,
+    createdAt,
+    activeTaskIds: resumeContext.activeTasks.map((entry) => entry.task.id),
+    relatedSpecIds: resumeContext.activeSpecs.map((spec) => spec.id),
+    author: "spec-embryo",
+    body: bodySections.join("\n"),
+  });
+
+  return `Created handoff ${handoffId}\n${filePath}`;
+}

package/src/commands/init.ts

@@ -0,0 +1,101 @@
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import type { ParsedArgs } from "../cli.ts";
+import { flagValue, formatPath, hasFlag } from "../cli.ts";
+import { initializeProject, readProjectConfig } from "../repository.ts";
+import { pathExists } from "../storage.ts";
+import { buildAdoptionGuidance, renderAdoptionGuidance } from "../services/adoption.ts";
+import { inspectAdoptionState, normalizeManagedHomeInput } from "../services/layout.ts";
+
+async function promptForLayoutChoice(candidates: Array<{ relativePath: string; reason: string }>): Promise<string> {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new Error("Multiple docs/specs homes found. Re-run with --home <folder> or --standalone.");
+  }
+
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    const options = candidates.map((candidate) => `${candidate.relativePath}/spm`);
+    const promptLines = [
+      "Multiple documentation/spec surfaces were found.",
+      ...options.map((option, index) => `${index + 1}. ${option}`),
+      `${options.length + 1}. spm`,
+    ];
+    stdout.write(`${promptLines.join("\n")}\n`);
+    const answer = await rl.question("Choose the memory home number: ");
+    const numeric = Number.parseInt(answer.trim(), 10);
+
+    if (numeric >= 1 && numeric <= options.length) {
+      return options[numeric - 1]!;
+    }
+
+    if (numeric === options.length + 1) {
+      return "spm";
+    }
+
+    throw new Error("Invalid init selection.");
+  } finally {
+    rl.close();
+  }
+}
+
+export async function runInitCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  const explicitHome = flagValue(parsed, "home");
+  const configFile = join(rootDir, ".specpm", "config.toml");
+  const existingConfig = (await pathExists(configFile)) ? await readProjectConfig(rootDir) : undefined;
+  const inspection = await inspectAdoptionState(rootDir, {
+    explicitHome,
+    standalone: hasFlag(parsed, "standalone"),
+    config: existingConfig,
+  });
+
+  let memoryDir = explicitHome ? normalizeManagedHomeInput(explicitHome) : inspection.layoutChoice.memoryDir;
+  if (inspection.layoutChoice.requiresChoice) {
+    memoryDir = await promptForLayoutChoice(inspection.layoutChoice.candidates);
+  }
+
+  const result = await initializeProject(rootDir, {
+    force: hasFlag(parsed, "force"),
+    memoryDir,
+  });
+  const createdLines = result.created.map((filePath) => `created ${formatPath(rootDir, filePath)}`);
+  const skippedLines = result.skipped.map((filePath) => `kept ${formatPath(rootDir, filePath)}`);
+  const guidance = buildAdoptionGuidance({
+    adoption: inspection,
+    memoryDir: result.memoryDir,
+    created: result.created.map((filePath) => formatPath(rootDir, filePath)),
+    skipped: result.skipped.map((filePath) => formatPath(rootDir, filePath)),
+    commandContext: "init",
+  });
+
+  if (parsed.flags.has("json")) {
+    return JSON.stringify(
+      {
+        memory_dir: result.memoryDir,
+        adopted_home: inspection.layoutChoice.adoptedHome,
+        adoption_state: inspection.state,
+        inspection,
+        sequence: result.sequence,
+        created: result.created.map((filePath) => formatPath(rootDir, filePath)),
+        skipped: result.skipped.map((filePath) => formatPath(rootDir, filePath)),
+        guidance,
+      },
+      null,
+      2,
+    );
+  }
+
+  return [
+    "Initialized Spec Embryo project memory.",
+    `Adoption state: ${inspection.state}`,
+    `Memory home: ${result.memoryDir}`,
+    "",
+    "Init sequence:",
+    ...result.sequence.map((step, index) => `${index + 1}. ${step}`),
+    "",
+    ...renderAdoptionGuidance(guidance),
+    "",
+    ...createdLines,
+    ...(skippedLines.length > 0 ? ["", ...skippedLines] : []),
+  ].join("\n");
+}

package/src/commands/reshape.ts

@@ -0,0 +1,20 @@
+import type { ParsedArgs } from "../cli.ts";
+import { flagValue, hasFlag } from "../cli.ts";
+import { reshapeProject } from "../repository.ts";
+import { normalizeManagedHomeInput } from "../services/layout.ts";
+
+export async function runReshapeCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  const home = flagValue(parsed, "home");
+  const result = await reshapeProject(rootDir, {
+    memoryDir: home ? normalizeManagedHomeInput(home) : undefined,
+    dryRun: hasFlag(parsed, "dry-run"),
+  });
+
+  return [
+    `${result.applied ? "Reshaped" : "Planned reshape for"} project memory.`,
+    `Target memory home: ${result.targetMemoryDir}`,
+    "",
+    ...result.actions.map((action) => `- ${action}`),
+    ...(result.warnings.length > 0 ? ["", "Warnings:", ...result.warnings.map((warning) => `- ${warning}`)] : []),
+  ].join("\n");
+}

package/src/commands/resume.ts

@@ -0,0 +1,19 @@
+import type { ParsedArgs } from "../cli.ts";
+import { backendFlag, hasFlag } from "../cli.ts";
+import { resolveResumeBackend } from "../backends/index.ts";
+import { buildResumeContext } from "../engine.ts";
+import { loadProjectContext } from "../repository.ts";
+
+export async function runResumeCommand(rootDir: string, parsed: ParsedArgs): Promise<string> {
+  const context = await loadProjectContext(rootDir);
+  const backendName = backendFlag(parsed, context.config.defaults.resumeBackend);
+  const backend = resolveResumeBackend(backendName, context.config);
+  const result = await backend.run(buildResumeContext(context), {
+    rootDir,
+    config: context.config,
+    json: hasFlag(parsed, "json"),
+    spawn: hasFlag(parsed, "spawn"),
+  });
+
+  return result.text;
+}