@ofear/xdou 1.0.0

package/dist/cli.js

@@ -0,0 +1,1112 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command, Flags } from "@oclif/core";
+import fs5 from "fs-extra";
+import pc2 from "picocolors";
+import Table from "cli-table3";
+import YAML2 from "yaml";
+import { join as join6 } from "path";
+
+// src/orchestrator.ts
+import pc from "picocolors";
+import fs4 from "fs-extra";
+import { join as join5 } from "path";
+
+// src/core/artifact-store.ts
+import fs from "fs-extra";
+import writeFileAtomic from "write-file-atomic";
+import { join, resolve } from "path";
+import { randomUUID } from "crypto";
+var ArtifactStore = class {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  runDir(runId) {
+    return join(this.root, "runs", runId);
+  }
+  async createRun(mission) {
+    const id = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "").slice(0, 14)}-${randomUUID().slice(0, 8)}`;
+    const dir = this.runDir(id);
+    await fs.ensureDir(dir);
+    const manifest = { id, mission, createdAt: (/* @__PURE__ */ new Date()).toISOString(), updatedAt: (/* @__PURE__ */ new Date()).toISOString(), status: "created", phase: "created", artifactDir: dir, events: 0 };
+    await this.writeJson(id, "manifest.json", manifest);
+    await this.writeText(id, "mission.md", `# Mission
+
+${mission}
+`);
+    await this.appendEvent(id, { type: "run.created", by: "xdou", mission });
+    return manifest;
+  }
+  artifactPath(runId, relativePath) {
+    const root = resolve(this.runDir(runId));
+    const target = resolve(root, relativePath);
+    if (target !== root && !target.startsWith(`${root}\\`) && !target.startsWith(`${root}/`)) throw new Error(`Artifact path escapes run directory: ${relativePath}`);
+    return target;
+  }
+  async writeText(runId, relativePath, content) {
+    const path = this.artifactPath(runId, relativePath);
+    await fs.ensureDir(join(path, ".."));
+    await writeFileAtomic(path, content, "utf8");
+    return path;
+  }
+  async writeJson(runId, relativePath, value) {
+    return this.writeText(runId, relativePath, `${JSON.stringify(value, null, 2)}
+`);
+  }
+  async readManifest(runId) {
+    return fs.readJson(join(this.runDir(runId), "manifest.json"));
+  }
+  async updateManifest(runId, patch) {
+    const current = await this.readManifest(runId);
+    const next = { ...current, ...patch, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.writeJson(runId, "manifest.json", next);
+    return next;
+  }
+  async appendEvent(runId, event) {
+    const path = join(this.runDir(runId), "timeline.ndjson");
+    await fs.ensureDir(join(path, ".."));
+    const enriched = { time: (/* @__PURE__ */ new Date()).toISOString(), ...event };
+    await fs.appendFile(path, `${JSON.stringify(enriched)}
+`, "utf8");
+    if (event.type !== "run.created") {
+      const manifestPath = join(this.runDir(runId), "manifest.json");
+      if (await fs.pathExists(manifestPath)) {
+        const manifest = await this.readManifest(runId);
+        await this.writeJson(runId, "manifest.json", { ...manifest, events: manifest.events + 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+    }
+  }
+  async latestRunId() {
+    const runs = await this.listRuns();
+    return runs.at(-1)?.id;
+  }
+  async listRuns() {
+    const runsDir = join(this.root, "runs");
+    if (!await fs.pathExists(runsDir)) return [];
+    const entries = await fs.readdir(runsDir);
+    const manifests = [];
+    for (const entry of entries.sort()) {
+      const manifestPath = join(runsDir, entry, "manifest.json");
+      if (await fs.pathExists(manifestPath)) manifests.push(await fs.readJson(manifestPath));
+    }
+    return manifests;
+  }
+  async abortRun(runId, reason) {
+    await this.appendEvent(runId, { type: "run.aborted", by: "xdou", reason });
+    return this.updateManifest(runId, { status: "aborted", phase: "aborted", abortedReason: reason });
+  }
+  async recoverStaleRuns(staleAfterMs = 5 * 6e4) {
+    const now = Date.now();
+    const recovered = [];
+    for (const run of await this.listRuns()) {
+      if (run.status !== "running") continue;
+      const updatedAt = Date.parse(run.updatedAt);
+      const isStale = Number.isFinite(updatedAt) && now - updatedAt >= staleAfterMs;
+      const pidAlive = run.processPid ? this.isPidAlive(run.processPid) : false;
+      if (!pidAlive && isStale) recovered.push(await this.abortRun(run.id, run.processPid ? `process ${run.processPid} is not running` : "running manifest is stale and has no live process pid"));
+    }
+    return recovered;
+  }
+  isPidAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/core/context-compiler.ts
+function list(title, items) {
+  if (!items?.length) return [];
+  return [title, ...items.map((item) => `- ${item}`), ""];
+}
+function compileContextPacket(input) {
+  const lines = [
+    `XDOU CONTEXT PACKET`,
+    `RUN: ${input.runId}`,
+    `AGENT: ${input.agent}`,
+    `ROLE: ${input.role}`,
+    `BUDGET: ${input.budget ?? "balanced"}`,
+    "",
+    "MISSION:",
+    input.mission,
+    ""
+  ];
+  if (input.projectContext && input.budget !== "minimal") lines.push("PROJECT CONTEXT:", input.projectContext, "");
+  if (input.plan) lines.push("CANONICAL PLAN:", input.plan, "");
+  if (input.task) {
+    lines.push(`TASK ${input.task.id}: ${input.task.title}`, input.task.objective);
+    if (input.task.files?.length) lines.push("Files:", ...input.task.files.map((f) => `- ${f}`));
+    if (input.task.validation?.length) lines.push("Validation:", ...input.task.validation.map((v) => `- ${v}`));
+    lines.push("");
+  }
+  lines.push(...list("ACCEPTED DECISIONS:", input.decisions));
+  lines.push(...list("REJECTED APPROACHES:", input.rejected));
+  lines.push(...list("KNOWN RISKS:", input.risks));
+  if (input.diff) lines.push("DIFF TO REVIEW:", input.diff, "");
+  if (input.validation) lines.push("VALIDATION RESULT:", `Command: ${input.validation.command}`, `Status: ${input.validation.status}`, input.validation.output, "");
+  if (input.role === "reviewer") {
+    lines.push(
+      "SEMANTIC REVIEW CONTRACT:",
+      "You are the semantic completion gate. Decide whether the implementation satisfies the mission, not merely whether tests pass.",
+      "End your response with exactly one machine-readable verdict block:",
+      "REVIEW_VERDICT:",
+      '{"verdict":"approve|request_changes|blocked","confidence":0.0,"reason":"one sentence","missingRequirements":["requirement not satisfied"]}',
+      "Use request_changes when the diff/tests are green but the mission is semantically incomplete or incorrect.",
+      ""
+    );
+  }
+  if (input.budget === "full" && input.transcript) lines.push("RAW TRANSCRIPT FOR DEBUGGING ONLY:", input.transcript, "");
+  lines.push("OUTPUT CONTRACT:", "Return concise structured markdown with: Summary, Files changed/reviewed, Tests run, Issues/risks, Recommended next step.");
+  return lines.join("\n");
+}
+
+// src/core/repo.ts
+import { execa } from "execa";
+import fs2 from "fs-extra";
+import { join as join2, dirname } from "path";
+async function isGitRepo(cwd) {
+  const result = await execa("git", ["rev-parse", "--is-inside-work-tree"], { cwd, reject: false });
+  return result.exitCode === 0 && result.stdout.trim() === "true";
+}
+async function ensureGitRepo(cwd) {
+  if (!await isGitRepo(cwd)) throw new Error("xdou must run inside a git repository. Run git init first.");
+}
+async function isWorkingTreeClean(cwd) {
+  const result = await execa("git", ["status", "--porcelain"], { cwd, reject: false });
+  return result.exitCode === 0 && result.stdout.trim().length === 0;
+}
+async function ensureCleanWorkingTree(cwd) {
+  if (!await isWorkingTreeClean(cwd)) throw new Error("Refusing to run coding agents on a dirty working tree. Commit/stash changes first, or run planning/brainstorming only.");
+}
+async function gitDiff(cwd) {
+  const tracked = await execa("git", ["diff", "HEAD", "--", "."], { cwd, reject: false });
+  const untracked = await execa("git", ["ls-files", "--others", "--exclude-standard"], { cwd, reject: false });
+  const patches = [tracked.stdout].filter(Boolean);
+  for (const file of untracked.stdout.split(/\r?\n/).filter(Boolean)) {
+    const path = join2(cwd, file);
+    const content = await fs2.readFile(path, "utf8").catch(() => void 0);
+    if (content === void 0) continue;
+    const lines = content.split(/\r?\n/);
+    if (lines.at(-1) === "") lines.pop();
+    patches.push([
+      `diff --git a/${file} b/${file}`,
+      "new file mode 100644",
+      "index 0000000..0000000",
+      "--- /dev/null",
+      `+++ b/${file}`,
+      `@@ -0,0 +1,${lines.length} @@`,
+      ...lines.map((line) => `+${line}`)
+    ].join("\n"));
+  }
+  return patches.join("\n\n");
+}
+async function currentHead(cwd) {
+  const r = await execa("git", ["rev-parse", "HEAD"], { cwd });
+  return r.stdout.trim();
+}
+async function createRunWorktree(repoRoot, runId, artifactDir = ".xdou") {
+  const baseRef = await currentHead(repoRoot);
+  const worktreePath = join2(repoRoot, artifactDir, "worktrees", runId);
+  await fs2.remove(worktreePath);
+  await fs2.ensureDir(join2(worktreePath, ".."));
+  await execa("git", ["worktree", "add", "--detach", worktreePath, baseRef], { cwd: repoRoot });
+  return { cwd: worktreePath, worktreePath, baseRef };
+}
+async function createProjectSnapshot(repoRoot, snapshotPath) {
+  await fs2.remove(snapshotPath);
+  await fs2.ensureDir(snapshotPath);
+  const tracked = await execa("git", ["ls-files", "-z"], { cwd: repoRoot });
+  const files = tracked.stdout.split("\0").filter(Boolean);
+  for (const file of files) {
+    const source = join2(repoRoot, file);
+    const target = join2(snapshotPath, file);
+    await fs2.ensureDir(dirname(target));
+    await fs2.copyFile(source, target).catch(() => void 0);
+  }
+  return snapshotPath;
+}
+async function applyPatch(cwd, patch) {
+  if (!patch.trim() || patch.trim() === "No diff produced.") throw new Error("Run has no diff to apply.");
+  await ensureCleanWorkingTree(cwd);
+  const files = [...patch.matchAll(/^diff --git a\/(.*?) b\/(.*?)$/gm)].map((match) => match[2]).filter((file) => Boolean(file));
+  const normalizedPatch = patch.endsWith("\n") ? patch : `${patch}
+`;
+  await execa("git", ["apply", "--check", "-"], { cwd, input: normalizedPatch });
+  await execa("git", ["apply", "-"], { cwd, input: normalizedPatch });
+  return { filesChanged: new Set(files).size, files: [...new Set(files)] };
+}
+async function repoSummary(cwd) {
+  const files = ["package.json", "pyproject.toml", "Cargo.toml", "go.mod", "README.md"];
+  const parts = [];
+  for (const file of files) if (await fs2.pathExists(join2(cwd, file))) parts.push(`## ${file}
+${await fs2.readFile(join2(cwd, file), "utf8")}`);
+  return parts.join("\n\n").slice(0, 24e3);
+}
+
+// src/core/mission-check.ts
+var IGNORED_SYMBOLS = /* @__PURE__ */ new Set(["add", "update", "print", "test", "run", "export", "import"]);
+function expectedSymbolsFromMission(mission) {
+  const symbols = /* @__PURE__ */ new Set();
+  for (const match of mission.matchAll(/\b([A-Za-z_$][\w$]*)\s*\(/g)) {
+    const symbol = match[1];
+    if (symbol && !IGNORED_SYMBOLS.has(symbol.toLowerCase())) symbols.add(symbol);
+  }
+  return [...symbols];
+}
+function checkMissionCompletion(mission, diff) {
+  const expectedSymbols = expectedSymbolsFromMission(mission);
+  const effectiveDiff = diff.trim() === "No diff produced." ? "" : diff;
+  if (!expectedSymbols.length) {
+    return { status: effectiveDiff.trim() ? "passed" : "skipped", expectedSymbols, missingSymbols: [], message: effectiveDiff.trim() ? "No explicit function symbols found in mission; non-empty diff produced." : "No explicit function symbols found in mission." };
+  }
+  const missingSymbols = expectedSymbols.filter((symbol) => !new RegExp(`\\b${escapeRegExp(symbol)}\\b`).test(effectiveDiff));
+  return {
+    status: missingSymbols.length ? "failed" : "passed",
+    expectedSymbols,
+    missingSymbols,
+    message: missingSymbols.length ? `Produced diff is missing mission symbol(s): ${missingSymbols.join(", ")}` : "Produced diff contains all explicit mission symbols."
+  };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/core/acceptance-tests.ts
+import { execa as execa2 } from "execa";
+import { pathToFileURL } from "url";
+import { join as join3, normalize } from "path";
+var OPERATION_CASES = {
+  add: [{ args: [2, 3], expected: 5 }, { args: [-1, 4], expected: 3 }],
+  subtract: [{ args: [9, 4], expected: 5 }, { args: [1, 5], expected: -4 }],
+  multiply: [{ args: [3, 4], expected: 12 }, { args: [-2, 5], expected: -10 }],
+  divide: [{ args: [8, 2], expected: 4 }, { args: [9, 3], expected: 3 }],
+  modulo: [{ args: [9, 4], expected: 1 }, { args: [10, 5], expected: 0 }]
+};
+function generateAcceptanceTests(mission) {
+  const targetFile = extractTargetFile(mission);
+  const symbols = extractKnownOperationSymbols(mission);
+  if (!targetFile) return { status: "skipped", command: "xdou generated-acceptance", tests: [], reason: "No target source file detected in mission." };
+  if (!symbols.length) return { status: "skipped", command: "xdou generated-acceptance", targetFile, tests: [], reason: "No known behavior template detected in mission." };
+  const tests = symbols.flatMap((symbol) => OPERATION_CASES[symbol].map((testCase) => ({ symbol, ...testCase })));
+  return { status: "generated", command: `xdou-acceptance ${targetFile}`, targetFile, tests };
+}
+async function runGeneratedAcceptanceTests(cwd, mission) {
+  const plan = generateAcceptanceTests(mission);
+  if (plan.status === "skipped") return { command: plan.command, status: "skipped", output: plan.reason ?? "No generated acceptance tests." };
+  const script = buildAcceptanceScript(cwd, plan);
+  const result = await execa2("node", ["--input-type=module", "--eval", script], { cwd, reject: false, timeout: 2 * 6e4, all: true });
+  return {
+    command: plan.command,
+    status: result.exitCode === 0 ? "passed" : "failed",
+    output: (result.all ?? "").slice(-2e4),
+    ...typeof result.exitCode === "number" ? { exitCode: result.exitCode } : {}
+  };
+}
+function extractTargetFile(mission) {
+  const match = /export(?:ed)?\s+from\s+([\w./\\-]+\.(?:mjs|js|cjs|ts))/i.exec(mission);
+  if (!match?.[1]) return void 0;
+  return normalize(match[1]).replace(/\\/g, "/");
+}
+function extractKnownOperationSymbols(mission) {
+  const found = /* @__PURE__ */ new Set();
+  for (const symbol of Object.keys(OPERATION_CASES)) {
+    const pattern = new RegExp(`\\b${symbol}\\s*\\(`, "i");
+    if (pattern.test(mission)) found.add(symbol);
+  }
+  return [...found];
+}
+function buildAcceptanceScript(cwd, plan) {
+  const moduleUrl = pathToFileURL(join3(cwd, plan.targetFile)).href;
+  return `
+const mod = await import(${JSON.stringify(moduleUrl)});
+const tests = ${JSON.stringify(plan.tests)};
+let failures = 0;
+for (const test of tests) {
+  const fn = mod[test.symbol];
+  if (typeof fn !== 'function') {
+    console.error(test.symbol + ' is not exported as a function');
+    failures += 1;
+    continue;
+  }
+  const actual = fn(...test.args);
+  if (!Object.is(actual, test.expected)) {
+    console.error(test.symbol + '(' + test.args.join(', ') + ') expected ' + test.expected + ' but got ' + actual);
+    failures += 1;
+  }
+}
+if (failures > 0) process.exit(1);
+console.log('generated acceptance tests passed: ' + tests.length);
+`;
+}
+
+// src/core/review-verdict.ts
+function extractReviewVerdict(output) {
+  const marker = /REVIEW_VERDICT\s*:/i.exec(output);
+  if (!marker) return blockedVerdict("Reviewer output missing REVIEW_VERDICT JSON block.");
+  const tail = output.slice(marker.index + marker[0].length).trim();
+  const json = extractFirstJsonObject(tail);
+  if (!json) return blockedVerdict("Reviewer output has REVIEW_VERDICT marker but no JSON object.");
+  try {
+    const parsed = JSON.parse(json);
+    if (!isReviewDecision(parsed.verdict)) return blockedVerdict("Reviewer verdict must be approve, request_changes, or blocked.");
+    return {
+      verdict: parsed.verdict,
+      confidence: clampConfidence(parsed.confidence),
+      reason: typeof parsed.reason === "string" && parsed.reason.trim() ? parsed.reason : "No reason provided.",
+      missingRequirements: Array.isArray(parsed.missingRequirements) ? parsed.missingRequirements.filter((item) => typeof item === "string") : []
+    };
+  } catch (error) {
+    return blockedVerdict(`Reviewer verdict JSON could not be parsed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function reviewVerdictBlocks(verdict) {
+  return verdict.verdict === "request_changes" || verdict.verdict === "blocked";
+}
+function blockedVerdict(reason) {
+  return { verdict: "blocked", confidence: 1, reason, missingRequirements: ["structured semantic review verdict"] };
+}
+function isReviewDecision(value) {
+  return value === "approve" || value === "request_changes" || value === "blocked";
+}
+function clampConfidence(value) {
+  return typeof value === "number" && Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0;
+}
+function extractFirstJsonObject(text) {
+  const start = text.indexOf("{");
+  if (start < 0) return void 0;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return text.slice(start, index + 1);
+    }
+  }
+  return void 0;
+}
+
+// src/core/validation.ts
+import { execa as execa3 } from "execa";
+import fs3 from "fs-extra";
+import { join as join4 } from "path";
+async function detectValidationCommands(cwd) {
+  const commands = [];
+  if (await fs3.pathExists(join4(cwd, "package.json"))) {
+    const pkg = await fs3.readJson(join4(cwd, "package.json"));
+    if (pkg.scripts?.test) commands.push("npm test");
+    if (pkg.scripts?.typecheck) commands.push("npm run typecheck");
+    if (pkg.scripts?.build) commands.push("npm run build");
+  }
+  if (await fs3.pathExists(join4(cwd, "pyproject.toml")) || await fs3.pathExists(join4(cwd, "pytest.ini"))) commands.push("python -m pytest -q");
+  if (await fs3.pathExists(join4(cwd, "Cargo.toml"))) commands.push("cargo test");
+  if (await fs3.pathExists(join4(cwd, "go.mod"))) commands.push("go test ./...");
+  return commands;
+}
+async function runValidation(cwd, commands) {
+  const commandsToRun = commands ?? await detectValidationCommands(cwd);
+  const results = [];
+  for (const command of commandsToRun) {
+    const result = await execa3(command, { cwd, shell: true, reject: false, timeout: 10 * 6e4, all: true });
+    const validationResult = { command, status: result.exitCode === 0 ? "passed" : "failed", output: (result.all ?? "").slice(-2e4) };
+    if (typeof result.exitCode === "number") validationResult.exitCode = result.exitCode;
+    results.push(validationResult);
+  }
+  if (!results.length) results.push({ command: "auto-detect", status: "skipped", output: "No validation command detected." });
+  return results;
+}
+
+// src/agents/base.ts
+import { execa as execa4 } from "execa";
+import which from "which";
+var CliAgentAdapter = class {
+  command;
+  roles;
+  constructor(options) {
+    this.command = options.command;
+    this.roles = options.roles;
+  }
+  async detect() {
+    try {
+      const path = await which(this.command);
+      const version = await this.readVersion();
+      return { available: true, path, ...version ? { version } : {} };
+    } catch (error) {
+      return { available: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  async run(input) {
+    const invocation = this.buildInvocation(input);
+    const started = Date.now();
+    try {
+      const options = {
+        cwd: invocation.cwd,
+        shell: invocation.shell,
+        timeout: input.timeoutMs ?? 30 * 6e4,
+        reject: false,
+        all: false,
+        ...invocation.stdin ? { input: invocation.stdin } : { stdin: "ignore" },
+        ...invocation.env ? { env: invocation.env } : {}
+      };
+      const result = await execa4(invocation.command, invocation.args, options);
+      return {
+        agent: this.id,
+        command: invocation.command,
+        args: invocation.args,
+        exitCode: result.exitCode ?? 0,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        durationMs: Date.now() - started,
+        ok: (result.exitCode ?? 0) === 0
+      };
+    } catch (error) {
+      return {
+        agent: this.id,
+        command: invocation.command,
+        args: invocation.args,
+        exitCode: 1,
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error),
+        durationMs: Date.now() - started,
+        ok: false
+      };
+    }
+  }
+  async readVersion() {
+    const result = await execa4(this.command, ["--version"], { reject: false, timeout: 1e4 });
+    const text = `${result.stdout}
+${result.stderr}`.trim();
+    return text || void 0;
+  }
+};
+
+// src/agents/claude-code.ts
+var ClaudeCodeAdapter = class extends CliAgentAdapter {
+  id;
+  type = "claude-code";
+  maxTurns;
+  constructor(options = {}) {
+    super({ command: options.command ?? "claude", roles: options.roles ?? ["architect", "reviewer", "debugger"] });
+    this.id = options.id ?? "claude";
+    this.maxTurns = options.maxTurns ?? 10;
+  }
+  buildInvocation(input) {
+    return { command: this.command, args: ["-p", input.prompt, "--max-turns", String(this.maxTurns), "--output-format", "json"], cwd: input.cwd, shell: false };
+  }
+};
+
+// src/agents/codex.ts
+var CodexAdapter = class extends CliAgentAdapter {
+  id;
+  type = "codex";
+  fullAuto;
+  constructor(options = {}) {
+    super({ command: options.command ?? "codex", roles: options.roles ?? ["implementer", "fixer", "critic"] });
+    this.id = options.id ?? "codex";
+    this.fullAuto = options.fullAuto ?? false;
+  }
+  buildInvocation(input) {
+    const args = ["exec", "--cd", input.cwd, "-"];
+    if (this.fullAuto) args.splice(3, 0, "--dangerously-bypass-approvals-and-sandbox");
+    return { command: this.command, args, cwd: input.cwd, shell: false, stdin: input.prompt };
+  }
+};
+
+// src/agents/opencode.ts
+var OpenCodeAdapter = class extends CliAgentAdapter {
+  id;
+  type = "opencode";
+  model;
+  constructor(options = {}) {
+    super({ command: options.command ?? "opencode", roles: options.roles ?? ["implementer", "reviewer"] });
+    this.id = options.id ?? "opencode";
+    this.model = options.model;
+  }
+  buildInvocation(input) {
+    const args = ["run", input.prompt];
+    if (this.model) args.push("--model", this.model);
+    return { command: this.command, args, cwd: input.cwd, shell: false };
+  }
+};
+
+// src/agents/openrouter.ts
+import { generateText } from "ai";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+var OpenRouterAdapter = class {
+  id;
+  type = "openrouter";
+  roles;
+  model;
+  apiKeyEnv;
+  constructor(options) {
+    this.id = options.id;
+    this.model = options.model;
+    this.roles = options.roles ?? ["brainstormer", "critic", "reviewer"];
+    this.apiKeyEnv = options.apiKeyEnv ?? "OPENROUTER_API_KEY";
+  }
+  buildInvocation(input) {
+    return { command: "openrouter-api", args: [this.model, input.prompt], cwd: input.cwd, shell: false };
+  }
+  detect() {
+    const key = process.env[this.apiKeyEnv];
+    return Promise.resolve(key ? { available: true, version: this.model } : { available: false, error: `${this.apiKeyEnv} is not set` });
+  }
+  async run(input) {
+    const started = Date.now();
+    const apiKey = process.env[this.apiKeyEnv];
+    if (!apiKey) {
+      return { agent: this.id, command: "openrouter-api", args: [this.model], exitCode: 1, stdout: "", stderr: `${this.apiKeyEnv} is not set`, durationMs: Date.now() - started, ok: false };
+    }
+    try {
+      const openrouter = createOpenRouter({ apiKey });
+      const result = await generateText({ model: openrouter.chat(this.model), prompt: input.prompt, abortSignal: AbortSignal.timeout(input.timeoutMs ?? 10 * 6e4) });
+      return { agent: this.id, command: "openrouter-api", args: [this.model], exitCode: 0, stdout: result.text, stderr: "", durationMs: Date.now() - started, ok: true };
+    } catch (error) {
+      return { agent: this.id, command: "openrouter-api", args: [this.model], exitCode: 1, stdout: "", stderr: error instanceof Error ? error.message : String(error), durationMs: Date.now() - started, ok: false };
+    }
+  }
+};
+
+// src/agents/registry.ts
+var SAFE_ID = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
+function assertSafeAgentId(id) {
+  if (!SAFE_ID.test(id)) throw new Error(`Invalid agent id "${id}". Use 1-64 letters, numbers, _ or -; no path separators.`);
+}
+function asRoles(roles, fallback) {
+  return roles?.length ? roles : fallback;
+}
+function defaultAgents(definitions = {}) {
+  const agents = {
+    claude: new ClaudeCodeAdapter({ id: "claude" }),
+    codex: new CodexAdapter({ id: "codex", fullAuto: false }),
+    opencode: new OpenCodeAdapter({ id: "opencode" })
+  };
+  for (const [id, def] of Object.entries(definitions)) {
+    assertSafeAgentId(id);
+    if (def.enabled === false) continue;
+    if (def.type === "claude-code") agents[id] = new ClaudeCodeAdapter({ id, ...def.command ? { command: def.command } : {}, roles: asRoles(def.roles, ["architect", "reviewer", "debugger"]) });
+    if (def.type === "codex") agents[id] = new CodexAdapter({ id, ...def.command ? { command: def.command } : {}, roles: asRoles(def.roles, ["implementer", "fixer", "critic"]), fullAuto: def.fullAuto ?? false });
+    if (def.type === "opencode") agents[id] = new OpenCodeAdapter({ id, ...def.command ? { command: def.command } : {}, roles: asRoles(def.roles, ["implementer", "reviewer"]), ...def.model ? { model: def.model } : {} });
+    if (def.type === "openrouter") {
+      if (!def.model) throw new Error(`OpenRouter agent "${id}" requires model`);
+      agents[id] = new OpenRouterAdapter({ id, model: def.model, roles: asRoles(def.roles, ["brainstormer", "critic", "reviewer"]) });
+    }
+  }
+  return agents;
+}
+function selectAgents(names, agents = defaultAgents()) {
+  return names.map((name) => {
+    const agent = agents[name];
+    if (!agent) throw new Error(`Unknown agent "${name}". Known agents: ${Object.keys(agents).join(", ")}`);
+    return agent;
+  });
+}
+
+// src/orchestrator.ts
+var XdouOrchestrator = class {
+  cwd;
+  store;
+  agents;
+  constructor(cwd, artifactDir = ".xdou", agentDefinitions = {}, agentOverrides = {}) {
+    this.cwd = cwd;
+    this.store = new ArtifactStore(join5(cwd, artifactDir));
+    this.agents = { ...defaultAgents(agentDefinitions), ...agentOverrides };
+  }
+  async detectAgents() {
+    const entries = await Promise.all(Object.entries(this.agents).map(async ([name, agent]) => [name, await agent.detect()]));
+    return Object.fromEntries(entries);
+  }
+  async brainstorm(mission, names = ["claude", "codex"]) {
+    await ensureGitRepo(this.cwd);
+    const run = await this.store.createRun(mission);
+    await this.store.updateManifest(run.id, { status: "running", phase: "brainstorm" });
+    const project = await repoSummary(this.cwd);
+    const snapshotCwd = await createProjectSnapshot(this.cwd, join5(this.store.runDir(run.id), "project-snapshot"));
+    await this.store.writeText(run.id, "project.md", project || "No common project metadata found.");
+    const council = await this.runCouncil(run.id, mission, project, snapshotCwd, names, []);
+    const councilText = this.formatCouncil(council);
+    await this.store.writeText(run.id, "brainstorm.md", councilText);
+    await this.store.writeText(run.id, "council.md", councilText);
+    await this.store.updateManifest(run.id, { status: "completed", phase: "brainstormed" });
+    return run.id;
+  }
+  async run(options) {
+    await ensureGitRepo(this.cwd);
+    if (options.execute !== false) await ensureCleanWorkingTree(this.cwd);
+    const run = await this.store.createRun(options.mission);
+    const cleanupSignals = this.installAbortSignalHandlers(run.id);
+    await this.store.updateManifest(run.id, { status: "running", phase: "council", processPid: process.pid });
+    const project = await repoSummary(this.cwd);
+    const snapshotCwd = await createProjectSnapshot(this.cwd, join5(this.store.runDir(run.id), "project-snapshot"));
+    await this.store.writeText(run.id, "project.md", project || "No common project metadata found.");
+    const selected = selectAgents(options.team ?? ["claude", "codex", "claude"], this.agents);
+    const architect = selected[0];
+    const implementer = selected[1];
+    const fallbackReviewer = selected[2] ?? selected[0];
+    if (!architect || !implementer || !fallbackReviewer) throw new Error("A run needs at least architect, implementer, and reviewer agents.");
+    const brainstormers = options.brainstormers ?? [architect.id, implementer.id];
+    const critics = options.critics ?? [];
+    const reviewerNames = options.reviewers ?? [fallbackReviewer.id];
+    const council = await this.runCouncil(run.id, options.mission, project, snapshotCwd, brainstormers, critics, options.timeoutMs);
+    const councilText = this.formatCouncil(council);
+    await this.store.writeText(run.id, "council.md", councilText || "No council agents configured.");
+    await this.store.updateManifest(run.id, { phase: "planning" });
+    const synthesisPrompt = [
+      compileContextPacket({ runId: run.id, agent: architect.id, role: "architect", mission: options.mission, projectContext: project, budget: "balanced" }),
+      "",
+      "CO-DEVELOPMENT COUNCIL INPUTS:",
+      councilText || "No council inputs.",
+      "",
+      "SYNTHESIS CONTRACT:",
+      "Create one canonical plan that selects the strongest ideas, resolves disagreements, lists risks, and gives the implementer precise execution steps."
+    ].join("\n");
+    const planInput = { cwd: snapshotCwd, runDir: this.store.runDir(run.id), prompt: synthesisPrompt, ...options.timeoutMs ? { timeoutMs: options.timeoutMs } : {} };
+    const planResult = await architect.run(planInput);
+    const rawPlan = planResult.stdout || planResult.stderr;
+    const synthesis = this.formatSynthesis(architect.id, rawPlan, council);
+    await this.store.writeText(run.id, "plan.md", rawPlan);
+    await this.store.writeText(run.id, "synthesis.md", synthesis);
+    await this.store.writeJson(run.id, `agents/${architect.id}/plan-result.json`, planResult);
+    await this.store.appendEvent(run.id, { type: "plan.created", by: architect.id, ok: planResult.ok });
+    if (!planResult.ok) {
+      await this.store.updateManifest(run.id, { status: "blocked", phase: "planning_failed" });
+      throw new Error(`Architect failed: ${planResult.stderr}`);
+    }
+    if (options.execute === false) {
+      cleanupSignals();
+      await this.store.updateManifest(run.id, { status: "completed", phase: "planned" });
+      return run.id;
+    }
+    const workspace = options.isolated === false ? { cwd: this.cwd } : await createRunWorktree(this.cwd, run.id);
+    await this.store.updateManifest(run.id, { phase: "implementation", ...workspace.worktreePath ? { worktreePath: workspace.worktreePath, baseRef: workspace.baseRef } : {} });
+    const implPrompt = compileContextPacket({ runId: run.id, agent: implementer.id, role: "implementer", mission: options.mission, projectContext: project, plan: synthesis, budget: "balanced" });
+    const implInput = { cwd: workspace.cwd, runDir: this.store.runDir(run.id), prompt: implPrompt, ...options.timeoutMs ? { timeoutMs: options.timeoutMs } : {} };
+    const implResult = await implementer.run(implInput);
+    await this.store.writeJson(run.id, `agents/${implementer.id}/implementation-result.json`, implResult);
+    await this.store.appendEvent(run.id, { type: "implementation.finished", by: implementer.id, ok: implResult.ok });
+    let diff = await gitDiff(workspace.cwd);
+    await this.store.writeText(run.id, "diff.patch", diff || "No diff produced.");
+    let validation = await this.validateWorkspace(run.id, options.mission, workspace.cwd, diff);
+    await this.store.appendEvent(run.id, { type: "validation.finished", ok: !validation.some((v) => v.status === "failed") });
+    await this.store.updateManifest(run.id, { phase: "review" });
+    let reviewResults = await this.runReviews(run.id, snapshotCwd, options.mission, synthesis, diff, validation, reviewerNames, options.timeoutMs);
+    let failed = this.hasBlockers(implResult, validation, reviewResults);
+    const maxFixAttempts = options.maxFixAttempts ?? 1;
+    const fixerName = options.fixer ?? implementer.id;
+    for (let attempt = 1; failed && attempt <= maxFixAttempts; attempt += 1) {
+      const [fixer] = selectAgents([fixerName], this.agents);
+      if (!fixer) break;
+      await this.store.updateManifest(run.id, { phase: `fix_${attempt}`, fixAttempts: attempt });
+      await this.store.appendEvent(run.id, { type: "fix.started", by: fixer.id, attempt });
+      const lastValidation = validation.at(-1);
+      const fixPrompt = compileContextPacket({
+        runId: run.id,
+        agent: fixer.id,
+        role: "fixer",
+        mission: options.mission,
+        projectContext: project,
+        plan: synthesis,
+        diff,
+        budget: "balanced",
+        ...lastValidation ? { validation: lastValidation } : {}
+      });
+      await this.store.writeText(run.id, `fixes/attempt-${attempt}/inbox.md`, fixPrompt);
+      const fixInput = { cwd: workspace.cwd, runDir: this.store.runDir(run.id), prompt: fixPrompt, ...options.timeoutMs ? { timeoutMs: options.timeoutMs } : {} };
+      const fixResult = await fixer.run(fixInput);
+      await this.store.writeJson(run.id, `fixes/attempt-${attempt}/result.json`, fixResult);
+      await this.store.appendEvent(run.id, { type: "fix.finished", by: fixer.id, attempt, ok: fixResult.ok });
+      diff = await gitDiff(workspace.cwd);
+      await this.store.writeText(run.id, `fixes/attempt-${attempt}/diff.patch`, diff || "No diff produced.");
+      await this.store.writeText(run.id, "diff.patch", diff || "No diff produced.");
+      validation = await this.validateWorkspace(run.id, options.mission, workspace.cwd, diff);
+      await this.store.writeJson(run.id, `fixes/attempt-${attempt}/validation.json`, validation);
+      await this.store.appendEvent(run.id, { type: "validation.finished", attempt, ok: !validation.some((v) => v.status === "failed") });
+      reviewResults = await this.runReviews(run.id, snapshotCwd, options.mission, synthesis, diff, validation, reviewerNames, options.timeoutMs);
+      failed = this.hasBlockers(fixResult, validation, reviewResults);
+    }
+    if (failed && maxFixAttempts > 0) await this.store.appendEvent(run.id, { type: "fix.exhausted", attempts: maxFixAttempts });
+    await this.store.writeText(run.id, "final-summary.md", this.formatFinalSummary(options.mission, run.id, synthesis, validation, reviewResults, failed, workspace.worktreePath));
+    const finalManifest = await this.store.updateManifest(run.id, { status: failed ? "blocked" : "completed", phase: failed ? "needs_attention" : "done" });
+    await this.store.writeJson(run.id, "result.json", { runId: run.id, status: finalManifest.status, phase: finalManifest.phase, artifactDir: finalManifest.artifactDir, worktreePath: finalManifest.worktreePath, validation, reviews: reviewResults.map((review) => ({ agent: review.agent, ok: review.result.ok, verdict: review.verdict })) });
+    cleanupSignals();
+    if (failed) console.error(pc.yellow(`xdou run ${run.id} completed with blockers; inspect ${this.store.runDir(run.id)}`));
+    return run.id;
+  }
+  async applyRun(runId) {
+    await ensureGitRepo(this.cwd);
+    const manifest = await this.store.readManifest(runId);
+    if (manifest.status !== "completed") throw new Error(`Refusing to apply run ${runId} with status ${manifest.status}.`);
+    const diffPath = join5(this.store.runDir(runId), "diff.patch");
+    const diff = await fs4.readFile(diffPath, "utf8");
+    const applied = await applyPatch(this.cwd, diff);
+    const result = { runId, applied: true, filesChanged: applied.filesChanged, files: applied.files, artifactDir: manifest.artifactDir };
+    await this.store.writeJson(runId, "apply-result.json", result);
+    await this.store.appendEvent(runId, { type: "run.applied", by: "xdou", filesChanged: applied.filesChanged });
+    await this.store.updateManifest(runId, { appliedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    return result;
+  }
+  async runCouncil(runId, mission, project, cwd, brainstormers, critics, timeoutMs) {
+    const specs = [
+      ...brainstormers.map((name) => ({ name, role: "brainstormer" })),
+      ...critics.map((name) => ({ name, role: "critic" }))
+    ];
+    const outputs = await Promise.all(specs.map(async (spec) => {
+      const [agent] = selectAgents([spec.name], this.agents);
+      if (!agent) return void 0;
+      const prompt = compileContextPacket({ runId, agent: agent.id, role: spec.role, mission, projectContext: project, budget: "balanced" });
+      await this.store.writeText(runId, `agents/${agent.id}/${spec.role}-inbox.md`, prompt);
+      const input = { cwd, runDir: this.store.runDir(runId), prompt, ...timeoutMs ? { timeoutMs } : {} };
+      const result = await agent.run(input);
+      await this.store.writeJson(runId, `agents/${agent.id}/${spec.role}-result.json`, result);
+      await this.store.appendEvent(runId, { type: "council.finished", by: agent.id, role: spec.role, ok: result.ok, exitCode: result.exitCode });
+      return { agent: agent.id, role: spec.role, result };
+    }));
+    return outputs.filter((output) => Boolean(output));
+  }
+  async runReviews(runId, cwd, mission, plan, diff, validation, reviewers, timeoutMs) {
+    const lastValidation = validation.at(-1);
+    const outputs = await Promise.all(selectAgents(reviewers, this.agents).map(async (reviewer) => {
+      const reviewContext = { runId, agent: reviewer.id, role: "reviewer", mission, plan, diff, budget: "minimal", ...lastValidation ? { validation: lastValidation } : {} };
+      const prompt = compileContextPacket(reviewContext);
+      await this.store.writeText(runId, `agents/${reviewer.id}/review-inbox.md`, prompt);
+      const input = { cwd, runDir: this.store.runDir(runId), prompt, ...timeoutMs ? { timeoutMs } : {} };
+      const result = await reviewer.run(input);
+      const verdict = extractReviewVerdict(result.stdout || result.stderr);
+      await this.store.writeJson(runId, `agents/${reviewer.id}/review-result.json`, result);
+      await this.store.writeJson(runId, `agents/${reviewer.id}/review-verdict.json`, verdict);
+      await this.store.appendEvent(runId, { type: "review.finished", by: reviewer.id, ok: result.ok, verdict: verdict.verdict });
+      return { agent: reviewer.id, result, verdict };
+    }));
+    await this.store.writeText(runId, "review.md", outputs.map((review) => `## ${review.agent}
+
+${review.result.stdout || review.result.stderr}`).join("\n\n---\n\n"));
+    await this.store.writeJson(runId, "review-verdicts.json", outputs.map((review) => ({ agent: review.agent, ...review.verdict })));
+    return outputs;
+  }
+  async validateWorkspace(runId, mission, cwd, diff) {
+    const validation = await runValidation(cwd);
+    const generatedAcceptance = await runGeneratedAcceptanceTests(cwd, mission);
+    await this.store.writeJson(runId, "generated-acceptance.json", generatedAcceptance);
+    const missionCheck = checkMissionCompletion(mission, diff || "No diff produced.");
+    await this.store.writeJson(runId, "mission-check.json", missionCheck);
+    const combined = [
+      ...validation,
+      generatedAcceptance,
+      {
+        command: "xdou mission-completion-check",
+        status: missionCheck.status === "failed" ? "failed" : "passed",
+        output: missionCheck.message,
+        exitCode: missionCheck.status === "failed" ? 1 : 0
+      }
+    ];
+    await this.store.writeJson(runId, "validation.json", combined);
+    return combined;
+  }
+  formatCouncil(council) {
+    return council.map((entry) => `## ${entry.agent} (${entry.role})
+
+${entry.result.stdout || entry.result.stderr}`).join("\n\n---\n\n");
+  }
+  formatSynthesis(architect, plan, council) {
+    const participants = council.map((entry) => `${entry.agent}:${entry.role}`).join(", ") || "none";
+    return [`# Synthesis`, "", `Architect: ${architect}`, `Council: ${participants}`, "", "## Selected implementation direction", "", plan, "", "## Collaboration rule", "", "Implementation follows this synthesized plan, then independent reviewers inspect the resulting diff and validation output."].join("\n");
+  }
+  hasBlockers(lastMutation, validation, reviews) {
+    return !lastMutation.ok || validation.some((v) => v.status === "failed") || reviews.some((review) => !review.result.ok || reviewVerdictBlocks(review.verdict));
+  }
+  installAbortSignalHandlers(runId) {
+    const handle = (signal) => {
+      void this.store.abortRun(runId, `received ${signal}`).finally(() => process.exit(130));
+    };
+    process.once("SIGINT", handle);
+    process.once("SIGTERM", handle);
+    return () => {
+      process.off("SIGINT", handle);
+      process.off("SIGTERM", handle);
+    };
+  }
+  formatFinalSummary(mission, runId, synthesis, validation, reviews, failed, worktreePath) {
+    return [
+      "# XDOU Run Summary",
+      "",
+      `Run: ${runId}`,
+      `Mission: ${mission}`,
+      `Status: ${failed ? "blocked" : "completed"}`,
+      ...worktreePath ? [`Worktree: ${worktreePath}`] : [],
+      `Reviewers: ${reviews.map((review) => review.agent).join(", ") || "none"}`,
+      "",
+      "## Validation",
+      ...validation.map((result) => `- ${result.status}: ${result.command}`),
+      "",
+      "## Synthesis",
+      synthesis,
+      "",
+      "## Review outcomes",
+      ...reviews.map((review) => `- ${review.agent}: ${review.result.ok ? "ok" : "failed"}`)
+    ].join("\n");
+  }
+};
+
+// src/config/schema.ts
+import { z } from "zod";
+var safeId = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
+var agentSchema = z.object({
+  type: z.enum(["claude-code", "codex", "opencode", "openrouter"]),
+  command: z.string().optional(),
+  model: z.string().optional(),
+  roles: z.array(z.string()).default([]),
+  enabled: z.boolean().default(true),
+  fullAuto: z.boolean().default(false)
+});
+var teamSchema = z.object({
+  brainstormers: z.array(z.string().regex(safeId)).default(["claude", "codex"]),
+  architect: z.string().regex(safeId).default("claude"),
+  critic: z.string().regex(safeId).default("codex"),
+  implementer: z.string().regex(safeId).default("codex"),
+  reviewer: z.array(z.string().regex(safeId)).default(["claude"]),
+  fixer: z.string().regex(safeId).default("codex")
+});
+var configSchema = z.object({
+  artifactDir: z.string().default(".xdou"),
+  agents: z.record(z.string().regex(safeId), agentSchema).default({}),
+  teams: z.record(z.string().regex(safeId), teamSchema).default({ default: teamSchema.parse({}) })
+});
+function parseConfig(input) {
+  return configSchema.parse(input ?? {});
+}
+function defaultConfig() {
+  return parseConfig({});
+}
+
+// src/config/load.ts
+import { cosmiconfig } from "cosmiconfig";
+import YAML from "yaml";
+async function loadConfig(cwd) {
+  const explorer = cosmiconfig("xdou", { searchPlaces: ["xdou.yaml", "xdou.yml", ".xdourc.yaml", "package.json"], loaders: { ".yaml": (_p, content) => YAML.parse(content), ".yml": (_p, content) => YAML.parse(content) } });
+  const result = await explorer.search(cwd);
+  if (!result) return { config: defaultConfig() };
+  return { config: parseConfig(result.config), filepath: result.filepath };
+}
+
+// src/cli.ts
+var Xdou = class _Xdou extends Command {
+  static description = "xdou: multi-agent coding from your terminal";
+  static strict = false;
+  static flags = {
+    cwd: Flags.string({ default: process.cwd(), description: "Working directory" }),
+    json: Flags.boolean({ default: false }),
+    agents: Flags.string({ description: "Comma-separated agent ids for brainstorm/plan/run" }),
+    "max-fix-attempts": Flags.integer({ default: 1, description: "Maximum fixer iterations for run" })
+  };
+  async run() {
+    const { argv, flags } = await this.parse(_Xdou);
+    const [cmd, ...rest] = argv;
+    const cwd = flags.cwd;
+    const { config } = await loadConfig(cwd);
+    const orchestrator = new XdouOrchestrator(cwd, config.artifactDir, config.agents);
+    const fallbackTeam = defaultConfig().teams.default;
+    if (!fallbackTeam) throw new Error("Internal error: default team missing");
+    const team = config.teams.default ?? fallbackTeam;
+    switch (cmd) {
+      case "init":
+        await this.initProject(cwd);
+        break;
+      case "agents":
+        await this.agents(orchestrator, rest, flags.json);
+        break;
+      case "brainstorm":
+        await this.brainstorm(orchestrator, rest, team, flags.agents);
+        break;
+      case "plan":
+        await this.plan(orchestrator, rest, team, flags.agents);
+        break;
+      case "run":
+        await this.runMission(orchestrator, rest, team, flags.agents, flags["max-fix-attempts"], flags.json);
+        break;
+      case "apply":
+        await this.apply(orchestrator, rest, flags.json);
+        break;
+      case "status":
+        await this.status(orchestrator, rest, flags.json);
+        break;
+      case "runs":
+        await this.runs(orchestrator, rest, flags.json);
+        break;
+      case "context":
+        await this.context(orchestrator, rest);
+        break;
+      case "config":
+        await this.configCommand(cwd, rest);
+        break;
+      case void 0:
+      case "help":
+      case "--help":
+      case "-h":
+        this.log("xdou: multi-agent coding from your terminal\n\nCommands:\n  init\n  agents [list|detect]\n  brainstorm <mission> [--agents a,b]\n  plan <mission>\n  run <mission> [--agents architect,implementer,reviewer] [--max-fix-attempts n] [--json]\n  apply <run-id> [--json]\n  status [run-id]\n  runs list\n  context [run-id]\n  config validate");
+        break;
+      default:
+        throw new Error(`Unknown command: ${cmd}. Try: xdou init | agents detect | brainstorm | plan | run | status | runs list | context | config validate`);
+    }
+  }
+  async initProject(cwd) {
+    const configPath = join6(cwd, "xdou.yaml");
+    if (await fs5.pathExists(configPath)) throw new Error(`Config already exists: ${configPath}`);
+    await fs5.writeFile(configPath, YAML2.stringify(defaultConfig()), "utf8");
+    await fs5.ensureDir(join6(cwd, ".xdou", "runs"));
+    await this.ensureGitignore(cwd);
+    this.log(`${pc2.green("created")} ${configPath}`);
+  }
+  async ensureGitignore(cwd) {
+    const path = join6(cwd, ".gitignore");
+    const current = await fs5.readFile(path, "utf8").catch(() => "");
+    const required = [".xdou/runs/", ".xdou/worktrees/"];
+    const existing = current.split(/\r?\n/);
+    const missing = required.filter((line) => !existing.includes(line));
+    if (missing.length) await fs5.appendFile(path, `${current && !current.endsWith("\n") ? "\n" : ""}${missing.join("\n")}
+`, "utf8");
+  }
+  async agents(orchestrator, args, json) {
+    const sub = args[0] ?? "list";
+    if (!["list", "detect"].includes(sub)) throw new Error("Usage: xdou agents [list|detect]");
+    const detected = await orchestrator.detectAgents();
+    if (json) {
+      this.log(JSON.stringify(detected, null, 2));
+      return;
+    }
+    const table = new Table({ head: ["agent", "available", "version/path"] });
+    for (const [name, info] of Object.entries(detected)) table.push([name, info.available ? pc2.green("yes") : pc2.red("no"), info.version ?? info.path ?? info.error ?? ""]);
+    this.log(table.toString());
+  }
+  mission(args) {
+    const text = args.join(" ").trim();
+    if (!text) throw new Error('Mission is required. Example: xdou run "add oauth"');
+    return text;
+  }
+  parseAgents(args, fallback, flagValue) {
+    if (flagValue) return flagValue.split(",").map((s) => s.trim()).filter(Boolean);
+    const idx = args.indexOf("--agents");
+    const value = idx >= 0 ? args[idx + 1] : void 0;
+    if (idx >= 0 && !value) throw new Error("--agents requires a comma-separated value");
+    return value ? value.split(",").map((s) => s.trim()).filter(Boolean) : fallback;
+  }
+  cleanMissionArgs(args) {
+    const idx = args.indexOf("--agents");
+    return idx >= 0 ? args.slice(0, idx) : args;
+  }
+  numberFlag(args, name, fallback) {
+    const idx = args.indexOf(name);
+    if (idx < 0) return fallback;
+    const value = Number(args[idx + 1]);
+    if (!Number.isInteger(value) || value < 0) throw new Error(`${name} requires a non-negative integer`);
+    return value;
+  }
+  cleanRunArgs(args) {
+    let cleaned = this.cleanMissionArgs(args);
+    const idx = cleaned.indexOf("--max-fix-attempts");
+    if (idx >= 0) cleaned = [...cleaned.slice(0, idx), ...cleaned.slice(idx + 2)];
+    return cleaned;
+  }
+  async brainstorm(orchestrator, args, team, agentsFlag) {
+    const agents = this.parseAgents(args, team.brainstormers, agentsFlag);
+    const runId = await orchestrator.brainstorm(this.mission(this.cleanMissionArgs(args)), agents);
+    this.log(`${pc2.green("brainstorm complete")} run=${runId} artifacts=${orchestrator.store.runDir(runId)}`);
+  }
+  async plan(orchestrator, args, team, agentsFlag) {
+    const agents = this.parseAgents(args, [team.architect, team.implementer, team.reviewer[0] ?? team.architect], agentsFlag);
+    const runId = await orchestrator.run({
+      cwd: orchestrator.cwd,
+      mission: this.mission(this.cleanRunArgs(args)),
+      execute: false,
+      team: agents,
+      brainstormers: team.brainstormers,
+      critics: [team.critic],
+      reviewers: team.reviewer
+    });
+    this.log(`${pc2.green("plan complete")} run=${runId} artifacts=${orchestrator.store.runDir(runId)}`);
+  }
+  async runMission(orchestrator, args, team, agentsFlag, maxFixAttempts = 1, json = false) {
+    const agents = this.parseAgents(args, [team.architect, team.implementer, team.reviewer[0] ?? team.architect], agentsFlag);
+    const runId = await orchestrator.run({
+      cwd: orchestrator.cwd,
+      mission: this.mission(this.cleanRunArgs(args)),
+      team: agents,
+      brainstormers: team.brainstormers,
+      critics: [team.critic],
+      reviewers: team.reviewer,
+      fixer: team.fixer,
+      maxFixAttempts
+    });
+    const manifest = await orchestrator.store.readManifest(runId);
+    const payload = { runId, status: manifest.status, phase: manifest.phase, artifactDir: manifest.artifactDir, worktreePath: manifest.worktreePath };
+    this.log(json ? JSON.stringify(payload, null, 2) : `${pc2.green("run complete")} run=${runId} artifacts=${orchestrator.store.runDir(runId)}`);
+  }
+  async apply(orchestrator, args, json) {
+    const runId = args[0];
+    if (!runId) throw new Error("Usage: xdou apply <run-id>");
+    const result = await orchestrator.applyRun(runId);
+    this.log(json ? JSON.stringify(result, null, 2) : `${pc2.green("applied")} run=${runId} files=${result.filesChanged}`);
+  }
+  async status(orchestrator, args, json) {
+    await orchestrator.store.recoverStaleRuns();
+    const runId = args[0] ?? await orchestrator.store.latestRunId();
+    if (!runId) {
+      this.log("No runs found.");
+      return;
+    }
+    const manifest = await orchestrator.store.readManifest(runId);
+    this.log(json ? JSON.stringify(manifest, null, 2) : `${manifest.id} ${manifest.status}/${manifest.phase}
+${manifest.artifactDir}`);
+  }
+  async runs(orchestrator, args, json) {
+    if ((args[0] ?? "list") !== "list") throw new Error("Usage: xdou runs list");
+    await orchestrator.store.recoverStaleRuns();
+    const runs = await orchestrator.store.listRuns();
+    if (json) {
+      this.log(JSON.stringify(runs, null, 2));
+      return;
+    }
+    if (!runs.length) {
+      this.log("No runs found.");
+      return;
+    }
+    const table = new Table({ head: ["run", "status", "phase", "mission"] });
+    for (const run of runs) table.push([run.id, run.status, run.phase, run.mission]);
+    this.log(table.toString());
+  }
+  async context(orchestrator, args) {
+    const runId = args[0] ?? await orchestrator.store.latestRunId();
+    if (!runId) throw new Error("No run id supplied and no previous run found.");
+    const inboxPath = join6(orchestrator.store.runDir(runId), "agents");
+    this.log(inboxPath);
+  }
+  async configCommand(cwd, args) {
+    if ((args[0] ?? "validate") !== "validate") throw new Error("Usage: xdou config validate");
+    const loaded = await loadConfig(cwd);
+    this.log(`${pc2.green("valid")} ${loaded.filepath ?? "defaults"}`);
+  }
+};
+void Xdou.run().catch((error) => {
+  console.error(pc2.red(error instanceof Error ? error.message : String(error)));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map