@archal/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,3427 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { Command as Command8 } from "commander";
+
+// src/commands/run.ts
+import { Command } from "commander";
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve4 } from "path";
+
+// src/runner/orchestrator.ts
+import { readFileSync as readFileSync6, existsSync as existsSync5 } from "fs";
+import { resolve as resolve3, dirname as dirname2 } from "path";
+
+// src/runner/scenario-parser.ts
+import { readFileSync } from "fs";
+import { basename } from "path";
+
+// src/utils/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var LOG_LEVEL_COLORS = {
+  debug: "\x1B[90m",
+  // gray
+  info: "\x1B[36m",
+  // cyan
+  warn: "\x1B[33m",
+  // yellow
+  error: "\x1B[31m"
+  // red
+};
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var globalOptions = {
+  level: "warn",
+  quiet: false,
+  json: false,
+  verbose: false
+};
+function configureLogger(options) {
+  globalOptions = { ...globalOptions, ...options };
+}
+function shouldLog(level) {
+  if (globalOptions.quiet && level !== "error") {
+    return false;
+  }
+  return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[globalOptions.level];
+}
+function formatTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function formatLogEntry(entry) {
+  if (globalOptions.json) {
+    return JSON.stringify(entry);
+  }
+  const color = LOG_LEVEL_COLORS[entry.level];
+  const levelTag = `${color}${BOLD}${entry.level.toUpperCase().padEnd(5)}${RESET}`;
+  const timestamp = `${DIM}${entry.timestamp}${RESET}`;
+  let line = `${timestamp} ${levelTag} ${entry.message}`;
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    const dataStr = Object.entries(entry.data).map(([k, v]) => `${DIM}${k}=${RESET}${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+    line += ` ${dataStr}`;
+  }
+  return line;
+}
+function log(level, message, data) {
+  if (!shouldLog(level)) {
+    return;
+  }
+  const entry = {
+    level,
+    message,
+    timestamp: formatTimestamp(),
+    data
+  };
+  const formatted = formatLogEntry(entry);
+  process.stderr.write(formatted + "\n");
+}
+function debug(message, data) {
+  log("debug", message, data);
+}
+function info(message, data) {
+  log("info", message, data);
+}
+function warn(message, data) {
+  log("warn", message, data);
+}
+function error(message, data) {
+  log("error", message, data);
+}
+function success(message) {
+  if (!globalOptions.verbose) return;
+  process.stderr.write(`\x1B[32m${BOLD}  OK${RESET} ${message}
+`);
+}
+function fail(message) {
+  if (!globalOptions.verbose) return;
+  process.stderr.write(`\x1B[31m${BOLD}FAIL${RESET} ${message}
+`);
+}
+function progress(message) {
+  if (!globalOptions.verbose) return;
+  process.stderr.write(`${DIM}  ...${RESET} ${message}
+`);
+}
+function banner(text) {
+  if (!globalOptions.verbose) return;
+  const line = "=".repeat(Math.max(text.length + 4, 40));
+  process.stderr.write(`
+\x1B[36m${BOLD}${line}${RESET}
+`);
+  process.stderr.write(`\x1B[36m${BOLD}  ${text}${RESET}
+`);
+  process.stderr.write(`\x1B[36m${BOLD}${line}${RESET}
+
+`);
+}
+function table(headers, rows) {
+  if (!globalOptions.verbose) return;
+  const colWidths = headers.map((h, i) => {
+    const maxDataWidth = rows.reduce((max, row) => {
+      const cell = row[i] ?? "";
+      return Math.max(max, cell.length);
+    }, 0);
+    return Math.max(h.length, maxDataWidth);
+  });
+  const headerLine = headers.map((h, i) => h.padEnd(colWidths[i] ?? 0)).join("  ");
+  const separator = colWidths.map((w) => "-".repeat(w)).join("  ");
+  process.stderr.write(`${BOLD}${headerLine}${RESET}
+`);
+  process.stderr.write(`${DIM}${separator}${RESET}
+`);
+  for (const row of rows) {
+    const line = row.map((cell, i) => cell.padEnd(colWidths[i] ?? 0)).join("  ");
+    process.stderr.write(`${line}
+`);
+  }
+}
+
+// src/runner/scenario-parser.ts
+function extractSections(markdown) {
+  const lines = markdown.split("\n");
+  let title = "";
+  const sections = {};
+  let currentSection = "";
+  for (const line of lines) {
+    const h1Match = line.match(/^#\s+(.+)/);
+    if (h1Match) {
+      title = h1Match[1]?.trim() ?? "";
+      continue;
+    }
+    const h2Match = line.match(/^##\s+(.+)/);
+    if (h2Match) {
+      currentSection = (h2Match[1] ?? "").trim().toLowerCase();
+      sections[currentSection] = [];
+      continue;
+    }
+    const sectionLines = currentSection ? sections[currentSection] : void 0;
+    if (sectionLines) {
+      sectionLines.push(line);
+    }
+  }
+  const getSection = (name) => {
+    const content = sections[name];
+    if (!content) return "";
+    return content.join("\n").trim();
+  };
+  return {
+    title,
+    setup: getSection("setup"),
+    expectedBehavior: getSection("expected behavior"),
+    successCriteria: getSection("success criteria"),
+    config: getSection("config")
+  };
+}
+function parseCriterionLine(line, index) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  const bulletStripped = trimmed.replace(/^[-*]\s+/, "").replace(/^\d+\.\s+/, "");
+  if (!bulletStripped) return null;
+  let type = "probabilistic";
+  let description = bulletStripped;
+  const tagMatch = description.match(/^\[([DP])]\s*(.*)/i);
+  if (tagMatch) {
+    const tag = (tagMatch[1] ?? "").toUpperCase();
+    type = tag === "D" ? "deterministic" : "probabilistic";
+    description = tagMatch[2]?.trim() ?? "";
+  } else {
+    type = inferCriterionType(description);
+  }
+  return {
+    id: `criterion-${index + 1}`,
+    description,
+    type
+  };
+}
+function inferCriterionType(description) {
+  const deterministicPatterns = [
+    /^exactly\s+\d+/i,
+    /^at\s+least\s+\d+/i,
+    /^at\s+most\s+\d+/i,
+    /^no\s+more\s+than\s+\d+/i,
+    /^fewer\s+than\s+\d+/i,
+    /^more\s+than\s+\d+/i,
+    /\bis\s+(created|merged|closed|open|deleted|removed)\b/i,
+    /\bexists?\b/i,
+    /\bno\s+errors?\b/i,
+    /\bcount\s+(is|equals|==)\b/i,
+    /\b(should|must)\s+(have|contain)\s+exactly\b/i,
+    /^\d+\s+\w+\s+(are|were|is|was)\b/i,
+    /\b(zero|none)\s+\w+\s+(are|were|remain)\b/i
+  ];
+  for (const pattern of deterministicPatterns) {
+    if (pattern.test(description)) {
+      return "deterministic";
+    }
+  }
+  return "probabilistic";
+}
+function parseConfigSection(configText) {
+  const result = {};
+  if (!configText) return result;
+  const lines = configText.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = trimmed.slice(0, colonIndex).trim().toLowerCase();
+    const value = trimmed.slice(colonIndex + 1).trim();
+    switch (key) {
+      case "twins": {
+        result.twins = value.split(",").map((t) => t.trim()).filter(Boolean);
+        break;
+      }
+      case "timeout": {
+        const num = parseInt(value, 10);
+        if (!Number.isNaN(num) && num > 0) {
+          result.timeout = num;
+        }
+        break;
+      }
+      case "runs": {
+        const num = parseInt(value, 10);
+        if (!Number.isNaN(num) && num > 0) {
+          result.runs = num;
+        }
+        break;
+      }
+      case "evaluator":
+      case "evaluator-model":
+      case "evaluatormodel":
+      case "model": {
+        result.evaluatorModel = value;
+        break;
+      }
+      default: {
+        debug(`Unknown config key in scenario: "${key}"`);
+      }
+    }
+  }
+  return result;
+}
+function inferTwinsFromContent(setup, expectedBehavior) {
+  const combined = `${setup}
+${expectedBehavior}`.toLowerCase();
+  const twins = [];
+  const twinKeywords = {
+    github: ["github", "repository", "repo", "pull request", "pr", "issue", "commit", "branch", "merge"],
+    slack: ["slack", "channel", "message", "thread", "workspace", "dm", "direct message"],
+    linear: ["linear", "ticket", "project", "cycle", "backlog"],
+    jira: ["jira", "sprint", "epic", "story", "board"]
+  };
+  for (const [twin, keywords] of Object.entries(twinKeywords)) {
+    if (keywords.some((kw) => combined.includes(kw))) {
+      twins.push(twin);
+    }
+  }
+  return twins;
+}
+function parseScenarioFile(filePath) {
+  const content = readFileSync(filePath, "utf-8");
+  return parseScenarioMarkdown(content, filePath);
+}
+function parseScenarioMarkdown(markdown, sourcePath) {
+  const sections = extractSections(markdown);
+  if (!sections.title) {
+    const fallbackTitle = sourcePath ? basename(sourcePath, ".md").replace(/-/g, " ") : "Untitled Scenario";
+    warn(`Scenario missing title heading, using fallback: "${fallbackTitle}"`);
+    sections.title = fallbackTitle;
+  }
+  if (!sections.setup) {
+    warn("Scenario missing ## Setup section");
+  }
+  if (!sections.expectedBehavior) {
+    warn("Scenario missing ## Expected Behavior section");
+  }
+  if (!sections.successCriteria) {
+    warn("Scenario missing ## Success Criteria section");
+  }
+  const criteriaLines = sections.successCriteria.split("\n");
+  const successCriteria = [];
+  let criterionIndex = 0;
+  for (const line of criteriaLines) {
+    const criterion = parseCriterionLine(line, criterionIndex);
+    if (criterion) {
+      successCriteria.push(criterion);
+      criterionIndex++;
+    }
+  }
+  const parsedConfig = parseConfigSection(sections.config);
+  const inferredTwins = parsedConfig.twins && parsedConfig.twins.length > 0 ? parsedConfig.twins : inferTwinsFromContent(sections.setup, sections.expectedBehavior);
+  const config = {
+    twins: inferredTwins,
+    timeout: parsedConfig.timeout ?? 120,
+    runs: parsedConfig.runs ?? 5,
+    evaluatorModel: parsedConfig.evaluatorModel
+  };
+  debug("Parsed scenario", {
+    title: sections.title,
+    criteriaCount: successCriteria.length,
+    deterministicCount: successCriteria.filter((c) => c.type === "deterministic").length,
+    probabilisticCount: successCriteria.filter((c) => c.type === "probabilistic").length,
+    twins: config.twins.join(", ")
+  });
+  return {
+    title: sections.title,
+    setup: sections.setup,
+    expectedBehavior: sections.expectedBehavior,
+    successCriteria,
+    config
+  };
+}
+function validateScenario(scenario) {
+  const errors = [];
+  if (!scenario.title) {
+    errors.push("Scenario must have a title");
+  }
+  if (!scenario.setup) {
+    errors.push("Scenario must have a Setup section");
+  }
+  if (!scenario.expectedBehavior) {
+    errors.push("Scenario must have an Expected Behavior section");
+  }
+  if (scenario.successCriteria.length === 0) {
+    errors.push("Scenario must have at least one success criterion");
+  }
+  for (const criterion of scenario.successCriteria) {
+    if (!criterion.description) {
+      errors.push(`Criterion ${criterion.id} has an empty description`);
+    }
+  }
+  if (scenario.config.twins.length === 0) {
+    errors.push("Scenario does not reference any known twins (specify in Config section or mention services in Setup/Expected Behavior)");
+  }
+  if (scenario.config.timeout <= 0) {
+    errors.push("Timeout must be a positive number");
+  }
+  if (scenario.config.runs <= 0) {
+    errors.push("Runs must be a positive number");
+  }
+  return errors;
+}
+
+// src/runner/seed-generator.ts
+var GITHUB_SEED_MAPPINGS = [
+  {
+    keywords: ["empty", "blank", "new", "fresh", "clean", "no issues", "no pull requests", "bare"],
+    seedName: "empty",
+    weight: 1
+  },
+  {
+    keywords: ["small", "simple", "basic", "starter", "minimal", "few issues", "small team", "small project"],
+    seedName: "small-project",
+    weight: 1
+  },
+  {
+    keywords: [
+      "enterprise",
+      "large",
+      "many issues",
+      "complex",
+      "multiple contributors",
+      "ci/cd",
+      "workflows",
+      "protected branches",
+      "teams",
+      "organization"
+    ],
+    seedName: "enterprise-repo",
+    weight: 1
+  },
+  {
+    keywords: ["conflict", "merge conflict", "conflicting", "diverged", "cannot merge"],
+    seedName: "merge-conflict",
+    weight: 2
+  },
+  {
+    keywords: ["permission", "denied", "forbidden", "access denied", "unauthorized", "read-only"],
+    seedName: "permissions-denied",
+    weight: 2
+  },
+  {
+    keywords: ["rate limit", "throttle", "too many requests", "429"],
+    seedName: "rate-limited",
+    weight: 2
+  },
+  {
+    keywords: [
+      "stale",
+      "old",
+      "inactive",
+      "outdated",
+      "abandoned",
+      "stale issues",
+      "untriaged"
+    ],
+    seedName: "stale-issues",
+    weight: 2
+  },
+  {
+    keywords: [
+      "pagination",
+      "large backlog",
+      "many issues",
+      "50 issues",
+      "paginate",
+      "page 2",
+      "multiple pages"
+    ],
+    seedName: "large-backlog",
+    weight: 2
+  }
+];
+var SLACK_SEED_MAPPINGS = [
+  {
+    keywords: ["empty", "blank", "new workspace", "fresh", "clean"],
+    seedName: "empty",
+    weight: 1
+  },
+  {
+    keywords: ["small team", "few channels", "simple", "basic", "starter"],
+    seedName: "small-team",
+    weight: 1
+  },
+  {
+    keywords: [
+      "engineering",
+      "development",
+      "engineering team",
+      "developers",
+      "incidents",
+      "on-call",
+      "sprints",
+      "standups"
+    ],
+    seedName: "engineering-team",
+    weight: 1
+  },
+  {
+    keywords: ["support", "customer", "tickets", "help desk", "routing"],
+    seedName: "support-team",
+    weight: 1
+  },
+  {
+    keywords: ["busy", "high volume", "many messages", "active", "noisy"],
+    seedName: "high-volume",
+    weight: 1
+  }
+];
+var TWIN_SEED_REGISTRY = {
+  github: GITHUB_SEED_MAPPINGS,
+  slack: SLACK_SEED_MAPPINGS
+};
+var DEFAULT_SEEDS = {
+  github: "small-project",
+  slack: "small-team"
+};
+function normalizeText(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s/]/g, " ").replace(/\s+/g, " ").trim();
+}
+function scoreMappingAgainstText(text, mapping) {
+  const normalized = normalizeText(text);
+  const matched = [];
+  let score = 0;
+  for (const keyword of mapping.keywords) {
+    if (normalized.includes(keyword)) {
+      matched.push(keyword);
+      score += mapping.weight;
+    }
+  }
+  return { score, matched };
+}
+function selectSeedForTwin(twinName, setupDescription) {
+  const mappings = TWIN_SEED_REGISTRY[twinName];
+  if (!mappings || mappings.length === 0) {
+    debug(`No seed mappings for twin "${twinName}", using "default"`);
+    return {
+      twinName,
+      seedName: "default",
+      confidence: 0,
+      matchedKeywords: []
+    };
+  }
+  let bestSeed = DEFAULT_SEEDS[twinName] ?? "default";
+  let bestScore = 0;
+  let bestMatched = [];
+  for (const mapping of mappings) {
+    const { score, matched } = scoreMappingAgainstText(setupDescription, mapping);
+    if (score > bestScore) {
+      bestScore = score;
+      bestSeed = mapping.seedName;
+      bestMatched = matched;
+    }
+  }
+  const maxPossibleScore = mappings.reduce(
+    (sum, m) => sum + m.keywords.length * m.weight,
+    0
+  );
+  const confidence = maxPossibleScore > 0 ? Math.min(bestScore / 5, 1) : 0;
+  debug("Seed selection", {
+    twin: twinName,
+    seed: bestSeed,
+    confidence: confidence.toFixed(2),
+    matchedKeywords: bestMatched.join(", ")
+  });
+  return {
+    twinName,
+    seedName: bestSeed,
+    confidence,
+    matchedKeywords: bestMatched
+  };
+}
+function generateSeedSelections(twins, setupDescription) {
+  return twins.map((twin) => selectSeedForTwin(twin, setupDescription));
+}
+function overrideSeedSelection(selections, overrides) {
+  return selections.map((sel) => {
+    const override = overrides[sel.twinName];
+    if (override) {
+      debug(`Seed override for ${sel.twinName}: ${override}`);
+      return {
+        ...sel,
+        seedName: override,
+        confidence: 1,
+        matchedKeywords: ["(manual override)"]
+      };
+    }
+    return sel;
+  });
+}
+function getAvailableSeeds(twinName) {
+  const mappings = TWIN_SEED_REGISTRY[twinName];
+  if (!mappings) return [];
+  const seedNames = /* @__PURE__ */ new Set();
+  for (const mapping of mappings) {
+    seedNames.add(mapping.seedName);
+  }
+  return Array.from(seedNames);
+}
+
+// src/runner/agent-executor.ts
+import { readFileSync as readFileSync2, writeFileSync, renameSync, existsSync, unlinkSync } from "fs";
+import { createRequire } from "module";
+import { tmpdir } from "os";
+import { join, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// src/utils/process.ts
+import { spawn } from "child_process";
+function spawnWithTimeout(options) {
+  const {
+    command,
+    args,
+    timeoutMs,
+    cwd,
+    env,
+    pipeStdio = false,
+    onStdout,
+    onStderr
+  } = options;
+  return new Promise((resolve8, reject) => {
+    const startTime = Date.now();
+    let timedOut = false;
+    let stdoutBuf = "";
+    let stderrBuf = "";
+    const spawnOpts = {
+      cwd,
+      env: env ? { ...process.env, ...env } : process.env,
+      stdio: pipeStdio ? "inherit" : "pipe",
+      shell: process.platform === "win32"
+    };
+    debug("Spawning process", { command, args: args.join(" "), timeoutMs });
+    let child;
+    try {
+      child = spawn(command, args, spawnOpts);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      reject(new Error(`Failed to spawn process "${command}": ${message}`));
+      return;
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      debug("Process timed out, killing", { command, timeoutMs });
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill("SIGKILL");
+        }
+      }, 5e3);
+    }, timeoutMs);
+    if (!pipeStdio && child.stdout) {
+      child.stdout.on("data", (chunk) => {
+        const text = chunk.toString();
+        stdoutBuf += text;
+        if (onStdout) {
+          onStdout(text);
+        }
+      });
+    }
+    if (!pipeStdio && child.stderr) {
+      child.stderr.on("data", (chunk) => {
+        const text = chunk.toString();
+        stderrBuf += text;
+        if (onStderr) {
+          onStderr(text);
+        }
+      });
+    }
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(new Error(`Process "${command}" errored: ${err.message}`));
+    });
+    child.on("close", (exitCode) => {
+      clearTimeout(timer);
+      const durationMs = Date.now() - startTime;
+      debug("Process exited", { command, exitCode, durationMs, timedOut });
+      resolve8({
+        exitCode,
+        stdout: stdoutBuf,
+        stderr: stderrBuf,
+        timedOut,
+        durationMs
+      });
+    });
+  });
+}
+function spawnMcpStdioProcess(options) {
+  const { command, args, env, cwd } = options;
+  debug("Spawning MCP stdio process", { command, args: args.join(" ") });
+  const child = spawn(command, args, {
+    cwd,
+    env: env ? { ...process.env, ...env } : process.env,
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: process.platform === "win32"
+  });
+  child.on("error", (err) => {
+    error(`MCP process "${command}" errored: ${err.message}`);
+  });
+  return child;
+}
+function killProcess(child, gracePeriodMs = 5e3) {
+  return new Promise((resolve8) => {
+    if (child.killed || child.exitCode !== null) {
+      resolve8();
+      return;
+    }
+    child.kill("SIGTERM");
+    const forceKillTimer = setTimeout(() => {
+      if (!child.killed) {
+        child.kill("SIGKILL");
+      }
+    }, gracePeriodMs);
+    child.on("close", () => {
+      clearTimeout(forceKillTimer);
+      resolve8();
+    });
+  });
+}
+
+// src/runner/agent-executor.ts
+var __dirname = fileURLToPath(new URL(".", import.meta.url));
+function resolveTwinCommand(twinName) {
+  const distPath = resolve(__dirname, "..", "..", "twins", twinName, "dist", "index.js");
+  if (existsSync(distPath)) {
+    return { command: "node", args: [distPath] };
+  }
+  try {
+    const require2 = createRequire(import.meta.url);
+    const packageMain = require2.resolve(`@archal/twin-${twinName}`);
+    return { command: "node", args: [packageMain] };
+  } catch {
+  }
+  return { command: "npx", args: [`@archal/twin-${twinName}`] };
+}
+async function waitForFile(filePath, timeoutMs = 1e4) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (existsSync(filePath)) return true;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  return false;
+}
+async function captureSeedState(twinConfigs) {
+  const runId = `archal-seed-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const beforeState = {};
+  const twinPaths = {};
+  const processes = [];
+  for (const config of twinConfigs) {
+    const { command, args } = resolveTwinCommand(config.twinName);
+    const stateFilePath = join(tmpdir(), `${runId}-${config.twinName}-state.json`);
+    debug(`Capturing seed state for ${config.twinName}`, { seed: config.seedName });
+    const twinArgs = [
+      ...args,
+      "--seed",
+      config.seedName,
+      "--state-file",
+      stateFilePath
+    ];
+    if (config.rateLimitMax && config.rateLimitMax > 0) {
+      twinArgs.push("--rate-limit", String(config.rateLimitMax));
+    }
+    const child = spawnMcpStdioProcess({ command, args: twinArgs });
+    processes.push(child);
+    twinPaths[config.twinName] = { stateFile: stateFilePath };
+    const appeared = await waitForFile(stateFilePath, 1e4);
+    if (appeared) {
+      try {
+        const raw = readFileSync2(stateFilePath, "utf-8");
+        beforeState[config.twinName] = JSON.parse(raw);
+      } catch {
+        warn(`Failed to read seed state for ${config.twinName}`);
+        beforeState[config.twinName] = {};
+      }
+    } else {
+      warn(`State file not written for ${config.twinName} within timeout`);
+      beforeState[config.twinName] = {};
+    }
+    await killProcess(child, 3e3);
+  }
+  return { beforeState, twinPaths };
+}
+function writeMcpConfig(twinConfigs, runId) {
+  const twinPaths = {};
+  const mcpServers = {};
+  for (const config of twinConfigs) {
+    const { command, args: baseArgs } = resolveTwinCommand(config.twinName);
+    const stateFile = join(tmpdir(), `${runId}-${config.twinName}-state.json`);
+    const traceFile = join(tmpdir(), `${runId}-${config.twinName}-trace.json`);
+    twinPaths[config.twinName] = { stateFile, traceFile };
+    const twinArgs = [
+      ...baseArgs,
+      "--seed",
+      config.seedName,
+      "--state-file",
+      stateFile,
+      "--trace-file",
+      traceFile
+    ];
+    if (config.rateLimitMax && config.rateLimitMax > 0) {
+      twinArgs.push("--rate-limit", String(config.rateLimitMax));
+    }
+    mcpServers[config.twinName] = { command, args: twinArgs };
+  }
+  const configData = { mcpServers };
+  const configPath = join(tmpdir(), `${runId}-mcp-config.json`);
+  const tmpPath = configPath + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(configData, null, 2));
+  renameSync(tmpPath, configPath);
+  debug("Wrote MCP config", { configPath, twins: Object.keys(mcpServers).join(", ") });
+  return { configPath, twinPaths };
+}
+async function executeAgent(agentConfig, mcpConfigPath, mcpServersJson, twinNames, timeoutMs) {
+  const agentEnv = {
+    ...agentConfig.env,
+    MCP_CONFIG_PATH: mcpConfigPath,
+    ARCHAL_MCP_CONFIG: mcpConfigPath,
+    ARCHAL_MCP_SERVERS: mcpServersJson,
+    ARCHAL_TWIN_NAMES: twinNames.join(",")
+  };
+  info("Executing agent", {
+    command: agentConfig.command,
+    timeout: `${timeoutMs}ms`
+  });
+  const result = await spawnWithTimeout({
+    command: agentConfig.command,
+    args: agentConfig.args,
+    timeoutMs,
+    cwd: agentConfig.cwd,
+    env: agentEnv,
+    onStdout: (chunk) => {
+      debug(`[agent stdout] ${chunk.trimEnd()}`);
+    },
+    onStderr: (chunk) => {
+      debug(`[agent stderr] ${chunk.trimEnd()}`);
+    }
+  });
+  if (result.timedOut) {
+    warn(`Agent timed out after ${timeoutMs}ms`);
+  } else if (result.exitCode !== 0) {
+    warn(`Agent exited with code ${result.exitCode}`);
+  } else {
+    info("Agent completed successfully", { durationMs: result.durationMs });
+  }
+  return {
+    exitCode: result.exitCode,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    timedOut: result.timedOut,
+    durationMs: result.durationMs
+  };
+}
+function collectStateFromFiles(twinPaths) {
+  const state = {};
+  for (const [name, paths] of Object.entries(twinPaths)) {
+    try {
+      if (existsSync(paths.stateFile)) {
+        const raw = readFileSync2(paths.stateFile, "utf-8");
+        state[name] = JSON.parse(raw);
+      } else {
+        warn(`State file not found for twin "${name}" at ${paths.stateFile}`);
+        state[name] = {};
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warn(`Failed to read state for twin "${name}": ${msg}`);
+      state[name] = {};
+    }
+  }
+  return state;
+}
+function collectTraceFromFiles(twinPaths) {
+  const allTraces = [];
+  for (const [name, paths] of Object.entries(twinPaths)) {
+    try {
+      if (existsSync(paths.traceFile)) {
+        const raw = readFileSync2(paths.traceFile, "utf-8");
+        const entries = JSON.parse(raw);
+        allTraces.push(...entries);
+      } else {
+        debug(`Trace file not found for twin "${name}"`);
+      }
+    } catch {
+      debug(`Could not parse trace file for twin "${name}"`);
+    }
+  }
+  allTraces.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  return allTraces;
+}
+function cleanupTempFiles(mcpConfigPath, twinPaths, seedPaths) {
+  const filesToClean = [mcpConfigPath, mcpConfigPath + ".tmp"];
+  for (const paths of Object.values(twinPaths)) {
+    filesToClean.push(paths.stateFile, paths.stateFile + ".tmp");
+    filesToClean.push(paths.traceFile, paths.traceFile + ".tmp");
+  }
+  if (seedPaths) {
+    for (const paths of Object.values(seedPaths)) {
+      filesToClean.push(paths.stateFile, paths.stateFile + ".tmp");
+    }
+  }
+  for (const file of filesToClean) {
+    try {
+      if (existsSync(file)) unlinkSync(file);
+    } catch {
+    }
+  }
+}
+function splitCommand(cmd) {
+  const result = [];
+  let current = "";
+  let inQuote = false;
+  let quoteChar = "";
+  for (const ch of cmd) {
+    if (!inQuote && (ch === '"' || ch === "'")) {
+      inQuote = true;
+      quoteChar = ch;
+    } else if (inQuote && ch === quoteChar) {
+      inQuote = false;
+    } else if (!inQuote && ch === " ") {
+      if (current) result.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current) result.push(current);
+  return result;
+}
+function resolveAgentConfig(agentCommand, projectConfigPath) {
+  if (agentCommand) {
+    const parts = splitCommand(agentCommand);
+    return {
+      command: parts[0],
+      args: parts.slice(1)
+    };
+  }
+  if (projectConfigPath) {
+    try {
+      const raw = readFileSync2(projectConfigPath, "utf-8");
+      const config = JSON.parse(raw);
+      if (config.agent?.command) {
+        return {
+          command: config.agent.command,
+          args: config.agent.args ?? [],
+          env: config.agent.env
+        };
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      error(`Failed to load agent config from ${projectConfigPath}: ${message}`);
+    }
+  }
+  const envCommand = process.env["ARCHAL_AGENT_COMMAND"];
+  if (envCommand) {
+    const parts = splitCommand(envCommand);
+    return {
+      command: parts[0],
+      args: parts.slice(1)
+    };
+  }
+  return null;
+}
+
+// src/runner/reporter.ts
+import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { dirname, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = fileURLToPath2(new URL(".", import.meta.url));
+var RESET2 = "\x1B[0m";
+var BOLD2 = "\x1B[1m";
+var DIM2 = "\x1B[2m";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var CYAN = "\x1B[36m";
+function printHeader(scenarioTitle, seedSelections) {
+  process.stderr.write(`
+${CYAN}${BOLD2}archal${RESET2} ${DIM2}\u2014${RESET2} ${scenarioTitle}
+`);
+  for (const sel of seedSelections) {
+    process.stderr.write(`  ${DIM2}twin:${RESET2} ${sel.twinName} ${DIM2}(seed: ${sel.seedName})${RESET2}
+`);
+  }
+}
+function printRunProgress(runIndex, totalRuns, score, error2) {
+  const dots = ".".repeat(Math.max(1, 20 - String(runIndex + 1).length - String(totalRuns).length));
+  if (error2) {
+    const shortError = error2.length > 60 ? error2.slice(0, 59) + "\u2026" : error2;
+    process.stderr.write(`  run ${runIndex + 1}/${totalRuns} ${DIM2}${dots}${RESET2} ${RED}ERROR${RESET2} ${DIM2}(${shortError})${RESET2}
+`);
+    return;
+  }
+  const sc = score >= 100 ? GREEN : score >= 50 ? YELLOW : RED;
+  const pct = `${sc}${score.toFixed(0)}%${RESET2}`;
+  process.stderr.write(`  run ${runIndex + 1}/${totalRuns} ${DIM2}${dots}${RESET2} ${pct}
+`);
+}
+function formatTraceSummary(report) {
+  const lines = [];
+  const firstRun = report.runs[0];
+  if (!firstRun || firstRun.trace.length === 0) return lines;
+  const trace = firstRun.trace;
+  const toolCounts = /* @__PURE__ */ new Map();
+  for (const entry of trace) {
+    const count = toolCounts.get(entry.toolName) ?? 0;
+    toolCounts.set(entry.toolName, count + 1);
+  }
+  lines.push(`  ${DIM2}actions:${RESET2}`);
+  for (const [tool, count] of toolCounts) {
+    const entries = trace.filter((e) => e.toolName === tool);
+    const summary = summarizeToolCalls(tool, entries);
+    if (summary) {
+      lines.push(`    ${DIM2}\u2192${RESET2} ${summary}`);
+    } else {
+      lines.push(`    ${DIM2}\u2192${RESET2} ${tool} \xD7${count}`);
+    }
+  }
+  const totalCalls = trace.length;
+  lines.push(`    ${DIM2}\u2192 ${totalCalls} total API calls${RESET2}`);
+  return lines;
+}
+function summarizeToolCalls(toolName, entries) {
+  const count = entries.length;
+  const ids = [];
+  for (const entry of entries) {
+    const input = entry.input;
+    const id = input["issue_number"] ?? input["number"] ?? input["id"] ?? input["channel"] ?? input["name"];
+    if (id !== void 0) {
+      ids.push(id);
+    }
+  }
+  const toolLabel = toolName.replace(/_/g, " ").replace(/-/g, " ");
+  if (ids.length > 0 && ids.length <= 6) {
+    const idStr = ids.map((id) => typeof id === "number" ? `#${id}` : String(id)).join(", ");
+    return `${toolLabel} \xD7${count} (${idStr})`;
+  }
+  if (count === 1) {
+    return toolLabel;
+  }
+  return `${toolLabel} \xD7${count}`;
+}
+function generateReport(report, format) {
+  switch (format) {
+    case "terminal":
+      return formatTerminal(report);
+    case "json":
+      return formatJson(report);
+    case "junit":
+      return formatJunit(report);
+  }
+}
+function loadTwinFidelity(twinNames) {
+  const lines = [];
+  for (const name of twinNames) {
+    try {
+      let fidelityPath = null;
+      const monorepoPath = resolve2(__dirname2, "..", "..", "twins", name, "fidelity.json");
+      if (existsSync2(monorepoPath)) {
+        fidelityPath = monorepoPath;
+      }
+      if (!fidelityPath) {
+        try {
+          const require2 = createRequire2(import.meta.url);
+          const twinMain = require2.resolve(`@archal/twin-${name}`);
+          const candidate = resolve2(dirname(twinMain), "..", "fidelity.json");
+          if (existsSync2(candidate)) {
+            fidelityPath = candidate;
+          }
+        } catch {
+        }
+      }
+      if (!fidelityPath) continue;
+      const raw = readFileSync3(fidelityPath, "utf-8");
+      const data = JSON.parse(raw);
+      lines.push(`  ${DIM2}twin fidelity:${RESET2} ${data.twin} v${data.version}`);
+      for (const cap of data.capabilities) {
+        const icon = cap.supported ? `${GREEN}\u2713${RESET2}` : `${DIM2}\u2717${RESET2}`;
+        lines.push(`    ${icon} ${DIM2}${cap.name}${RESET2}`);
+      }
+    } catch {
+    }
+  }
+  return lines;
+}
+function formatTerminal(report) {
+  const lines = [];
+  const totalRuns = report.runs.length;
+  const traceSummary = formatTraceSummary(report);
+  if (traceSummary.length > 0) {
+    lines.push("");
+    lines.push(...traceSummary);
+  }
+  lines.push("");
+  const criterionIds = [];
+  if (report.runs.length > 0) {
+    for (const evaluation of report.runs[0].evaluations) {
+      criterionIds.push(evaluation.criterionId);
+    }
+  }
+  for (const criterionId of criterionIds) {
+    let passCount = 0;
+    for (const run of report.runs) {
+      const evaluation = run.evaluations.find((e) => e.criterionId === criterionId);
+      if (evaluation && evaluation.status === "pass") {
+        passCount++;
+      }
+    }
+    const allPassed = passCount === totalRuns;
+    const nonePassed = passCount === 0;
+    const description = report.criterionDescriptions?.[criterionId] ?? criterionId;
+    const termWidth = process.stdout.columns ?? 80;
+    const statusPlainLen = `pass ${totalRuns}/${totalRuns}`.length;
+    const reservedRight = 2 + statusPlainLen;
+    const maxLabelLen = Math.max(20, termWidth - reservedRight - 4);
+    let truncatedLabel;
+    if (description.length > maxLabelLen) {
+      const truncPoint = description.lastIndexOf(" ", maxLabelLen - 1);
+      truncatedLabel = truncPoint > maxLabelLen * 0.6 ? description.slice(0, truncPoint) + "\u2026" : description.slice(0, maxLabelLen - 1) + "\u2026";
+    } else {
+      truncatedLabel = description;
+    }
+    const dotCount = Math.max(2, termWidth - 2 - truncatedLabel.length - 1 - statusPlainLen);
+    const dots = `${DIM2}${".".repeat(dotCount)}${RESET2}`;
+    let statusStr;
+    if (allPassed) {
+      statusStr = `${GREEN}pass ${passCount}/${totalRuns}${RESET2}`;
+    } else if (nonePassed) {
+      statusStr = `${RED}fail ${passCount}/${totalRuns}${RESET2}`;
+    } else {
+      statusStr = `${YELLOW}warn ${passCount}/${totalRuns}${RESET2}`;
+    }
+    lines.push(`  ${truncatedLabel} ${dots} ${statusStr}`);
+    const criterionType = report.criterionTypes?.[criterionId];
+    if (!allPassed && criterionType === "probabilistic") {
+      for (const run of report.runs) {
+        const ev = run.evaluations.find((e) => e.criterionId === criterionId);
+        if (ev && ev.status !== "pass" && ev.explanation) {
+          const maxExplLen = Math.max(40, termWidth - 12);
+          const truncExpl = ev.explanation.length > maxExplLen ? ev.explanation.slice(0, maxExplLen - 1) + "\u2026" : ev.explanation;
+          lines.push(`    ${DIM2}run ${run.runIndex + 1}: ${truncExpl}${RESET2}`);
+        }
+      }
+    }
+  }
+  lines.push("");
+  const sc = report.satisfactionScore >= 80 ? GREEN : report.satisfactionScore >= 50 ? YELLOW : RED;
+  lines.push(`  ${BOLD2}satisfaction:${RESET2} ${sc}${BOLD2}${report.satisfactionScore.toFixed(1)}%${RESET2} ${DIM2}(${totalRuns} runs)${RESET2}`);
+  if (report.twinNames && report.twinNames.length > 0) {
+    const fidelityLines = loadTwinFidelity(report.twinNames);
+    if (fidelityLines.length > 0) {
+      lines.push("");
+      lines.push(...fidelityLines);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatJson(report) {
+  return JSON.stringify(report, null, 2);
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function formatJunit(report) {
+  const lines = [];
+  let totalTests = 0;
+  let totalFailures = 0;
+  let totalTime = 0;
+  for (const run of report.runs) {
+    totalTests += run.evaluations.length;
+    totalFailures += run.evaluations.filter((e) => e.status === "fail").length;
+    totalTime += run.durationMs;
+  }
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push(
+    `<testsuites name="${escapeXml(report.scenarioTitle)}" tests="${totalTests}" failures="${totalFailures}" time="${(totalTime / 1e3).toFixed(3)}">`
+  );
+  for (const run of report.runs) {
+    const runTests = run.evaluations.length;
+    const runFailures = run.evaluations.filter((e) => e.status === "fail").length;
+    const runTime = (run.durationMs / 1e3).toFixed(3);
+    lines.push(
+      `  <testsuite name="Run ${run.runIndex + 1}" tests="${runTests}" failures="${runFailures}" time="${runTime}">`
+    );
+    if (run.error) {
+      lines.push(
+        `    <testcase name="agent-execution" time="${runTime}">`
+      );
+      lines.push(
+        `      <failure message="${escapeXml(run.error)}" type="ExecutionError">${escapeXml(run.error)}</failure>`
+      );
+      lines.push("    </testcase>");
+    }
+    for (const evaluation of run.evaluations) {
+      const testName = escapeXml(evaluation.criterionId);
+      lines.push(`    <testcase name="${testName}" time="0.000">`);
+      if (evaluation.status === "fail") {
+        lines.push(
+          `      <failure message="${escapeXml(evaluation.explanation)}" type="CriterionFailed">${escapeXml(evaluation.explanation)}</failure>`
+        );
+      } else if (evaluation.status === "partial") {
+        lines.push(
+          `      <system-out>PARTIAL: ${escapeXml(evaluation.explanation)} (confidence: ${(evaluation.confidence * 100).toFixed(0)}%)</system-out>`
+        );
+      }
+      lines.push("    </testcase>");
+    }
+    lines.push("  </testsuite>");
+  }
+  lines.push("</testsuites>");
+  return lines.join("\n");
+}
+function printReport(report, format) {
+  const output = generateReport(report, format);
+  process.stdout.write(output + "\n");
+}
+
+// src/evaluator/deterministic.ts
+function stripParenthetical(text) {
+  return text.replace(/\s*\(.*?\)\s*/g, " ").trim();
+}
+function cleanPredicate(pred) {
+  let cleaned = stripParenthetical(pred);
+  cleaned = cleaned.replace(/\s+(?:on|in|to|from|of)\s+(?:the\s+)?.+$/, "");
+  return cleaned.trim();
+}
+function parseAssertion(description) {
+  const lower = stripParenthetical(description).toLowerCase().trim();
+  const noLabeledMatch = lower.match(/^no\s+(.+?)\s+labeled\s+["']?([^"']+?)["']?\s+(?:are|were|is|was|should be)\s+(.+)$/);
+  if (noLabeledMatch) {
+    return {
+      type: "no_matching",
+      subject: noLabeledMatch[1]?.trim() ?? "",
+      predicate: cleanPredicate(noLabeledMatch[3]?.trim() ?? ""),
+      labelFilter: noLabeledMatch[2]?.trim()
+    };
+  }
+  const exactWithVerb = lower.match(/^exactly\s+(\d+)\s+(.+?)\s+(?:are|were|is|was|should be)\s+(.+)$/);
+  if (exactWithVerb) {
+    return {
+      type: "exact_count",
+      subject: exactWithVerb[2]?.trim() ?? "",
+      value: parseInt(exactWithVerb[1] ?? "0", 10),
+      predicate: cleanPredicate(exactWithVerb[3]?.trim() ?? "")
+    };
+  }
+  const exactWithoutVerb = lower.match(/^exactly\s+(\d+)\s+(.+)$/);
+  if (exactWithoutVerb) {
+    return {
+      type: "exact_count",
+      subject: exactWithoutVerb[2]?.trim() ?? "",
+      value: parseInt(exactWithoutVerb[1] ?? "0", 10)
+    };
+  }
+  const minWithVerb = lower.match(/^at\s+least\s+(\d+)\s+(.+?)\s+(?:are|were|is|was|should be)\s+(.+)$/);
+  if (minWithVerb) {
+    return {
+      type: "min_count",
+      subject: minWithVerb[2]?.trim() ?? "",
+      value: parseInt(minWithVerb[1] ?? "0", 10),
+      predicate: cleanPredicate(minWithVerb[3]?.trim() ?? "")
+    };
+  }
+  const minWithoutVerb = lower.match(/^at\s+least\s+(\d+)\s+(.+)$/);
+  if (minWithoutVerb) {
+    return {
+      type: "min_count",
+      subject: minWithoutVerb[2]?.trim() ?? "",
+      value: parseInt(minWithoutVerb[1] ?? "0", 10)
+    };
+  }
+  const maxWithVerb = lower.match(/^(?:at\s+most|no\s+more\s+than)\s+(\d+)\s+(.+?)\s+(?:are|were|is|was|should be)\s+(.+)$/);
+  if (maxWithVerb) {
+    return {
+      type: "max_count",
+      subject: maxWithVerb[2]?.trim() ?? "",
+      value: parseInt(maxWithVerb[1] ?? "0", 10),
+      predicate: maxWithVerb[3]?.trim() || void 0
+    };
+  }
+  const maxWithoutVerb = lower.match(/^(?:at\s+most|no\s+more\s+than)\s+(\d+)\s+(.+)$/);
+  if (maxWithoutVerb) {
+    return {
+      type: "max_count",
+      subject: maxWithoutVerb[2]?.trim() ?? "",
+      value: parseInt(maxWithoutVerb[1] ?? "0", 10)
+    };
+  }
+  const fewerMatch = lower.match(/^fewer\s+than\s+(\d+)\s+(.+)/);
+  if (fewerMatch) {
+    return {
+      type: "max_count",
+      subject: fewerMatch[2]?.trim() ?? "",
+      value: parseInt(fewerMatch[1] ?? "1", 10) - 1
+    };
+  }
+  const moreMatch = lower.match(/^more\s+than\s+(\d+)\s+(.+)/);
+  if (moreMatch) {
+    return {
+      type: "min_count",
+      subject: moreMatch[2]?.trim() ?? "",
+      value: parseInt(moreMatch[1] ?? "0", 10) + 1
+    };
+  }
+  const numSubjectMatch = lower.match(/^(\d+)\s+(.+?)\s+(?:are|were|is|was)\s+(.+)$/);
+  if (numSubjectMatch) {
+    return {
+      type: "exact_count",
+      subject: numSubjectMatch[2]?.trim() ?? "",
+      value: parseInt(numSubjectMatch[1] ?? "0", 10),
+      predicate: numSubjectMatch[3]?.trim()
+    };
+  }
+  if (/^no\s+errors?\s+(in\s+)?(trace|log|output)/i.test(lower)) {
+    return { type: "no_errors", subject: "trace" };
+  }
+  const stateMatch = lower.match(/^(?:the\s+)?(.+?)\s+(?:is|was|has been|should be)\s+(created|merged|closed|open|deleted|removed|resolved|approved|rejected)/);
+  if (stateMatch) {
+    return {
+      type: "state_check",
+      subject: stateMatch[1]?.trim() ?? "",
+      predicate: stateMatch[2]?.trim()
+    };
+  }
+  const existsMatch = lower.match(/^(?:the\s+)?(.+?)\s+(?:exists?|is present|was created|has been created)/);
+  if (existsMatch) {
+    return { type: "exists", subject: existsMatch[1]?.trim() ?? "" };
+  }
+  const noneMatch = lower.match(/^(?:no|zero|none)\s+(.+?)(?:\s+(?:remain|exist|left|present|found))?\s*$/);
+  if (noneMatch) {
+    return {
+      type: "exact_count",
+      subject: noneMatch[1]?.trim() ?? "",
+      value: 0
+    };
+  }
+  return null;
+}
+function flattenTwinState(state) {
+  const flattened = {};
+  for (const value of Object.values(state)) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      const twinData = value;
+      const hasArrayValues = Object.values(twinData).some(Array.isArray);
+      if (hasArrayValues) {
+        for (const [entityName, entityData] of Object.entries(twinData)) {
+          if (Array.isArray(entityData)) {
+            const existing = flattened[entityName];
+            if (Array.isArray(existing)) {
+              flattened[entityName] = [...existing, ...entityData];
+            } else {
+              flattened[entityName] = entityData;
+            }
+          }
+        }
+        continue;
+      }
+    }
+  }
+  if (Object.keys(flattened).length === 0) return state;
+  return flattened;
+}
+function resolveSubjectInState(subject, state) {
+  const flat = flattenTwinState(state);
+  const normalizedSubject = subject.replace(/\s+/g, "").toLowerCase();
+  for (const [key, value] of Object.entries(flat)) {
+    const normalizedKey = key.replace(/\s+/g, "").toLowerCase();
+    if (normalizedKey === normalizedSubject || normalizedKey === normalizedSubject + "s") {
+      if (Array.isArray(value)) return value;
+      if (typeof value === "object" && value !== null) return [value];
+    }
+    if (normalizedSubject.includes(normalizedKey) || normalizedKey.includes(normalizedSubject)) {
+      if (Array.isArray(value)) return value;
+    }
+  }
+  const subjectWords = subject.toLowerCase().split(/\s+/);
+  for (const [key, value] of Object.entries(flat)) {
+    if (typeof value !== "object" || value === null) continue;
+    const entries = Array.isArray(value) ? value : Object.values(value);
+    for (const word of subjectWords) {
+      if (key.toLowerCase().includes(word)) {
+        return entries;
+      }
+    }
+  }
+  return null;
+}
+function filterByPredicate(items, predicate) {
+  const lowerPredicate = predicate.toLowerCase();
+  return items.filter((item) => {
+    if (typeof item !== "object" || item === null) return false;
+    const obj = item;
+    if (obj["state"] !== void 0 && String(obj["state"]).toLowerCase() === lowerPredicate) {
+      return true;
+    }
+    if (obj["status"] !== void 0 && String(obj["status"]).toLowerCase() === lowerPredicate) {
+      return true;
+    }
+    if (lowerPredicate === "merged" && obj["merged"] === true) return true;
+    if (lowerPredicate === "closed" && (obj["state"] === "closed" || obj["closed"] === true)) return true;
+    if (lowerPredicate === "open" && obj["state"] === "open") return true;
+    if (lowerPredicate === "created" && obj["id"] !== void 0) return true;
+    if (lowerPredicate === "deleted" && obj["deleted"] === true) return true;
+    if (lowerPredicate === "resolved" && (obj["state"] === "resolved" || obj["resolved"] === true)) return true;
+    return false;
+  });
+}
+function countTraceErrors(trace) {
+  return trace.filter((entry) => entry.error !== null).length;
+}
+function evaluateDeterministic(criterion, stateView) {
+  const assertion = parseAssertion(criterion.description);
+  if (!assertion) {
+    debug(`Could not parse deterministic assertion: "${criterion.description}"`);
+    return {
+      criterionId: criterion.id,
+      status: "fail",
+      confidence: 0.5,
+      explanation: `Could not parse deterministic assertion from: "${criterion.description}"`
+    };
+  }
+  debug("Parsed assertion", {
+    type: assertion.type,
+    subject: assertion.subject,
+    value: String(assertion.value ?? ""),
+    predicate: assertion.predicate ?? ""
+  });
+  switch (assertion.type) {
+    case "no_errors": {
+      const errorCount = countTraceErrors(stateView.trace);
+      const passed = errorCount === 0;
+      return {
+        criterionId: criterion.id,
+        status: passed ? "pass" : "fail",
+        confidence: 1,
+        explanation: passed ? "No errors found in trace" : `Found ${errorCount} error(s) in trace`
+      };
+    }
+    case "exact_count":
+    case "min_count":
+    case "max_count": {
+      const afterItems = resolveSubjectInState(assertion.subject, stateView.after);
+      if (afterItems === null) {
+        const addedItems = stateView.diff.added[assertion.subject];
+        if (addedItems) {
+          return evaluateCount(
+            criterion.id,
+            assertion.type,
+            assertion.value ?? 0,
+            addedItems.length,
+            assertion.subject,
+            assertion.predicate
+          );
+        }
+        return {
+          criterionId: criterion.id,
+          status: "fail",
+          confidence: 0.5,
+          explanation: `Could not find "${assertion.subject}" in twin state`
+        };
+      }
+      if (assertion.predicate) {
+        const beforeItems = resolveSubjectInState(assertion.subject, stateView.before);
+        const afterFiltered = filterByPredicate(afterItems, assertion.predicate);
+        if (beforeItems) {
+          const beforeFiltered = filterByPredicate(beforeItems, assertion.predicate);
+          const newlyMatching = afterFiltered.length - beforeFiltered.length;
+          return evaluateCount(
+            criterion.id,
+            assertion.type,
+            assertion.value ?? 0,
+            Math.max(0, newlyMatching),
+            assertion.subject,
+            assertion.predicate
+          );
+        }
+        return evaluateCount(
+          criterion.id,
+          assertion.type,
+          assertion.value ?? 0,
+          afterFiltered.length,
+          assertion.subject,
+          assertion.predicate
+        );
+      }
+      return evaluateCount(
+        criterion.id,
+        assertion.type,
+        assertion.value ?? 0,
+        afterItems.length,
+        assertion.subject,
+        assertion.predicate
+      );
+    }
+    case "no_matching": {
+      const items = resolveSubjectInState(assertion.subject, stateView.after);
+      if (!items) {
+        return {
+          criterionId: criterion.id,
+          status: "fail",
+          confidence: 0.5,
+          explanation: `Could not find "${assertion.subject}" in twin state`
+        };
+      }
+      const labelFiltered = assertion.labelFilter ? items.filter((item) => {
+        if (typeof item !== "object" || item === null) return false;
+        const obj = item;
+        const labels = obj["labels"];
+        if (Array.isArray(labels)) {
+          return labels.some((l) => {
+            const labelName = typeof l === "string" ? l : l?.["name"];
+            return String(labelName).toLowerCase() === assertion.labelFilter?.toLowerCase();
+          });
+        }
+        return false;
+      }) : items;
+      const matching = assertion.predicate ? filterByPredicate(labelFiltered, assertion.predicate) : labelFiltered;
+      const passed = matching.length === 0;
+      return {
+        criterionId: criterion.id,
+        status: passed ? "pass" : "fail",
+        confidence: 1,
+        explanation: passed ? `No ${assertion.subject} labeled "${assertion.labelFilter}" are ${assertion.predicate}` : `Found ${matching.length} ${assertion.subject} labeled "${assertion.labelFilter}" that are ${assertion.predicate}`
+      };
+    }
+    case "exists": {
+      const items = resolveSubjectInState(assertion.subject, stateView.after);
+      const found = items !== null && items.length > 0;
+      return {
+        criterionId: criterion.id,
+        status: found ? "pass" : "fail",
+        confidence: 1,
+        explanation: found ? `"${assertion.subject}" exists in twin state` : `"${assertion.subject}" not found in twin state`
+      };
+    }
+    case "not_exists": {
+      const items = resolveSubjectInState(assertion.subject, stateView.after);
+      const absent = items === null || items.length === 0;
+      return {
+        criterionId: criterion.id,
+        status: absent ? "pass" : "fail",
+        confidence: 1,
+        explanation: absent ? `"${assertion.subject}" does not exist in twin state` : `"${assertion.subject}" still exists in twin state`
+      };
+    }
+    case "state_check": {
+      const items = resolveSubjectInState(assertion.subject, stateView.after);
+      if (!items || items.length === 0) {
+        return {
+          criterionId: criterion.id,
+          status: "fail",
+          confidence: 0.8,
+          explanation: `Could not find "${assertion.subject}" in twin state to check status`
+        };
+      }
+      const matching = assertion.predicate ? filterByPredicate(items, assertion.predicate) : items;
+      const passed = matching.length > 0;
+      return {
+        criterionId: criterion.id,
+        status: passed ? "pass" : "fail",
+        confidence: 1,
+        explanation: passed ? `"${assertion.subject}" is ${assertion.predicate ?? "in expected state"}` : `"${assertion.subject}" is not ${assertion.predicate ?? "in expected state"}`
+      };
+    }
+    case "comparison": {
+      return {
+        criterionId: criterion.id,
+        status: "fail",
+        confidence: 0.3,
+        explanation: `Comparison assertion type not fully implemented for: "${criterion.description}"`
+      };
+    }
+  }
+}
+function evaluateCount(criterionId, type, expected, actual, subject, predicate) {
+  const subjectDesc = predicate ? `${subject} ${predicate}` : subject;
+  switch (type) {
+    case "exact_count": {
+      const passed = actual === expected;
+      return {
+        criterionId,
+        status: passed ? "pass" : "fail",
+        confidence: 1,
+        explanation: passed ? `Found exactly ${expected} ${subjectDesc}` : `Expected exactly ${expected} ${subjectDesc}, found ${actual}`
+      };
+    }
+    case "min_count": {
+      const passed = actual >= expected;
+      return {
+        criterionId,
+        status: passed ? "pass" : "fail",
+        confidence: 1,
+        explanation: passed ? `Found ${actual} ${subjectDesc} (>= ${expected})` : `Expected at least ${expected} ${subjectDesc}, found ${actual}`
+      };
+    }
+    case "max_count": {
+      const passed = actual <= expected;
+      return {
+        criterionId,
+        status: passed ? "pass" : "fail",
+        confidence: 1,
+        explanation: passed ? `Found ${actual} ${subjectDesc} (<= ${expected})` : `Expected at most ${expected} ${subjectDesc}, found ${actual}`
+      };
+    }
+  }
+}
+
+// src/evaluator/llm-judge.ts
+import Anthropic from "@anthropic-ai/sdk";
+var SYSTEM_PROMPT = `You are an evaluator for AI agent testing. You assess whether an agent successfully met a specific success criterion during a scenario run.
+
+You will receive:
+1. A success criterion to evaluate
+2. The expected behavior description
+3. The state of the digital twin before the agent ran
+4. The state of the digital twin after the agent ran
+5. A diff of state changes
+6. The complete trace of tool calls the agent made
+
+Your job is to determine if the criterion was met. Respond ONLY with valid JSON in this exact format:
+
+{
+  "status": "pass" | "fail" | "partial",
+  "confidence": <number between 0 and 1>,
+  "explanation": "<brief explanation of your assessment>"
+}
+
+Rules:
+- "pass" means the criterion is clearly satisfied
+- "fail" means the criterion is clearly not satisfied
+- "partial" means the criterion is partially satisfied or the evidence is ambiguous
+- confidence is how certain you are in your assessment (1.0 = completely certain, 0.5 = uncertain)
+- Keep explanations concise (1-2 sentences)
+- Focus on observable evidence in the state and trace, not assumptions
+- If the criterion is about quality or helpfulness, assess based on content present in the state`;
+function buildUserPrompt(context) {
+  const traceFormatted = context.trace.map((entry) => ({
+    tool: entry.toolName,
+    input: entry.input,
+    output: entry.output,
+    error: entry.error,
+    durationMs: entry.durationMs
+  }));
+  const traceSummary = context.trace.length > 50 ? `(Showing first 25 and last 25 of ${context.trace.length} total calls)` : "";
+  const traceToShow = context.trace.length > 50 ? [...traceFormatted.slice(0, 25), { note: `... ${context.trace.length - 50} calls omitted ...` }, ...traceFormatted.slice(-25)] : traceFormatted;
+  return `## Success Criterion
+${context.criterion.description}
+
+## Expected Behavior
+${context.expectedBehavior}
+
+## State Before
+${JSON.stringify(summarizeState(context.stateBefore), null, 2)}
+
+## State After
+${JSON.stringify(summarizeState(context.stateAfter), null, 2)}
+
+## State Diff
+${JSON.stringify(context.stateDiff, null, 2)}
+
+## Agent Trace ${traceSummary}
+${JSON.stringify(traceToShow, null, 2)}`;
+}
+function summarizeState(state) {
+  const summary = {};
+  for (const [key, value] of Object.entries(state)) {
+    if (Array.isArray(value)) {
+      if (value.length <= 10) {
+        summary[key] = value;
+      } else {
+        summary[key] = {
+          _count: value.length,
+          _first3: value.slice(0, 3),
+          _last3: value.slice(-3)
+        };
+      }
+    } else {
+      summary[key] = value;
+    }
+  }
+  return summary;
+}
+function parseJudgeResponse(text) {
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (!jsonMatch) {
+    warn("LLM judge did not return valid JSON, defaulting to fail");
+    return {
+      status: "fail",
+      confidence: 0.3,
+      explanation: "Could not parse evaluator response"
+    };
+  }
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    const status = parsed["status"];
+    if (status !== "pass" && status !== "fail" && status !== "partial") {
+      return {
+        status: "fail",
+        confidence: 0.3,
+        explanation: `Invalid status from evaluator: ${String(status)}`
+      };
+    }
+    const confidence = typeof parsed["confidence"] === "number" ? Math.max(0, Math.min(1, parsed["confidence"])) : 0.5;
+    const explanation = typeof parsed["explanation"] === "string" ? parsed["explanation"] : "No explanation provided";
+    return { status, confidence, explanation };
+  } catch {
+    warn("Failed to parse LLM judge JSON response");
+    return {
+      status: "fail",
+      confidence: 0.3,
+      explanation: "Could not parse evaluator response JSON"
+    };
+  }
+}
+var clientInstance = null;
+function getClient(apiKey) {
+  if (!clientInstance) {
+    clientInstance = new Anthropic({ apiKey });
+  }
+  return clientInstance;
+}
+async function evaluateWithLlm(criterion, expectedBehavior, stateBefore, stateAfter, stateDiff, trace, options) {
+  const context = {
+    criterion,
+    expectedBehavior,
+    stateBefore,
+    stateAfter,
+    stateDiff,
+    trace
+  };
+  if (!options.apiKey) {
+    error("No API key provided for LLM evaluation");
+    return {
+      criterionId: criterion.id,
+      status: "fail",
+      confidence: 0,
+      explanation: "No ANTHROPIC_API_KEY configured for probabilistic evaluation"
+    };
+  }
+  const client = getClient(options.apiKey);
+  const userPrompt = buildUserPrompt(context);
+  debug("Calling LLM judge", {
+    criterion: criterion.id,
+    model: options.model,
+    traceLength: String(trace.length)
+  });
+  try {
+    const response = await client.messages.create({
+      model: options.model,
+      max_tokens: 512,
+      system: SYSTEM_PROMPT,
+      messages: [
+        {
+          role: "user",
+          content: userPrompt
+        }
+      ]
+    });
+    const textBlock = response.content.find((block) => block.type === "text");
+    if (!textBlock || textBlock.type !== "text") {
+      return {
+        criterionId: criterion.id,
+        status: "fail",
+        confidence: 0.3,
+        explanation: "LLM returned no text content"
+      };
+    }
+    const judgeResult = parseJudgeResponse(textBlock.text);
+    debug("LLM judge result", {
+      criterion: criterion.id,
+      status: judgeResult.status,
+      confidence: judgeResult.confidence.toFixed(2)
+    });
+    return {
+      criterionId: criterion.id,
+      status: judgeResult.status,
+      confidence: judgeResult.confidence,
+      explanation: judgeResult.explanation
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    error(`LLM judge call failed: ${message}`);
+    return {
+      criterionId: criterion.id,
+      status: "fail",
+      confidence: 0,
+      explanation: `LLM evaluation failed: ${message}`
+    };
+  }
+}
+
+// src/evaluator/evaluator.ts
+function calculateOverallScore(evaluations) {
+  if (evaluations.length === 0) return 0;
+  let totalScore = 0;
+  for (const evaluation of evaluations) {
+    switch (evaluation.status) {
+      case "pass":
+        totalScore += 100;
+        break;
+      case "partial":
+        totalScore += 50 * evaluation.confidence;
+        break;
+      case "fail":
+        totalScore += 0;
+        break;
+    }
+  }
+  return totalScore / evaluations.length;
+}
+async function evaluateRun(criteria, context, config) {
+  const evaluations = [];
+  const deterministicCriteria = criteria.filter((c) => c.type === "deterministic");
+  const probabilisticCriteria = criteria.filter((c) => c.type === "probabilistic");
+  info("Evaluating criteria", {
+    total: String(criteria.length),
+    deterministic: String(deterministicCriteria.length),
+    probabilistic: String(probabilisticCriteria.length)
+  });
+  for (const criterion of deterministicCriteria) {
+    progress(`Evaluating [D] ${criterion.description}`);
+    const result = evaluateDeterministic(criterion, {
+      before: context.stateBefore,
+      after: context.stateAfter,
+      diff: context.stateDiff,
+      trace: context.trace
+    });
+    evaluations.push(result);
+    debug("Deterministic evaluation", {
+      criterion: criterion.id,
+      status: result.status
+    });
+  }
+  for (const criterion of probabilisticCriteria) {
+    progress(`Evaluating [P] ${criterion.description}`);
+    const result = await evaluateWithLlm(
+      criterion,
+      context.expectedBehavior,
+      context.stateBefore,
+      context.stateAfter,
+      context.stateDiff,
+      context.trace,
+      { apiKey: config.apiKey, model: config.model }
+    );
+    evaluations.push(result);
+    debug("Probabilistic evaluation", {
+      criterion: criterion.id,
+      status: result.status,
+      confidence: result.confidence.toFixed(2)
+    });
+  }
+  evaluations.sort((a, b) => {
+    const aIdx = criteria.findIndex((c) => c.id === a.criterionId);
+    const bIdx = criteria.findIndex((c) => c.id === b.criterionId);
+    return aIdx - bIdx;
+  });
+  const overallScore = calculateOverallScore(evaluations);
+  info("Evaluation complete", {
+    overallScore: overallScore.toFixed(1) + "%",
+    passed: String(evaluations.filter((e) => e.status === "pass").length),
+    failed: String(evaluations.filter((e) => e.status === "fail").length),
+    partial: String(evaluations.filter((e) => e.status === "partial").length)
+  });
+  return { evaluations, overallScore };
+}
+function aggregateSatisfaction(runScores) {
+  if (runScores.length === 0) return 0;
+  const avg = runScores.reduce((sum, score) => sum + score, 0) / runScores.length;
+  return Math.round(avg * 10) / 10;
+}
+function generateSummary(evaluations, satisfactionScore) {
+  const totalRuns = evaluations.length;
+  const allCriteria = /* @__PURE__ */ new Map();
+  for (const runEvals of evaluations) {
+    for (const evaluation of runEvals) {
+      const existing = allCriteria.get(evaluation.criterionId) ?? { passed: 0, failed: 0, partial: 0 };
+      if (evaluation.status === "pass") existing.passed++;
+      else if (evaluation.status === "fail") existing.failed++;
+      else existing.partial++;
+      allCriteria.set(evaluation.criterionId, existing);
+    }
+  }
+  const consistentlyPassing = [];
+  const consistentlyFailing = [];
+  const flaky = [];
+  for (const [criterionId, counts] of allCriteria.entries()) {
+    if (counts.passed === totalRuns) {
+      consistentlyPassing.push(criterionId);
+    } else if (counts.failed === totalRuns) {
+      consistentlyFailing.push(criterionId);
+    } else {
+      flaky.push(criterionId);
+    }
+  }
+  const parts = [];
+  parts.push(`Satisfaction: ${satisfactionScore.toFixed(1)}% across ${totalRuns} runs.`);
+  if (consistentlyPassing.length > 0) {
+    parts.push(`Consistently passing: ${consistentlyPassing.join(", ")}.`);
+  }
+  if (consistentlyFailing.length > 0) {
+    parts.push(`Consistently failing: ${consistentlyFailing.join(", ")}.`);
+  }
+  if (flaky.length > 0) {
+    parts.push(`Non-deterministic: ${flaky.join(", ")}.`);
+  }
+  return parts.join(" ");
+}
+
+// src/telemetry/recorder.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync5, readdirSync, existsSync as existsSync4 } from "fs";
+import { join as join3 } from "path";
+import { randomUUID } from "crypto";
+
+// src/config/config.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync3 } from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+import { z } from "zod";
+var ARCHAL_DIR_NAME = ".archal";
+var CONFIG_FILE_NAME = "config.json";
+var evaluatorConfigSchema = z.object({
+  model: z.string().default("claude-sonnet-4-20250514"),
+  apiKey: z.string().default("env:ANTHROPIC_API_KEY")
+});
+var defaultsConfigSchema = z.object({
+  runs: z.number().int().positive().default(5),
+  timeout: z.number().int().positive().default(120)
+});
+var configFileSchema = z.object({
+  telemetry: z.boolean().default(false),
+  evaluator: evaluatorConfigSchema.default({}),
+  defaults: defaultsConfigSchema.default({})
+});
+function getArchalDir() {
+  return join2(homedir(), ARCHAL_DIR_NAME);
+}
+function getConfigPath() {
+  return join2(getArchalDir(), CONFIG_FILE_NAME);
+}
+function ensureArchalDir() {
+  const dir = getArchalDir();
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
+    debug("Created archal directory", { path: dir });
+  }
+  return dir;
+}
+function loadConfigFile() {
+  const configPath = getConfigPath();
+  if (!existsSync3(configPath)) {
+    debug("No config file found, using defaults", { path: configPath });
+    return configFileSchema.parse({});
+  }
+  try {
+    const raw = readFileSync4(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const config = configFileSchema.parse(parsed);
+    debug("Loaded config file", { path: configPath });
+    return config;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`Failed to parse config file at ${configPath}: ${message}`);
+    return configFileSchema.parse({});
+  }
+}
+function resolveApiKey(apiKeyConfig) {
+  if (apiKeyConfig.startsWith("env:")) {
+    const envVar = apiKeyConfig.slice(4);
+    return process.env[envVar] ?? "";
+  }
+  return apiKeyConfig;
+}
+function loadConfig() {
+  const file = loadConfigFile();
+  const envTelemetry = process.env["ARCHAL_TELEMETRY"];
+  const envModel = process.env["ARCHAL_MODEL"];
+  const envRuns = process.env["ARCHAL_RUNS"];
+  const envTimeout = process.env["ARCHAL_TIMEOUT"];
+  const envApiKey = process.env["ANTHROPIC_API_KEY"];
+  const telemetry = envTelemetry !== void 0 ? envTelemetry === "true" : file.telemetry;
+  const model = envModel ?? file.evaluator.model;
+  const runs = envRuns !== void 0 ? parseInt(envRuns, 10) : file.defaults.runs;
+  const timeout = envTimeout !== void 0 ? parseInt(envTimeout, 10) : file.defaults.timeout;
+  const apiKey = envApiKey ?? resolveApiKey(file.evaluator.apiKey);
+  return {
+    telemetry,
+    apiKey,
+    model,
+    runs: Number.isNaN(runs) ? 5 : runs,
+    timeout: Number.isNaN(timeout) ? 120 : timeout,
+    archalDir: getArchalDir(),
+    configPath: getConfigPath()
+  };
+}
+function saveConfig(config) {
+  const dir = ensureArchalDir();
+  const configPath = join2(dir, CONFIG_FILE_NAME);
+  let existing;
+  if (existsSync3(configPath)) {
+    try {
+      const raw = readFileSync4(configPath, "utf-8");
+      existing = configFileSchema.parse(JSON.parse(raw));
+    } catch {
+      existing = configFileSchema.parse({});
+    }
+  } else {
+    existing = configFileSchema.parse({});
+  }
+  const merged = {
+    telemetry: config.telemetry ?? existing.telemetry,
+    evaluator: {
+      ...existing.evaluator,
+      ...config.evaluator
+    },
+    defaults: {
+      ...existing.defaults,
+      ...config.defaults
+    }
+  };
+  writeFileSync2(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  debug("Saved config file", { path: configPath });
+}
+function initConfig() {
+  const configPath = getConfigPath();
+  if (existsSync3(configPath)) {
+    warn(`Config file already exists at ${configPath}`);
+    return configPath;
+  }
+  const defaultConfig = configFileSchema.parse({});
+  ensureArchalDir();
+  writeFileSync2(configPath, JSON.stringify(defaultConfig, null, 2) + "\n", "utf-8");
+  return configPath;
+}
+function setConfigValue(key, value) {
+  const file = loadConfigFile();
+  const parts = key.split(".");
+  if (parts.length === 1) {
+    const topKey = parts[0];
+    if (topKey === "telemetry") {
+      saveConfig({ ...file, telemetry: value === "true" });
+      return;
+    }
+  }
+  if (parts.length === 2) {
+    const [section, prop] = parts;
+    if (section === "evaluator" && (prop === "model" || prop === "apiKey")) {
+      saveConfig({
+        ...file,
+        evaluator: { ...file.evaluator, [prop]: value }
+      });
+      return;
+    }
+    if (section === "defaults" && (prop === "runs" || prop === "timeout")) {
+      const numValue = parseInt(value, 10);
+      if (Number.isNaN(numValue) || numValue <= 0) {
+        throw new Error(`Invalid numeric value for ${key}: ${value}`);
+      }
+      saveConfig({
+        ...file,
+        defaults: { ...file.defaults, [prop]: numValue }
+      });
+      return;
+    }
+  }
+  throw new Error(
+    `Unknown config key: "${key}". Valid keys: telemetry, evaluator.model, evaluator.apiKey, defaults.runs, defaults.timeout`
+  );
+}
+function getConfigDisplay() {
+  const resolved = loadConfig();
+  return {
+    telemetry: resolved.telemetry,
+    evaluator: {
+      model: resolved.model,
+      apiKey: resolved.apiKey ? "***" + resolved.apiKey.slice(-4) : "(not set)"
+    },
+    defaults: {
+      runs: resolved.runs,
+      timeout: resolved.timeout
+    },
+    paths: {
+      archalDir: resolved.archalDir,
+      configFile: resolved.configPath
+    }
+  };
+}
+
+// src/telemetry/recorder.ts
+var TRACES_DIR = "traces";
+var MAX_STORED_TRACES = 100;
+function getTracesDir() {
+  return join3(getArchalDir(), TRACES_DIR);
+}
+function ensureTracesDir() {
+  const dir = getTracesDir();
+  if (!existsSync4(dir)) {
+    ensureArchalDir();
+    mkdirSync2(dir, { recursive: true });
+    debug("Created traces directory", { path: dir });
+  }
+  return dir;
+}
+function traceFilePath(traceId) {
+  return join3(getTracesDir(), `${traceId}.json`);
+}
+function recordTrace(report) {
+  const traceId = randomUUID();
+  const dir = ensureTracesDir();
+  const allEntries = [];
+  for (const run of report.runs) {
+    allEntries.push(...run.trace);
+  }
+  const stored = {
+    id: traceId,
+    scenarioTitle: report.scenarioTitle,
+    timestamp: report.timestamp,
+    satisfactionScore: report.satisfactionScore,
+    runCount: report.runs.length,
+    entries: allEntries,
+    report
+  };
+  const filePath = traceFilePath(traceId);
+  writeFileSync3(filePath, JSON.stringify(stored, null, 2), "utf-8");
+  debug("Recorded trace", { id: traceId, path: filePath, entries: String(allEntries.length) });
+  pruneOldTraces(dir);
+  return traceId;
+}
+function pruneOldTraces(dir) {
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(".json")).sort().reverse();
+    if (files.length > MAX_STORED_TRACES) {
+      const toRemove = files.slice(MAX_STORED_TRACES);
+      const { unlinkSync: unlinkSync2 } = __require("fs");
+      for (const file of toRemove) {
+        try {
+          unlinkSync2(join3(dir, file));
+          debug("Pruned old trace", { file });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+function loadTrace(traceId) {
+  const filePath = traceFilePath(traceId);
+  if (!existsSync4(filePath)) {
+    const partialMatch = findTraceByPrefix(traceId);
+    if (partialMatch) {
+      return loadTraceByPath(traceFilePath(partialMatch));
+    }
+    return null;
+  }
+  return loadTraceByPath(filePath);
+}
+function loadTraceByPath(filePath) {
+  try {
+    const raw = readFileSync5(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`Failed to load trace: ${message}`);
+    return null;
+  }
+}
+function findTraceByPrefix(prefix) {
+  const dir = getTracesDir();
+  if (!existsSync4(dir)) return null;
+  const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+  for (const file of files) {
+    const id = file.replace(".json", "");
+    if (id.startsWith(prefix)) {
+      return id;
+    }
+  }
+  return null;
+}
+function listTraces(limit = 20) {
+  const dir = getTracesDir();
+  if (!existsSync4(dir)) return [];
+  const files = readdirSync(dir).filter((f) => f.endsWith(".json")).sort().reverse().slice(0, limit);
+  const results = [];
+  for (const file of files) {
+    try {
+      const raw = readFileSync5(join3(dir, file), "utf-8");
+      const stored = JSON.parse(raw);
+      results.push({
+        id: stored.id,
+        scenarioTitle: stored.scenarioTitle,
+        timestamp: stored.timestamp,
+        satisfactionScore: stored.satisfactionScore,
+        runCount: stored.runCount,
+        entryCount: stored.entries.length
+      });
+    } catch {
+      debug(`Skipping corrupted trace file: ${file}`);
+    }
+  }
+  return results;
+}
+function exportTraceAsJson(traceId) {
+  const trace = loadTrace(traceId);
+  if (!trace) return null;
+  return JSON.stringify(trace, null, 2);
+}
+
+// src/telemetry/anonymizer.ts
+import { createHash } from "crypto";
+var API_KEY_PATTERNS = [
+  /(?:api[_-]?key|token|secret|password|authorization|bearer)\s*[:=]\s*["']?([a-zA-Z0-9_\-/.+=]{16,})["']?/gi,
+  /sk-[a-zA-Z0-9]{20,}/g,
+  /ghp_[a-zA-Z0-9]{36}/g,
+  /gho_[a-zA-Z0-9]{36}/g,
+  /xoxb-[a-zA-Z0-9-]+/g,
+  /xoxp-[a-zA-Z0-9-]+/g,
+  /xoxa-[a-zA-Z0-9-]+/g,
+  /glpat-[a-zA-Z0-9_-]{20}/g,
+  /Bearer\s+[a-zA-Z0-9_\-/.+=]{20,}/gi
+];
+var EMAIL_PATTERN = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+var USERNAME_FIELDS = /* @__PURE__ */ new Set([
+  "username",
+  "user",
+  "author",
+  "assignee",
+  "reviewer",
+  "creator",
+  "sender",
+  "recipient",
+  "login",
+  "owner",
+  "requester",
+  "reporter",
+  "committer",
+  "name",
+  "full_name",
+  "display_name",
+  "real_name"
+]);
+var PASSTHROUGH_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "type",
+  "state",
+  "status",
+  "created_at",
+  "updated_at",
+  "timestamp",
+  "number",
+  "count",
+  "merged",
+  "closed",
+  "draft",
+  "locked",
+  "private",
+  "public",
+  "archived"
+]);
+function hashValue(value, salt = "archal") {
+  const hash = createHash("sha256").update(`${salt}:${value}`).digest("hex");
+  return `anon_${hash.slice(0, 12)}`;
+}
+function stripApiKeys(text) {
+  let result = text;
+  for (const pattern of API_KEY_PATTERNS) {
+    result = result.replace(pattern, "[REDACTED_KEY]");
+  }
+  return result;
+}
+function anonymizeEmails(text) {
+  return text.replace(EMAIL_PATTERN, (email) => {
+    const domain = email.split("@")[1] ?? "unknown";
+    return `${hashValue(email)}@${domain}`;
+  });
+}
+function isUsernameField(key) {
+  const lower = key.toLowerCase();
+  return USERNAME_FIELDS.has(lower);
+}
+function shouldPassthrough(key) {
+  const lower = key.toLowerCase();
+  return PASSTHROUGH_FIELDS.has(lower);
+}
+function anonymizeValue(key, value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "string") {
+    if (shouldPassthrough(key)) return value;
+    let result = stripApiKeys(value);
+    result = anonymizeEmails(result);
+    if (isUsernameField(key)) {
+      return hashValue(result);
+    }
+    return result;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, idx) => anonymizeValue(`${key}[${idx}]`, item));
+  }
+  if (typeof value === "object") {
+    return anonymizeObject(value);
+  }
+  return value;
+}
+function anonymizeObject(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    result[key] = anonymizeValue(key, value);
+  }
+  return result;
+}
+function anonymizeTraceEntry(entry) {
+  return {
+    ...entry,
+    input: anonymizeObject(entry.input),
+    output: typeof entry.output === "object" && entry.output !== null ? anonymizeObject(entry.output) : entry.output,
+    error: entry.error ? {
+      ...entry.error,
+      message: stripApiKeys(entry.error.message),
+      details: entry.error.details !== void 0 ? typeof entry.error.details === "object" && entry.error.details !== null ? anonymizeObject(entry.error.details) : entry.error.details : void 0
+    } : null
+  };
+}
+function anonymizeTrace(entries) {
+  debug("Anonymizing trace", { entryCount: String(entries.length) });
+  return entries.map(anonymizeTraceEntry);
+}
+
+// src/telemetry/uploader.ts
+var ARCHAL_CLOUD_ENDPOINT = "https://api.archal.dev/v1/traces";
+var BATCH_SIZE = 50;
+function isTelemetryEnabled() {
+  const config = loadConfig();
+  return config.telemetry;
+}
+function buildMetadata(report) {
+  const twinNames = /* @__PURE__ */ new Set();
+  for (const run of report.runs) {
+    for (const entry of run.trace) {
+      const twinPrefix = entry.toolName.split("_")[0];
+      if (twinPrefix) {
+        twinNames.add(twinPrefix);
+      }
+    }
+  }
+  return {
+    cliVersion: "0.1.0",
+    nodeVersion: process.version,
+    platform: process.platform,
+    twinNames: Array.from(twinNames),
+    criteriaCount: report.runs[0]?.evaluations.length ?? 0
+  };
+}
+function batchEntries(entries) {
+  const batches = [];
+  for (let i = 0; i < entries.length; i += BATCH_SIZE) {
+    batches.push(entries.slice(i, i + BATCH_SIZE));
+  }
+  return batches;
+}
+async function uploadTrace(traceId, report) {
+  if (!isTelemetryEnabled()) {
+    debug("Telemetry is disabled, skipping upload");
+    return {
+      success: false,
+      message: "Telemetry is disabled. Enable with: archal config set telemetry true"
+    };
+  }
+  const allEntries = [];
+  for (const run of report.runs) {
+    allEntries.push(...run.trace);
+  }
+  const anonymizedEntries = anonymizeTrace(allEntries);
+  const metadata = buildMetadata(report);
+  const batches = batchEntries(anonymizedEntries);
+  info(`Preparing to upload trace ${traceId}`, {
+    entries: String(anonymizedEntries.length),
+    batches: String(batches.length)
+  });
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i];
+    const payload = {
+      traceId: `${traceId}${batches.length > 1 ? `-batch-${i + 1}` : ""}`,
+      scenarioTitle: report.scenarioTitle,
+      satisfactionScore: report.satisfactionScore,
+      runCount: report.runs.length,
+      timestamp: report.timestamp,
+      entries: batch,
+      metadata
+    };
+    const result = await sendBatch(payload, i + 1, batches.length);
+    if (!result.success) {
+      return result;
+    }
+  }
+  return {
+    success: true,
+    message: `Trace ${traceId} uploaded successfully (${anonymizedEntries.length} entries in ${batches.length} batch(es))`,
+    traceId
+  };
+}
+async function sendBatch(payload, batchNum, totalBatches) {
+  debug(`Uploading batch ${batchNum}/${totalBatches}`, {
+    entries: String(payload.entries.length),
+    endpoint: ARCHAL_CLOUD_ENDPOINT
+  });
+  info(`[Telemetry stub] Would send batch ${batchNum}/${totalBatches} to ${ARCHAL_CLOUD_ENDPOINT}`, {
+    traceId: payload.traceId,
+    scenario: payload.scenarioTitle,
+    entries: String(payload.entries.length),
+    satisfaction: payload.satisfactionScore.toFixed(1) + "%"
+  });
+  info(`[Telemetry stub] Payload size: ${JSON.stringify(payload).length} bytes`);
+  return {
+    success: true,
+    message: `Batch ${batchNum}/${totalBatches} sent`,
+    traceId: payload.traceId
+  };
+}
+async function uploadIfEnabled(traceId, report) {
+  if (!isTelemetryEnabled()) {
+    return;
+  }
+  try {
+    const result = await uploadTrace(traceId, report);
+    if (result.success) {
+      info("Telemetry uploaded", { traceId });
+    } else {
+      warn(`Telemetry upload skipped: ${result.message}`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`Telemetry upload failed: ${message}`);
+  }
+}
+
+// src/runner/orchestrator.ts
+function computeStateDiff(before, after) {
+  const diff = { added: {}, modified: {}, removed: {} };
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of allKeys) {
+    const beforeVal = before[key];
+    const afterVal = after[key];
+    if (beforeVal === void 0 && afterVal !== void 0) {
+      diff.added[key] = Array.isArray(afterVal) ? afterVal : [afterVal];
+    } else if (beforeVal !== void 0 && afterVal === void 0) {
+      diff.removed[key] = Array.isArray(beforeVal) ? beforeVal.map((item) => item.id ?? 0) : [0];
+    } else if (JSON.stringify(beforeVal) !== JSON.stringify(afterVal)) {
+      diff.modified[key] = Array.isArray(afterVal) ? afterVal : [afterVal];
+    }
+  }
+  return diff;
+}
+async function executeSingleRun(runIndex, scenario, agentConfig, seedSelections, evaluatorConfig, timeoutSeconds, rateLimit) {
+  const startTime = Date.now();
+  const runId = `archal-run-${runIndex}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  info(`Starting run ${runIndex + 1}`, { scenario: scenario.title });
+  const twinConfigs = seedSelections.map((sel) => ({
+    twinName: sel.twinName,
+    seedName: sel.seedName,
+    rateLimitMax: rateLimit
+  }));
+  try {
+    progress("Capturing seed state...");
+    const { beforeState, twinPaths: seedPaths } = await captureSeedState(twinConfigs);
+    const { configPath: mcpConfigPath, twinPaths } = writeMcpConfig(twinConfigs, runId);
+    const mcpConfigData = JSON.parse(readFileSync6(mcpConfigPath, "utf-8"));
+    const mcpServersJson = JSON.stringify(mcpConfigData.mcpServers);
+    const twinNames = twinConfigs.map((c) => c.twinName);
+    const agentResult = await executeAgent(
+      agentConfig,
+      mcpConfigPath,
+      mcpServersJson,
+      twinNames,
+      timeoutSeconds * 1e3
+    );
+    const stateAfter = collectStateFromFiles(twinPaths);
+    const trace = collectTraceFromFiles(twinPaths);
+    const diff = computeStateDiff(beforeState, stateAfter);
+    cleanupTempFiles(mcpConfigPath, twinPaths, seedPaths);
+    if (agentResult.timedOut) {
+      const durationMs2 = Date.now() - startTime;
+      return {
+        runIndex,
+        evaluations: scenario.successCriteria.map((c) => ({
+          criterionId: c.id,
+          status: "fail",
+          confidence: 1,
+          explanation: `Agent timed out after ${timeoutSeconds}s`
+        })),
+        overallScore: 0,
+        trace,
+        durationMs: durationMs2,
+        error: `Agent timed out after ${timeoutSeconds}s`
+      };
+    }
+    if (agentResult.exitCode !== 0 && agentResult.exitCode !== null) {
+      warn(`Agent exited with non-zero code ${agentResult.exitCode} on run ${runIndex + 1}`);
+    }
+    progress(`Evaluating run ${runIndex + 1}...`);
+    const evaluationResult = await evaluateRun(
+      scenario.successCriteria,
+      {
+        expectedBehavior: scenario.expectedBehavior,
+        stateBefore: beforeState,
+        stateAfter,
+        stateDiff: diff,
+        trace
+      },
+      evaluatorConfig
+    );
+    const durationMs = Date.now() - startTime;
+    return {
+      runIndex,
+      evaluations: evaluationResult.evaluations,
+      overallScore: evaluationResult.overallScore,
+      trace,
+      durationMs
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    error(`Run ${runIndex + 1} failed: ${message}`);
+    const durationMs = Date.now() - startTime;
+    return {
+      runIndex,
+      evaluations: scenario.successCriteria.map((c) => ({
+        criterionId: c.id,
+        status: "fail",
+        confidence: 1,
+        explanation: `Run failed: ${message}`
+      })),
+      overallScore: 0,
+      trace: [],
+      durationMs,
+      error: message
+    };
+  }
+}
+async function runScenario(options) {
+  const config = loadConfig();
+  const numRuns = options.runs ?? config.runs;
+  const timeoutSeconds = options.timeout ?? config.timeout;
+  const model = options.model ?? config.model;
+  const outputFormat = options.output ?? "terminal";
+  banner(`Archal: ${options.scenarioPath}`);
+  const scenario = parseScenarioFile(options.scenarioPath);
+  info(`Scenario: ${scenario.title}`, {
+    criteria: String(scenario.successCriteria.length),
+    twins: scenario.config.twins.join(", "),
+    runs: String(numRuns),
+    timeout: `${timeoutSeconds}s`
+  });
+  let seedSelections = generateSeedSelections(scenario.config.twins, scenario.setup);
+  if (options.seed) {
+    const overrides = {};
+    for (const twin of scenario.config.twins) {
+      overrides[twin] = options.seed;
+    }
+    seedSelections = overrideSeedSelection(seedSelections, overrides);
+  }
+  const scenarioDir = dirname2(resolve3(options.scenarioPath));
+  let projectConfigPath;
+  for (const dir of [scenarioDir, process.cwd()]) {
+    const candidate = resolve3(dir, ".archal.json");
+    if (existsSync5(candidate)) {
+      projectConfigPath = candidate;
+      break;
+    }
+  }
+  const agentConfig = options.agentConfig ?? resolveAgentConfig(options.agent, projectConfigPath) ?? {
+    command: process.env["ARCHAL_AGENT_COMMAND"] ?? "echo",
+    args: process.env["ARCHAL_AGENT_COMMAND"] ? [] : ["No agent command configured"]
+  };
+  if (agentConfig.command === "echo") {
+    process.stderr.write("Warning: No agent command configured. Use --agent flag, set ARCHAL_AGENT_COMMAND, or create .archal.json\n");
+  }
+  printHeader(scenario.title, seedSelections);
+  const evaluatorConfig = {
+    apiKey: config.apiKey,
+    model
+  };
+  const runs = [];
+  for (let i = 0; i < numRuns; i++) {
+    const result = await executeSingleRun(
+      i,
+      scenario,
+      agentConfig,
+      seedSelections,
+      evaluatorConfig,
+      timeoutSeconds,
+      options.rateLimit
+    );
+    runs.push(result);
+    printRunProgress(i, numRuns, result.overallScore, result.error);
+  }
+  const runScores = runs.map((r) => r.overallScore);
+  const satisfactionScore = aggregateSatisfaction(runScores);
+  const allEvaluations = runs.map((r) => r.evaluations);
+  const summary = generateSummary(allEvaluations, satisfactionScore);
+  const criterionDescriptions = {};
+  const criterionTypes = {};
+  for (const c of scenario.successCriteria) {
+    criterionDescriptions[c.id] = c.description;
+    criterionTypes[c.id] = c.type;
+  }
+  const report = {
+    scenarioTitle: scenario.title,
+    satisfactionScore,
+    criterionDescriptions,
+    criterionTypes,
+    twinNames: scenario.config.twins,
+    runs,
+    summary,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const traceId = recordTrace(report);
+  info("Trace recorded", { traceId });
+  await uploadIfEnabled(traceId, report);
+  printReport(report, outputFormat);
+  return report;
+}
+
+// src/commands/run.ts
+function createRunCommand() {
+  const cmd = new Command("run").description("Execute a scenario against digital twins").argument("<scenario>", "Path to scenario markdown file").option("-n, --runs <count>", "Number of runs", "5").option("-t, --timeout <seconds>", "Timeout per run in seconds", "120").option("-m, --model <model>", "Evaluator model for probabilistic criteria").option("-o, --output <format>", "Output format: terminal, json, junit", "terminal").option("-a, --agent <command>", "Agent command to execute").option("--seed <name>", "Override twin seed name").option("--rate-limit <count>", "Rate limit: max total requests before 429").option("-q, --quiet", "Suppress non-error output").option("-v, --verbose", "Enable debug logging").action(async (scenarioArg, opts) => {
+    if (opts.quiet) {
+      configureLogger({ quiet: true });
+    }
+    if (opts.verbose) {
+      configureLogger({ verbose: true, level: "debug" });
+    }
+    const scenarioPath = resolve4(scenarioArg);
+    if (!existsSync6(scenarioPath)) {
+      process.stderr.write(`Error: Scenario file not found: ${scenarioPath}
+`);
+      process.exit(1);
+    }
+    if (!scenarioPath.endsWith(".md")) {
+      process.stderr.write(`Error: Scenario file must be a markdown file (.md): ${scenarioPath}
+`);
+      process.exit(1);
+    }
+    const runs = parseInt(opts.runs, 10);
+    if (Number.isNaN(runs) || runs <= 0) {
+      process.stderr.write(`Error: --runs must be a positive integer
+`);
+      process.exit(1);
+    }
+    const timeout = parseInt(opts.timeout, 10);
+    if (Number.isNaN(timeout) || timeout <= 0) {
+      process.stderr.write(`Error: --timeout must be a positive integer
+`);
+      process.exit(1);
+    }
+    const validFormats = ["terminal", "json", "junit"];
+    const outputFormat = opts.output;
+    if (!validFormats.includes(outputFormat)) {
+      process.stderr.write(`Error: --output must be one of: ${validFormats.join(", ")}
+`);
+      process.exit(1);
+    }
+    if (outputFormat === "json") {
+      configureLogger({ json: true });
+    }
+    try {
+      const rateLimit = opts.rateLimit ? parseInt(opts.rateLimit, 10) : void 0;
+      const report = await runScenario({
+        scenarioPath,
+        agent: opts.agent,
+        runs,
+        timeout,
+        model: opts.model,
+        output: outputFormat,
+        seed: opts.seed,
+        rateLimit
+      });
+      if (report.satisfactionScore < 100) {
+        process.exit(1);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Error: ${message}
+`);
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/init.ts
+import { Command as Command2 } from "commander";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4, resolve as resolve5 } from "path";
+var SAMPLE_SCENARIO = `# Close Stale Issues
+
+## Setup
+
+A GitHub repository has stale issues in its backlog that need cleanup. Some issues are labeled "stale" and should be closed. Issues labeled "keep-open" must not be closed.
+
+## Expected Behavior
+
+The agent should list open issues, identify stale ones, close them with a comment, and skip any issue marked "keep-open".
+
+## Success Criteria
+
+- [D] At least 1 issue is closed
+- [D] No issues labeled "keep-open" are closed
+- [P] Comments on closed issues explain why they were closed
+
+## Config
+
+twins: github
+timeout: 60
+runs: 3
+`;
+var SAMPLE_CONFIG = `{
+  "agent": {
+    "command": "npx",
+    "args": ["tsx", "agent.ts"]
+  },
+  "runs": 3,
+  "timeout": 60
+}
+`;
+var SAMPLE_AGENT = `/**
+ * Starter agent \u2014 closes stale GitHub issues via MCP.
+ *
+ * Archal sets ARCHAL_MCP_CONFIG pointing to a JSON file with MCP server config.
+ * This agent connects to the GitHub twin, discovers the repo dynamically,
+ * lists open issues, and closes stale ones.
+ */
+
+import { readFileSync } from 'node:fs';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+
+interface McpServerConfig {
+  command: string;
+  args: string[];
+}
+
+interface McpConfig {
+  mcpServers: Record<string, McpServerConfig>;
+}
+
+interface Issue {
+  number: number;
+  title: string;
+  state: string;
+  labels: Array<{ name: string }>;
+}
+
+function parseToolResult(result: unknown): unknown {
+  const content = (result as { content: unknown }).content;
+  const text = typeof content === 'string'
+    ? content
+    : (content as Array<{ text?: string }>)[0]?.text ?? '[]';
+  return JSON.parse(text);
+}
+
+async function main(): Promise<void> {
+  // 1. Read MCP config (Archal provides this via environment variable)
+  const configPath = process.env['ARCHAL_MCP_CONFIG'];
+  if (!configPath) {
+    console.error('ARCHAL_MCP_CONFIG not set \u2014 are you running via archal run?');
+    process.exit(1);
+  }
+
+  const config: McpConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+  const serverName = Object.keys(config.mcpServers)[0];
+  if (!serverName) {
+    console.error('No MCP servers in config');
+    process.exit(1);
+  }
+
+  const serverConfig = config.mcpServers[serverName]!;
+
+  // 2. Connect to the twin via MCP stdio transport
+  const transport = new StdioClientTransport({
+    command: serverConfig.command,
+    args: serverConfig.args,
+  });
+
+  const client = new Client({ name: 'my-agent', version: '1.0.0' });
+  await client.connect(transport);
+
+  try {
+    // 3. List available tools (useful for debugging)
+    const { tools } = await client.listTools();
+    console.error(\`Connected to \${serverName}: \${tools.length} tools available\`);
+
+    // 4. Discover the repository dynamically
+    const repoResult = await client.callTool({
+      name: 'search_repositories',
+      arguments: { query: ' ' },
+    });
+    const repos = parseToolResult(repoResult) as { items: Array<{ full_name: string }> };
+    const firstRepo = repos.items[0];
+    if (!firstRepo) {
+      console.error('No repositories found');
+      process.exit(1);
+    }
+    const [owner, repo] = firstRepo.full_name.split('/');
+    console.error(\`Found repo: \${owner}/\${repo}\`);
+
+    // 5. List all open issues
+    const listResult = await client.callTool({
+      name: 'list_issues',
+      arguments: { owner, repo, state: 'open' },
+    });
+    const issues = parseToolResult(listResult) as Issue[];
+
+    // 6. Close stale issues (skip keep-open)
+    for (const issue of issues) {
+      const labelNames = issue.labels.map((l) => l.name);
+
+      if (!labelNames.includes('stale')) continue;
+      if (labelNames.includes('keep-open')) {
+        console.error(\`Skipping #\${issue.number} \u2014 labeled keep-open\`);
+        continue;
+      }
+
+      // Post a comment explaining closure
+      await client.callTool({
+        name: 'add_issue_comment',
+        arguments: {
+          owner,
+          repo,
+          issue_number: issue.number,
+          body: 'Closing as stale. Reopen if still relevant.',
+        },
+      });
+
+      // Close the issue
+      await client.callTool({
+        name: 'update_issue',
+        arguments: {
+          owner,
+          repo,
+          issue_number: issue.number,
+          state: 'closed',
+        },
+      });
+
+      console.error(\`Closed #\${issue.number} "\${issue.title}"\`);
+    }
+  } finally {
+    await client.close();
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+`;
+var SAMPLE_PACKAGE_JSON = `{
+  "type": "module",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.4.0"
+  },
+  "devDependencies": {
+    "tsx": "^4.19.0"
+  }
+}
+`;
+function writeIfMissing(filePath, content) {
+  if (!existsSync7(filePath)) {
+    writeFileSync4(filePath, content);
+    info(`Created ${filePath}`);
+  } else {
+    info(`Skipped ${filePath} (already exists)`);
+  }
+}
+function createInitCommand() {
+  const cmd = new Command2("init").description("Initialize an Archal test directory with sample scenario and agent").argument("[directory]", "Directory to initialize", "archal").action((directory) => {
+    const targetDir = resolve5(directory);
+    if (existsSync7(targetDir)) {
+      warn(`Directory already exists: ${targetDir}`);
+      warn("Skipping files that already exist.");
+    } else {
+      mkdirSync3(targetDir, { recursive: true });
+    }
+    writeIfMissing(join4(targetDir, "scenario.md"), SAMPLE_SCENARIO);
+    writeIfMissing(join4(targetDir, ".archal.json"), SAMPLE_CONFIG);
+    writeIfMissing(join4(targetDir, "agent.ts"), SAMPLE_AGENT);
+    writeIfMissing(join4(targetDir, "package.json"), SAMPLE_PACKAGE_JSON);
+    success("Archal initialized. Next steps:");
+    process.stderr.write(`
+  1. cd ${directory} && npm install
+`);
+    process.stderr.write(`  2. Edit scenario.md and agent.ts to fit your use case
+`);
+    process.stderr.write(`  3. Run: archal run scenario.md
+
+`);
+  });
+  return cmd;
+}
+
+// src/commands/twin.ts
+import { Command as Command3 } from "commander";
+var runningTwins = /* @__PURE__ */ new Map();
+var KNOWN_TWINS = [
+  { name: "github", package: "@archal/twin-github", description: "GitHub digital twin" },
+  { name: "slack", package: "@archal/twin-slack", description: "Slack digital twin" }
+];
+function createTwinCommand() {
+  const cmd = new Command3("twin").description("Manage digital twin processes");
+  cmd.command("start").description("Start a digital twin process").argument("<name>", "Twin name (e.g., github, slack)").option("--seed <seed>", "Seed name to load", "small-project").option("--transport <type>", "Transport type: stdio or http", "stdio").option("--port <port>", "Port for HTTP transport").action((name, opts) => {
+    const knownTwin = KNOWN_TWINS.find((t) => t.name === name);
+    if (!knownTwin) {
+      const available = KNOWN_TWINS.map((t) => t.name).join(", ");
+      error(`Unknown twin: "${name}". Available twins: ${available}`);
+      process.exit(1);
+    }
+    if (runningTwins.has(name)) {
+      warn(`Twin "${name}" is already running (PID: ${runningTwins.get(name)?.pid ?? "unknown"})`);
+      return;
+    }
+    const args = [knownTwin.package, "--seed", opts.seed, "--transport", opts.transport];
+    if (opts.transport === "http" && opts.port) {
+      args.push("--port", opts.port);
+    }
+    info(`Starting twin: ${name}`, { seed: opts.seed, transport: opts.transport });
+    const child = spawnMcpStdioProcess({
+      command: "npx",
+      args
+    });
+    const pid = child.pid ?? 0;
+    runningTwins.set(name, {
+      name,
+      pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      process: child
+    });
+    child.on("exit", (code) => {
+      info(`Twin "${name}" exited`, { code: String(code ?? "unknown") });
+      runningTwins.delete(name);
+    });
+    success(`Twin "${name}" started (PID: ${pid})`);
+  });
+  cmd.command("stop").description("Stop a running digital twin").argument("<name>", "Twin name to stop").action(async (name) => {
+    const twin = runningTwins.get(name);
+    if (!twin) {
+      error(`Twin "${name}" is not running`);
+      const running = Array.from(runningTwins.keys());
+      if (running.length > 0) {
+        info(`Running twins: ${running.join(", ")}`);
+      }
+      process.exit(1);
+    }
+    info(`Stopping twin: ${name}`, { pid: String(twin.pid) });
+    await killProcess(twin.process);
+    runningTwins.delete(name);
+    success(`Twin "${name}" stopped`);
+  });
+  cmd.command("list").description("List available digital twins").action(() => {
+    const headers = ["Name", "Package", "Description", "Seeds"];
+    const rows = KNOWN_TWINS.map((twin) => {
+      const seeds = getAvailableSeeds(twin.name);
+      return [
+        twin.name,
+        twin.package,
+        twin.description,
+        seeds.length > 0 ? seeds.join(", ") : "(default)"
+      ];
+    });
+    table(headers, rows);
+  });
+  cmd.command("status").description("Show status of running digital twins").action(() => {
+    if (runningTwins.size === 0) {
+      info("No twins currently running");
+      return;
+    }
+    const headers = ["Name", "PID", "Started", "Status"];
+    const rows = [];
+    for (const twin of runningTwins.values()) {
+      const isAlive = twin.process.exitCode === null;
+      rows.push([
+        twin.name,
+        String(twin.pid),
+        twin.startedAt,
+        isAlive ? "running" : `exited (${twin.process.exitCode})`
+      ]);
+    }
+    table(headers, rows);
+  });
+  return cmd;
+}
+
+// src/commands/scenario.ts
+import { Command as Command4 } from "commander";
+import { existsSync as existsSync8, readdirSync as readdirSync2, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4 } from "fs";
+import { resolve as resolve6, join as join5, extname } from "path";
+var SCENARIO_TEMPLATE = `# {{NAME}}
+
+## Setup
+
+Describe the initial state of the digital twins here.
+What should exist before the agent starts?
+
+## Expected Behavior
+
+Describe what the agent should do.
+What actions should it take? What workflow should it follow?
+
+## Success Criteria
+
+- [D] Exactly N items should be created
+- [P] The agent should handle errors gracefully
+- [P] Output should be clear and well-structured
+
+## Config
+
+twins: github
+timeout: 120
+runs: 5
+`;
+function findScenarioFiles(dir) {
+  const files = [];
+  if (!existsSync8(dir)) return files;
+  const entries = readdirSync2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join5(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findScenarioFiles(fullPath));
+    } else if (entry.isFile() && extname(entry.name) === ".md") {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function findScenariosDir() {
+  const candidates = [
+    resolve6("scenarios"),
+    resolve6("test", "scenarios"),
+    resolve6(".archal", "scenarios")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync8(candidate)) {
+      return candidate;
+    }
+  }
+  return resolve6("scenarios");
+}
+function createScenarioCommand() {
+  const cmd = new Command4("scenario").description("Manage test scenarios");
+  cmd.command("list").description("List available scenarios").option("-d, --dir <directory>", "Scenario directory to search").action((opts) => {
+    const scenariosDir = opts.dir ? resolve6(opts.dir) : findScenariosDir();
+    if (!existsSync8(scenariosDir)) {
+      warn(`Scenarios directory not found: ${scenariosDir}`);
+      info("Create a scenarios directory or use --dir to specify one");
+      return;
+    }
+    const files = findScenarioFiles(scenariosDir);
+    if (files.length === 0) {
+      info("No scenario files found");
+      info(`Create one with: archal scenario create my-scenario`);
+      return;
+    }
+    const headers = ["Scenario", "Path", "Criteria", "Twins"];
+    const rows = [];
+    for (const file of files) {
+      try {
+        const scenario = parseScenarioFile(file);
+        const relativePath = file.replace(resolve6(".") + "\\", "").replace(resolve6(".") + "/", "");
+        rows.push([
+          scenario.title,
+          relativePath,
+          String(scenario.successCriteria.length),
+          scenario.config.twins.join(", ") || "(auto)"
+        ]);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const relativePath = file.replace(resolve6(".") + "\\", "").replace(resolve6(".") + "/", "");
+        rows.push([
+          `(parse error)`,
+          relativePath,
+          "-",
+          message
+        ]);
+      }
+    }
+    table(headers, rows);
+    info(`
+Found ${files.length} scenario(s) in ${scenariosDir}`);
+  });
+  cmd.command("validate").description("Parse and validate a scenario file").argument("<file>", "Path to scenario markdown file").action((file) => {
+    const filePath = resolve6(file);
+    if (!existsSync8(filePath)) {
+      error(`File not found: ${filePath}`);
+      process.exit(1);
+    }
+    try {
+      const scenario = parseScenarioFile(filePath);
+      const errors = validateScenario(scenario);
+      info(`Scenario: ${scenario.title}`);
+      info(`Setup: ${scenario.setup.slice(0, 80)}${scenario.setup.length > 80 ? "..." : ""}`);
+      info(`Expected Behavior: ${scenario.expectedBehavior.slice(0, 80)}${scenario.expectedBehavior.length > 80 ? "..." : ""}`);
+      info(`Twins: ${scenario.config.twins.join(", ") || "(none detected)"}`);
+      info(`Timeout: ${scenario.config.timeout}s`);
+      info(`Runs: ${scenario.config.runs}`);
+      process.stdout.write("\n");
+      info("Success Criteria:");
+      for (const criterion of scenario.successCriteria) {
+        const tag = criterion.type === "deterministic" ? "[D]" : "[P]";
+        info(`  ${tag} ${criterion.description}`);
+      }
+      process.stdout.write("\n");
+      if (errors.length === 0) {
+        success("Scenario is valid");
+      } else {
+        fail(`Scenario has ${errors.length} validation error(s):`);
+        for (const err of errors) {
+          error(`  - ${err}`);
+        }
+        process.exit(1);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      error(`Failed to parse scenario: ${message}`);
+      process.exit(1);
+    }
+  });
+  cmd.command("create").description("Scaffold a new scenario file").argument("<name>", "Scenario name (will be used as filename)").option("-d, --dir <directory>", "Directory to create scenario in").option("--twin <twin>", "Twin to configure (github, slack, etc.)", "github").action((name, opts) => {
+    const scenariosDir = opts.dir ? resolve6(opts.dir) : findScenariosDir();
+    if (!existsSync8(scenariosDir)) {
+      mkdirSync4(scenariosDir, { recursive: true });
+      info(`Created scenarios directory: ${scenariosDir}`);
+    }
+    const fileName = name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "") + ".md";
+    const filePath = join5(scenariosDir, fileName);
+    if (existsSync8(filePath)) {
+      error(`Scenario file already exists: ${filePath}`);
+      process.exit(1);
+    }
+    const displayName = name.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    const content = SCENARIO_TEMPLATE.replace("{{NAME}}", displayName).replace("twins: github", `twins: ${opts.twin}`);
+    writeFileSync5(filePath, content, "utf-8");
+    success(`Created scenario: ${filePath}`);
+    info(`Edit the file to define your test scenario, then run:`);
+    info(`  archal scenario validate ${filePath}`);
+    info(`  archal run ${filePath}`);
+  });
+  return cmd;
+}
+
+// src/commands/trace.ts
+import { Command as Command5 } from "commander";
+function createTraceCommand() {
+  const cmd = new Command5("trace").description("Inspect and export run traces");
+  cmd.command("list").description("List recent traces").option("-n, --limit <count>", "Number of traces to show", "20").action((opts) => {
+    const limit = parseInt(opts.limit, 10);
+    if (Number.isNaN(limit) || limit <= 0) {
+      error("--limit must be a positive integer");
+      process.exit(1);
+    }
+    const traces = listTraces(limit);
+    if (traces.length === 0) {
+      info("No traces found. Run a scenario first: archal run <scenario.md>");
+      return;
+    }
+    const headers = ["ID", "Scenario", "Score", "Runs", "Entries", "Timestamp"];
+    const rows = traces.map((t) => [
+      t.id.slice(0, 8) + "...",
+      t.scenarioTitle.length > 30 ? t.scenarioTitle.slice(0, 27) + "..." : t.scenarioTitle,
+      t.satisfactionScore.toFixed(1) + "%",
+      String(t.runCount),
+      String(t.entryCount),
+      formatTimestamp2(t.timestamp)
+    ]);
+    table(headers, rows);
+    info(`
+Showing ${traces.length} most recent trace(s)`);
+    info('Use "archal trace show <id>" to view details');
+  });
+  cmd.command("show").description("Show detailed trace information").argument("<id>", "Trace ID (full or prefix)").option("--run <index>", "Show specific run (0-indexed)").option("--entries", "Show individual trace entries").action((id, opts) => {
+    const trace = loadTrace(id);
+    if (!trace) {
+      error(`Trace not found: ${id}`);
+      info('Use "archal trace list" to see available traces');
+      process.exit(1);
+    }
+    process.stdout.write("\n");
+    info(`Trace ID:     ${trace.id}`);
+    info(`Scenario:     ${trace.scenarioTitle}`);
+    info(`Timestamp:    ${trace.timestamp}`);
+    info(`Satisfaction: ${trace.satisfactionScore.toFixed(1)}%`);
+    info(`Runs:         ${trace.runCount}`);
+    info(`Total entries: ${trace.entries.length}`);
+    process.stdout.write("\n");
+    const report = trace.report;
+    if (opts.run !== void 0) {
+      const runIndex = parseInt(opts.run, 10);
+      const run = report.runs[runIndex];
+      if (!run) {
+        error(`Run index ${runIndex} out of range (0-${report.runs.length - 1})`);
+        process.exit(1);
+      }
+      info(`--- Run ${runIndex + 1} ---`);
+      info(`Score: ${run.overallScore.toFixed(1)}%`);
+      info(`Duration: ${run.durationMs}ms`);
+      if (run.error) {
+        error(`Error: ${run.error}`);
+      }
+      process.stdout.write("\n");
+      info("Evaluations:");
+      for (const evaluation of run.evaluations) {
+        const status = evaluation.status.toUpperCase().padEnd(7);
+        info(`  [${status}] ${evaluation.criterionId}: ${evaluation.explanation} (${(evaluation.confidence * 100).toFixed(0)}% confidence)`);
+      }
+      if (opts.entries) {
+        process.stdout.write("\n");
+        info("Trace entries:");
+        for (const entry of run.trace) {
+          info(`  ${entry.timestamp} ${entry.toolName} (${entry.durationMs}ms)${entry.error ? " ERROR" : ""}`);
+          if (entry.error) {
+            info(`    Error: ${entry.error.code} - ${entry.error.message}`);
+          }
+        }
+      }
+    } else {
+      info("Runs:");
+      const runHeaders = ["Run", "Score", "Duration", "Evaluations", "Errors"];
+      const runRows = report.runs.map((run) => [
+        String(run.runIndex + 1),
+        run.overallScore.toFixed(1) + "%",
+        run.durationMs + "ms",
+        `${run.evaluations.filter((e) => e.status === "pass").length}/${run.evaluations.length} pass`,
+        run.error ?? "-"
+      ]);
+      table(runHeaders, runRows);
+      process.stdout.write("\n");
+      info(`Summary: ${report.summary}`);
+      if (opts.entries) {
+        process.stdout.write("\n");
+        info("All trace entries:");
+        const entryHeaders = ["Time", "Tool", "Duration", "Error"];
+        const entryRows = trace.entries.slice(0, 50).map((e) => [
+          formatTimestamp2(e.timestamp),
+          e.toolName,
+          e.durationMs + "ms",
+          e.error ? `${e.error.code}: ${e.error.message}` : "-"
+        ]);
+        table(entryHeaders, entryRows);
+        if (trace.entries.length > 50) {
+          info(`
+... and ${trace.entries.length - 50} more entries. Use "archal trace export ${id}" for full data.`);
+        }
+      }
+    }
+  });
+  cmd.command("export").description("Export trace as JSON").argument("<id>", "Trace ID (full or prefix)").option("-o, --output <file>", "Output file path (default: stdout)").action((id, opts) => {
+    const json = exportTraceAsJson(id);
+    if (!json) {
+      error(`Trace not found: ${id}`);
+      info('Use "archal trace list" to see available traces');
+      process.exit(1);
+    }
+    if (opts.output) {
+      const { writeFileSync: writeFileSync6 } = __require("fs");
+      const { resolve: resolve8 } = __require("path");
+      const outPath = resolve8(opts.output);
+      writeFileSync6(outPath, json, "utf-8");
+      info(`Trace exported to: ${outPath}`);
+    } else {
+      process.stdout.write(json + "\n");
+    }
+  });
+  return cmd;
+}
+function formatTimestamp2(iso) {
+  try {
+    const date = new Date(iso);
+    return date.toLocaleString();
+  } catch {
+    return iso;
+  }
+}
+
+// src/commands/config.ts
+import { Command as Command6 } from "commander";
+function createConfigCommand() {
+  const cmd = new Command6("config").description("Manage Archal configuration");
+  cmd.command("show").description("Print current configuration").option("--json", "Output as JSON").action((opts) => {
+    const display = getConfigDisplay();
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(display, null, 2) + "\n");
+      return;
+    }
+    info("Current Archal configuration:\n");
+    printConfigSection("General", {
+      telemetry: String(display["telemetry"])
+    });
+    const evaluator = display["evaluator"];
+    printConfigSection("Evaluator", {
+      model: evaluator["model"] ?? "(not set)",
+      apiKey: evaluator["apiKey"] ?? "(not set)"
+    });
+    const defaults = display["defaults"];
+    printConfigSection("Defaults", {
+      runs: String(defaults["runs"]),
+      timeout: String(defaults["timeout"]) + "s"
+    });
+    const paths = display["paths"];
+    printConfigSection("Paths", {
+      archalDir: paths["archalDir"] ?? "(unknown)",
+      configFile: paths["configFile"] ?? "(unknown)"
+    });
+    process.stdout.write("\n");
+    info("Set values with: archal config set <key> <value>");
+    info("Valid keys: telemetry, evaluator.model, evaluator.apiKey, defaults.runs, defaults.timeout");
+  });
+  cmd.command("set").description("Set a configuration value").argument("<key>", "Configuration key (e.g., evaluator.model, defaults.runs)").argument("<value>", "Value to set").action((key, value) => {
+    try {
+      setConfigValue(key, value);
+      success(`Set ${key} = ${key.includes("apiKey") ? "***" : value}`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      error(message);
+      process.exit(1);
+    }
+  });
+  cmd.command("init").description("Create default configuration file").option("--force", "Overwrite existing config").action((opts) => {
+    const configPath = getConfigPath();
+    if (opts.force) {
+      const { existsSync: existsSync10, unlinkSync: unlinkSync2 } = __require("fs");
+      if (existsSync10(configPath)) {
+        unlinkSync2(configPath);
+      }
+    }
+    try {
+      const path = initConfig();
+      success(`Configuration initialized: ${path}`);
+      info("\nNext steps:");
+      info("  1. Set your API key:");
+      info("     archal config set evaluator.apiKey your-key-here");
+      info("     or set ANTHROPIC_API_KEY environment variable");
+      info("");
+      info("  2. Create a scenario:");
+      info("     archal scenario create my-first-test");
+      info("");
+      info("  3. Run it:");
+      info("     archal run scenarios/my-first-test.md");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      error(message);
+      process.exit(1);
+    }
+  });
+  cmd.command("path").description("Print the config file path").action(() => {
+    process.stdout.write(getConfigPath() + "\n");
+  });
+  return cmd;
+}
+function printConfigSection(name, values) {
+  process.stdout.write(`\x1B[1m  ${name}\x1B[0m
+`);
+  for (const [key, value] of Object.entries(values)) {
+    process.stdout.write(`    ${key.padEnd(15)} ${value}
+`);
+  }
+  process.stdout.write("\n");
+}
+
+// src/commands/demo.ts
+import { Command as Command7 } from "commander";
+import { existsSync as existsSync9 } from "fs";
+import { resolve as resolve7, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { createRequire as createRequire3 } from "module";
+var __dirname3 = fileURLToPath3(new URL(".", import.meta.url));
+function resolveDemoDir() {
+  const monorepoDemoDir = resolve7(__dirname3, "..", "demo");
+  if (existsSync9(resolve7(monorepoDemoDir, "scenario.md"))) {
+    return monorepoDemoDir;
+  }
+  try {
+    const require2 = createRequire3(import.meta.url);
+    const cliMain = require2.resolve("@archal/cli");
+    const pkgDir = dirname3(dirname3(cliMain));
+    const npmDemoDir = resolve7(pkgDir, "demo");
+    if (existsSync9(resolve7(npmDemoDir, "scenario.md"))) {
+      return npmDemoDir;
+    }
+  } catch {
+  }
+  throw new Error("Demo files not found. Ensure @archal/cli is installed correctly.");
+}
+function createDemoCommand() {
+  const cmd = new Command7("demo").description("Run a built-in demo: good agent vs bad agent on the same scenario").option("-q, --quiet", "Suppress non-error output").option("-v, --verbose", "Enable debug logging").action(async (opts) => {
+    if (opts.quiet) {
+      configureLogger({ quiet: true });
+    }
+    if (opts.verbose) {
+      configureLogger({ verbose: true, level: "debug" });
+    }
+    const demoDir = resolveDemoDir();
+    const scenarioPath = resolve7(demoDir, "scenario.md");
+    const goodAgentPath = resolve7(demoDir, "good-agent.mjs");
+    const badAgentPath = resolve7(demoDir, "bad-agent.mjs");
+    process.stderr.write("\n\x1B[36m\x1B[1marchal demo\x1B[0m \x1B[2m\u2014 same scenario, two agents\x1B[0m\n\n");
+    process.stderr.write("\x1B[1m\x1B[32m\u25B8 Good agent\x1B[0m \x1B[2m(checks labels, skips keep-open)\x1B[0m\n");
+    const goodReport = await runScenario({
+      scenarioPath,
+      agentConfig: { command: "node", args: [goodAgentPath] },
+      runs: 1,
+      timeout: 60,
+      output: "terminal"
+    });
+    process.stderr.write("\n");
+    process.stderr.write("\x1B[1m\x1B[31m\u25B8 Bad agent\x1B[0m \x1B[2m(closes everything, no comments)\x1B[0m\n");
+    const badReport = await runScenario({
+      scenarioPath,
+      agentConfig: { command: "node", args: [badAgentPath] },
+      runs: 1,
+      timeout: 60,
+      output: "terminal"
+    });
+    process.stderr.write("\n\x1B[2m\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\x1B[0m\n");
+    process.stderr.write("\n  Same scenario. Same digital twin. Different scores.\n");
+    process.stderr.write(`  Good agent: \x1B[32m${goodReport.satisfactionScore.toFixed(1)}%\x1B[0m
+`);
+    process.stderr.write(`  Bad agent:  \x1B[31m${badReport.satisfactionScore.toFixed(1)}%\x1B[0m
+
+`);
+    process.stderr.write("  \x1B[2mThis is what archal does \u2014 it measures agent behavior,\n");
+    process.stderr.write("  not just whether it runs.\x1B[0m\n\n");
+  });
+  return cmd;
+}
+
+// src/index.ts
+var program = new Command8();
+program.name("archal").description("The QA layer for the software factory era \u2014 test AI agents against digital twins").version("0.1.0").option("-q, --quiet", "Suppress non-error output").option("-v, --verbose", "Enable debug logging").hook("preAction", (_thisCommand) => {
+  const opts = program.opts();
+  if (opts.quiet) {
+    configureLogger({ quiet: true });
+  }
+  if (opts.verbose) {
+    configureLogger({ verbose: true, level: "debug" });
+  }
+});
+program.addCommand(createRunCommand());
+program.addCommand(createInitCommand());
+program.addCommand(createTwinCommand());
+program.addCommand(createScenarioCommand());
+program.addCommand(createTraceCommand());
+program.addCommand(createConfigCommand());
+program.addCommand(createDemoCommand());
+program.parseAsync(process.argv).catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(1);
+});