@codemoot/cli 0.2.1

package/dist/index.js

@@ -0,0 +1,3613 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command, InvalidArgumentError, Option } from "commander";
+import { CLEANUP_TIMEOUT_SEC, VERSION as VERSION2 } from "@codemoot/core";
+
+// src/commands/build.ts
+import { BuildStore, DebateStore, REVIEW_DIFF_MAX_CHARS, REVIEW_TEXT_MAX_CHARS, SessionManager, buildHandoffEnvelope, generateId, loadConfig, openDatabase as openDatabase2 } from "@codemoot/core";
+import chalk3 from "chalk";
+import { execSync } from "child_process";
+import { unlinkSync } from "fs";
+import { join as join2 } from "path";
+
+// src/progress.ts
+import chalk from "chalk";
+var THROTTLE_MS = 3e3;
+function createProgressCallbacks(label = "codex") {
+  let lastActivityAt = 0;
+  let lastMessage = "";
+  function printActivity(msg) {
+    const now = Date.now();
+    if (msg === lastMessage && now - lastActivityAt < THROTTLE_MS) return;
+    lastActivityAt = now;
+    lastMessage = msg;
+    console.error(chalk.dim(`  [${label}] ${msg}`));
+  }
+  return {
+    onSpawn(pid, command) {
+      console.error(chalk.dim(`  [${label}] Started (PID: ${pid}, cmd: ${command})`));
+    },
+    onStderr(_chunk) {
+    },
+    onProgress(chunk) {
+      for (const line of chunk.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const event = JSON.parse(trimmed);
+          formatEvent(event, printActivity);
+        } catch {
+        }
+      }
+    },
+    onHeartbeat(elapsedSec) {
+      if (elapsedSec % 30 === 0) {
+        printActivity(`${elapsedSec}s elapsed...`);
+      }
+    }
+  };
+}
+function formatEvent(event, print) {
+  const type = event.type;
+  if (type === "thread.started") {
+    const tid = event.thread_id ?? "";
+    print(`Thread: ${tid.slice(0, 12)}...`);
+    return;
+  }
+  if (type === "item.completed") {
+    const item = event.item;
+    if (!item) return;
+    if (item.type === "tool_call" || item.type === "function_call") {
+      const name = item.name ?? item.function ?? "tool";
+      const args = String(item.arguments ?? item.input ?? "").slice(0, 80);
+      const pathMatch = args.match(/["']([^"']*\.[a-z]{1,4})["']/i);
+      if (pathMatch) {
+        print(`${name}: ${pathMatch[1]}`);
+      } else {
+        print(`${name}${args ? `: ${args.slice(0, 60)}` : ""}`);
+      }
+      return;
+    }
+    if (item.type === "agent_message") {
+      const text = String(item.text ?? "");
+      const firstLine = text.split("\n").find((l) => l.trim().length > 10);
+      if (firstLine) {
+        const preview = firstLine.trim().slice(0, 80);
+        print(`Response: ${preview}${firstLine.trim().length > 80 ? "..." : ""}`);
+      }
+      return;
+    }
+  }
+  if (type === "turn.completed") {
+    const usage = event.usage;
+    if (usage) {
+      const input = (usage.input_tokens ?? 0) + (usage.cached_input_tokens ?? 0);
+      const output = usage.output_tokens ?? 0;
+      print(`Turn done (${input} in / ${output} out tokens)`);
+    }
+    return;
+  }
+}
+
+// src/utils.ts
+import { openDatabase } from "@codemoot/core";
+import chalk2 from "chalk";
+import { mkdirSync } from "fs";
+import { join } from "path";
+function getDbPath(projectDir) {
+  const base = projectDir ?? process.cwd();
+  const dbDir = join(base, ".cowork", "db");
+  mkdirSync(dbDir, { recursive: true });
+  return join(dbDir, "cowork.db");
+}
+async function withDatabase(fn) {
+  const db = openDatabase(getDbPath());
+  try {
+    return await fn(db);
+  } catch (error) {
+    console.error(chalk2.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/build.ts
+async function buildStartCommand(task, options) {
+  let db;
+  try {
+    const buildId = generateId();
+    const dbPath = getDbPath();
+    db = openDatabase2(dbPath);
+    const buildStore = new BuildStore(db);
+    const debateStore = new DebateStore(db);
+    const projectDir = process.cwd();
+    let baselineRef = null;
+    try {
+      const dirty = execSync("git status --porcelain", { cwd: projectDir, encoding: "utf-8" }).trim();
+      if (dirty && !options.allowDirty) {
+        db.close();
+        console.error(chalk3.red("Working tree is dirty. Commit or stash your changes first."));
+        console.error(chalk3.yellow("Use --allow-dirty to auto-stash."));
+        process.exit(1);
+      }
+      if (dirty && options.allowDirty) {
+        execSync('git stash push -u -m "codemoot-build-baseline"', { cwd: projectDir, encoding: "utf-8" });
+        console.error(chalk3.yellow('Auto-stashed dirty changes with marker "codemoot-build-baseline"'));
+      }
+      baselineRef = execSync("git rev-parse HEAD", { cwd: projectDir, encoding: "utf-8" }).trim();
+    } catch {
+      console.error(chalk3.yellow("Warning: Not a git repository. No baseline tracking."));
+    }
+    const debateId = generateId();
+    debateStore.upsert({ debateId, role: "proposer", status: "active" });
+    debateStore.upsert({ debateId, role: "critic", status: "active" });
+    debateStore.saveState(debateId, "proposer", {
+      debateId,
+      question: task,
+      models: ["codex-architect", "codex-reviewer"],
+      round: 0,
+      turn: 0,
+      thread: [],
+      runningSummary: "",
+      stanceHistory: [],
+      usage: { totalPromptTokens: 0, totalCompletionTokens: 0, totalCalls: 0, startedAt: Date.now() },
+      status: "running",
+      sessionIds: {},
+      resumeStats: { attempted: 0, succeeded: 0, fallbacks: 0 }
+    });
+    const sessionMgr = new SessionManager(db);
+    const session2 = sessionMgr.resolveActive("build");
+    sessionMgr.recordEvent({
+      sessionId: session2.id,
+      command: "build",
+      subcommand: "start",
+      promptPreview: `Build started: ${task}`
+    });
+    buildStore.create({ buildId, task, debateId, baselineRef: baselineRef ?? void 0 });
+    buildStore.updateWithEvent(
+      buildId,
+      { debateId },
+      { eventType: "debate_started", actor: "system", phase: "debate", payload: { task, debateId, baselineRef } }
+    );
+    const output = {
+      buildId,
+      debateId,
+      task,
+      baselineRef,
+      sessionId: session2.id,
+      maxRounds: options.maxRounds ?? 5,
+      status: "planning",
+      phase: "debate"
+    };
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk3.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function buildStatusCommand(buildId) {
+  let db;
+  try {
+    const dbPath = getDbPath();
+    db = openDatabase2(dbPath);
+    const store = new BuildStore(db);
+    const run = store.get(buildId);
+    if (!run) {
+      db.close();
+      console.error(chalk3.red(`No build found with ID: ${buildId}`));
+      process.exit(1);
+    }
+    const events = store.getEvents(buildId);
+    const bugsFound = store.countEventsByType(buildId, "bug_found");
+    const fixesApplied = store.countEventsByType(buildId, "fix_completed");
+    const output = {
+      buildId: run.buildId,
+      task: run.task,
+      status: run.status,
+      phase: run.currentPhase,
+      loop: run.currentLoop,
+      debateId: run.debateId,
+      baselineRef: run.baselineRef,
+      planCodexSession: run.planCodexSession,
+      reviewCodexSession: run.reviewCodexSession,
+      planVersion: run.planVersion,
+      reviewCycles: run.reviewCycles,
+      bugsFound,
+      bugsFixed: fixesApplied,
+      totalEvents: events.length,
+      createdAt: new Date(run.createdAt).toISOString(),
+      updatedAt: new Date(run.updatedAt).toISOString(),
+      completedAt: run.completedAt ? new Date(run.completedAt).toISOString() : null,
+      recentEvents: events.slice(-10).map((e) => ({
+        seq: e.seq,
+        type: e.eventType,
+        actor: e.actor,
+        phase: e.phase,
+        loop: e.loopIndex,
+        tokens: e.tokensUsed,
+        time: new Date(e.createdAt).toISOString()
+      }))
+    };
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk3.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function buildListCommand(options) {
+  let db;
+  try {
+    const dbPath = getDbPath();
+    db = openDatabase2(dbPath);
+    const store = new BuildStore(db);
+    const builds = store.list({
+      status: options.status,
+      limit: options.limit ?? 20
+    });
+    const output = builds.map((b) => ({
+      buildId: b.buildId,
+      task: b.task,
+      status: b.status,
+      phase: b.phase,
+      loop: b.loop,
+      reviewCycles: b.reviewCycles,
+      createdAt: new Date(b.createdAt).toISOString(),
+      updatedAt: new Date(b.updatedAt).toISOString()
+    }));
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk3.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function buildEventCommand(buildId, eventType, options) {
+  let db;
+  try {
+    const dbPath = getDbPath();
+    db = openDatabase2(dbPath);
+    const store = new BuildStore(db);
+    const run = store.get(buildId);
+    if (!run) {
+      db.close();
+      console.error(chalk3.red(`No build found with ID: ${buildId}`));
+      process.exit(1);
+    }
+    let payload;
+    if (!process.stdin.isTTY) {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      const input = Buffer.concat(chunks).toString("utf-8").trim();
+      if (input) {
+        try {
+          payload = JSON.parse(input);
+        } catch {
+          payload = { text: input };
+        }
+      }
+    }
+    const updates = {};
+    if (eventType === "plan_approved") {
+      updates.currentPhase = "plan_approved";
+      updates.status = "implementing";
+      updates.planVersion = run.planVersion + 1;
+    } else if (eventType === "impl_completed") {
+      updates.currentPhase = "review";
+      updates.status = "reviewing";
+    } else if (eventType === "review_verdict") {
+      const verdict = payload?.verdict;
+      if (verdict === "approved") {
+        updates.currentPhase = "done";
+        updates.status = "completed";
+        updates.completedAt = Date.now();
+      } else {
+        updates.currentPhase = "fix";
+        updates.status = "fixing";
+        updates.reviewCycles = run.reviewCycles + 1;
+      }
+    } else if (eventType === "fix_completed") {
+      updates.currentPhase = "review";
+      updates.status = "reviewing";
+      updates.currentLoop = run.currentLoop + 1;
+    }
+    store.updateWithEvent(
+      buildId,
+      updates,
+      {
+        eventType,
+        actor: "system",
+        phase: updates.currentPhase ?? run.currentPhase,
+        loopIndex: options.loop ?? run.currentLoop,
+        payload,
+        tokensUsed: options.tokens ?? 0
+      }
+    );
+    const updated = store.get(buildId);
+    console.log(JSON.stringify({
+      buildId,
+      eventType,
+      newStatus: updated?.status,
+      newPhase: updated?.currentPhase,
+      seq: updated?.lastEventSeq
+    }));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk3.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function buildReviewCommand(buildId) {
+  let db;
+  try {
+    const dbPath = getDbPath();
+    db = openDatabase2(dbPath);
+    const buildStore = new BuildStore(db);
+    const config = loadConfig();
+    const projectDir = process.cwd();
+    const run = buildStore.get(buildId);
+    if (!run) {
+      db.close();
+      console.error(chalk3.red(`No build found with ID: ${buildId}`));
+      process.exit(1);
+    }
+    let diff = "";
+    if (run.baselineRef) {
+      try {
+        const tmpIndex = join2(projectDir, ".git", "codemoot-review-index");
+        try {
+          execSync(`git read-tree HEAD`, { cwd: projectDir, encoding: "utf-8", env: { ...process.env, GIT_INDEX_FILE: tmpIndex } });
+          execSync("git add -A", { cwd: projectDir, encoding: "utf-8", env: { ...process.env, GIT_INDEX_FILE: tmpIndex } });
+          diff = execSync(`git diff --cached ${run.baselineRef}`, { cwd: projectDir, encoding: "utf-8", maxBuffer: 1024 * 1024, env: { ...process.env, GIT_INDEX_FILE: tmpIndex } });
+        } finally {
+          try {
+            unlinkSync(tmpIndex);
+          } catch {
+          }
+        }
+      } catch (err) {
+        console.error(chalk3.red(`Failed to generate diff: ${err instanceof Error ? err.message : String(err)}`));
+        db.close();
+        process.exit(1);
+      }
+    }
+    if (!diff.trim()) {
+      db.close();
+      console.error(chalk3.yellow("No changes detected against baseline."));
+      process.exit(0);
+    }
+    const { ModelRegistry: ModelRegistry8, CliAdapter: CliAdapterClass } = await import("@codemoot/core");
+    const registry = ModelRegistry8.fromConfig(config, projectDir);
+    const adapter = registry.getAdapter("codex-reviewer") ?? registry.getAdapter("codex-architect");
+    if (!adapter) {
+      db.close();
+      console.error(chalk3.red("No codex adapter found in config"));
+      process.exit(1);
+    }
+    const sessionMgr = new SessionManager(db);
+    const session2 = sessionMgr.resolveActive("build-review");
+    const overflowCheck = sessionMgr.preCallOverflowCheck(session2.id);
+    if (overflowCheck.rolled) {
+      console.error(chalk3.yellow(`  ${overflowCheck.message}`));
+    }
+    const currentSession = sessionMgr.get(session2.id);
+    const existingSession = overflowCheck.rolled ? void 0 : currentSession?.codexThreadId ?? run.reviewCodexSession ?? void 0;
+    const prompt = buildHandoffEnvelope({
+      command: "build-review",
+      task: `Review code changes for the task: "${run.task}"
+
+GIT DIFF (against baseline ${run.baselineRef}):
+${diff.slice(0, REVIEW_DIFF_MAX_CHARS)}
+
+Review for:
+1. Correctness \u2014 does the code work as intended?
+2. Bugs \u2014 any logic errors, edge cases, or crashes?
+3. Security \u2014 any vulnerabilities introduced?
+4. Code quality \u2014 naming, structure, patterns
+5. Completeness \u2014 does it fully implement the task?`,
+      resumed: Boolean(existingSession),
+      constraints: run.reviewCycles > 0 ? [`This is review cycle ${run.reviewCycles + 1}. Focus on whether prior issues were addressed.`] : void 0
+    });
+    const progress = createProgressCallbacks("build-review");
+    const result = await adapter.callWithResume(prompt, {
+      sessionId: existingSession,
+      timeout: 6e5,
+      ...progress
+    });
+    if (result.sessionId) {
+      sessionMgr.updateThreadId(session2.id, result.sessionId);
+    }
+    sessionMgr.addUsageFromResult(session2.id, result.usage, prompt, result.text);
+    sessionMgr.recordEvent({
+      sessionId: session2.id,
+      command: "build",
+      subcommand: "review",
+      promptPreview: `Build review for ${buildId}: ${run.task}`,
+      responsePreview: result.text.slice(0, 500),
+      promptFull: prompt,
+      responseFull: result.text,
+      usageJson: JSON.stringify(result.usage),
+      durationMs: result.durationMs,
+      codexThreadId: result.sessionId
+    });
+    const tail = result.text.slice(-500);
+    const verdictMatch = tail.match(/^(?:-\s*)?VERDICT:\s*(APPROVED|NEEDS_REVISION)/m);
+    const approved = verdictMatch?.[1] === "APPROVED";
+    buildStore.updateWithEvent(
+      buildId,
+      {
+        reviewCodexSession: result.sessionId ?? existingSession,
+        reviewCycles: run.reviewCycles + 1
+      },
+      {
+        eventType: "review_verdict",
+        actor: "codex",
+        phase: "review",
+        loopIndex: run.currentLoop,
+        payload: {
+          verdict: approved ? "approved" : "needs_revision",
+          response: result.text.slice(0, REVIEW_TEXT_MAX_CHARS),
+          sessionId: result.sessionId,
+          resumed: existingSession ? result.sessionId === existingSession : false
+        },
+        codexThreadId: result.sessionId,
+        tokensUsed: result.usage.totalTokens
+      }
+    );
+    if (approved) {
+      buildStore.updateWithEvent(
+        buildId,
+        { currentPhase: "done", status: "completed", completedAt: Date.now() },
+        { eventType: "phase_transition", actor: "system", phase: "done", payload: { reason: "review_approved" } }
+      );
+    } else {
+      buildStore.updateWithEvent(
+        buildId,
+        { currentPhase: "fix", status: "fixing" },
+        { eventType: "phase_transition", actor: "system", phase: "fix", payload: { reason: "review_needs_revision" } }
+      );
+    }
+    const output = {
+      buildId,
+      review: result.text,
+      verdict: approved ? "approved" : "needs_revision",
+      sessionId: result.sessionId,
+      resumed: existingSession ? result.sessionId === existingSession : false,
+      tokens: result.usage,
+      durationMs: result.durationMs
+    };
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk3.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/debate.ts
+import {
+  DebateStore as DebateStore2,
+  MessageStore,
+  ModelRegistry,
+  SessionManager as SessionManager2,
+  buildReconstructionPrompt,
+  generateId as generateId2,
+  getTokenBudgetStatus,
+  loadConfig as loadConfig2,
+  openDatabase as openDatabase3,
+  parseDebateVerdict,
+  preflightTokenCheck
+} from "@codemoot/core";
+import chalk4 from "chalk";
+async function debateStartCommand(topic, options) {
+  let db;
+  try {
+    const debateId = generateId2();
+    const dbPath = getDbPath();
+    db = openDatabase3(dbPath);
+    const store = new DebateStore2(db);
+    store.upsert({ debateId, role: "proposer", status: "active" });
+    store.upsert({ debateId, role: "critic", status: "active" });
+    store.saveState(debateId, "proposer", {
+      debateId,
+      question: topic,
+      models: ["codex-architect", "codex-reviewer"],
+      round: 0,
+      turn: 0,
+      thread: [],
+      runningSummary: "",
+      stanceHistory: [],
+      usage: { totalPromptTokens: 0, totalCompletionTokens: 0, totalCalls: 0, startedAt: Date.now() },
+      status: "running",
+      sessionIds: {},
+      resumeStats: { attempted: 0, succeeded: 0, fallbacks: 0 },
+      maxRounds: options.maxRounds ?? 5
+    });
+    const output = {
+      debateId,
+      topic,
+      maxRounds: options.maxRounds ?? 5,
+      status: "started"
+    };
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk4.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function debateTurnCommand(debateId, prompt, options) {
+  let db;
+  try {
+    const dbPath = getDbPath();
+    db = openDatabase3(dbPath);
+    const store = new DebateStore2(db);
+    const msgStore = new MessageStore(db);
+    const config = loadConfig2();
+    const projectDir = process.cwd();
+    const registry = ModelRegistry.fromConfig(config, projectDir);
+    const criticRow = store.get(debateId, "critic");
+    if (!criticRow) {
+      db.close();
+      console.error(chalk4.red(`No debate found with ID: ${debateId}`));
+      process.exit(1);
+    }
+    if (criticRow.status === "completed") {
+      db.close();
+      console.error(chalk4.red(`Debate ${debateId} is already completed. Start a new debate to continue discussion.`));
+      process.exit(1);
+    }
+    const adapter = registry.tryGetAdapter("codex-reviewer") ?? registry.tryGetAdapter("codex-architect");
+    if (!adapter) {
+      db.close();
+      console.error(chalk4.red("No codex adapter found in config. Available: codex-reviewer or codex-architect"));
+      process.exit(1);
+    }
+    const rawRound = options.round ?? criticRow.round + 1;
+    const newRound = Number.isFinite(rawRound) && rawRound > 0 ? rawRound : criticRow.round + 1;
+    const rawTimeout = options.timeout ?? 600;
+    const timeout = (Number.isFinite(rawTimeout) && rawTimeout > 0 ? rawTimeout : 600) * 1e3;
+    const proposerStateForLimit = store.loadState(debateId, "proposer");
+    const rawMax = proposerStateForLimit?.maxRounds ?? 5;
+    const maxRounds = Number.isFinite(rawMax) && rawMax > 0 ? rawMax : 5;
+    if (newRound > maxRounds) {
+      console.error(chalk4.red(`Round ${newRound} exceeds max rounds (${maxRounds}). Complete or increase limit.`));
+      db.close();
+      process.exit(1);
+    }
+    const existing = msgStore.getByRound(debateId, newRound, "critic");
+    if (existing?.status === "completed") {
+      if (criticRow.round < newRound) {
+        store.upsert({
+          debateId,
+          role: "critic",
+          codexSessionId: existing.sessionId ?? criticRow.codexSessionId ?? void 0,
+          round: newRound,
+          status: "active"
+        });
+      }
+      const output = {
+        debateId,
+        round: newRound,
+        response: existing.responseText,
+        sessionId: existing.sessionId,
+        resumed: false,
+        cached: true,
+        usage: existing.usageJson ? (() => {
+          try {
+            return JSON.parse(existing.usageJson);
+          } catch {
+            return null;
+          }
+        })() : null,
+        durationMs: existing.durationMs
+      };
+      console.log(JSON.stringify(output, null, 2));
+      db.close();
+      return;
+    }
+    const staleThreshold = timeout + 6e4;
+    const recovered = msgStore.recoverStaleForDebate(debateId, staleThreshold);
+    if (recovered > 0) {
+      console.error(chalk4.yellow(`  Recovered ${recovered} stale message(s) from prior crash.`));
+    }
+    const current = msgStore.getByRound(debateId, newRound, "critic");
+    let msgId;
+    if (current) {
+      msgId = current.id;
+      if (current.status === "failed" || current.status === "queued") {
+        msgStore.updatePrompt(msgId, prompt);
+      }
+    } else {
+      msgId = msgStore.insertQueued({
+        debateId,
+        round: newRound,
+        role: "critic",
+        bridge: "codex",
+        model: adapter.modelId ?? "codex",
+        promptText: prompt
+      });
+    }
+    if (!msgStore.markRunning(msgId)) {
+      const recheckRow = msgStore.getByRound(debateId, newRound, "critic");
+      if (recheckRow?.status === "completed") {
+        const output = {
+          debateId,
+          round: newRound,
+          response: recheckRow.responseText,
+          sessionId: recheckRow.sessionId,
+          resumed: false,
+          cached: true,
+          usage: recheckRow.usageJson ? (() => {
+            try {
+              return JSON.parse(recheckRow.usageJson);
+            } catch {
+              return null;
+            }
+          })() : null,
+          durationMs: recheckRow.durationMs
+        };
+        console.log(JSON.stringify(output, null, 2));
+        db.close();
+        return;
+      }
+      db.close();
+      console.error(chalk4.red(`Cannot transition message ${msgId} to running (current status: ${recheckRow?.status})`));
+      process.exit(1);
+    }
+    const sessionMgr = new SessionManager2(db);
+    const unifiedSession = sessionMgr.resolveActive("debate");
+    let existingSessionId = unifiedSession.codexThreadId ?? criticRow.codexSessionId ?? void 0;
+    const attemptedResume = existingSessionId != null;
+    const completedHistory = msgStore.getHistory(debateId).filter((m) => m.status === "completed");
+    const maxContext = adapter.capabilities.maxContextTokens;
+    const preflight = preflightTokenCheck(completedHistory, prompt, maxContext);
+    if (preflight.shouldStop) {
+      console.error(chalk4.yellow(`  Token budget at ${Math.round(preflight.utilizationRatio * 100)}% (${preflight.totalTokensUsed}/${maxContext}). Consider completing this debate.`));
+    } else if (preflight.shouldSummarize) {
+      console.error(chalk4.yellow(`  Token budget at ${Math.round(preflight.utilizationRatio * 100)}%. Older rounds will be summarized on resume failure.`));
+    }
+    const overflowCheck = sessionMgr.preCallOverflowCheck(unifiedSession.id);
+    if (overflowCheck.rolled) {
+      console.error(chalk4.yellow(`  ${overflowCheck.message}`));
+      existingSessionId = void 0;
+    }
+    try {
+      const progress = createProgressCallbacks("debate");
+      let result = await adapter.callWithResume(prompt, {
+        sessionId: existingSessionId,
+        timeout,
+        ...progress
+      });
+      const resumed = attemptedResume && result.sessionId === existingSessionId;
+      const resumeFailed = attemptedResume && !resumed;
+      if (resumeFailed && result.text.length < 50) {
+        console.error(chalk4.yellow("  Resume failed with minimal response. Reconstructing from ledger..."));
+        const history = msgStore.getHistory(debateId);
+        const reconstructed = buildReconstructionPrompt(history, prompt);
+        result = await adapter.callWithResume(reconstructed, {
+          timeout,
+          ...progress
+        });
+      }
+      if (result.text.length < 200 && (result.durationMs ?? 0) > 6e4) {
+        console.error(chalk4.yellow(`  Warning: GPT response is only ${result.text.length} chars after ${Math.round((result.durationMs ?? 0) / 1e3)}s \u2014 possible output truncation (codex may have spent its turn on tool calls).`));
+      }
+      const verdict = parseDebateVerdict(result.text);
+      const completed = msgStore.markCompleted(msgId, {
+        responseText: result.text,
+        verdict,
+        usageJson: JSON.stringify(result.usage),
+        durationMs: result.durationMs ?? 0,
+        sessionId: result.sessionId ?? null
+      });
+      if (!completed) {
+        console.error(chalk4.red(`Message ${msgId} ledger transition to completed failed (possible concurrent invocation or state drift).`));
+        db.close();
+        process.exit(1);
+      }
+      if (resumeFailed) {
+        store.incrementResumeFailCount(debateId, "critic");
+      }
+      if (result.sessionId) {
+        sessionMgr.updateThreadId(unifiedSession.id, result.sessionId);
+      }
+      sessionMgr.addUsageFromResult(unifiedSession.id, result.usage, prompt, result.text);
+      sessionMgr.recordEvent({
+        sessionId: unifiedSession.id,
+        command: "debate",
+        subcommand: "turn",
+        promptPreview: prompt.slice(0, 500),
+        responsePreview: result.text.slice(0, 500),
+        promptFull: prompt,
+        responseFull: result.text,
+        usageJson: JSON.stringify(result.usage),
+        durationMs: result.durationMs,
+        codexThreadId: result.sessionId
+      });
+      store.upsert({
+        debateId,
+        role: "critic",
+        codexSessionId: result.sessionId ?? existingSessionId,
+        round: newRound,
+        status: "active"
+      });
+      const proposerState = store.loadState(debateId, "proposer");
+      if (proposerState) {
+        const stats = proposerState.resumeStats ?? { attempted: 0, succeeded: 0, fallbacks: 0 };
+        if (attemptedResume) stats.attempted++;
+        if (resumed) stats.succeeded++;
+        if (resumeFailed) stats.fallbacks++;
+        proposerState.resumeStats = stats;
+        store.saveState(debateId, "proposer", proposerState);
+      }
+      const output = {
+        debateId,
+        round: newRound,
+        response: result.text,
+        sessionId: result.sessionId,
+        resumed,
+        cached: false,
+        stance: verdict.stance,
+        usage: result.usage,
+        durationMs: result.durationMs
+      };
+      const stanceColor = verdict.stance === "SUPPORT" ? chalk4.green : verdict.stance === "OPPOSE" ? chalk4.red : chalk4.yellow;
+      console.error(stanceColor(`
+Round ${newRound} \u2014 Stance: ${verdict.stance}`));
+      const previewLines = result.text.split("\n").filter((l) => l.trim().length > 10).slice(0, 3);
+      for (const line of previewLines) {
+        console.error(chalk4.dim(`  ${line.trim().slice(0, 120)}`));
+      }
+      console.error(chalk4.dim(`Duration: ${(result.durationMs / 1e3).toFixed(1)}s | Tokens: ${result.usage?.totalTokens ?? "?"} | Resumed: ${resumed}`));
+      console.log(JSON.stringify(output, null, 2));
+    } catch (error) {
+      msgStore.markFailed(msgId, error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk4.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function debateStatusCommand(debateId) {
+  let db;
+  try {
+    const dbPath = getDbPath();
+    db = openDatabase3(dbPath);
+    const store = new DebateStore2(db);
+    const turns = store.getByDebateId(debateId);
+    if (turns.length === 0) {
+      db.close();
+      console.error(chalk4.red(`No debate found with ID: ${debateId}`));
+      process.exit(1);
+    }
+    const state = store.loadState(debateId, "proposer");
+    const msgStore = new MessageStore(db);
+    const msgHistory = msgStore.getHistory(debateId);
+    const tokenStatus = getTokenBudgetStatus(msgHistory, 4e5);
+    const output = {
+      debateId,
+      topic: state?.question ?? "unknown",
+      status: turns.some((t) => t.status === "active") ? "active" : turns[0].status,
+      round: Math.max(...turns.map((t) => t.round)),
+      participants: turns.map((t) => ({
+        role: t.role,
+        codexSessionId: t.codexSessionId,
+        round: t.round,
+        status: t.status,
+        resumeFailCount: t.resumeFailCount,
+        lastActivity: new Date(t.lastActivityAt).toISOString()
+      })),
+      resumeStats: state?.resumeStats ?? null,
+      tokenBudget: {
+        used: tokenStatus.totalTokensUsed,
+        max: tokenStatus.maxContextTokens,
+        utilization: `${Math.round(tokenStatus.utilizationRatio * 100)}%`,
+        messages: msgHistory.length
+      }
+    };
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk4.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function debateListCommand(options) {
+  let db;
+  try {
+    const dbPath = getDbPath();
+    db = openDatabase3(dbPath);
+    const store = new DebateStore2(db);
+    const desiredLimit = options.limit ?? 20;
+    const rows = store.list({
+      status: options.status,
+      limit: desiredLimit * 3
+    });
+    const debates = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const existing = debates.get(row.debateId) ?? [];
+      existing.push(row);
+      debates.set(row.debateId, existing);
+    }
+    const output = Array.from(debates.entries()).slice(0, desiredLimit).map(([id, turns]) => {
+      const state = store.loadState(id, "proposer");
+      return {
+        debateId: id,
+        topic: state?.question ?? "unknown",
+        status: turns.some((t) => t.status === "active") ? "active" : turns[0].status,
+        round: Math.max(...turns.map((t) => t.round)),
+        lastActivity: new Date(Math.max(...turns.map((t) => t.lastActivityAt))).toISOString()
+      };
+    });
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk4.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function debateHistoryCommand(debateId) {
+  let db;
+  try {
+    const dbPath = getDbPath();
+    db = openDatabase3(dbPath);
+    const msgStore = new MessageStore(db);
+    const history = msgStore.getHistory(debateId);
+    if (history.length === 0) {
+      const debateStore = new DebateStore2(db);
+      const turns = debateStore.getByDebateId(debateId);
+      if (turns.length > 0) {
+        console.error(chalk4.yellow(`No messages stored for debate ${debateId} \u2014 this debate predates message persistence (schema v4). Only metadata is available via "debate status".`));
+      } else {
+        console.error(chalk4.red(`No debate found with ID: ${debateId}`));
+      }
+      db.close();
+      process.exit(1);
+    }
+    const tokenStatus = getTokenBudgetStatus(history, 4e5);
+    const output = {
+      debateId,
+      messageCount: history.length,
+      tokenBudget: {
+        used: tokenStatus.totalTokensUsed,
+        max: tokenStatus.maxContextTokens,
+        utilization: `${Math.round(tokenStatus.utilizationRatio * 100)}%`
+      },
+      messages: history.map((m) => ({
+        round: m.round,
+        role: m.role,
+        bridge: m.bridge,
+        model: m.model,
+        status: m.status,
+        stance: m.stance,
+        confidence: m.confidence,
+        durationMs: m.durationMs,
+        sessionId: m.sessionId,
+        promptPreview: m.promptText.slice(0, 200),
+        responsePreview: m.responseText?.slice(0, 200) ?? null,
+        error: m.error,
+        createdAt: new Date(m.createdAt).toISOString(),
+        completedAt: m.completedAt ? new Date(m.completedAt).toISOString() : null
+      }))
+    };
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk4.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function debateCompleteCommand(debateId) {
+  let db;
+  try {
+    const dbPath = getDbPath();
+    db = openDatabase3(dbPath);
+    const store = new DebateStore2(db);
+    const turns = store.getByDebateId(debateId);
+    if (turns.length === 0) {
+      console.error(chalk4.red(`No debate found with ID: ${debateId}`));
+      db.close();
+      process.exit(1);
+    }
+    const completeTransaction = db.transaction(() => {
+      store.updateStatus(debateId, "proposer", "completed");
+      store.updateStatus(debateId, "critic", "completed");
+    });
+    completeTransaction();
+    console.log(JSON.stringify({ debateId, status: "completed" }));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk4.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/cleanup.ts
+import {
+  BuildStore as BuildStore2,
+  JobStore,
+  ModelRegistry as ModelRegistry2,
+  SessionManager as SessionManager3,
+  buildHandoffEnvelope as buildHandoffEnvelope2,
+  computeThreeWayStats,
+  createIgnoreFilter,
+  generateId as generateId3,
+  hostFindingsSchema,
+  loadConfig as loadConfig3,
+  mergeThreeWay,
+  openDatabase as openDatabase4,
+  recalculateConfidenceStats,
+  runAllScanners
+} from "@codemoot/core";
+import chalk5 from "chalk";
+import { readFileSync } from "fs";
+async function cleanupCommand(path, options) {
+  let db;
+  try {
+    const { resolve: resolve2 } = await import("path");
+    const projectDir = resolve2(path);
+    if (options.background) {
+      const bgDb = openDatabase4(getDbPath());
+      const jobStore = new JobStore(bgDb);
+      const jobId = jobStore.enqueue({
+        type: "cleanup",
+        payload: { path: projectDir, scope: options.scope, timeout: options.timeout, maxDisputes: options.maxDisputes, hostFindings: options.hostFindings, output: options.output }
+      });
+      console.log(JSON.stringify({ jobId, status: "queued", message: "Cleanup enqueued. Check with: codemoot jobs status " + jobId }));
+      bgDb.close();
+      return;
+    }
+    const scopes = options.scope === "all" ? ["deps", "unused-exports", "hardcoded", "duplicates", "deadcode", "security", "near-duplicates", "anti-patterns"] : [options.scope];
+    const dbPath = getDbPath();
+    db = openDatabase4(dbPath);
+    const buildStore = new BuildStore2(db);
+    const buildId = generateId3();
+    const startTime = Date.now();
+    buildStore.create({ buildId, task: `cleanup:${options.scope}` });
+    console.error(chalk5.cyan(`Cleanup scan started (ID: ${buildId})`));
+    console.error(chalk5.cyan(`Scopes: ${scopes.join(", ")}`));
+    console.error(chalk5.cyan(`Project: ${projectDir}`));
+    let hostFindings = [];
+    if (options.hostFindings) {
+      console.error(chalk5.cyan(`Host findings: ${options.hostFindings}`));
+      try {
+        const raw = readFileSync(options.hostFindings, "utf-8");
+        const parsed = JSON.parse(raw);
+        const validated = hostFindingsSchema.parse(parsed);
+        hostFindings = validated.map((f) => ({
+          key: `${f.scope}:${f.file}:${f.symbol}`,
+          scope: f.scope,
+          confidence: f.confidence,
+          file: f.file,
+          line: f.line,
+          description: f.description,
+          recommendation: f.recommendation,
+          deterministicEvidence: [],
+          semanticEvidence: [],
+          hostEvidence: [`Host: ${f.description}`],
+          sources: ["host"],
+          disputed: false
+        }));
+        console.error(chalk5.dim(`  [host] Loaded ${hostFindings.length} findings`));
+      } catch (err) {
+        console.error(chalk5.red(`Failed to load host findings: ${err instanceof Error ? err.message : String(err)}`));
+        db.close();
+        process.exit(1);
+      }
+    }
+    const ig = createIgnoreFilter(projectDir, { skipGitignore: options.noGitignore });
+    console.error(chalk5.yellow("\nPhase 1: Scanning (parallel)..."));
+    let codexAdapter = null;
+    try {
+      const config = loadConfig3();
+      const registry = ModelRegistry2.fromConfig(config, projectDir);
+      try {
+        codexAdapter = registry.getAdapter("codex-reviewer");
+      } catch {
+        try {
+          codexAdapter = registry.getAdapter("codex-architect");
+        } catch {
+        }
+      }
+    } catch {
+    }
+    const sessionMgr = new SessionManager3(db);
+    const session2 = sessionMgr.resolveActive("cleanup");
+    const overflowCheck = sessionMgr.preCallOverflowCheck(session2.id);
+    if (overflowCheck.rolled) {
+      console.error(chalk5.yellow(`  ${overflowCheck.message}`));
+    }
+    const currentSession = sessionMgr.get(session2.id);
+    const sessionThreadId = currentSession?.codexThreadId ?? void 0;
+    const [deterministicFindings, semanticFindings] = await Promise.all([
+      Promise.resolve().then(() => {
+        console.error(chalk5.dim("  [deterministic] Starting..."));
+        const findings = runAllScanners(projectDir, scopes, ig);
+        console.error(chalk5.dim(`  [deterministic] Done: ${findings.length} findings`));
+        return findings;
+      }),
+      runCodexScan(codexAdapter, projectDir, scopes, options.timeout, sessionMgr, session2.id, sessionThreadId)
+    ]);
+    buildStore.updateWithEvent(
+      buildId,
+      { status: "reviewing", currentPhase: "review", metadata: { cleanupPhase: "scan" } },
+      {
+        eventType: "scan_completed",
+        actor: "system",
+        phase: "review",
+        payload: {
+          deterministicCount: deterministicFindings.length,
+          semanticCount: semanticFindings.length,
+          hostCount: hostFindings.length
+        }
+      }
+    );
+    console.error(chalk5.yellow("\nPhase 2: Merging findings (3-way)..."));
+    const mergedFindings = mergeThreeWay(deterministicFindings, semanticFindings, hostFindings);
+    const stats = computeThreeWayStats(deterministicFindings, semanticFindings, hostFindings, mergedFindings);
+    console.error(chalk5.dim(`  Merged: ${mergedFindings.length} total, ${stats.agreed} agreed, ${stats.disputed} disputed`));
+    if (hostFindings.length > 0) {
+      console.error(chalk5.dim(`  Sources: deterministic=${stats.deterministic}, codex=${stats.semantic}, host=${stats.host}`));
+    }
+    buildStore.updateWithEvent(
+      buildId,
+      { metadata: { cleanupPhase: "merge" } },
+      {
+        eventType: "merge_completed",
+        actor: "system",
+        phase: "review",
+        payload: { totalFindings: mergedFindings.length, ...stats }
+      }
+    );
+    const hasAdjudicatable = stats.disputed > 0 || mergedFindings.some((f) => f.confidence === "medium");
+    if (codexAdapter && hasAdjudicatable && options.maxDisputes > 0) {
+      console.error(chalk5.yellow(`
+Phase 2.5: Adjudicating up to ${options.maxDisputes} disputed findings...`));
+      await adjudicateFindings(codexAdapter, mergedFindings, options.maxDisputes, stats);
+      buildStore.updateWithEvent(
+        buildId,
+        { metadata: { cleanupPhase: "adjudicate" } },
+        {
+          eventType: "adjudicated",
+          actor: "codex",
+          phase: "review",
+          payload: { adjudicated: stats.adjudicated }
+        }
+      );
+    }
+    const durationMs = Date.now() - startTime;
+    const actionableScopes = /* @__PURE__ */ new Set(["deps", "unused-exports", "hardcoded"]);
+    const actionableCount = mergedFindings.filter(
+      (f) => actionableScopes.has(f.scope) && (f.confidence === "high" || f.confidence === "medium")
+    ).length;
+    const report = {
+      scopes,
+      findings: mergedFindings.sort((a, b) => {
+        const confOrder = { high: 0, medium: 1, low: 2 };
+        const confDiff = confOrder[a.confidence] - confOrder[b.confidence];
+        if (confDiff !== 0) return confDiff;
+        return a.key.localeCompare(b.key);
+      }),
+      stats,
+      durationMs
+    };
+    buildStore.updateWithEvent(
+      buildId,
+      { status: "completed", currentPhase: "done", completedAt: Date.now() },
+      {
+        eventType: "phase_transition",
+        actor: "system",
+        phase: "done",
+        payload: {
+          totalFindings: mergedFindings.length,
+          actionable: actionableCount,
+          reportOnly: mergedFindings.length - actionableCount
+        }
+      }
+    );
+    console.error(chalk5.green(`
+Scan complete in ${(durationMs / 1e3).toFixed(1)}s`));
+    console.error(chalk5.green(`Build ID: ${buildId}`));
+    console.error(`  Actionable: ${chalk5.red(String(actionableCount))}`);
+    console.error(`  Report-only: ${chalk5.dim(String(mergedFindings.length - actionableCount))}`);
+    console.error(`  High: ${stats.highConfidence} | Medium: ${stats.mediumConfidence} | Low: ${stats.lowConfidence}`);
+    if (stats.adjudicated > 0) console.error(`  Adjudicated: ${stats.adjudicated}`);
+    if (!options.quiet && mergedFindings.length > 0) {
+      console.error(chalk5.yellow("\n\u2500\u2500 Findings Summary \u2500\u2500"));
+      const byScope = /* @__PURE__ */ new Map();
+      for (const f of report.findings) {
+        const arr = byScope.get(f.scope) ?? [];
+        arr.push(f);
+        byScope.set(f.scope, arr);
+      }
+      for (const [scope, items] of byScope) {
+        const high = items.filter((f) => f.confidence === "high").length;
+        const med = items.filter((f) => f.confidence === "medium").length;
+        const low = items.filter((f) => f.confidence === "low").length;
+        console.error(chalk5.cyan(`
+  ${scope} (${items.length})`));
+        for (const f of items.filter((i) => i.confidence !== "low").slice(0, 5)) {
+          const conf = f.confidence === "high" ? chalk5.red("HIGH") : chalk5.yellow("MED");
+          const loc = f.line ? `${f.file}:${f.line}` : f.file;
+          console.error(`    ${conf} ${loc} \u2014 ${f.description}`);
+        }
+        if (high + med > 5) {
+          console.error(chalk5.dim(`    ... and ${high + med - 5} more`));
+        }
+        if (low > 0) {
+          console.error(chalk5.dim(`    + ${low} low-confidence (report-only)`));
+        }
+      }
+      console.error("");
+    }
+    sessionMgr.recordEvent({
+      sessionId: session2.id,
+      command: "cleanup",
+      subcommand: "report",
+      promptPreview: `Cleanup: ${scopes.join(", ")} on ${projectDir}`,
+      responsePreview: `${mergedFindings.length} findings (${stats.highConfidence} high, ${stats.mediumConfidence} med, ${stats.lowConfidence} low)`,
+      responseFull: JSON.stringify(report),
+      durationMs
+    });
+    if (options.output) {
+      const { writeFileSync: writeFileSync3 } = await import("fs");
+      writeFileSync3(options.output, JSON.stringify(report, null, 2), "utf-8");
+      console.error(chalk5.green(`  Findings written to ${options.output}`));
+    }
+    console.log(JSON.stringify(report, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk5.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function runCodexScan(adapter, _projectDir, scopes, timeoutSec, sessionMgr, sessionId, sessionThreadId) {
+  if (!adapter) {
+    console.error(chalk5.yellow("  [codex] No adapter available \u2014 skipping semantic scan"));
+    return [];
+  }
+  console.error(chalk5.dim("  [codex] Starting semantic scan..."));
+  const scopeDescriptions = scopes.map((s) => {
+    if (s === "deps") return "unused dependencies (check each package.json dep, including dynamic imports)";
+    if (s === "unused-exports") return "unused exports (exported but never imported anywhere)";
+    if (s === "hardcoded") return "hardcoded values (magic numbers, URLs, credentials)";
+    if (s === "duplicates") return "duplicate logic (similar function bodies across files)";
+    if (s === "deadcode") return "dead code (unreachable or unused internal code)";
+    return s;
+  }).join(", ");
+  const prompt = buildHandoffEnvelope2({
+    command: "cleanup",
+    task: `Scan this codebase for AI slop and code quality issues.
+
+SCAN FOR: ${scopeDescriptions}
+
+Where scope/confidence/file/line/symbol fields are:
+- scope: deps, unused-exports, hardcoded, duplicates, or deadcode
+- confidence: high, medium, or low
+- file: relative path from project root (forward slashes)
+- line: line number (or 0 if N/A)
+- symbol: the specific identifier (dep name, export name, variable name, or content hash)
+
+IMPORTANT KEY FORMAT: The key will be built as scope:file:symbol \u2014 use the SAME symbol that a static scanner would use:
+- deps: the package name (e.g. "lodash")
+- unused-exports: the export name (e.g. "myFunction")
+- hardcoded: for numbers use "num:VALUE:LLINE" (e.g. "num:42:L15"), for URLs use "url:HOSTNAME:LLINE" (e.g. "url:api.example.com:L20"), for credentials use "cred:LLINE" (e.g. "cred:L15")
+- duplicates: "HASH:FUNCNAME" where HASH is first 8 chars of md5 of normalized body (e.g. "a1b2c3d4:myFunction")
+- deadcode: the function/variable name`,
+    constraints: [
+      "Be thorough but precise. Only report real issues you can verify.",
+      "Check for dynamic imports (import()) before flagging unused deps",
+      "Check barrel re-exports and index files before flagging unused exports",
+      "Check type-only imports (import type)",
+      "Check framework conventions and cross-package monorepo dependencies"
+    ],
+    resumed: Boolean(sessionThreadId)
+  });
+  try {
+    const progress = createProgressCallbacks("cleanup-scan");
+    const result = await adapter.callWithResume(prompt, { sessionId: sessionThreadId, timeout: timeoutSec * 1e3, ...progress });
+    if (sessionMgr && sessionId) {
+      if (result.sessionId) {
+        sessionMgr.updateThreadId(sessionId, result.sessionId);
+      }
+      sessionMgr.addUsageFromResult(sessionId, result.usage, prompt, result.text);
+      sessionMgr.recordEvent({
+        sessionId,
+        command: "cleanup",
+        subcommand: "scan",
+        promptPreview: `Cleanup scan: ${scopes.join(", ")}`,
+        responsePreview: result.text.slice(0, 500),
+        usageJson: JSON.stringify(result.usage),
+        durationMs: result.durationMs,
+        codexThreadId: result.sessionId
+      });
+    }
+    const findings = [];
+    for (const line of result.text.split("\n")) {
+      const match = line.match(/^FINDING:\s*([^|]+)\|([^|]+)\|([^|]+)\|(\d+)\|([^|]+)\|([^|]+)\|(.+)/);
+      if (match) {
+        const scope = match[1].trim();
+        if (!scopes.includes(scope)) continue;
+        const file = match[3].trim();
+        const symbol = match[5].trim();
+        findings.push({
+          key: `${scope}:${file}:${symbol}`,
+          scope,
+          confidence: match[2].trim(),
+          file,
+          line: Number.parseInt(match[4], 10) || void 0,
+          description: match[6].trim(),
+          recommendation: match[7].trim(),
+          deterministicEvidence: [],
+          semanticEvidence: [`Codex: ${match[6].trim()}`],
+          hostEvidence: [],
+          sources: ["semantic"],
+          disputed: false
+        });
+      }
+    }
+    console.error(chalk5.dim(`  [codex] Done: ${findings.length} findings`));
+    return findings;
+  } catch (error) {
+    console.error(chalk5.yellow(`  [codex] Scan failed: ${error instanceof Error ? error.message : String(error)}`));
+    return [];
+  }
+}
+async function adjudicateFindings(adapter, findings, maxDisputes, stats) {
+  const toAdjudicate = findings.filter((f) => f.disputed || f.confidence === "medium").slice(0, maxDisputes);
+  for (const finding of toAdjudicate) {
+    try {
+      const allEvidence = [...finding.deterministicEvidence, ...finding.semanticEvidence, ...finding.hostEvidence];
+      const prompt = buildHandoffEnvelope2({
+        command: "adjudicate",
+        task: `Verify this finding.
+
+FINDING: ${finding.description}
+FILE: ${finding.file}${finding.line ? `:${finding.line}` : ""}
+SCOPE: ${finding.scope}
+SOURCES: ${finding.sources.join(", ")}
+EVIDENCE: ${allEvidence.join("; ")}`,
+        constraints: ["Check for dynamic imports, barrel re-exports, type-only usage, runtime/indirect usage"],
+        resumed: false
+      });
+      const adjProgress = createProgressCallbacks("adjudicate");
+      const result = await adapter.callWithResume(prompt, { timeout: 6e4, ...adjProgress });
+      const match = result.text.match(/ADJUDICATE:\s*(CONFIRMED|DISMISSED|UNCERTAIN)\s+(.*)/);
+      if (match) {
+        const verdict = match[1];
+        if (verdict === "CONFIRMED") {
+          finding.confidence = "high";
+          finding.semanticEvidence.push(`Adjudicated: CONFIRMED \u2014 ${match[2]}`);
+        } else if (verdict === "DISMISSED") {
+          finding.confidence = "low";
+          finding.semanticEvidence.push(`Adjudicated: DISMISSED \u2014 ${match[2]}`);
+        } else {
+          finding.semanticEvidence.push(`Adjudicated: UNCERTAIN \u2014 ${match[2]}`);
+          continue;
+        }
+        finding.disputed = false;
+        stats.adjudicated++;
+      }
+    } catch {
+    }
+  }
+  recalculateConfidenceStats(findings, stats);
+}
+
+// src/commands/cost.ts
+import { openDatabase as openDatabase5, SessionManager as SessionManager4 } from "@codemoot/core";
+import chalk6 from "chalk";
+function parseUsage(usageJson) {
+  try {
+    const u = JSON.parse(usageJson);
+    const input = u.inputTokens ?? u.input_tokens ?? 0;
+    const output = u.outputTokens ?? u.output_tokens ?? 0;
+    const total = u.totalTokens ?? u.total_tokens ?? input + output;
+    return { input, output, total };
+  } catch {
+    return { input: 0, output: 0, total: 0 };
+  }
+}
+async function costCommand(options) {
+  const db = openDatabase5(getDbPath());
+  try {
+    let rows;
+    let scopeLabel;
+    if (options.scope === "session") {
+      const sessionMgr = new SessionManager4(db);
+      const session2 = options.session ? sessionMgr.get(options.session) : sessionMgr.resolveActive("cost");
+      if (!session2) {
+        console.error(chalk6.red(options.session ? `Session not found: ${options.session}` : "No active session. Run: codemoot init"));
+        db.close();
+        process.exit(1);
+      }
+      rows = db.prepare(
+        "SELECT command, subcommand, usage_json, duration_ms, created_at FROM session_events WHERE session_id = ? ORDER BY created_at ASC"
+      ).all(session2.id);
+      scopeLabel = `session ${session2.id.slice(0, 8)}`;
+    } else if (options.scope === "all") {
+      rows = db.prepare(
+        "SELECT command, subcommand, usage_json, duration_ms, created_at FROM session_events ORDER BY created_at ASC"
+      ).all();
+      scopeLabel = "all-time";
+    } else {
+      const cutoff = Date.now() - options.days * 24 * 60 * 60 * 1e3;
+      rows = db.prepare(
+        "SELECT command, subcommand, usage_json, duration_ms, created_at FROM session_events WHERE created_at > ? ORDER BY created_at ASC"
+      ).all(cutoff);
+      scopeLabel = `last ${options.days} days`;
+    }
+    let totalInput = 0;
+    let totalOutput = 0;
+    let totalTokens = 0;
+    let totalDuration = 0;
+    const byCommand = {};
+    const byDay = {};
+    for (const row of rows) {
+      const usage = parseUsage(row.usage_json);
+      totalInput += usage.input;
+      totalOutput += usage.output;
+      totalTokens += usage.total;
+      totalDuration += row.duration_ms ?? 0;
+      const cmd = row.command ?? "unknown";
+      if (!byCommand[cmd]) byCommand[cmd] = { calls: 0, tokens: 0, durationMs: 0 };
+      byCommand[cmd].calls++;
+      byCommand[cmd].tokens += usage.total;
+      byCommand[cmd].durationMs += row.duration_ms ?? 0;
+      const day = new Date(row.created_at).toISOString().slice(0, 10);
+      if (!byDay[day]) byDay[day] = { calls: 0, tokens: 0 };
+      byDay[day].calls++;
+      byDay[day].tokens += usage.total;
+    }
+    const output = {
+      scope: scopeLabel,
+      totalCalls: rows.length,
+      totalTokens,
+      totalInputTokens: totalInput,
+      totalOutputTokens: totalOutput,
+      totalDurationMs: totalDuration,
+      avgTokensPerCall: rows.length > 0 ? Math.round(totalTokens / rows.length) : 0,
+      avgDurationMs: rows.length > 0 ? Math.round(totalDuration / rows.length) : 0,
+      byCommand,
+      byDay
+    };
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db.close();
+    console.error(chalk6.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/doctor.ts
+import { existsSync, accessSync, constants } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { join as join3 } from "path";
+import chalk7 from "chalk";
+import { VERSION } from "@codemoot/core";
+async function doctorCommand() {
+  const cwd = process.cwd();
+  const checks = [];
+  console.error(chalk7.cyan(`
+  CodeMoot Doctor v${VERSION}
+`));
+  try {
+    const version = execSync2("codex --version", { stdio: "pipe", encoding: "utf-8" }).trim();
+    checks.push({ name: "codex-cli", status: "pass", message: `Codex CLI ${version}` });
+  } catch {
+    checks.push({
+      name: "codex-cli",
+      status: "fail",
+      message: "Codex CLI not found in PATH",
+      fix: "npm install -g @openai/codex"
+    });
+  }
+  const configPath = join3(cwd, ".cowork.yml");
+  if (existsSync(configPath)) {
+    checks.push({ name: "config", status: "pass", message: ".cowork.yml found" });
+  } else {
+    checks.push({
+      name: "config",
+      status: "fail",
+      message: ".cowork.yml not found",
+      fix: "codemoot init"
+    });
+  }
+  const dbDir = join3(cwd, ".cowork", "db");
+  const dbPath = join3(dbDir, "cowork.db");
+  if (existsSync(dbDir)) {
+    try {
+      accessSync(dbDir, constants.W_OK);
+      checks.push({
+        name: "database",
+        status: existsSync(dbPath) ? "pass" : "warn",
+        message: existsSync(dbPath) ? "Database exists and writable" : "Database directory exists, DB will be created on first use"
+      });
+    } catch {
+      checks.push({
+        name: "database",
+        status: "fail",
+        message: ".cowork/db/ is not writable",
+        fix: "Check file permissions on .cowork/db/"
+      });
+    }
+  } else {
+    checks.push({
+      name: "database",
+      status: "warn",
+      message: ".cowork/db/ not found \u2014 will be created by codemoot init",
+      fix: "codemoot init"
+    });
+  }
+  let gitFound = false;
+  let searchDir = cwd;
+  while (searchDir) {
+    if (existsSync(join3(searchDir, ".git"))) {
+      gitFound = true;
+      break;
+    }
+    const parent = join3(searchDir, "..");
+    if (parent === searchDir) break;
+    searchDir = parent;
+  }
+  if (gitFound) {
+    checks.push({ name: "git", status: "pass", message: "Git repository detected" });
+  } else {
+    checks.push({
+      name: "git",
+      status: "warn",
+      message: "Not a git repository \u2014 diff/shipit/watch features limited"
+    });
+  }
+  const nodeVersion = process.version;
+  const major = Number.parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  if (major >= 18) {
+    checks.push({ name: "node", status: "pass", message: `Node.js ${nodeVersion}` });
+  } else {
+    checks.push({
+      name: "node",
+      status: "fail",
+      message: `Node.js ${nodeVersion} \u2014 requires >= 18`,
+      fix: "Install Node.js 18+"
+    });
+  }
+  if (existsSync(dbPath)) {
+    try {
+      const { openDatabase: openDatabase14 } = await import("@codemoot/core");
+      const db = openDatabase14(dbPath);
+      const row = db.prepare("PRAGMA user_version").get();
+      const version = row?.user_version ?? 0;
+      if (version >= 7) {
+        checks.push({ name: "schema", status: "pass", message: `Schema version ${version}` });
+      } else {
+        checks.push({
+          name: "schema",
+          status: "warn",
+          message: `Schema version ${version} \u2014 will auto-migrate on next command`
+        });
+      }
+      db.close();
+    } catch {
+      checks.push({ name: "schema", status: "warn", message: "Could not read schema version" });
+    }
+  }
+  let hasFailure = false;
+  for (const check of checks) {
+    const icon = check.status === "pass" ? chalk7.green("PASS") : check.status === "warn" ? chalk7.yellow("WARN") : chalk7.red("FAIL");
+    console.error(`  ${icon} ${check.name}: ${check.message}`);
+    if (check.fix) {
+      console.error(chalk7.dim(`       \u2192 ${check.fix}`));
+    }
+    if (check.status === "fail") hasFailure = true;
+  }
+  console.error("");
+  const output = {
+    version: VERSION,
+    checks,
+    healthy: !hasFailure
+  };
+  console.log(JSON.stringify(output, null, 2));
+  if (hasFailure) {
+    process.exit(1);
+  }
+}
+
+// src/commands/events.ts
+import { openDatabase as openDatabase6 } from "@codemoot/core";
+import chalk8 from "chalk";
+async function eventsCommand(options) {
+  const db = openDatabase6(getDbPath());
+  const query = options.type === "all" ? db.prepare(`
+        SELECT 'session_event' as source, id, session_id, command, subcommand, prompt_preview, response_preview, usage_json, duration_ms, created_at
+        FROM session_events
+        WHERE id > ?
+        ORDER BY id ASC
+        LIMIT ?
+      `) : options.type === "jobs" ? db.prepare(`
+          SELECT 'job_log' as source, id, job_id, seq, level, event_type, message, payload_json, created_at
+          FROM job_logs
+          WHERE id > ?
+          ORDER BY id ASC
+          LIMIT ?
+        `) : db.prepare(`
+          SELECT 'session_event' as source, id, session_id, command, subcommand, prompt_preview, response_preview, usage_json, duration_ms, created_at
+          FROM session_events
+          WHERE id > ?
+          ORDER BY id ASC
+          LIMIT ?
+        `);
+  let cursor = options.sinceSeq;
+  const poll = () => {
+    const rows = query.all(cursor, options.limit);
+    for (const row of rows) {
+      console.log(JSON.stringify(row));
+      cursor = row.id;
+    }
+    return rows.length;
+  };
+  poll();
+  if (!options.follow) {
+    db.close();
+    return;
+  }
+  console.error(chalk8.dim("Following events... (Ctrl+C to stop)"));
+  const interval = setInterval(() => {
+    poll();
+  }, 1e3);
+  const shutdown = () => {
+    clearInterval(interval);
+    db.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+// src/commands/fix.ts
+import { execFileSync, execSync as execSync3 } from "child_process";
+import {
+  DEFAULT_RULES,
+  ModelRegistry as ModelRegistry3,
+  SessionManager as SessionManager5,
+  buildHandoffEnvelope as buildHandoffEnvelope3,
+  evaluatePolicy,
+  loadConfig as loadConfig4,
+  openDatabase as openDatabase7,
+  REVIEW_DIFF_MAX_CHARS as REVIEW_DIFF_MAX_CHARS2
+} from "@codemoot/core";
+import chalk9 from "chalk";
+async function fixCommand(fileOrGlob, options) {
+  const projectDir = process.cwd();
+  const db = openDatabase7(getDbPath());
+  const config = loadConfig4();
+  const registry = ModelRegistry3.fromConfig(config, projectDir);
+  const adapter = registry.tryGetAdapter("codex-reviewer") ?? registry.tryGetAdapter("codex-architect");
+  if (!adapter) {
+    try {
+      execSync3("codex --version", { stdio: "pipe", encoding: "utf-8" });
+    } catch {
+      console.error(chalk9.red("Codex CLI is not installed or not in PATH."));
+      console.error(chalk9.yellow("Install it: npm install -g @openai/codex"));
+      db.close();
+      process.exit(1);
+    }
+    console.error(chalk9.red("No codex adapter found in config. Run: codemoot init"));
+    db.close();
+    process.exit(1);
+  }
+  const sessionMgr = new SessionManager5(db);
+  const session2 = options.session ? sessionMgr.get(options.session) : sessionMgr.resolveActive("fix");
+  if (!session2) {
+    console.error(chalk9.red(options.session ? `Session not found: ${options.session}` : "No active session. Run: codemoot init"));
+    db.close();
+    process.exit(1);
+  }
+  const currentSession = sessionMgr.get(session2.id);
+  let threadId = currentSession?.codexThreadId ?? void 0;
+  const rounds = [];
+  let converged = false;
+  console.error(
+    chalk9.cyan(
+      `Autofix loop: ${fileOrGlob} (max ${options.maxRounds} rounds, focus: ${options.focus})`
+    )
+  );
+  for (let round = 1; round <= options.maxRounds; round++) {
+    const overflowCheck = sessionMgr.preCallOverflowCheck(session2.id);
+    if (overflowCheck.rolled) {
+      console.error(chalk9.yellow(`  ${overflowCheck.message}`));
+      threadId = void 0;
+    }
+    const roundStart = Date.now();
+    console.error(chalk9.dim(`
+\u2500\u2500 Round ${round}/${options.maxRounds} \u2500\u2500`));
+    let diffContent = "";
+    if (options.diff) {
+      try {
+        diffContent = execFileSync("git", ["diff", ...options.diff.split(/\s+/)], {
+          cwd: projectDir,
+          encoding: "utf-8",
+          maxBuffer: 1024 * 1024
+        });
+      } catch {
+        diffContent = "";
+      }
+    }
+    const reviewPrompt = buildHandoffEnvelope3({
+      command: "review",
+      task: options.diff ? `Review and identify fixable issues in this diff.
+
+GIT DIFF (${options.diff}):
+${diffContent.slice(0, REVIEW_DIFF_MAX_CHARS2)}` : `Review ${fileOrGlob} and identify fixable issues. Read the file(s) first, then report issues with exact line numbers.`,
+      constraints: [
+        `Focus: ${options.focus}`,
+        "For each issue, provide the EXACT fix as a code snippet.",
+        "Format fixes as: FIX: <file>:<line> <description>\n```\n<fixed code>\n```",
+        round > 1 ? `This is re-review round ${round}. Previous fixes were applied. Check if issues are resolved.` : ""
+      ].filter(Boolean),
+      resumed: Boolean(threadId)
+    });
+    const timeoutMs = options.timeout * 1e3;
+    const progress = createProgressCallbacks("fix-review");
+    console.error(chalk9.dim("  Reviewing..."));
+    const reviewResult = await adapter.callWithResume(reviewPrompt, {
+      sessionId: threadId,
+      timeout: timeoutMs,
+      ...progress
+    });
+    if (reviewResult.sessionId) {
+      threadId = reviewResult.sessionId;
+      sessionMgr.updateThreadId(session2.id, reviewResult.sessionId);
+    }
+    sessionMgr.addUsageFromResult(session2.id, reviewResult.usage, reviewPrompt, reviewResult.text);
+    const tail = reviewResult.text.slice(-500);
+    const verdictMatch = tail.match(/VERDICT:\s*(APPROVED|NEEDS_REVISION)/i);
+    const scoreMatch = tail.match(/SCORE:\s*(\d+)\/10/);
+    const verdict = verdictMatch ? verdictMatch[1].toLowerCase() : "unknown";
+    const score = scoreMatch ? Number.parseInt(scoreMatch[1], 10) : null;
+    const criticalCount = (reviewResult.text.match(/CRITICAL/gi) ?? []).length;
+    const warningCount = (reviewResult.text.match(/WARNING/gi) ?? []).length;
+    console.error(
+      `  Verdict: ${verdict}, Score: ${score ?? "?"}/10, Critical: ${criticalCount}, Warning: ${warningCount}`
+    );
+    if (verdict === "approved" && criticalCount === 0) {
+      rounds.push({
+        round,
+        reviewVerdict: verdict,
+        reviewScore: score,
+        criticalCount,
+        warningCount,
+        fixApplied: false,
+        durationMs: Date.now() - roundStart
+      });
+      converged = true;
+      console.error(chalk9.green("  Review APPROVED \u2014 no fixes needed."));
+      break;
+    }
+    if (options.dryRun) {
+      console.error(chalk9.yellow("  Dry-run: skipping fix application."));
+      rounds.push({
+        round,
+        reviewVerdict: verdict,
+        reviewScore: score,
+        criticalCount,
+        warningCount,
+        fixApplied: false,
+        durationMs: Date.now() - roundStart
+      });
+      continue;
+    }
+    console.error(chalk9.dim("  Applying fixes..."));
+    const fixPrompt = buildHandoffEnvelope3({
+      command: "custom",
+      task: `Based on the review above, apply ALL suggested fixes to the codebase. Use your file editing tools to make the changes. After applying, verify the changes compile correctly. Only fix issues that were identified \u2014 do not refactor or change unrelated code.`,
+      constraints: [
+        "Make minimal, targeted changes only.",
+        "Do not add comments, docstrings, or formatting changes.",
+        "If a fix is ambiguous, skip it rather than guess."
+      ],
+      resumed: true
+    });
+    const fixResult = await adapter.callWithResume(fixPrompt, {
+      sessionId: threadId,
+      timeout: timeoutMs,
+      ...progress
+    });
+    if (fixResult.sessionId) {
+      threadId = fixResult.sessionId;
+      sessionMgr.updateThreadId(session2.id, fixResult.sessionId);
+    }
+    sessionMgr.addUsageFromResult(session2.id, fixResult.usage, fixPrompt, fixResult.text);
+    const fixApplied = !fixResult.text.includes("no changes") && !fixResult.text.includes("No fixes");
+    console.error(
+      fixApplied ? chalk9.green("  Fixes applied.") : chalk9.yellow("  No fixes applied.")
+    );
+    rounds.push({
+      round,
+      reviewVerdict: verdict,
+      reviewScore: score,
+      criticalCount,
+      warningCount,
+      fixApplied,
+      durationMs: Date.now() - roundStart
+    });
+    if (!fixApplied) {
+      console.error(chalk9.yellow("  No changes made \u2014 stopping loop."));
+      break;
+    }
+  }
+  const lastRound = rounds[rounds.length - 1];
+  const policyCtx = {
+    criticalCount: lastRound?.criticalCount ?? 0,
+    warningCount: lastRound?.warningCount ?? 0,
+    verdict: lastRound?.reviewVerdict ?? "unknown",
+    stepsCompleted: { fix: converged ? "passed" : "failed" },
+    cleanupHighCount: 0
+  };
+  const policy = evaluatePolicy("review.completed", policyCtx, DEFAULT_RULES);
+  const output = {
+    target: fileOrGlob,
+    converged,
+    rounds,
+    totalRounds: rounds.length,
+    finalVerdict: lastRound?.reviewVerdict ?? "unknown",
+    finalScore: lastRound?.reviewScore ?? null,
+    policy,
+    sessionId: session2.id,
+    codexThreadId: threadId
+  };
+  console.log(JSON.stringify(output, null, 2));
+  db.close();
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "fs";
+import { basename, join as join4 } from "path";
+import { loadConfig as loadConfig5, writeConfig } from "@codemoot/core";
+import chalk10 from "chalk";
+async function initCommand(options) {
+  const cwd = process.cwd();
+  const configPath = join4(cwd, ".cowork.yml");
+  if (existsSync2(configPath) && !options.force) {
+    console.error(chalk10.red("Already initialized. Use --force to overwrite."));
+    process.exit(1);
+  }
+  const validPresets = ["cli-first"];
+  let presetName = "cli-first";
+  if (options.preset) {
+    if (!validPresets.includes(options.preset)) {
+      console.error(chalk10.red(`Unknown preset: ${options.preset}. Available: ${validPresets.join(", ")}`));
+      process.exit(1);
+    }
+    presetName = options.preset;
+  } else if (options.nonInteractive) {
+    presetName = "cli-first";
+  } else {
+    const { selectPreset } = await import("./prompts-NYEQYOVN.js");
+    presetName = await selectPreset();
+  }
+  const config = loadConfig5({ preset: presetName, skipFile: options.force });
+  config.project.name = basename(cwd);
+  writeConfig(config, cwd);
+  console.log(chalk10.green(`
+Initialized with '${presetName}' preset`));
+  const modelEntries = Object.entries(config.models);
+  for (const [alias, modelConfig] of modelEntries) {
+    console.log(chalk10.gray(`  ${alias}: ${modelConfig.model}`));
+  }
+  console.log(chalk10.gray('\nNext: codemoot plan "describe your task"'));
+}
+
+// src/commands/install-skills.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname, join as join5 } from "path";
+import chalk11 from "chalk";
+var SKILLS = [
+  {
+    path: ".claude/skills/codex-review/SKILL.md",
+    description: "/codex-review \u2014 Get GPT review via Codex CLI",
+    content: `---
+name: codex-review
+description: Get an independent GPT review via Codex CLI. Use when you want a second opinion on code, plans, or architecture from a different AI model.
+user-invocable: true
+---
+
+# /codex-review \u2014 Get GPT Review via Codex CLI
+
+## Usage
+\`/codex-review <file, glob, or description of what to review>\`
+
+## Description
+Sends content to GPT via \`codemoot review\` for an independent review with session persistence. GPT has full codebase access and reviews are tracked in SQLite. Uses your ChatGPT subscription \u2014 zero API cost.
+
+## Instructions
+
+When the user invokes \`/codex-review\`, follow these steps:
+
+### Step 1: Gather project context
+Before sending to GPT, gather relevant context so GPT understands the project:
+
+1. Check if \`CLAUDE.md\` or \`README.md\` exists \u2014 read the first 200 lines for project overview
+2. Check if \`.claude/settings.json\` or similar config exists
+3. Note the project language, framework, and key patterns
+
+This context will be included in the prompt to reduce false positives.
+
+### Step 2: Determine review mode
+
+**If the user specifies a file or glob:**
+\`\`\`bash
+codemoot review <file-or-glob> --focus all
+\`\`\`
+
+**If the user specifies a diff:**
+\`\`\`bash
+codemoot review --diff HEAD~3..HEAD
+\`\`\`
+
+**If the user gives a freeform description:**
+\`\`\`bash
+codemoot review --prompt "PROJECT CONTEXT: <context from step 1>
+
+REVIEW TASK: <user's description>
+
+Evaluate on: Correctness, Completeness, Quality, Security, Feasibility.
+For security findings, verify by reading the actual code before flagging.
+Provide SCORE: X/10 and VERDICT: APPROVED or NEEDS_REVISION"
+\`\`\`
+
+**For presets:**
+\`\`\`bash
+codemoot review <target> --preset security-audit
+codemoot review <target> --preset quick-scan
+codemoot review <target> --preset performance
+\`\`\`
+
+### Step 3: Parse and present the output
+The command outputs JSON to stdout. Parse it and present as clean markdown:
+
+\`\`\`
+## GPT Review Results
+
+**Score**: X/10 | **Verdict**: APPROVED/NEEDS_REVISION
+
+### Findings
+- [CRITICAL] file:line \u2014 description
+- [WARNING] file:line \u2014 description
+
+### GPT's Full Analysis
+<review text>
+
+Session: <sessionId> | Tokens: <usage> | Duration: <durationMs>ms
+\`\`\`
+
+### Step 4: If NEEDS_REVISION
+Ask if user wants to fix and re-review. If yes:
+1. Fix the issues
+2. Run \`codemoot review\` again \u2014 session resume gives GPT context of prior review
+3. GPT will check if previous issues were addressed
+
+### Important Notes
+- **Session resume**: Each review builds on prior context. GPT remembers what it reviewed before.
+- **Codebase access**: GPT can read project files during review via codex tools.
+- **No arg size limits**: Content is piped via stdin, not passed as CLI args.
+- **Presets**: Use --preset for specialized reviews (security-audit, performance, quick-scan, pre-commit, api-review).
+- **Background mode**: Add --background to enqueue and continue working.
+`
+  },
+  {
+    path: ".claude/skills/debate/SKILL.md",
+    description: "/debate \u2014 Claude vs GPT multi-round debate",
+    content: `---
+name: debate
+description: Real Claude vs GPT multi-round debate. Use when you need a second opinion, want to debate architecture decisions, or evaluate competing approaches.
+user-invocable: true
+---
+
+# /debate \u2014 Real Claude vs GPT Multi-Round Debate
+
+## Usage
+\`/debate <topic or question>\`
+
+## Description
+Structured debate: Claude proposes, GPT critiques, Claude revises, GPT re-evaluates \u2014 looping until convergence or max rounds. Real multi-model collaboration via codemoot CLI with session persistence.
+
+## Instructions
+
+### Phase 0: Setup
+1. Parse topic from user's message
+2. Start debate:
+\`\`\`bash
+codemoot debate start "TOPIC_HERE"
+\`\`\`
+3. Save the \`debateId\` from JSON output
+4. Announce: "Entering debate mode: Claude vs GPT"
+
+### Phase 1: Claude's Opening Proposal
+Think deeply. Generate your genuine proposal. Be thorough and specific.
+
+### Phase 1.5: Gather Codebase Context
+If topic relates to code, use Grep/Glob/Read to find relevant files. Summarize for GPT.
+
+### Phase 2: Send to GPT
+\`\`\`bash
+codemoot debate turn DEBATE_ID "You are a senior technical reviewer debating with Claude about a codebase. You have full access to project files.
+
+DEBATE TOPIC: <topic>
+CODEBASE CONTEXT: <summary>
+CLAUDE'S PROPOSAL: <proposal>
+
+Respond with:
+1. What you agree with
+2. What you disagree with
+3. Suggested improvements
+4. STANCE: SUPPORT, OPPOSE, or UNCERTAIN" --round N
+\`\`\`
+
+### Phase 3: Check Convergence
+- STANCE: SUPPORT \u2192 go to Phase 5
+- Max rounds reached \u2192 go to Phase 5
+- Otherwise \u2192 Phase 4
+
+### Phase 4: Claude's Revision
+Read GPT's critique. Revise genuinely. Send back to GPT.
+
+### Phase 5: Final Synthesis
+\`\`\`bash
+codemoot debate complete DEBATE_ID
+\`\`\`
+Present: final position, agreements, disagreements, stats.
+
+### Rules
+1. Be genuine \u2014 don't just agree to end the debate
+2. Session resume is automatic via callWithResume()
+3. State persisted to SQLite
+4. Zero API cost (ChatGPT subscription)
+5. 600s default timeout per turn
+`
+  },
+  {
+    path: ".claude/skills/build/SKILL.md",
+    description: "/build \u2014 Autonomous build loop with GPT review",
+    content: `---
+name: build
+description: Autonomous build loop \u2014 debate, plan, implement, review, fix \u2014 all in one session with GPT review.
+user-invocable: true
+---
+
+# /build \u2014 Autonomous Build Loop
+
+## Usage
+\`/build <task description>\`
+
+## Description
+Full pipeline: debate approach with GPT \u2192 user approval \u2192 implement \u2192 GPT review \u2192 fix \u2192 re-review until approved. SQLite tracking throughout.
+
+## Instructions
+
+### Phase 0: Initialize
+1. Record user's exact request (acceptance criteria)
+2. \`codemoot build start "TASK"\`
+3. Save buildId and debateId
+
+### Phase 1: Debate the Approach (MANDATORY)
+Use /debate protocol. Loop until GPT says STANCE: SUPPORT.
+- Gather codebase context first
+- Send detailed implementation plan to GPT
+- Revise on OPPOSE/UNCERTAIN \u2014 never skip
+
+### Phase 1.5: User Approval Gate
+Present agreed plan. Wait for explicit approval via AskUserQuestion.
+\`\`\`bash
+codemoot build event BUILD_ID plan_approved
+codemoot debate complete DEBATE_ID
+\`\`\`
+
+### Phase 2: Implement
+Write code. Run tests: \`pnpm run test\`
+Never send broken code to review.
+\`\`\`bash
+codemoot build event BUILD_ID impl_completed
+\`\`\`
+
+### Phase 3: GPT Review
+\`\`\`bash
+codemoot build review BUILD_ID
+\`\`\`
+Parse verdict: approved \u2192 Phase 4.5, needs_revision \u2192 Phase 4
+
+### Phase 4: Fix Issues
+Fix every CRITICAL and BUG. Run tests. Back to Phase 3.
+\`\`\`bash
+codemoot build event BUILD_ID fix_completed
+\`\`\`
+
+### Phase 4.5: Completeness Check
+Compare deliverables against original request. Every requirement must be met.
+
+### Phase 5: Done
+\`\`\`bash
+codemoot build status BUILD_ID
+\`\`\`
+Present summary with metrics, requirements checklist, GPT verdict.
+
+### Rules
+1. NEVER skip debate rounds
+2. NEVER skip user approval
+3. NEVER declare done without completeness check
+4. Run tests after every implementation/fix
+5. Zero API cost (ChatGPT subscription)
+`
+  },
+  {
+    path: ".claude/skills/cleanup/SKILL.md",
+    description: "/cleanup \u2014 Bidirectional AI slop scanner",
+    content: `---
+name: cleanup
+description: Bidirectional AI slop scanner \u2014 Claude + GPT independently analyze, then debate disagreements.
+user-invocable: true
+---
+
+# /cleanup \u2014 Bidirectional AI Slop Scanner
+
+## Usage
+\`/cleanup [scope]\` where scope is: deps, unused-exports, hardcoded, duplicates, deadcode, or all
+
+## Description
+Claude analyzes independently, then codemoot cleanup runs deterministic regex + GPT scans. 3-way merge with majority-vote confidence.
+
+## Instructions
+
+### Phase 1: Claude Independent Analysis
+Scan the codebase yourself using Grep/Glob/Read. For each scope:
+- **deps**: Check package.json deps against actual imports
+- **unused-exports**: Find exported symbols not imported elsewhere
+- **hardcoded**: Magic numbers, URLs, credentials
+- **duplicates**: Similar function logic across files
+- **deadcode**: Declared but never referenced
+
+Save findings as JSON to a temp file.
+
+### Phase 2: Run codemoot cleanup
+\`\`\`bash
+codemoot cleanup --scope SCOPE --host-findings /path/to/claude-findings.json
+\`\`\`
+
+### Phase 3: Present merged results
+Show summary: total, high confidence, disputed, adjudicated, by source.
+
+### Phase 4: Rebuttal Round
+For Claude/GPT disagreements, optionally debate via \`codemoot debate turn\`.
+`
+  },
+  {
+    path: ".claude/agents/codex-liaison.md",
+    description: "Codex Liaison agent \u2014 iterates with GPT until 9.5/10",
+    content: `# Codex Liaison Agent
+
+## Role
+Specialized teammate that communicates with GPT via Codex CLI to get independent reviews and iterate until quality reaches 9.5/10.
+
+## How You Work
+1. Send content to GPT via \`codex exec\` for review
+2. Parse feedback and score
+3. If score < 9.5: revise and re-submit
+4. Loop until 9.5/10 or max 7 iterations
+5. Report final version back to team lead
+
+## Calling Codex CLI
+\`\`\`bash
+codex exec --skip-git-repo-check -o ".codex-liaison-output.txt" "PROMPT_HERE"
+\`\`\`
+
+## Important Rules
+- NEVER fabricate GPT's responses
+- NEVER skip iterations if GPT says NEEDS_REVISION
+- Use your own judgment when GPT's feedback conflicts with project requirements
+- 9.5/10 threshold is strict
+`
+  }
+];
+var CLAUDE_MD_SECTION = `
+## CodeMoot \u2014 Multi-Model Collaboration
+
+This project uses [CodeMoot](https://github.com/katarmal-ram/codemoot) for Claude + GPT collaboration. CodeMoot bridges Claude Code and Codex CLI so they work as partners \u2014 one plans, the other reviews.
+
+### How Sessions Work
+- Every \`codemoot\` command uses a **unified session** with GPT via Codex CLI
+- Sessions persist across commands \u2014 GPT remembers prior reviews, debates, and fixes
+- Sessions are stored in \`.cowork/db/cowork.db\` (SQLite)
+- When a session's token budget fills up, it auto-rolls to a new thread
+- Run \`codemoot session current\` to see the active session
+
+### Available Commands (use these, not raw codex)
+- \`codemoot review <file-or-dir>\` \u2014 GPT reviews code with codebase access
+- \`codemoot review --prompt "question"\` \u2014 GPT explores codebase to answer
+- \`codemoot review --diff HEAD~3..HEAD\` \u2014 Review git changes
+- \`codemoot review --preset security-audit\` \u2014 Specialized review presets
+- \`codemoot fix <file>\` \u2014 Autofix loop: review \u2192 apply fixes \u2192 re-review
+- \`codemoot debate start "topic"\` \u2014 Multi-round Claude vs GPT debate
+- \`codemoot cleanup\` \u2014 Scan for unused deps, dead code, duplicates
+- \`codemoot shipit --profile safe\` \u2014 Composite workflow (lint+test+review)
+- \`codemoot cost\` \u2014 Token usage dashboard
+- \`codemoot doctor\` \u2014 Check prerequisites
+
+### Slash Commands
+- \`/codex-review\` \u2014 Quick GPT review (uses codemoot review internally)
+- \`/debate\` \u2014 Start a Claude vs GPT debate
+- \`/build\` \u2014 Full build loop: debate \u2192 plan \u2192 implement \u2192 GPT review \u2192 fix
+- \`/cleanup\` \u2014 Bidirectional AI slop scanner
+
+### When to Use CodeMoot
+- After implementing a feature \u2192 \`codemoot review src/\`
+- Before committing \u2192 \`codemoot review --diff HEAD --preset pre-commit\`
+- Architecture decisions \u2192 \`/debate "REST vs GraphQL?"\`
+- Full feature build \u2192 \`/build "add user authentication"\`
+- After shipping \u2192 \`codemoot shipit --profile safe\`
+
+### Session Tips
+- Sessions auto-resume \u2014 GPT retains context from prior commands
+- \`codemoot session list\` shows all sessions with token usage
+- \`codemoot cost --scope session\` shows current session spend
+- Start fresh with \`codemoot session start --name "new-feature"\`
+`;
+var HOOKS_CONFIG = {
+  hooks: {
+    PostToolUse: [
+      {
+        matcher: "Bash",
+        pattern: "git commit",
+        command: 'echo "Tip: Run codemoot review --diff HEAD~1 for a GPT review of this commit"'
+      }
+    ]
+  }
+};
+async function installSkillsCommand(options) {
+  const cwd = process.cwd();
+  let installed = 0;
+  let skipped = 0;
+  console.error(chalk11.cyan("\n  Installing CodeMoot integration for Claude Code\n"));
+  console.error(chalk11.dim("  Skills & Agents:"));
+  for (const skill of SKILLS) {
+    const fullPath = join5(cwd, skill.path);
+    const dir = dirname(fullPath);
+    if (existsSync3(fullPath) && !options.force) {
+      console.error(chalk11.dim(`  SKIP ${skill.path} (exists)`));
+      skipped++;
+      continue;
+    }
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync(fullPath, skill.content, "utf-8");
+    console.error(chalk11.green(`  OK   ${skill.path}`));
+    installed++;
+  }
+  console.error("");
+  console.error(chalk11.dim("  CLAUDE.md:"));
+  const claudeMdPath = join5(cwd, "CLAUDE.md");
+  const marker = "## CodeMoot \u2014 Multi-Model Collaboration";
+  if (existsSync3(claudeMdPath)) {
+    const existing = readFileSync2(claudeMdPath, "utf-8");
+    if (existing.includes(marker)) {
+      if (options.force) {
+        const markerIdx = existing.indexOf(marker);
+        const before = existing.slice(0, markerIdx);
+        const afterMarker = existing.slice(markerIdx + marker.length);
+        const nextHeadingMatch = afterMarker.match(/\n#{1,2} (?!#)(?!CodeMoot)/);
+        const after = nextHeadingMatch ? afterMarker.slice(nextHeadingMatch.index) : "";
+        writeFileSync(claudeMdPath, before.trimEnd() + "\n" + CLAUDE_MD_SECTION + after, "utf-8");
+        console.error(chalk11.green("  OK   CLAUDE.md (updated CodeMoot section)"));
+        installed++;
+      } else {
+        console.error(chalk11.dim("  SKIP CLAUDE.md (CodeMoot section exists)"));
+        skipped++;
+      }
+    } else {
+      writeFileSync(claudeMdPath, existing.trimEnd() + "\n" + CLAUDE_MD_SECTION, "utf-8");
+      console.error(chalk11.green("  OK   CLAUDE.md (appended CodeMoot section)"));
+      installed++;
+    }
+  } else {
+    writeFileSync(claudeMdPath, `# Project Instructions
+${CLAUDE_MD_SECTION}`, "utf-8");
+    console.error(chalk11.green("  OK   CLAUDE.md (created with CodeMoot section)"));
+    installed++;
+  }
+  console.error("");
+  console.error(chalk11.dim("  Hooks:"));
+  const settingsDir = join5(cwd, ".claude");
+  const settingsPath = join5(settingsDir, "settings.json");
+  if (existsSync3(settingsPath)) {
+    try {
+      const existing = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+      const hasCodemootHook = Array.isArray(existing.hooks?.PostToolUse) && existing.hooks.PostToolUse.some((h) => h.command?.includes("codemoot"));
+      if (hasCodemootHook && !options.force) {
+        console.error(chalk11.dim("  SKIP .claude/settings.json (codemoot hook exists)"));
+        skipped++;
+      } else {
+        const otherHooks = Array.isArray(existing.hooks?.PostToolUse) ? existing.hooks.PostToolUse.filter((h) => !h.command?.includes("codemoot")) : [];
+        existing.hooks = {
+          ...existing.hooks,
+          PostToolUse: [...otherHooks, ...HOOKS_CONFIG.hooks.PostToolUse]
+        };
+        writeFileSync(settingsPath, JSON.stringify(existing, null, 2), "utf-8");
+        console.error(chalk11.green("  OK   .claude/settings.json (added post-commit hint hook)"));
+        installed++;
+      }
+    } catch (err) {
+      console.error(chalk11.yellow(`  WARN .claude/settings.json parse error: ${err.message}`));
+      console.error(chalk11.yellow("       Back up and delete the file, then re-run install-skills"));
+      skipped++;
+    }
+  } else {
+    mkdirSync2(settingsDir, { recursive: true });
+    writeFileSync(settingsPath, JSON.stringify(HOOKS_CONFIG, null, 2), "utf-8");
+    console.error(chalk11.green("  OK   .claude/settings.json (created with post-commit hook)"));
+    installed++;
+  }
+  console.error("");
+  console.error(chalk11.cyan(`  Installed: ${installed}, Skipped: ${skipped}`));
+  console.error("");
+  console.error(chalk11.dim("  Slash commands: /codex-review, /debate, /build, /cleanup"));
+  console.error(chalk11.dim("  CLAUDE.md: Claude now knows about codemoot commands & sessions"));
+  console.error(chalk11.dim("  Hook: Post-commit hint to run codemoot review"));
+  console.error("");
+  const output = {
+    installed,
+    skipped,
+    total: SKILLS.length + 2,
+    // +CLAUDE.md +hooks
+    skills: SKILLS.map((s) => ({ path: s.path, description: s.description }))
+  };
+  console.log(JSON.stringify(output, null, 2));
+}
+
+// src/commands/session.ts
+import { SessionManager as SessionManager6 } from "@codemoot/core";
+import chalk12 from "chalk";
+async function sessionStartCommand(options) {
+  await withDatabase(async (db) => {
+    const mgr = new SessionManager6(db);
+    const id = mgr.create(options.name);
+    const session2 = mgr.get(id);
+    mgr.recordEvent({
+      sessionId: id,
+      command: "session",
+      subcommand: "start",
+      promptPreview: `Session started: ${session2?.name ?? id}`
+    });
+    console.log(JSON.stringify({
+      sessionId: id,
+      name: session2?.name ?? null,
+      status: "active",
+      message: "Session created. All GPT commands will now use this session."
+    }, null, 2));
+  });
+}
+async function sessionCurrentCommand() {
+  await withDatabase(async (db) => {
+    const mgr = new SessionManager6(db);
+    const session2 = mgr.getActive();
+    if (!session2) {
+      console.log(JSON.stringify({ active: false, message: 'No active session. Run "codemoot session start" to create one.' }));
+      return;
+    }
+    const events = mgr.getEvents(session2.id, 5);
+    const overflow = mgr.getOverflowStatus(session2.id);
+    console.log(JSON.stringify({
+      sessionId: session2.id,
+      name: session2.name,
+      codexThreadId: session2.codexThreadId,
+      status: session2.status,
+      tokenBudget: {
+        used: overflow.cumulativeTokens,
+        lastTurnInput: overflow.lastTurnInputTokens,
+        max: overflow.maxContext,
+        utilization: `${Math.round(overflow.utilizationRatio * 100)}%`
+      },
+      recentEvents: events.map((e) => ({
+        command: e.command,
+        subcommand: e.subcommand,
+        durationMs: e.durationMs,
+        createdAt: new Date(e.createdAt).toISOString()
+      })),
+      createdAt: new Date(session2.createdAt).toISOString(),
+      updatedAt: new Date(session2.updatedAt).toISOString()
+    }, null, 2));
+  });
+}
+async function sessionListCommand(options) {
+  await withDatabase(async (db) => {
+    const mgr = new SessionManager6(db);
+    const sessions = mgr.list({
+      status: options.status,
+      limit: options.limit ?? 20
+    });
+    const output = sessions.map((s) => ({
+      sessionId: s.id,
+      name: s.name,
+      status: s.status,
+      codexThreadId: s.codexThreadId ? `${s.codexThreadId.slice(0, 12)}...` : null,
+      tokenUsage: s.tokenUsage,
+      createdAt: new Date(s.createdAt).toISOString(),
+      updatedAt: new Date(s.updatedAt).toISOString()
+    }));
+    console.log(JSON.stringify(output, null, 2));
+  });
+}
+async function sessionStatusCommand(sessionId) {
+  await withDatabase(async (db) => {
+    const mgr = new SessionManager6(db);
+    const session2 = mgr.get(sessionId);
+    if (!session2) {
+      console.error(chalk12.red(`No session found with ID: ${sessionId}`));
+      process.exit(1);
+    }
+    const events = mgr.getEvents(sessionId, 20);
+    const overflow = mgr.getOverflowStatus(sessionId);
+    console.log(JSON.stringify({
+      sessionId: session2.id,
+      name: session2.name,
+      codexThreadId: session2.codexThreadId,
+      status: session2.status,
+      tokenBudget: {
+        used: overflow.cumulativeTokens,
+        lastTurnInput: overflow.lastTurnInputTokens,
+        max: overflow.maxContext,
+        utilization: `${Math.round(overflow.utilizationRatio * 100)}%`,
+        shouldWarn: overflow.shouldWarn,
+        shouldReconstruct: overflow.shouldReconstruct
+      },
+      eventCount: events.length,
+      events: events.map((e) => ({
+        command: e.command,
+        subcommand: e.subcommand,
+        promptPreview: e.promptPreview,
+        responsePreview: e.responsePreview,
+        durationMs: e.durationMs,
+        createdAt: new Date(e.createdAt).toISOString()
+      })),
+      createdAt: new Date(session2.createdAt).toISOString(),
+      updatedAt: new Date(session2.updatedAt).toISOString(),
+      completedAt: session2.completedAt ? new Date(session2.completedAt).toISOString() : null
+    }, null, 2));
+  });
+}
+async function sessionCloseCommand(sessionId) {
+  await withDatabase(async (db) => {
+    const mgr = new SessionManager6(db);
+    const session2 = mgr.get(sessionId);
+    if (!session2) {
+      console.error(chalk12.red(`No session found with ID: ${sessionId}`));
+      process.exit(1);
+    }
+    mgr.complete(sessionId);
+    console.log(JSON.stringify({ sessionId, status: "completed" }));
+  });
+}
+
+// src/commands/jobs.ts
+import { JobStore as JobStore2, openDatabase as openDatabase8 } from "@codemoot/core";
+import chalk13 from "chalk";
+async function jobsListCommand(options) {
+  let db;
+  try {
+    db = openDatabase8(getDbPath());
+    const store = new JobStore2(db);
+    const jobs2 = store.list({
+      status: options.status,
+      type: options.type,
+      limit: options.limit ?? 20
+    });
+    const output = jobs2.map((j) => ({
+      id: j.id,
+      type: j.type,
+      status: j.status,
+      priority: j.priority,
+      retryCount: j.retryCount,
+      workerId: j.workerId,
+      createdAt: new Date(j.createdAt).toISOString(),
+      startedAt: j.startedAt ? new Date(j.startedAt).toISOString() : null,
+      finishedAt: j.finishedAt ? new Date(j.finishedAt).toISOString() : null
+    }));
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk13.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function jobsLogsCommand(jobId, options) {
+  let db;
+  try {
+    db = openDatabase8(getDbPath());
+    const store = new JobStore2(db);
+    const job = store.get(jobId);
+    if (!job) {
+      console.error(chalk13.red(`No job found with ID: ${jobId}`));
+      db.close();
+      process.exit(1);
+    }
+    const logs = store.getLogs(jobId, options.fromSeq ?? 0, options.limit ?? 100);
+    const output = {
+      jobId: job.id,
+      type: job.type,
+      status: job.status,
+      logs: logs.map((l) => ({
+        seq: l.seq,
+        level: l.level,
+        event: l.eventType,
+        message: l.message,
+        time: new Date(l.createdAt).toISOString()
+      }))
+    };
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk13.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function jobsCancelCommand(jobId) {
+  let db;
+  try {
+    db = openDatabase8(getDbPath());
+    const store = new JobStore2(db);
+    const job = store.get(jobId);
+    if (!job) {
+      console.error(chalk13.red(`No job found with ID: ${jobId}`));
+      db.close();
+      process.exit(1);
+    }
+    store.cancel(jobId);
+    console.log(JSON.stringify({ jobId, status: "canceled" }));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk13.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function jobsRetryCommand(jobId) {
+  let db;
+  try {
+    db = openDatabase8(getDbPath());
+    const store = new JobStore2(db);
+    const job = store.get(jobId);
+    if (!job) {
+      console.error(chalk13.red(`No job found with ID: ${jobId}`));
+      db.close();
+      process.exit(1);
+    }
+    const retried = store.retry(jobId);
+    if (!retried) {
+      console.error(chalk13.red(`Cannot retry job ${jobId}: status=${job.status}, retries=${job.retryCount}/${job.maxRetries}`));
+      db.close();
+      process.exit(1);
+    }
+    console.log(JSON.stringify({ jobId, status: "queued", retryCount: job.retryCount + 1 }));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk13.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function jobsStatusCommand(jobId) {
+  let db;
+  try {
+    db = openDatabase8(getDbPath());
+    const store = new JobStore2(db);
+    const job = store.get(jobId);
+    if (!job) {
+      console.error(chalk13.red(`No job found with ID: ${jobId}`));
+      db.close();
+      process.exit(1);
+    }
+    const logs = store.getLogs(jobId, 0, 5);
+    const output = {
+      id: job.id,
+      type: job.type,
+      status: job.status,
+      priority: job.priority,
+      retryCount: job.retryCount,
+      maxRetries: job.maxRetries,
+      workerId: job.workerId,
+      sessionId: job.sessionId,
+      payload: JSON.parse(job.payloadJson),
+      result: job.resultJson ? JSON.parse(job.resultJson) : null,
+      error: job.errorText,
+      recentLogs: logs.map((l) => ({
+        seq: l.seq,
+        level: l.level,
+        event: l.eventType,
+        message: l.message
+      })),
+      createdAt: new Date(job.createdAt).toISOString(),
+      startedAt: job.startedAt ? new Date(job.startedAt).toISOString() : null,
+      finishedAt: job.finishedAt ? new Date(job.finishedAt).toISOString() : null
+    };
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    db?.close();
+    console.error(chalk13.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/plan.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { ModelRegistry as ModelRegistry4, Orchestrator, loadConfig as loadConfig6, openDatabase as openDatabase9 } from "@codemoot/core";
+import chalk15 from "chalk";
+
+// src/render.ts
+import chalk14 from "chalk";
+import ora from "ora";
+var roleColors = {
+  architect: chalk14.blue,
+  reviewer: chalk14.yellow,
+  implementer: chalk14.green
+};
+function getRoleColor(role) {
+  return roleColors[role] ?? chalk14.white;
+}
+function renderEvent(event, _config) {
+  switch (event.type) {
+    case "session.started":
+      console.log(chalk14.gray(`
+\u2501\u2501\u2501 Session ${event.sessionId} \u2501\u2501\u2501`));
+      console.log(chalk14.gray(`Workflow: ${event.workflow}`));
+      console.log(chalk14.gray(`Task: ${event.task}
+`));
+      break;
+    case "session.completed":
+      console.log(chalk14.green("\n\u2501\u2501\u2501 Session Complete \u2501\u2501\u2501"));
+      console.log(chalk14.cyan(`  Cost:     $${event.totalCost.toFixed(4)}`));
+      console.log(chalk14.cyan(`  Tokens:   ${event.totalTokens.toLocaleString()}`));
+      console.log(chalk14.cyan(`  Duration: ${(event.durationMs / 1e3).toFixed(1)}s`));
+      break;
+    case "session.failed":
+      console.log(chalk14.red("\n\u2501\u2501\u2501 Session Failed \u2501\u2501\u2501"));
+      console.log(chalk14.red(`  Error: ${event.error}`));
+      console.log(chalk14.red(`  Last step: ${event.lastStep}`));
+      break;
+    case "step.started": {
+      const color = getRoleColor(event.role);
+      console.log(
+        color(`
+\u25B6 [${event.role}] ${event.stepId} (${event.model}, iter ${event.iteration})`)
+      );
+      break;
+    }
+    case "step.completed":
+      console.log(
+        chalk14.gray(
+          `  \u2713 ${event.stepId} (${(event.durationMs / 1e3).toFixed(1)}s, ${event.tokenUsage.totalTokens} tokens)`
+        )
+      );
+      break;
+    case "step.failed":
+      console.log(chalk14.red(`  \u2717 ${event.stepId}: ${event.error}`));
+      break;
+    case "text.delta": {
+      const deltaColor = getRoleColor(event.role);
+      process.stdout.write(deltaColor(event.delta));
+      break;
+    }
+    case "text.done":
+      process.stdout.write("\n");
+      break;
+    case "loop.iteration": {
+      const verdictColor = event.verdict === "approved" ? chalk14.green : chalk14.yellow;
+      console.log(
+        verdictColor(`
+  \u21BB Loop ${event.iteration}/${event.maxIterations}: ${event.verdict}`)
+      );
+      if (event.feedback) {
+        console.log(chalk14.gray(`    Feedback: ${event.feedback.slice(0, 200)}...`));
+      }
+      break;
+    }
+    case "cost.update":
+      console.log(
+        chalk14.cyan(
+          `  $${event.costUsd.toFixed(4)} (cumulative: $${event.cumulativeSessionCost.toFixed(4)})`
+        )
+      );
+      break;
+  }
+}
+function printSessionSummary(result) {
+  console.log(chalk14.bold("\nSession Summary"));
+  console.log(chalk14.gray("-".repeat(40)));
+  console.log(`  Session:    ${chalk14.white(result.sessionId)}`);
+  console.log(
+    `  Status:     ${result.status === "completed" ? chalk14.green("completed") : chalk14.red(result.status)}`
+  );
+  console.log(`  Cost:       ${chalk14.cyan(`$${result.totalCost.toFixed(4)}`)}`);
+  console.log(`  Tokens:     ${chalk14.cyan(result.totalTokens.toLocaleString())}`);
+  console.log(`  Duration:   ${chalk14.cyan(`${(result.durationMs / 1e3).toFixed(1)}s`)}`);
+  console.log(`  Iterations: ${chalk14.cyan(String(result.iterations))}`);
+  console.log(chalk14.gray("-".repeat(40)));
+}
+
+// src/commands/plan.ts
+async function planCommand(task, options) {
+  try {
+    const config = loadConfig6();
+    const projectDir = process.cwd();
+    const registry = ModelRegistry4.fromConfig(config, projectDir);
+    const health = await registry.healthCheckAll();
+    for (const [alias, hasKey] of health) {
+      if (!hasKey) {
+        console.warn(chalk15.yellow(`Warning: No API key for model "${alias}"`));
+      }
+    }
+    const dbPath = getDbPath();
+    const db = openDatabase9(dbPath);
+    const orchestrator = new Orchestrator({ registry, db, config });
+    orchestrator.on("event", (event) => renderEvent(event, config));
+    const result = await orchestrator.plan(task, {
+      maxRounds: options.rounds
+    });
+    if (options.output) {
+      writeFileSync2(options.output, result.finalOutput, "utf-8");
+      console.log(chalk15.green(`Plan saved to ${options.output}`));
+    }
+    printSessionSummary(result);
+    db.close();
+    process.exit(result.status === "completed" ? 0 : 2);
+  } catch (error) {
+    console.error(chalk15.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/review.ts
+import { loadConfig as loadConfig7, ModelRegistry as ModelRegistry5, BINARY_SNIFF_BYTES, REVIEW_DIFF_MAX_CHARS as REVIEW_DIFF_MAX_CHARS3, SessionManager as SessionManager7, JobStore as JobStore3, openDatabase as openDatabase10, buildHandoffEnvelope as buildHandoffEnvelope4, getReviewPreset } from "@codemoot/core";
+import chalk16 from "chalk";
+import { execFileSync as execFileSync2, execSync as execSync4 } from "child_process";
+import { closeSync, globSync, openSync, readFileSync as readFileSync3, readSync, statSync, existsSync as existsSync4 } from "fs";
+import { resolve } from "path";
+var MAX_FILE_SIZE = 100 * 1024;
+var MAX_TOTAL_SIZE = 200 * 1024;
+async function reviewCommand(fileOrGlob, options) {
+  try {
+    const projectDir = process.cwd();
+    const modes = [
+      fileOrGlob ? "file" : "",
+      options.prompt ? "prompt" : "",
+      options.stdin ? "stdin" : "",
+      options.diff ? "diff" : ""
+    ].filter(Boolean);
+    if (modes.length === 0) {
+      console.error(chalk16.red("No input specified. Use: <file-or-glob>, --prompt, --stdin, or --diff"));
+      process.exit(1);
+    }
+    if (modes.length > 1) {
+      console.error(chalk16.red(`Conflicting input modes: ${modes.join(", ")}. Use exactly one.`));
+      process.exit(1);
+    }
+    if (options.scope && !options.prompt && !options.stdin) {
+      console.error(chalk16.red("--scope can only be used with --prompt or --stdin"));
+      process.exit(1);
+    }
+    const config = loadConfig7();
+    const registry = ModelRegistry5.fromConfig(config, projectDir);
+    const adapter = registry.tryGetAdapter("codex-reviewer") ?? registry.tryGetAdapter("codex-architect");
+    if (!adapter) {
+      try {
+        execSync4("codex --version", { stdio: "pipe", encoding: "utf-8" });
+      } catch {
+        console.error(chalk16.red("Codex CLI is not installed or not in PATH."));
+        console.error(chalk16.yellow("Install it: npm install -g @openai/codex"));
+        console.error(chalk16.yellow("Then run: codemoot init"));
+        process.exit(1);
+      }
+      console.error(chalk16.red("No codex adapter found in config. Run: codemoot init"));
+      console.error(chalk16.dim("Diagnose: codemoot doctor"));
+      process.exit(1);
+    }
+    if (options.background) {
+      const db2 = openDatabase10(getDbPath());
+      const jobStore = new JobStore3(db2);
+      const jobId = jobStore.enqueue({
+        type: "review",
+        payload: {
+          fileOrGlob: fileOrGlob ?? null,
+          focus: options.focus,
+          timeout: options.timeout,
+          prompt: options.prompt,
+          stdin: options.stdin,
+          diff: options.diff,
+          scope: options.scope,
+          cwd: projectDir
+        }
+      });
+      console.log(JSON.stringify({ jobId, status: "queued", message: "Review enqueued. Check with: codemoot jobs status " + jobId }));
+      db2.close();
+      return;
+    }
+    const db = openDatabase10(getDbPath());
+    const sessionMgr = new SessionManager7(db);
+    const session2 = options.session ? sessionMgr.get(options.session) : sessionMgr.resolveActive("review");
+    if (!session2) {
+      console.error(chalk16.red(options.session ? `Session not found: ${options.session}` : "No active session. Run: codemoot init"));
+      db.close();
+      process.exit(1);
+    }
+    const overflowCheck = sessionMgr.preCallOverflowCheck(session2.id);
+    if (overflowCheck.rolled) {
+      console.error(chalk16.yellow(`  ${overflowCheck.message}`));
+    }
+    const preset = options.preset ? getReviewPreset(options.preset) : void 0;
+    if (options.preset && !preset) {
+      console.error(chalk16.red(`Unknown preset: ${options.preset}. Use: security-audit, performance, quick-scan, pre-commit, api-review`));
+      db.close();
+      process.exit(1);
+    }
+    const focusArea = preset?.focus ?? options.focus ?? "all";
+    const focusConstraint = focusArea === "all" ? "Review for: correctness, bugs, security, performance, code quality" : `Focus specifically on: ${focusArea}`;
+    const presetConstraints = preset?.constraints ?? [];
+    const currentSession = sessionMgr.get(session2.id);
+    const sessionThreadId = currentSession?.codexThreadId ?? void 0;
+    const isResumed = Boolean(sessionThreadId);
+    let prompt;
+    let promptPreview;
+    const mode = modes[0];
+    if (mode === "prompt" || mode === "stdin") {
+      let instruction = options.prompt ?? "";
+      if (mode === "stdin") {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk);
+        }
+        instruction = Buffer.concat(chunks).toString("utf-8").trim();
+        if (!instruction) {
+          console.error(chalk16.red("No input received from stdin"));
+          db.close();
+          process.exit(1);
+        }
+      }
+      prompt = buildHandoffEnvelope4({
+        command: "review",
+        task: `TASK: ${instruction}
+
+Start by listing candidate files, then inspect them thoroughly.`,
+        constraints: [focusConstraint, ...presetConstraints],
+        scope: options.scope,
+        resumed: isResumed
+      });
+      promptPreview = `Prompt review: ${instruction.slice(0, 100)}`;
+      console.error(chalk16.cyan(`Reviewing via prompt (session: ${session2.id.slice(0, 8)}...)...`));
+    } else if (mode === "diff") {
+      let diff;
+      try {
+        diff = execFileSync2("git", ["diff", ...options.diff.split(/\s+/)], {
+          cwd: projectDir,
+          encoding: "utf-8",
+          maxBuffer: 1024 * 1024
+        });
+      } catch (err) {
+        console.error(chalk16.red(`Failed to get diff for ${options.diff}: ${err instanceof Error ? err.message : String(err)}`));
+        db.close();
+        process.exit(1);
+      }
+      if (!diff.trim()) {
+        console.error(chalk16.yellow(`No changes in diff: ${options.diff}`));
+        db.close();
+        process.exit(0);
+      }
+      prompt = buildHandoffEnvelope4({
+        command: "review",
+        task: `Review the following code changes.
+
+GIT DIFF (${options.diff}):
+${diff.slice(0, REVIEW_DIFF_MAX_CHARS3)}`,
+        constraints: [focusConstraint, ...presetConstraints],
+        resumed: isResumed
+      });
+      promptPreview = `Diff review: ${options.diff}`;
+      console.error(chalk16.cyan(`Reviewing diff ${options.diff} (session: ${session2.id.slice(0, 8)}...)...`));
+    } else {
+      let globPattern = fileOrGlob;
+      const resolvedInput = resolve(projectDir, globPattern);
+      if (existsSync4(resolvedInput) && statSync(resolvedInput).isDirectory()) {
+        globPattern = `${globPattern}/**/*`;
+        console.error(chalk16.dim(`  Expanding directory to: ${globPattern}`));
+      }
+      const paths = globSync(globPattern, { cwd: projectDir }).map((p) => resolve(projectDir, p));
+      if (paths.length === 0) {
+        console.error(chalk16.red(`No files matched: ${fileOrGlob}`));
+        db.close();
+        process.exit(1);
+      }
+      const files = [];
+      let totalSize = 0;
+      for (const filePath of paths) {
+        const stat = statSync(filePath);
+        if (!stat.isFile()) continue;
+        if (stat.size > MAX_FILE_SIZE) {
+          console.error(chalk16.yellow(`Skipping ${filePath} (${(stat.size / 1024).toFixed(0)}KB > 100KB limit)`));
+          continue;
+        }
+        if (totalSize + stat.size > MAX_TOTAL_SIZE) {
+          console.error(chalk16.yellow(`Skipping remaining files (total would exceed 200KB)`));
+          break;
+        }
+        const buf = Buffer.alloc(BINARY_SNIFF_BYTES);
+        const fd = openSync(filePath, "r");
+        const bytesRead = readSync(fd, buf, 0, BINARY_SNIFF_BYTES, 0);
+        closeSync(fd);
+        if (buf.subarray(0, bytesRead).includes(0)) {
+          console.error(chalk16.yellow(`Skipping ${filePath} (binary file)`));
+          continue;
+        }
+        const content = readFileSync3(filePath, "utf-8");
+        const relativePath = filePath.replace(projectDir, "").replace(/\\/g, "/").replace(/^\//, "");
+        files.push({ path: relativePath, content });
+        totalSize += stat.size;
+      }
+      if (files.length === 0) {
+        console.error(chalk16.red("No readable files to review"));
+        db.close();
+        process.exit(1);
+      }
+      const fileContents = files.map((f) => `--- ${f.path} ---
+${f.content}`).join("\n\n");
+      prompt = buildHandoffEnvelope4({
+        command: "review",
+        task: `Review the following code files.
+
+FILES TO REVIEW:
+${fileContents}`,
+        constraints: [focusConstraint, ...presetConstraints],
+        resumed: isResumed
+      });
+      promptPreview = `Review ${files.length} file(s): ${files.map((f) => f.path).join(", ")}`;
+      console.error(chalk16.cyan(`Reviewing ${files.length} file(s) via codex (session: ${session2.id.slice(0, 8)}...)...`));
+    }
+    const timeoutMs = (options.timeout ?? 600) * 1e3;
+    const progress = createProgressCallbacks("review");
+    const result = await adapter.callWithResume(prompt, {
+      sessionId: sessionThreadId,
+      timeout: timeoutMs,
+      ...progress
+    });
+    if (result.sessionId) {
+      sessionMgr.updateThreadId(session2.id, result.sessionId);
+    }
+    sessionMgr.addUsageFromResult(session2.id, result.usage, prompt, result.text);
+    sessionMgr.recordEvent({
+      sessionId: session2.id,
+      command: "review",
+      subcommand: mode,
+      promptPreview: promptPreview.slice(0, 500),
+      responsePreview: result.text.slice(0, 500),
+      promptFull: prompt,
+      responseFull: result.text,
+      usageJson: JSON.stringify(result.usage),
+      durationMs: result.durationMs,
+      codexThreadId: result.sessionId
+    });
+    const findings = [];
+    for (const line of result.text.split("\n")) {
+      const match = line.match(/^-\s*(CRITICAL|WARNING|INFO):\s*(\S+?)(?::(\d+))?\s+(.+)/);
+      if (match) {
+        findings.push({
+          severity: match[1].toLowerCase(),
+          file: match[2],
+          line: match[3] ?? "?",
+          message: match[4]
+        });
+      }
+    }
+    const tail = result.text.slice(-500);
+    const verdictMatch = tail.match(/^(?:-\s*)?VERDICT:\s*(APPROVED|NEEDS_REVISION)/m);
+    const scoreMatch = tail.match(/SCORE:\s*(\d+)\/10/);
+    const output = {
+      mode,
+      findings,
+      verdict: verdictMatch ? verdictMatch[1].toLowerCase() : "unknown",
+      score: scoreMatch ? Number.parseInt(scoreMatch[1], 10) : null,
+      review: result.text,
+      sessionId: session2.id,
+      codexThreadId: result.sessionId,
+      resumed: sessionThreadId ? result.sessionId === sessionThreadId : false,
+      usage: result.usage,
+      durationMs: result.durationMs
+    };
+    const verdictColor = output.verdict === "approved" ? chalk16.green : chalk16.red;
+    console.error(verdictColor(`
+Verdict: ${output.verdict.toUpperCase()} (${output.score ?? "?"}/10)`));
+    if (findings.length > 0) {
+      console.error(chalk16.yellow(`Findings (${findings.length}):`));
+      for (const f of findings) {
+        const sev = f.severity === "critical" ? chalk16.red("CRITICAL") : f.severity === "warning" ? chalk16.yellow("WARNING") : chalk16.dim("INFO");
+        console.error(`  ${sev} ${f.file}:${f.line} \u2014 ${f.message}`);
+      }
+    } else {
+      console.error(chalk16.green("No issues found."));
+    }
+    console.error(chalk16.dim(`Duration: ${(output.durationMs / 1e3).toFixed(1)}s | Tokens: ${output.usage?.totalTokens ?? "?"}`));
+    console.log(JSON.stringify(output, null, 2));
+    db.close();
+  } catch (error) {
+    console.error(chalk16.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/run.ts
+import { ModelRegistry as ModelRegistry6, Orchestrator as Orchestrator2, loadConfig as loadConfig8, openDatabase as openDatabase11 } from "@codemoot/core";
+import chalk17 from "chalk";
+async function runCommand(task, options) {
+  try {
+    const config = loadConfig8();
+    const projectDir = process.cwd();
+    const registry = ModelRegistry6.fromConfig(config, projectDir);
+    const health = await registry.healthCheckAll();
+    for (const [alias, hasKey] of health) {
+      if (!hasKey) {
+        console.warn(chalk17.yellow(`Warning: No API key for model "${alias}"`));
+      }
+    }
+    const dbPath = getDbPath();
+    const db = openDatabase11(dbPath);
+    const orchestrator = new Orchestrator2({ registry, db, config });
+    orchestrator.on("event", (event) => renderEvent(event, config));
+    const result = await orchestrator.run(task, {
+      mode: options.mode ?? config.mode,
+      maxIterations: options.maxIterations,
+      stream: options.stream
+    });
+    printSessionSummary(result);
+    db.close();
+    process.exit(result.status === "completed" ? 0 : 2);
+  } catch (error) {
+    console.error(chalk17.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/shipit.ts
+import { execSync as execSync5 } from "child_process";
+import { DEFAULT_RULES as DEFAULT_RULES2, evaluatePolicy as evaluatePolicy2 } from "@codemoot/core";
+import chalk18 from "chalk";
+var PROFILES = {
+  fast: ["review"],
+  safe: ["lint", "test", "review", "cleanup"],
+  full: ["lint", "test", "review", "cleanup", "commit"]
+};
+function runStep(name, dryRun) {
+  const start = Date.now();
+  if (dryRun) {
+    return { name, status: "skipped", output: "dry-run", durationMs: 0 };
+  }
+  try {
+    let cmd;
+    switch (name) {
+      case "lint":
+        cmd = "npx biome check .";
+        break;
+      case "test":
+        cmd = "pnpm run test";
+        break;
+      case "review":
+        cmd = "codemoot review --preset pre-commit --diff HEAD";
+        break;
+      case "cleanup":
+        cmd = "codemoot cleanup --scope deps";
+        break;
+      case "commit":
+        return { name, status: "skipped", output: "handled by shipit", durationMs: 0 };
+      default:
+        return { name, status: "skipped", output: `unknown step: ${name}`, durationMs: 0 };
+    }
+    const output = execSync5(cmd, {
+      encoding: "utf-8",
+      timeout: 3e5,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return {
+      name,
+      status: "passed",
+      output: output.slice(0, 2e3),
+      durationMs: Date.now() - start
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { name, status: "failed", output: msg.slice(0, 2e3), durationMs: Date.now() - start };
+  }
+}
+async function shipitCommand(options) {
+  const profile = options.profile;
+  const steps = PROFILES[profile];
+  if (!steps) {
+    console.error(chalk18.red(`Unknown profile: ${profile}. Use: fast, safe, full`));
+    process.exit(1);
+  }
+  if (options.dryRun) {
+    console.error(chalk18.cyan(`Shipit dry-run (profile: ${profile})`));
+    console.error(chalk18.dim(`Steps: ${steps.join(" \u2192 ")}`));
+  } else {
+    console.error(chalk18.cyan(`Shipit (profile: ${profile}): ${steps.join(" \u2192 ")}`));
+  }
+  const results = [];
+  let shouldStop = false;
+  for (const step of steps) {
+    if (shouldStop) {
+      results.push({ name: step, status: "skipped", durationMs: 0 });
+      continue;
+    }
+    const result = runStep(step, options.dryRun);
+    results.push(result);
+    if (!options.dryRun) {
+      const icon = result.status === "passed" ? chalk18.green("OK") : result.status === "failed" ? chalk18.red("FAIL") : chalk18.dim("SKIP");
+      console.error(`  ${icon} ${result.name} (${result.durationMs}ms)`);
+    }
+    if (result.status === "failed" && (step === "lint" || step === "test")) {
+      shouldStop = true;
+    }
+  }
+  const reviewResult = results.find((r) => r.name === "review");
+  const criticalCount = reviewResult?.output?.match(/CRITICAL/gi)?.length ?? 0;
+  const warningCount = reviewResult?.output?.match(/WARNING/gi)?.length ?? 0;
+  const verdictMatch = reviewResult?.output?.match(/VERDICT:\s*(APPROVED|NEEDS_REVISION)/i);
+  const policyCtx = {
+    criticalCount,
+    warningCount,
+    verdict: verdictMatch ? verdictMatch[1].toLowerCase() : "unknown",
+    stepsCompleted: Object.fromEntries(results.map((r) => [r.name, r.status])),
+    cleanupHighCount: 0
+  };
+  const policyResult = evaluatePolicy2("review.completed", policyCtx, DEFAULT_RULES2);
+  if (policyResult.decision === "block") {
+    console.error(chalk18.red("Policy BLOCKED:"));
+    for (const v of policyResult.violations) {
+      console.error(chalk18.red(`  - ${v.message}`));
+    }
+  } else if (policyResult.decision === "warn") {
+    for (const v of policyResult.violations) {
+      console.error(chalk18.yellow(`  Warning: ${v.message}`));
+    }
+  }
+  const output = {
+    profile,
+    steps: results,
+    policy: policyResult,
+    canCommit: policyResult.decision !== "block" && !shouldStop && !options.noCommit
+  };
+  if (options.json) {
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    const allPassed = results.every((r) => r.status === "passed" || r.status === "skipped");
+    if (allPassed && policyResult.decision !== "block") {
+      console.error(chalk18.green("\nAll checks passed. Ready to commit."));
+    } else {
+      console.error(chalk18.red("\nSome checks failed or policy blocked."));
+    }
+  }
+}
+
+// src/commands/start.ts
+import { existsSync as existsSync5 } from "fs";
+import { execFileSync as execFileSync3, execSync as execSync6 } from "child_process";
+import { join as join6, basename as basename2 } from "path";
+import chalk19 from "chalk";
+import { loadConfig as loadConfig9, writeConfig as writeConfig2 } from "@codemoot/core";
+async function startCommand() {
+  const cwd = process.cwd();
+  console.error(chalk19.cyan("\n  CodeMoot \u2014 First Run Setup\n"));
+  console.error(chalk19.dim("  [1/4] Checking Codex CLI..."));
+  let codexVersion = null;
+  try {
+    codexVersion = execSync6("codex --version", { stdio: "pipe", encoding: "utf-8" }).trim();
+  } catch {
+  }
+  if (!codexVersion) {
+    console.error(chalk19.red("  Codex CLI is not installed."));
+    console.error(chalk19.yellow("  Install it: npm install -g @openai/codex"));
+    console.error(chalk19.yellow("  Then run: codemoot start"));
+    process.exit(1);
+  }
+  console.error(chalk19.green(`  Codex CLI ${codexVersion} found.`));
+  console.error(chalk19.dim("  [2/4] Checking project config..."));
+  const configPath = join6(cwd, ".cowork.yml");
+  if (existsSync5(configPath)) {
+    console.error(chalk19.green("  .cowork.yml exists \u2014 using it."));
+  } else {
+    const config = loadConfig9({ preset: "cli-first", skipFile: true });
+    config.project.name = basename2(cwd);
+    writeConfig2(config, cwd);
+    console.error(chalk19.green("  Created .cowork.yml with cli-first preset."));
+  }
+  console.error(chalk19.dim("  [3/4] Detecting project..."));
+  const hasGit = existsSync5(join6(cwd, ".git"));
+  const hasSrc = existsSync5(join6(cwd, "src"));
+  const hasPackageJson = existsSync5(join6(cwd, "package.json"));
+  let reviewTarget = "";
+  if (hasGit) {
+    try {
+      const diff = execSync6("git diff --name-only HEAD", { cwd, encoding: "utf-8", stdio: "pipe" }).trim();
+      if (diff) {
+        const files = diff.split("\n").filter((f) => f.endsWith(".ts") || f.endsWith(".js") || f.endsWith(".tsx") || f.endsWith(".jsx") || f.endsWith(".py"));
+        if (files.length > 0) {
+          reviewTarget = files.slice(0, 10).join(" ");
+          console.error(chalk19.green(`  Found ${files.length} changed file(s) \u2014 reviewing those.`));
+        }
+      }
+    } catch {
+    }
+  }
+  if (!reviewTarget) {
+    if (hasSrc) {
+      reviewTarget = "src/";
+      console.error(chalk19.green("  Found src/ directory \u2014 reviewing it."));
+    } else if (hasPackageJson) {
+      reviewTarget = "**/*.ts";
+      console.error(chalk19.green("  TypeScript project \u2014 reviewing *.ts files."));
+    } else {
+      console.error(chalk19.yellow("  No src/ or package.json found. Try: codemoot review <path>"));
+      process.exit(0);
+    }
+  }
+  console.error(chalk19.dim("  [4/4] Running quick review..."));
+  console.error(chalk19.cyan(`
+  codemoot review ${reviewTarget} --preset quick-scan
+`));
+  try {
+    const output = execFileSync3("codemoot", ["review", reviewTarget, "--preset", "quick-scan"], {
+      cwd,
+      encoding: "utf-8",
+      timeout: 3e5,
+      stdio: ["pipe", "pipe", "inherit"],
+      shell: process.platform === "win32"
+    });
+    try {
+      const result = JSON.parse(output);
+      const findingCount = result.findings?.length ?? 0;
+      const verdict = result.verdict ?? "unknown";
+      const score = result.score;
+      console.error("");
+      if (findingCount > 0) {
+        console.error(chalk19.yellow(`  Found ${findingCount} issue(s). Score: ${score ?? "?"}/10`));
+        console.error("");
+        console.error(chalk19.cyan("  Next steps:"));
+        console.error(chalk19.dim(`    codemoot fix ${reviewTarget} --dry-run   # preview fixes`));
+        console.error(chalk19.dim(`    codemoot fix ${reviewTarget}             # apply fixes`));
+        console.error(chalk19.dim("    codemoot review --preset security-audit  # deeper scan"));
+      } else if (verdict === "approved") {
+        console.error(chalk19.green(`  Code looks good! Score: ${score ?? "?"}/10`));
+        console.error("");
+        console.error(chalk19.cyan("  Next steps:"));
+        console.error(chalk19.dim("    codemoot review --preset security-audit  # security scan"));
+        console.error(chalk19.dim('    codemoot debate start "your question"    # debate with GPT'));
+        console.error(chalk19.dim("    codemoot watch                           # watch for changes"));
+      } else {
+        console.error(chalk19.dim(`  Review complete. Verdict: ${verdict}, Score: ${score ?? "?"}/10`));
+      }
+    } catch {
+      console.log(output);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("ETIMEDOUT") || msg.includes("timeout")) {
+      console.error(chalk19.yellow("  Review timed out. Try: codemoot review --preset quick-scan"));
+    } else {
+      console.error(chalk19.red(`  Review failed: ${msg.slice(0, 200)}`));
+    }
+  }
+  console.error(chalk19.dim("  Tip: Run codemoot install-skills to add /debate, /build, /cleanup"));
+  console.error(chalk19.dim("  slash commands to Claude Code in this project."));
+  console.error("");
+}
+
+// src/commands/watch.ts
+import { JobStore as JobStore4, openDatabase as openDatabase12 } from "@codemoot/core";
+import chalk20 from "chalk";
+import { watch } from "chokidar";
+
+// src/watch/debouncer.ts
+var DEFAULT_CONFIG = {
+  quietMs: 800,
+  maxWaitMs: 5e3,
+  cooldownMs: 1500,
+  maxBatchSize: 50
+};
+var batchCounter = 0;
+var Debouncer = class {
+  config;
+  pending = /* @__PURE__ */ new Map();
+  quietTimer = null;
+  maxWaitTimer = null;
+  cooldownUntil = 0;
+  windowStart = 0;
+  onFlush;
+  destroyed = false;
+  constructor(onFlush, config) {
+    this.onFlush = onFlush;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  push(e) {
+    if (this.destroyed) return false;
+    if (e.ts < this.cooldownUntil) return false;
+    if (this.pending.size === 0) {
+      this.windowStart = e.ts;
+      this.startMaxWaitTimer();
+    }
+    this.pending.set(e.path, e);
+    this.restartQuietTimer();
+    if (this.pending.size >= this.config.maxBatchSize) {
+      this.flush("maxBatch");
+    }
+    return true;
+  }
+  flushNow() {
+    this.flush("manual");
+  }
+  cancel() {
+    this.clearTimers();
+    this.pending.clear();
+  }
+  destroy() {
+    this.cancel();
+    this.destroyed = true;
+  }
+  getPendingCount() {
+    return this.pending.size;
+  }
+  flush(reason) {
+    if (this.pending.size === 0) return;
+    this.clearTimers();
+    const now = Date.now();
+    const batch = {
+      files: [...this.pending.keys()],
+      batchId: `wb-${++batchCounter}`,
+      windowStart: this.windowStart,
+      windowEnd: now,
+      reason
+    };
+    this.pending.clear();
+    this.cooldownUntil = now + this.config.cooldownMs;
+    this.onFlush(batch);
+  }
+  restartQuietTimer() {
+    if (this.quietTimer) clearTimeout(this.quietTimer);
+    this.quietTimer = setTimeout(() => this.flush("quiet"), this.config.quietMs);
+  }
+  startMaxWaitTimer() {
+    if (this.maxWaitTimer) return;
+    this.maxWaitTimer = setTimeout(() => this.flush("maxWait"), this.config.maxWaitMs);
+  }
+  clearTimers() {
+    if (this.quietTimer) {
+      clearTimeout(this.quietTimer);
+      this.quietTimer = null;
+    }
+    if (this.maxWaitTimer) {
+      clearTimeout(this.maxWaitTimer);
+      this.maxWaitTimer = null;
+    }
+  }
+};
+
+// src/commands/watch.ts
+async function watchCommand(options) {
+  const projectDir = process.cwd();
+  const db = openDatabase12(getDbPath());
+  const jobStore = new JobStore4(db);
+  const debouncer = new Debouncer(
+    (batch) => {
+      const dedupeKey = `watch-review:${batch.files.sort().join(",")}`.slice(0, 255);
+      if (jobStore.hasActiveByType("watch-review")) {
+        console.error(
+          chalk20.yellow(`  Skipping batch ${batch.batchId} \u2014 watch-review already queued/running`)
+        );
+        return;
+      }
+      const jobId = jobStore.enqueue({
+        type: "watch-review",
+        payload: {
+          files: batch.files,
+          focus: options.focus,
+          timeout: options.timeout,
+          cwd: projectDir,
+          batchId: batch.batchId,
+          reason: batch.reason
+        },
+        dedupeKey
+      });
+      const event = {
+        type: "watch_batch",
+        jobId,
+        batchId: batch.batchId,
+        files: batch.files.length,
+        reason: batch.reason,
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      console.log(JSON.stringify(event));
+    },
+    {
+      quietMs: options.quietMs,
+      maxWaitMs: options.maxWaitMs,
+      cooldownMs: options.cooldownMs
+    }
+  );
+  const ignored = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/dist/**",
+    "**/.cowork/**",
+    "**/coverage/**",
+    "**/*.db",
+    "**/*.db-journal",
+    "**/*.db-wal"
+  ];
+  console.error(chalk20.cyan(`Watching ${options.glob} for changes...`));
+  console.error(
+    chalk20.dim(
+      `  quiet=${options.quietMs}ms, maxWait=${options.maxWaitMs}ms, cooldown=${options.cooldownMs}ms`
+    )
+  );
+  const watcher = watch(options.glob, {
+    cwd: projectDir,
+    ignored,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
+  });
+  watcher.on("all", (event, path) => {
+    if (event === "add" || event === "change" || event === "unlink") {
+      debouncer.push({ path, event, ts: Date.now() });
+    }
+  });
+  const shutdown = () => {
+    console.error(chalk20.dim("\nShutting down watcher..."));
+    debouncer.flushNow();
+    debouncer.destroy();
+    watcher.close();
+    db.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+// src/commands/worker.ts
+import {
+  JobStore as JobStore5,
+  ModelRegistry as ModelRegistry7,
+  REVIEW_DIFF_MAX_CHARS as REVIEW_DIFF_MAX_CHARS4,
+  buildHandoffEnvelope as buildHandoffEnvelope5,
+  loadConfig as loadConfig10,
+  openDatabase as openDatabase13
+} from "@codemoot/core";
+import chalk21 from "chalk";
+import { execSync as execSync7 } from "child_process";
+async function workerCommand(options) {
+  const projectDir = process.cwd();
+  const db = openDatabase13(getDbPath());
+  const jobStore = new JobStore5(db);
+  const config = loadConfig10();
+  const registry = ModelRegistry7.fromConfig(config, projectDir);
+  const adapter = registry.tryGetAdapter("codex-reviewer") ?? registry.tryGetAdapter("codex-architect");
+  if (!adapter) {
+    try {
+      execSync7("codex --version", { stdio: "pipe", encoding: "utf-8" });
+    } catch {
+      console.error(chalk21.red("Codex CLI is not installed or not in PATH."));
+      console.error(chalk21.yellow("Install it: npm install -g @openai/codex"));
+      db.close();
+      process.exit(1);
+    }
+    console.error(chalk21.red("No codex adapter found in config. Run: codemoot init"));
+    db.close();
+    process.exit(1);
+  }
+  const workerId = options.workerId;
+  console.error(
+    chalk21.cyan(`Worker ${workerId} started (poll: ${options.pollMs}ms, once: ${options.once})`)
+  );
+  let running = true;
+  const shutdown = () => {
+    running = false;
+    console.error(chalk21.dim("\nWorker shutting down..."));
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  while (running) {
+    const job = jobStore.claimNext(workerId)[0];
+    if (!job) {
+      if (options.once) {
+        console.error(chalk21.dim("No jobs in queue. Exiting (--once mode)."));
+        break;
+      }
+      await new Promise((r) => setTimeout(r, options.pollMs));
+      continue;
+    }
+    console.error(chalk21.cyan(`Processing job ${job.id} (type: ${job.type})`));
+    jobStore.appendLog(job.id, "info", "job_started", `Worker ${workerId} claimed job`);
+    try {
+      const { resolve: resolve2, normalize } = await import("path");
+      const payload = JSON.parse(job.payloadJson);
+      const rawCwd = resolve2(payload.path ?? payload.cwd ?? projectDir);
+      const cwd = normalize(rawCwd);
+      if (!cwd.startsWith(normalize(projectDir))) {
+        throw new Error(`Path traversal blocked: "${cwd}" is outside project directory "${projectDir}"`);
+      }
+      const timeout = (payload.timeout ?? 600) * 1e3;
+      let prompt;
+      if (job.type === "review" || job.type === "watch-review") {
+        const focus = payload.focus ?? "all";
+        const focusConstraint = focus === "all" ? "Review for: correctness, bugs, security, performance, code quality" : `Focus specifically on: ${focus}`;
+        if (payload.prompt) {
+          prompt = buildHandoffEnvelope5({
+            command: "review",
+            task: `TASK: ${payload.prompt}
+
+Start by listing candidate files, then inspect them thoroughly.`,
+            constraints: [focusConstraint],
+            resumed: false
+          });
+        } else if (payload.diff) {
+          const { execFileSync: execFileSync4 } = await import("child_process");
+          const diffArgs = payload.diff.split(/\s+/).filter((a) => a.length > 0);
+          for (const arg of diffArgs) {
+            if (arg.startsWith("-") || !/^[a-zA-Z0-9_.~^:\/\\@{}]+$/.test(arg)) {
+              throw new Error(`Invalid diff argument: "${arg}" \u2014 only git refs and paths allowed`);
+            }
+          }
+          const diff = execFileSync4("git", ["diff", ...diffArgs], {
+            cwd,
+            encoding: "utf-8",
+            maxBuffer: 1024 * 1024
+          });
+          prompt = buildHandoffEnvelope5({
+            command: "review",
+            task: `Review these code changes.
+
+GIT DIFF:
+${diff.slice(0, REVIEW_DIFF_MAX_CHARS4)}`,
+            constraints: [focusConstraint],
+            resumed: false
+          });
+        } else if (payload.files && Array.isArray(payload.files)) {
+          prompt = buildHandoffEnvelope5({
+            command: "review",
+            task: `Review these files: ${payload.files.join(", ")}. Read each file and report issues.`,
+            constraints: [focusConstraint],
+            resumed: false
+          });
+        } else {
+          prompt = buildHandoffEnvelope5({
+            command: "review",
+            task: "Review the codebase for issues. Start by listing key files.",
+            constraints: [focusConstraint],
+            resumed: false
+          });
+        }
+      } else if (job.type === "cleanup") {
+        prompt = buildHandoffEnvelope5({
+          command: "cleanup",
+          task: `Scan ${cwd} for: unused dependencies, dead code, duplicates, hardcoded values. Report findings with confidence levels.`,
+          constraints: [`Scope: ${payload.scope ?? "all"}`],
+          resumed: false
+        });
+      } else {
+        jobStore.fail(job.id, `Unsupported job type: ${job.type}`);
+        continue;
+      }
+      jobStore.appendLog(job.id, "info", "codex_started", "Sending to codex...");
+      const progress = createProgressCallbacks("worker");
+      const result = await adapter.callWithResume(prompt, {
+        timeout,
+        ...progress
+      });
+      jobStore.appendLog(
+        job.id,
+        "info",
+        "codex_completed",
+        `Received ${result.text.length} chars in ${result.durationMs}ms`
+      );
+      const resultData = {
+        text: result.text,
+        usage: result.usage,
+        durationMs: result.durationMs,
+        sessionId: result.sessionId
+      };
+      jobStore.succeed(job.id, resultData);
+      console.error(chalk21.green(`Job ${job.id} completed (${result.durationMs}ms)`));
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      jobStore.appendLog(job.id, "error", "job_failed", errMsg);
+      jobStore.fail(job.id, errMsg);
+      console.error(chalk21.red(`Job ${job.id} failed: ${errMsg}`));
+    }
+    if (options.once) break;
+  }
+  db.close();
+  console.error(chalk21.dim("Worker stopped."));
+}
+
+// src/index.ts
+var program = new Command();
+program.name("codemoot").description("Multi-model collaborative AI development tool").version(VERSION2).option("--verbose", "Enable debug logging");
+program.command("start").description("First-run setup: verify codex, init config, run quick review").action(startCommand);
+program.command("doctor").description("Preflight diagnostics: check codex, config, database, git, node").action(doctorCommand);
+program.command("install-skills").description("Install Claude Code slash commands (/debate, /build, /codex-review, /cleanup)").option("--force", "Overwrite existing skill files", false).action(installSkillsCommand);
+program.command("init").description("Initialize CodeMoot in the current project").option("--preset <name>", "Use preset (balanced|budget)").option("--non-interactive", "Skip prompts, use defaults").option("--force", "Overwrite existing .cowork.yml").action(initCommand);
+program.command("run").description("Run a task through the full workflow").argument("<task>", "Task description (natural language)").option("--mode <mode>", "Execution mode (autonomous|interactive)", "autonomous").option("--max-iterations <n>", "Max review loop iterations", (v) => Number.parseInt(v, 10), 3).option("--no-stream", "Disable streaming output").action(runCommand);
+program.command("review").description("Review code via codex \u2014 files, prompts, or diffs").argument("[file-or-glob]", "File path or glob pattern to review").option("--prompt <instruction>", "Freeform prompt \u2014 codex explores codebase via tools").option("--stdin", "Read prompt from stdin").option("--diff <revspec>", "Review a git diff (e.g., HEAD~3..HEAD, origin/main...HEAD)").option("--scope <glob>", "Restrict codex exploration to matching files (only with --prompt/--stdin)").addOption(new Option("--focus <area>", "Focus area").choices(["security", "performance", "bugs", "all"]).default("all")).option("--preset <name>", "Use named preset (security-audit|performance|quick-scan|pre-commit|api-review)").option("--session <id>", "Use specific session (default: active session)").option("--background", "Enqueue review and return immediately").option("--timeout <seconds>", "Timeout in seconds", (v) => {
+  if (!/^\d+$/.test(v)) throw new InvalidArgumentError("Timeout must be a positive integer");
+  const n = Number.parseInt(v, 10);
+  if (n <= 0) throw new InvalidArgumentError("Timeout must be a positive integer");
+  return n;
+}, 600).action(reviewCommand);
+program.command("cleanup").description("Scan codebase for AI slop: security vulns, anti-patterns, near-duplicates, dead code, and more").argument("[path]", "Project path to scan", ".").addOption(new Option("--scope <scope>", "What to scan for").choices(["deps", "unused-exports", "hardcoded", "duplicates", "deadcode", "security", "near-duplicates", "anti-patterns", "all"]).default("all")).option("--timeout <seconds>", "Codex scan timeout in seconds", (v) => {
+  if (!/^\d+$/.test(v)) throw new InvalidArgumentError("Timeout must be a positive integer");
+  const n = Number.parseInt(v, 10);
+  if (n <= 0) throw new InvalidArgumentError("Timeout must be a positive integer");
+  return n;
+}, CLEANUP_TIMEOUT_SEC).option("--max-disputes <n>", "Max findings to adjudicate", (v) => {
+  if (!/^\d+$/.test(v)) throw new InvalidArgumentError("Must be a non-negative integer");
+  return Number.parseInt(v, 10);
+}, 10).option("--host-findings <path>", "JSON file with host AI findings for 3-way merge").option("--output <path>", "Write findings report to JSON file").option("--background", "Enqueue cleanup and return immediately").option("--no-gitignore", "Skip .gitignore rules (scan everything)").option("--quiet", "Suppress human-readable summary").action(cleanupCommand);
+program.command("plan").description("Generate a plan using architect + reviewer loop").argument("<task>", "Task to plan").option("--rounds <n>", "Max plan-review rounds", (v) => Number.parseInt(v, 10), 3).option("--output <file>", "Save plan to file").action(planCommand);
+var debate = program.command("debate").description("Multi-model debate with session persistence");
+debate.command("start").description("Start a new debate").argument("<topic>", "Debate topic or question").option("--max-rounds <n>", "Max debate rounds", (v) => Number.parseInt(v, 10), 5).action(debateStartCommand);
+debate.command("turn").description("Send a prompt to GPT and get critique (with session resume)").argument("<debate-id>", "Debate ID from start command").argument("<prompt>", "Prompt to send to GPT").option("--round <n>", "Round number", (v) => Number.parseInt(v, 10)).option("--timeout <seconds>", "Timeout in seconds", (v) => Number.parseInt(v, 10), 600).action(debateTurnCommand);
+debate.command("status").description("Show debate status and session info").argument("<debate-id>", "Debate ID").action(debateStatusCommand);
+debate.command("list").description("List all debates").option("--status <status>", "Filter by status (active|completed|stale)").option("--limit <n>", "Max results", (v) => Number.parseInt(v, 10), 20).action(debateListCommand);
+debate.command("history").description("Show full message history with token budget").argument("<debate-id>", "Debate ID").action(debateHistoryCommand);
+debate.command("complete").description("Mark a debate as completed").argument("<debate-id>", "Debate ID").action(debateCompleteCommand);
+var build = program.command("build").description("Automated build loop: debate \u2192 plan \u2192 implement \u2192 review \u2192 fix");
+build.command("start").description("Start a new build session").argument("<task>", "Task description").option("--max-rounds <n>", "Max debate rounds", (v) => Number.parseInt(v, 10), 5).option("--allow-dirty", "Allow starting with dirty working tree (auto-stashes)").action(buildStartCommand);
+build.command("status").description("Show build status and event log").argument("<build-id>", "Build ID").action(buildStatusCommand);
+build.command("list").description("List all builds").option("--status <status>", "Filter by status").option("--limit <n>", "Max results", (v) => Number.parseInt(v, 10), 20).action(buildListCommand);
+build.command("event").description("Record a build event (phase transition)").argument("<build-id>", "Build ID").argument("<event-type>", "Event type (plan_approved|impl_completed|fix_completed|etc)").option("--loop <n>", "Loop index", (v) => Number.parseInt(v, 10)).option("--tokens <n>", "Tokens used", (v) => Number.parseInt(v, 10)).action(buildEventCommand);
+build.command("review").description("Send implementation to codex for review (with codebase access)").argument("<build-id>", "Build ID").action(buildReviewCommand);
+var session = program.command("session").description("Unified session management \u2014 persistent GPT context across commands");
+session.command("start").description("Start a new session").option("--name <name>", "Session name").action(sessionStartCommand);
+session.command("current").description("Show the active session").action(sessionCurrentCommand);
+session.command("list").description("List all sessions").option("--status <status>", "Filter by status (active|completed|stale)").option("--limit <n>", "Max results", (v) => Number.parseInt(v, 10), 20).action(sessionListCommand);
+session.command("status").description("Show detailed session info with events").argument("<session-id>", "Session ID").action(sessionStatusCommand);
+session.command("close").description("Mark a session as completed").argument("<session-id>", "Session ID").action(sessionCloseCommand);
+var jobs = program.command("jobs").description("Background job queue \u2014 async reviews, cleanups, and more");
+jobs.command("list").description("List jobs").option("--status <status>", "Filter by status (queued|running|succeeded|failed|canceled)").option("--type <type>", "Filter by type (review|cleanup|build-review|composite|watch-review)").option("--limit <n>", "Max results", (v) => Number.parseInt(v, 10), 20).action(jobsListCommand);
+jobs.command("status").description("Show job details with recent logs").argument("<job-id>", "Job ID").action(jobsStatusCommand);
+jobs.command("logs").description("Show job logs").argument("<job-id>", "Job ID").option("--from-seq <n>", "Start from log sequence number", (v) => Number.parseInt(v, 10), 0).option("--limit <n>", "Max log entries", (v) => Number.parseInt(v, 10), 100).action(jobsLogsCommand);
+jobs.command("cancel").description("Cancel a queued or running job").argument("<job-id>", "Job ID").action(jobsCancelCommand);
+jobs.command("retry").description("Retry a failed job").argument("<job-id>", "Job ID").action(jobsRetryCommand);
+program.command("fix").description("Autofix loop: review code, apply fixes, re-review until approved").argument("<file-or-glob>", "File path or glob pattern to fix").option("--max-rounds <n>", "Max review-fix rounds", (v) => Number.parseInt(v, 10), 3).addOption(new Option("--focus <area>", "Focus area").choices(["security", "performance", "bugs", "all"]).default("bugs")).option("--timeout <seconds>", "Timeout per round", (v) => Number.parseInt(v, 10), 600).option("--dry-run", "Review only, do not apply fixes", false).option("--diff <revspec>", "Fix issues in a git diff").option("--session <id>", "Use specific session").action(fixCommand);
+program.command("shipit").description("Run composite workflow: lint \u2192 test \u2192 review \u2192 cleanup \u2192 commit").addOption(new Option("--profile <profile>", "Workflow profile").choices(["fast", "safe", "full"]).default("safe")).option("--dry-run", "Print planned steps without executing", false).option("--no-commit", "Run checks but skip commit step").option("--json", "Machine-readable JSON output", false).option("--strict-output", "Strict model output parsing", false).action(shipitCommand);
+program.command("cost").description("Token usage and cost dashboard").addOption(new Option("--scope <scope>", "Time scope").choices(["session", "daily", "all"]).default("daily")).option("--days <n>", "Number of days for daily scope", (v) => Number.parseInt(v, 10), 30).option("--session <id>", "Session ID for session scope").action(costCommand);
+program.command("watch").description("Watch files and enqueue reviews on change").option("--glob <pattern>", "Glob pattern to watch", "**/*.{ts,tsx,js,jsx}").addOption(new Option("--focus <area>", "Focus area").choices(["security", "performance", "bugs", "all"]).default("all")).option("--timeout <seconds>", "Review timeout", (v) => Number.parseInt(v, 10), 600).option("--quiet-ms <ms>", "Quiet period before flush", (v) => Number.parseInt(v, 10), 800).option("--max-wait-ms <ms>", "Max wait before forced flush", (v) => Number.parseInt(v, 10), 5e3).option("--cooldown-ms <ms>", "Cooldown after flush", (v) => Number.parseInt(v, 10), 1500).action(watchCommand);
+program.command("events").description("Stream session events and job logs as JSONL").option("--follow", "Follow mode \u2014 poll for new events", false).option("--since-seq <n>", "Start from sequence number", (v) => Number.parseInt(v, 10), 0).option("--limit <n>", "Max events per poll", (v) => Number.parseInt(v, 10), 100).addOption(new Option("--type <type>", "Event source filter").choices(["all", "sessions", "jobs"]).default("all")).action(eventsCommand);
+jobs.command("worker").description("Start background job worker (processes queued jobs)").option("--once", "Process one job and exit", false).option("--poll-ms <ms>", "Poll interval in milliseconds", (v) => Number.parseInt(v, 10), 2e3).option("--worker-id <id>", "Worker identifier", `w-${Date.now()}`).action(workerCommand);
+program.parse();
+export {
+  program
+};
+//# sourceMappingURL=index.js.map