dev-harness-cli 1.0.0

package/cli/commands/contract.mjs

@@ -0,0 +1,155 @@
+/**
+ * contract — Sprint Contract negotiation (propose/review/status/escalate).
+ *
+ * Manages the generator-evaluator agreement loop.
+ *
+ * Usage:
+ *   harness-dev contract propose [--scope "msg"] [--exclusions "msg"]
+ *   harness-dev contract review [--agreed|--needs-revision]
+ *   harness-dev contract status
+ *   harness-dev contract escalate [--reason "msg"]
+ */
+import { resolve } from 'node:path';
+import { die, CliError, EXIT } from '../lib/errors.mjs';
+import { proposeContract, reviewContract, getContractStatus, escalateContract } from '../lib/contract.mjs';
+
+const SUBCOMMANDS = ['propose', 'review', 'status', 'escalate'];
+
+export default async function contractCommand(args) {
+  const json = !!(args.json || args.flags?.json);
+  const rawTarget = args.flags?.target;
+  const targetDir = (typeof rawTarget === 'string') ? resolve(rawTarget) : process.cwd();
+  const sub = args.subcommand;
+
+  if (!sub || !SUBCOMMANDS.includes(sub)) {
+    die(new CliError(`Usage: harness-dev contract ${SUBCOMMANDS.join('|')}`, EXIT.USAGE_ERROR), json);
+    return;
+  }
+
+  // ── propose ──────────────────────────────────────────────────────────────
+  if (sub === 'propose') {
+    const scope = args.flags?.scope || args.positionals.join(' ');
+    const exclusions = args.flags?.exclusions || null;
+    const criteria = args.flags?.criteria ? args.flags.criteria.split('|') : null;
+
+    if (!scope) {
+      die(new CliError(
+        'Usage: harness-dev contract propose --scope "I will build X" [--exclusions "W"] [--criteria "test1|test2"]',
+        EXIT.USAGE_ERROR,
+      ), json);
+      return;
+    }
+
+    const result = proposeContract(targetDir, { scope, exclusions, criteria });
+
+    if (json) {
+      process.stdout.write(JSON.stringify({
+        command: 'contract',
+        subcommand: 'propose',
+        status: result.ok ? 'ok' : 'error',
+        message: result.ok ? 'Contract proposed. Evaluator review needed.' : result.error,
+      }) + '\n');
+      return;
+    }
+
+    if (result.ok) {
+      process.stdout.write('✓ Contract proposed. Run: harness-dev contract review\n');
+    } else {
+      process.stderr.write(`✗ ${result.error}\n`);
+    }
+    return;
+  }
+
+  // ── review ───────────────────────────────────────────────────────────────
+  if (sub === 'review') {
+    const agreed = args.flags?.agreed === true || args.flags?.agreed === 'true';
+    const needsRevision = args.flags?.['needs-revision'] === true || args.flags?.['needs-revision'] === 'true';
+    const notes = args.flags?.notes || null;
+
+    if (!agreed && !needsRevision) {
+      die(new CliError(
+        'Usage: harness-dev contract review --agreed [--notes "msg"]  OR  --needs-revision [--notes "msg"]',
+        EXIT.USAGE_ERROR,
+      ), json);
+      return;
+    }
+
+    const decision = agreed ? 'agreed' : 'needs-revision';
+    const result = reviewContract(targetDir, decision, notes);
+
+    if (json) {
+      process.stdout.write(JSON.stringify({
+        command: 'contract',
+        subcommand: 'review',
+        status: result.ok ? 'ok' : 'error',
+        message: result.ok
+          ? result.escalated
+            ? 'Max negotiation rounds reached. Contract escalated to human.'
+            : `Contract ${decision}.`
+          : result.error,
+        escalated: result.escalated,
+      }) + '\n');
+      return;
+    }
+
+    if (result.ok) {
+      const msg = result.escalated
+        ? '✓ Max negotiation rounds reached. Contract escalated to human.'
+        : `✓ Contract marked as "${decision}"`;
+      process.stdout.write(msg + '\n');
+    } else {
+      process.stderr.write(`✗ ${result.error}\n`);
+    }
+    return;
+  }
+
+  // ── status ───────────────────────────────────────────────────────────────
+  if (sub === 'status') {
+    const { status, rounds } = getContractStatus(targetDir);
+
+    if (json) {
+      process.stdout.write(JSON.stringify({
+        command: 'contract',
+        subcommand: 'status',
+        status: status ? 'ok' : 'error',
+        contractStatus: status || 'not_found',
+        rounds,
+        message: status
+          ? `Contract ${status} (round ${rounds}/5)`
+          : 'No sprint-contract.md found. Run: harness-dev contract propose',
+      }) + '\n');
+      return;
+    }
+
+    if (status) {
+      process.stdout.write(`Contract status: ${status} (round ${rounds}/5)\n`);
+    } else {
+      process.stdout.write('No sprint-contract.md found. Run: harness-dev contract propose\n');
+    }
+    return;
+  }
+
+  // ── escalate ─────────────────────────────────────────────────────────────
+  if (sub === 'escalate') {
+    const reason = args.flags?.reason || args.positionals.join(' ') || null;
+
+    const result = escalateContract(targetDir, reason);
+
+    if (json) {
+      process.stdout.write(JSON.stringify({
+        command: 'contract',
+        subcommand: 'escalate',
+        status: result.ok ? 'ok' : 'error',
+        message: result.ok ? 'Contract escalated to human.' : result.error,
+      }) + '\n');
+      return;
+    }
+
+    if (result.ok) {
+      process.stdout.write('✓ Contract escalated to human.\n');
+    } else {
+      process.stderr.write(`✗ ${result.error}\n`);
+    }
+    return;
+  }
+}

package/cli/commands/detect-tool.mjs

@@ -0,0 +1,112 @@
+/**
+ * detect-tool — Detect which agent coding tools are configured in a project.
+ *
+ * Scans the project directory for tool-specific files:
+ *   - CLAUDE.md       → claude-code
+ *   - .cursorrules    → cursor
+ *   - AGENTS.md       → generic (read by Codex, Aider, Continue, OpenCode)
+ *   - .aider.conf*    → aider
+ *   - continue.json   → continue
+ *   - hermes/ skill   → hermes
+ *
+ * Also reads harness-config.json agentTool field if present.
+ *
+ * Usage:
+ *   harness-dev detect-tool [--target <dir>] [--json]
+ */
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parseCommandArgs } from '../lib/command-helpers.mjs';
+import { emitJson, emitHuman } from '../lib/output.mjs';
+import { loadConfig } from '../lib/state.mjs';
+import { getAllDetectionSignatures, AGENTS_MD_TOOLS, TOOL_REGISTRY } from '../lib/tool-registry.mjs';
+
+export default async function detectToolCommand(args) {
+  const { json, targetDir } = parseCommandArgs(args);
+
+  const detected = [];
+  const hasAgentsMd = existsSync(resolve(targetDir, 'AGENTS.md'));
+
+  // 1. Scan for tool-specific detection files (from registry)
+  for (const { tool, file } of getAllDetectionSignatures()) {
+    if (existsSync(resolve(targetDir, file))) {
+      if (!detected.includes(tool)) {
+        detected.push(tool);
+      }
+    }
+  }
+
+  // 2. AGENTS.md present → tools that read it natively are "available"
+  if (hasAgentsMd) {
+    for (const tool of AGENTS_MD_TOOLS) {
+      if (!detected.includes(tool)) {
+        detected.push(tool);
+      }
+    }
+  }
+
+  // 3. Read config.agentTool if present
+  const { config, ok } = loadConfig(targetDir);
+  const configuredTool = ok && config.agentTool ? config.agentTool : null;
+
+  // 4. Recommend: configured tool > first detected tool-specific > 'generic'
+  let recommended = configuredTool;
+  if (!recommended && detected.length > 0) {
+    // Prefer tool-specific (has a file) over AGENTS.md-native
+    const specific = detected.find(t => {
+      const entry = TOOL_REGISTRY[t];
+      return entry && entry.file !== null;
+    });
+    recommended = specific || detected[0];
+  }
+  if (!recommended) {
+    recommended = 'generic';
+  }
+
+  // 5. Build per-tool details for richer output
+  const toolDetails = detected.map(t => {
+    const entry = TOOL_REGISTRY[t];
+    return {
+      tool: t,
+      label: entry?.label || t,
+      file: entry?.file || null,
+      notes: entry?.notes || '',
+    };
+  });
+
+  const result = {
+    command: 'detect-tool',
+    status: 'ok',
+    message: detected.length > 0
+      ? `Detected ${detected.length} agent tool(s): ${detected.join(', ')}`
+      : 'No agent tools detected. Run: harness-dev init',
+    available: detected,
+    configured: configuredTool,
+    recommended,
+    hasAgentsMd,
+    tools: toolDetails,
+  };
+
+  if (json) {
+    emitJson(result);
+    return;
+  }
+
+  emitHuman(`═══ Agent Tool Detection ═══\n\n`);
+  if (detected.length > 0) {
+    emitHuman(`Available tools:\n`);
+    for (const t of toolDetails) {
+      const marker = t.tool === recommended ? ' ← recommended' : '';
+      const source = t.tool === configuredTool ? ' (from config)' : '';
+      const fileInfo = t.file ? ` [${t.file}]` : ' [AGENTS.md]';
+      emitHuman(`  • ${t.label}${source}${marker}${fileInfo}\n`);
+    }
+  } else {
+    emitHuman(`  No agent tools detected.\n`);
+    emitHuman(`  Run: harness-dev init to scaffold a project.\n`);
+  }
+  if (hasAgentsMd) {
+    emitHuman(`\n  AGENTS.md present — tools that read it natively are available.\n`);
+  }
+  emitHuman(`\n  Recommended: ${TOOL_REGISTRY[recommended]?.label || recommended}\n`);
+}

package/cli/commands/init.mjs

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+/**
+ * init — Scaffold full harness in target directory.
+ *
+ * Creates all harness files: template-based (AGENTS.md, harness-config.json,
+ * init.sh, progress.md, sprint-contract.md) plus project files (feature_list.json,
+ * feature-list.schema.json, session-handoff.md, etc.), git init, .gitignore.
+ *
+ * Usage: harness-dev init [--stack <name>] [--target <dir>] [--agent-tool <name>] [--force] [--no-git] [--json]
+ */
+import { resolve, join } from 'node:path';
+import {
+  existsSync, writeFileSync, mkdirSync, readFileSync,
+} from 'node:fs';
+import { generateTemplates } from '../lib/templates.mjs';
+import { detectStack, getStackMeta } from '../lib/detect-stack.mjs';
+import { listStacks } from '../lib/vars.mjs';
+import { CliError, EXIT, die } from '../lib/errors.mjs';
+import { execGit } from '../lib/git.mjs';
+import {
+  getExtraFiles,
+  getConfigFileContent,
+  getVersionFileContent,
+  getGitignoreContent,
+  KNOWN_AGENT_TOOLS,
+} from '../lib/scaffold.mjs';
+import { getToolEntry } from '../lib/tool-registry.mjs';
+
+
+// ── Git helpers ──────────────────────────────────────────────────────────────
+
+/**
+ * Check if targetDir is inside a git repository.
+ */
+function isInsideGitRepo(targetDir) {
+  return execGit('git rev-parse --git-dir 2>/dev/null', targetDir).ok;
+}
+
+/**
+ * Check if git repo is empty (no commits yet).
+ */
+function isGitRepoEmpty(targetDir) {
+  const r = execGit('git rev-list -n 1 HEAD 2>/dev/null', targetDir);
+  return !r.ok || r.stdout === '';
+}
+
+/**
+ * Init git repo and create initial commit.
+ */
+function initGit(targetDir) {
+  const messages = [];
+
+  if (!isInsideGitRepo(targetDir)) {
+    execGit('git init', targetDir);
+    messages.push('Initialized empty git repo');
+  }
+
+  if (isGitRepoEmpty(targetDir)) {
+    // Stage everything and commit
+    execGit('git add -A', targetDir);
+    execGit('git commit -m "harness: initial scaffold" --allow-empty', targetDir);
+    messages.push('Created initial commit: harness: initial scaffold');
+  } else {
+    messages.push('Git repo already has commits — skipped initial commit');
+  }
+
+  return messages;
+}
+
+// ── Command handler ──────────────────────────────────────────────────────────
+
+export default async function initCommand(args) {
+  const json = !!(args.json || args.flags?.json);
+  const force = args.flags?.force === true || args.flags?.force === 'true';
+  const noGit = args.flags?.['no-git'] === true || args.flags?.['no-git'] === 'true';
+  const agentTool = args.flags?.['agent-tool'] || null;
+
+  // Validate agent-tool if specified
+  if (agentTool && !KNOWN_AGENT_TOOLS.includes(agentTool)) {
+    die(
+      new CliError(
+        `Unknown agent tool "${agentTool}". Valid: ${KNOWN_AGENT_TOOLS.join(', ')}`,
+        EXIT.USAGE_ERROR,
+      ),
+      json,
+    );
+    return;
+  }
+  // Guard: --target without value passes boolean true — fall back to cwd
+  const rawTarget = args.flags?.target;
+  const targetDir = resolve((typeof rawTarget === 'string') ? rawTarget : process.cwd());
+
+  // Resolve stack — explicit or auto-detect
+  let stack;
+  const explicitStack = args.flags?.stack;
+  const validStacks = listStacks();
+
+  if (explicitStack) {
+    if (!validStacks.includes(explicitStack)) {
+      // Allow unknown stacks — user/agent will fill stackMeta in harness-config.json
+      // during DEFINE phase (testCmd, lintCmd, buildCmd, installCmd, etc.)
+      process.stderr.write(
+        `Note: stack "${explicitStack}" is not built-in. ` +
+        `Fill stackMeta in harness-config.json during DEFINE phase ` +
+        `(testCmd, lintCmd, buildCmd, installCmd, coverageCmd).\n`
+      );
+    }
+    stack = explicitStack;
+  } else {
+    // Auto-detect
+    const detected = detectStack(targetDir);
+    if (detected.name === 'generic') {
+      die(
+        new CliError(
+          'Could not auto-detect project stack. Specify with --stack <name>. ' +
+          `Valid: ${validStacks.join(', ')}, or any custom stack name ` +
+          `(fill stackMeta during DEFINE phase).`,
+          EXIT.USAGE_ERROR,
+        ),
+        json,
+      );
+      return;
+    }
+    stack = detected.name;
+  }
+
+  // Build the full file manifest
+  const extraFiles = getExtraFiles(stack);
+
+  // Config file and version file from stacks.json metadata
+  const meta = getStackMeta(stack);
+  let configFileRel = null;
+  let versionFileRel = null;
+  if (meta && meta.configFile) {
+    configFileRel = meta.configFile; // e.g. "pyproject.toml"
+  }
+  if (meta && meta.versionFile) {
+    versionFileRel = meta.versionFile; // e.g. ".python-version"
+  }
+
+  // Collate all output paths for existence check
+  // We separate "harness files" (our scaffold — conflict = abort) from
+  // "project files" (user's own — skip silently if they exist).
+  const harnessPaths = [];
+  const projectPaths = [];
+
+  // Template files — known template names
+  const templateNames = [
+    'AGENTS.md', 'harness-config.json', 'init.sh',
+    'progress.md', 'sprint-contract.md', 'evaluator-rubric.md',
+  ];
+  for (const name of templateNames) {
+    harnessPaths.push(join(targetDir, name));
+  }
+
+  // Extra scaffold files
+  for (const relPath of Object.keys(extraFiles)) {
+    harnessPaths.push(join(targetDir, relPath));
+  }
+
+  // .gitignore
+  harnessPaths.push(join(targetDir, '.gitignore'));
+
+  // Stack config file and version file — these are the user's own project files.
+  // Skip if they exist (don't abort scaffold for them).
+  if (configFileRel) {
+    projectPaths.push({ rel: configFileRel, abs: join(targetDir, configFileRel) });
+  }
+  if (versionFileRel) {
+    projectPaths.push({ rel: versionFileRel, abs: join(targetDir, versionFileRel) });
+  }
+
+  // Check for existing harness files (unless --force)
+  if (!force) {
+    const conflicts = harnessPaths.filter(p => existsSync(p));
+    if (conflicts.length > 0) {
+      const msg = conflicts.length === 1
+        ? `File already exists: ${conflicts[0]}` +
+          '\nUse --force to overwrite existing files.'
+        : `${conflicts.length} harness file(s) already exist in ${targetDir}` +
+          `\nFirst conflict: ${conflicts[0]}` +
+          '\nUse --force to overwrite existing files.';
+      die(new CliError(msg, EXIT.VALIDATION_FAILURE), json);
+      return;
+    }
+  }
+
+  // ── Write phase ──────────────────────────────────────────────────────
+
+  // Ensure target directory exists
+  mkdirSync(targetDir, { recursive: true });
+
+  // Ensure docs/ directory exists
+  mkdirSync(join(targetDir, 'docs'), { recursive: true });
+
+  const created = [];
+  const errors = [];
+
+  // 1. Template files
+  try {
+    const tmplResult = generateTemplates({ stack, target: targetDir });
+    for (const f of tmplResult.files) {
+      created.push(f);
+    }
+    for (const e of tmplResult.errors) {
+      errors.push(e);
+    }
+  } catch (err) {
+    errors.push(`Template generation: ${err.message}`);
+  }
+
+  // 2. Extra files (inline content)
+  for (const [relPath, content] of Object.entries(extraFiles)) {
+    const absPath = join(targetDir, relPath);
+    // Ensure subdirectories exist
+    mkdirSync(resolve(absPath, '..'), { recursive: true });
+    try {
+      writeFileSync(absPath, content, 'utf-8');
+      created.push(absPath);
+    } catch (err) {
+      errors.push(`${relPath}: ${err.message}`);
+    }
+  }
+
+  // 3. Stack config file — skip if it already exists (user's project file)
+  if (configFileRel) {
+    const cfPath = join(targetDir, configFileRel);
+    if (force || !existsSync(cfPath)) {
+      const cfContent = getConfigFileContent(stack);
+      if (cfContent !== null) {
+        try {
+          writeFileSync(cfPath, cfContent, 'utf-8');
+          created.push(cfPath);
+        } catch (err) {
+          errors.push(`${configFileRel}: ${err.message}`);
+        }
+      }
+    } else {
+      // Skipped — already exists, will report in output
+    }
+  }
+
+  // 4. Stack version file — skip if it already exists
+  if (versionFileRel) {
+    const vfPath = join(targetDir, versionFileRel);
+    if (force || !existsSync(vfPath)) {
+      const vfContent = getVersionFileContent(stack);
+      if (vfContent !== null && vfContent !== '') {
+        try {
+          writeFileSync(vfPath, vfContent, 'utf-8');
+          created.push(vfPath);
+        } catch (err) {
+          errors.push(`${versionFileRel}: ${err.message}`);
+        }
+      }
+    } else {
+      // Skipped — already exists
+    }
+  }
+
+  // 5. .gitignore
+  const gitignorePath = join(targetDir, '.gitignore');
+  try {
+    writeFileSync(gitignorePath, getGitignoreContent(stack), 'utf-8');
+    created.push(gitignorePath);
+  } catch (err) {
+    errors.push(`.gitignore: ${err.message}`);
+  }
+
+  // 5b. Agent-tool file (e.g. CLAUDE.md, .cursorrules, .windsurfrules)
+  //     Generated from the already-rendered AGENTS.md content + optional header.
+  //     No separate templates needed — AGENTS.md is the canonical source.
+  if (agentTool) {
+    const toolEntry = getToolEntry(agentTool);
+    if (toolEntry && toolEntry.file) {
+      const agentsMdPath = join(targetDir, 'AGENTS.md');
+      if (existsSync(agentsMdPath)) {
+        try {
+          const agentsContent = readFileSync(agentsMdPath, 'utf-8');
+          const header = toolEntry.header || '';
+          const outPath = join(targetDir, toolEntry.file);
+          // Ensure subdirectory exists (e.g. .github/copilot-instructions.md)
+          mkdirSync(resolve(outPath, '..'), { recursive: true });
+          writeFileSync(outPath, header + '\n' + agentsContent, 'utf-8');
+          created.push(outPath);
+        } catch (err) {
+          errors.push(`${toolEntry.file}: ${err.message}`);
+        }
+      }
+    }
+
+    // Set agentTool in the generated harness-config.json
+    const configPath = join(targetDir, 'harness-config.json');
+    if (existsSync(configPath)) {
+      try {
+        const cfg = JSON.parse(readFileSync(configPath, 'utf-8'));
+        cfg.agentTool = agentTool;
+        writeFileSync(configPath, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+      } catch (err) {
+        errors.push(`harness-config.json agentTool: ${err.message}`);
+      }
+    }
+  }
+
+  // 6. Git init (unless --no-git)
+  const gitMessages = [];
+  if (!noGit) {
+    try {
+      const msgs = initGit(targetDir);
+      gitMessages.push(...msgs);
+    } catch (err) {
+      errors.push(`Git init: ${err.message}`);
+    }
+  }
+
+  // ── Output ───────────────────────────────────────────────────────────
+
+  if (json) {
+    const status = errors.length > 0 ? 'partial' : 'ok';
+    const message = errors.length > 0
+      ? `Created ${created.length} file(s) with ${errors.length} error(s)`
+      : `Created ${created.length} file(s) for stack "${stack}"`;
+    process.stdout.write(JSON.stringify({
+      command: 'init',
+      status,
+      message,
+      stack,
+      target: targetDir,
+      filesCreated: created.length,
+      files: created,
+      git: gitMessages,
+      errors,
+    }) + '\n');
+    if (errors.length > 0) {
+      process.exit(EXIT.VALIDATION_FAILURE);
+    }
+    return;
+  }
+
+  // Human output
+  for (const f of created) {
+    process.stdout.write(`  ✓ ${f}\n`);
+  }
+  for (const e of errors) {
+    process.stderr.write(`  ✗ ${e}\n`);
+  }
+  for (const g of gitMessages) {
+    process.stdout.write(`  ● ${g}\n`);
+  }
+  process.stdout.write(`\nCreated ${created.length} file(s) for stack "${stack}" in ${targetDir}\n`);
+}

package/cli/commands/learn.mjs

@@ -0,0 +1,47 @@
+/**
+ * learn — Append a lesson to progress.md.
+ *
+ * Usage:
+ *   harness-dev learn "Lesson text here"
+ *   harness-dev learn "Lesson text" --json
+ */
+import { CliError, EXIT, die } from '../lib/errors.mjs';
+import { appendLesson } from '../lib/progress.mjs';
+import { parseCommandArgs } from '../lib/command-helpers.mjs';
+import { emitJson, emitHuman, emitHumanError } from '../lib/output.mjs';
+
+export default async function learnCommand(args) {
+  const { json, targetDir, subcommand, positionals } = parseCommandArgs(args);
+  const message = subcommand || positionals.join(' ');
+
+  if (!message) {
+    die(
+      new CliError(
+        'Lesson message required.\n  Example: harness-dev learn "Token refresh gotcha — accepts access_token in body"',
+        EXIT.USAGE_ERROR,
+      ),
+      json,
+    );
+    return;
+  }
+
+  const result = appendLesson(targetDir, message);
+
+  if (json) {
+    emitJson({
+      command: 'learn',
+      lesson: message,
+      status: result.ok ? 'ok' : 'error',
+      message: result.ok
+        ? `Lesson saved: "${message}"`
+        : (result.error || 'Failed to save lesson'),
+    });
+    return;
+  }
+
+  if (result.ok) {
+    emitHuman(`✓ Lesson saved\n  "${message}"\n`);
+  } else {
+    emitHumanError(`✗ ${result.error}\n`);
+  }
+}

package/cli/commands/pause.mjs

@@ -0,0 +1,34 @@
+/**
+ * pause — Pause autopilot execution.
+ *
+ * Sets config.paused = true. The outer loop checks this
+ * before starting a new phase in autopilot mode.
+ *
+ * Usage: harness-dev pause [--json]
+ */
+import { set } from '../lib/state.mjs';
+import { parseCommandArgs } from '../lib/command-helpers.mjs';
+import { emitJson, emitHuman, emitHumanError } from '../lib/output.mjs';
+
+export default async function pauseCommand(args) {
+  const { json, targetDir } = parseCommandArgs(args);
+
+  const result = set(targetDir, 'paused', true);
+
+  if (json) {
+    emitJson({
+      command: 'pause',
+      status: result.ok ? 'ok' : 'error',
+      message: result.ok
+        ? 'Pipeline paused. Autopilot will stop after current phase gate.'
+        : (result.error || 'Failed to pause'),
+    });
+    return;
+  }
+
+  if (result.ok) {
+    emitHuman('✓ Pipeline paused. Autopilot will stop after current phase gate.\n');
+  } else {
+    emitHumanError(`✗ ${result.error}\n`);
+  }
+}