@mulep/cli 0.2.14

package/dist/index.js

@@ -0,0 +1,4790 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command, InvalidArgumentError, Option } from "commander";
+import { CLEANUP_TIMEOUT_SEC, VERSION as VERSION2 } from "@mulep/core";
+
+// src/commands/build.ts
+import { BuildStore, DebateStore, REVIEW_DIFF_MAX_CHARS, REVIEW_TEXT_MAX_CHARS, SessionManager, buildHandoffEnvelope, generateId, loadConfig, openDatabase as openDatabase2 } from "@mulep/core";
+import chalk3 from "chalk";
+import { execFileSync, execSync } from "child_process";
+import { unlinkSync } from "fs";
+import { join as join2 } from "path";
+
+// src/progress.ts
+import chalk from "chalk";
+var THROTTLE_MS = 3e4;
+var MAX_CARRY_OVER = 64 * 1024;
+function createProgressCallbacks(label = "codex") {
+  let lastActivityAt = 0;
+  let lastMessage = "";
+  let carryOver = "";
+  let droppedEvents = 0;
+  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}`));
+  }
+  function parseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    try {
+      const event = JSON.parse(trimmed);
+      formatEvent(event, printActivity);
+    } catch {
+      droppedEvents++;
+    }
+  }
+  return {
+    onSpawn(pid, command) {
+      const exe = command.replace(/^"([^"]+)".*/, "$1").split(/[\s/\\]+/).pop() ?? command;
+      console.error(chalk.dim(`  [${label}] Started (PID: ${pid}, cmd: ${exe})`));
+    },
+    onStderr(_chunk) {
+    },
+    onProgress(chunk) {
+      const data = carryOver + chunk;
+      const lines = data.split("\n");
+      carryOver = lines.pop() ?? "";
+      if (carryOver.length > MAX_CARRY_OVER) {
+        carryOver = "";
+        droppedEvents++;
+      }
+      for (const line of lines) {
+        parseLine(line);
+      }
+    },
+    onClose() {
+      if (carryOver.trim()) {
+        parseLine(carryOver);
+        carryOver = "";
+      }
+      if (droppedEvents > 0) {
+        console.error(chalk.dim(`  [${label}] ${droppedEvents} event(s) dropped (parse errors or buffer overflow)`));
+        droppedEvents = 0;
+      }
+    },
+    onHeartbeat(elapsedSec) {
+      if (elapsedSec % 60 === 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 rawArgs = item.arguments ?? item.input ?? "";
+      const args = (typeof rawArgs === "string" ? rawArgs : JSON.stringify(rawArgs)).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 (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 "@mulep/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, ".mulep", "db");
+  mkdirSync(dbDir, { recursive: true });
+  return join(dbDir, "mulep.db");
+}
+async function withDatabase(fn) {
+  const db = openDatabase(getDbPath());
+  const originalExit = process.exit;
+  let requestedExitCode;
+  process.exit = ((code) => {
+    requestedExitCode = typeof code === "number" ? code : 1;
+    throw new Error("__WITH_DATABASE_EXIT__");
+  });
+  try {
+    return await fn(db);
+  } catch (error) {
+    if (requestedExitCode === void 0) {
+      console.error(chalk2.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    }
+    throw error;
+  } finally {
+    process.exit = originalExit;
+    db.close();
+    if (requestedExitCode !== void 0) {
+      originalExit(requestedExitCode);
+    }
+  }
+}
+
+// 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 "mulep-build-baseline"', { cwd: projectDir, encoding: "utf-8" });
+        console.error(chalk3.yellow('Auto-stashed dirty changes with marker "mulep-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", "mulep-review-index");
+        try {
+          execFileSync("git", ["read-tree", "HEAD"], { cwd: projectDir, encoding: "utf-8", env: { ...process.env, GIT_INDEX_FILE: tmpIndex } });
+          execFileSync("git", ["add", "-A"], { cwd: projectDir, encoding: "utf-8", env: { ...process.env, GIT_INDEX_FILE: tmpIndex } });
+          diff = execFileSync("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("@mulep/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 currentSession = sessionMgr.get(session2.id);
+    const existingSession = 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");
+    let result;
+    try {
+      result = await adapter.callWithResume(prompt, {
+        sessionId: existingSession,
+        timeout: 6e5,
+        ...progress
+      });
+    } catch (err) {
+      if (existingSession) {
+        console.error(chalk3.yellow("  Clearing stale codex thread ID after failure."));
+        sessionMgr.updateThreadId(session2.id, null);
+      }
+      throw err;
+    }
+    if (existingSession && result.sessionId !== existingSession) {
+      sessionMgr.updateThreadId(session2.id, null);
+    }
+    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 ?? void 0,
+        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.slice(0, 2e3),
+      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 "@mulep/core";
+import chalk4 from "chalk";
+import { mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join3 } from "path";
+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,
+      defaultTimeout: options.timeout
+    });
+    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);
+  }
+}
+var DEFAULT_RESPONSE_CAP = 16384;
+var MAX_RESPONSE_CAP = 24576;
+function buildResponseOutput(debateId, round, responseText, cap, explicitOutput) {
+  const text = responseText ?? "";
+  const byteLen = Buffer.byteLength(text, "utf-8");
+  const truncated = byteLen > cap;
+  let responseFile;
+  if (truncated && !explicitOutput) {
+    const dir = join3(process.cwd(), ".mulep", "debates");
+    mkdirSync2(dir, { recursive: true, mode: 448 });
+    responseFile = join3(dir, `${debateId}-r${round}.txt`);
+    writeFileSync(responseFile, text, { encoding: "utf-8", mode: 384 });
+  } else if (explicitOutput && text.length > 0) {
+    responseFile = explicitOutput;
+  }
+  let sliced = text;
+  if (truncated) {
+    let lo = 0;
+    let hi = text.length;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (Buffer.byteLength(text.slice(0, mid), "utf-8") <= cap) lo = mid;
+      else hi = mid - 1;
+    }
+    sliced = text.slice(0, lo);
+  }
+  return {
+    response: sliced,
+    responseTruncated: truncated,
+    responseBytes: byteLen,
+    responseCap: cap,
+    responseFile
+  };
+}
+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 responseCap = Math.min(
+      options.responseCap && options.responseCap > 0 ? options.responseCap : DEFAULT_RESPONSE_CAP,
+      MAX_RESPONSE_CAP
+    );
+    const quiet = options.quiet ?? false;
+    const proposerStateForLimit = store.loadState(debateId, "proposer");
+    const storedTimeout = proposerStateForLimit?.defaultTimeout;
+    const rawTimeout = options.timeout ?? storedTimeout ?? 600;
+    const timeout = (Number.isFinite(rawTimeout) && rawTimeout > 0 ? rawTimeout : 600) * 1e3;
+    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"
+        });
+      }
+      if (options.output && existing.responseText) {
+        writeFileSync(options.output, existing.responseText, "utf-8");
+        if (!quiet) console.error(chalk4.dim(`Full response written to ${options.output}`));
+      }
+      const responseFields = buildResponseOutput(debateId, newRound, existing.responseText, responseCap, options.output);
+      const output = {
+        debateId,
+        round: newRound,
+        ...responseFields,
+        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 && !quiet) {
+      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") {
+        if (options.output && recheckRow.responseText) {
+          writeFileSync(options.output, recheckRow.responseText, "utf-8");
+          if (!quiet) console.error(chalk4.dim(`Full response written to ${options.output}`));
+        }
+        const recheckResponseFields = buildResponseOutput(debateId, newRound, recheckRow.responseText, responseCap, options.output);
+        const output = {
+          debateId,
+          round: newRound,
+          ...recheckResponseFields,
+          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 && !options.force) {
+      console.error(chalk4.red(`Token budget at ${Math.round(preflight.utilizationRatio * 100)}% (${preflight.totalTokensUsed}/${maxContext}). Debate blocked \u2014 use --force to override.`));
+      db.close();
+      process.exit(1);
+    } else if (preflight.shouldStop && options.force) {
+      if (!quiet) console.error(chalk4.yellow(`  Token budget at ${Math.round(preflight.utilizationRatio * 100)}% (${preflight.totalTokensUsed}/${maxContext}) \u2014 forced past budget limit.`));
+    } else if (preflight.shouldSummarize) {
+      if (!quiet) console.error(chalk4.yellow(`  Token budget at ${Math.round(preflight.utilizationRatio * 100)}%. Older rounds will be summarized on resume failure.`));
+    }
+    try {
+      const progress = createProgressCallbacks("debate");
+      let result;
+      try {
+        result = await adapter.callWithResume(prompt, {
+          sessionId: existingSessionId,
+          timeout,
+          ...progress
+        });
+      } catch (err) {
+        if (existingSessionId) {
+          sessionMgr.updateThreadId(unifiedSession.id, null);
+        }
+        throw err;
+      }
+      if (existingSessionId && result.sessionId !== existingSessionId) {
+        sessionMgr.updateThreadId(unifiedSession.id, null);
+      }
+      const resumed = attemptedResume && result.sessionId === existingSessionId;
+      const resumeFailed = attemptedResume && !resumed;
+      if (resumeFailed && result.text.length < 50) {
+        if (!quiet) 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) {
+        if (!quiet) 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 ?? void 0,
+        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);
+      }
+      if (options.output) {
+        writeFileSync(options.output, result.text, "utf-8");
+        if (!quiet) console.error(chalk4.dim(`Full response written to ${options.output}`));
+      }
+      const freshResponseFields = buildResponseOutput(debateId, newRound, result.text, responseCap, options.output);
+      const output = {
+        debateId,
+        round: newRound,
+        ...freshResponseFields,
+        sessionId: result.sessionId,
+        resumed,
+        cached: false,
+        stance: verdict.stance,
+        usage: result.usage,
+        durationMs: result.durationMs
+      };
+      if (!quiet) {
+        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 | Output: ${result.usage?.outputTokens ?? "?"} tokens | Input: ${result.usage?.inputTokens ?? "?"} (includes sandbox) | 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 debateNextCommand(debateId, options) {
+  const prompt = "Continue your analysis. Respond to the previous round's arguments and refine your position.";
+  return debateTurnCommand(debateId, prompt, options);
+}
+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, options = {}) {
+  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
+      }))
+    };
+    if (options.output) {
+      const fullOutput = {
+        ...output,
+        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,
+          promptText: m.promptText,
+          responseText: m.responseText ?? null,
+          error: m.error,
+          createdAt: new Date(m.createdAt).toISOString(),
+          completedAt: m.completedAt ? new Date(m.completedAt).toISOString() : null
+        }))
+      };
+      writeFileSync(options.output, JSON.stringify(fullOutput, null, 2), "utf-8");
+      console.error(chalk4.dim(`Full history written to ${options.output}`));
+    }
+    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 "@mulep/core";
+import chalk5 from "chalk";
+import { readFileSync } from "fs";
+async function cleanupCommand(path, options) {
+  let db;
+  try {
+    const { resolve: resolve6 } = await import("path");
+    const projectDir = resolve6(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: mulep 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 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: writeFileSync6 } = await import("fs");
+      writeFileSync6(options.output, JSON.stringify(report, null, 2), "utf-8");
+      console.error(chalk5.green(`  Findings written to ${options.output}`));
+    }
+    const reportJson = JSON.stringify(report, null, 2);
+    console.log(reportJson.length > 2e3 ? `${reportJson.slice(0, 2e3)}
+... (truncated, ${reportJson.length} chars total \u2014 use --output to save full report)` : reportJson);
+    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");
+    let result;
+    try {
+      result = await adapter.callWithResume(prompt, { sessionId: sessionThreadId, timeout: timeoutSec * 1e3, ...progress });
+    } catch (err) {
+      if (sessionThreadId && sessionMgr && sessionId) {
+        sessionMgr.updateThreadId(sessionId, null);
+      }
+      throw err;
+    }
+    if (sessionThreadId && result.sessionId !== sessionThreadId && sessionMgr && sessionId) {
+      sessionMgr.updateThreadId(sessionId, null);
+    }
+    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 "@mulep/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: mulep 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 join4 } from "path";
+import chalk7 from "chalk";
+import { VERSION } from "@mulep/core";
+async function doctorCommand() {
+  const cwd = process.cwd();
+  const checks = [];
+  console.error(chalk7.cyan(`
+  MuleP 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 = join4(cwd, ".mulep.yml");
+  if (existsSync(configPath)) {
+    checks.push({ name: "config", status: "pass", message: ".mulep.yml found" });
+  } else {
+    checks.push({
+      name: "config",
+      status: "fail",
+      message: ".mulep.yml not found",
+      fix: "mulep init"
+    });
+  }
+  const dbDir = join4(cwd, ".mulep", "db");
+  const dbPath = join4(dbDir, "mulep.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: ".mulep/db/ is not writable",
+        fix: "Check file permissions on .mulep/db/"
+      });
+    }
+  } else {
+    checks.push({
+      name: "database",
+      status: "warn",
+      message: ".mulep/db/ not found \u2014 will be created by mulep init",
+      fix: "mulep init"
+    });
+  }
+  let gitFound = false;
+  let searchDir = cwd;
+  while (searchDir) {
+    if (existsSync(join4(searchDir, ".git"))) {
+      gitFound = true;
+      break;
+    }
+    const parent = join4(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("@mulep/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 "@mulep/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 as execFileSync2, execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve } from "path";
+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 "@mulep/core";
+import chalk9 from "chalk";
+function parseFixes(text) {
+  const fixes = [];
+  const fixPattern = /FIX:\s*(\S+?):(\d+)\s+(.+?)(?:\n```old\n([\s\S]*?)\n```\s*\n```new\n([\s\S]*?)\n```|(?:\n```\n([\s\S]*?)\n```))/g;
+  let match;
+  match = fixPattern.exec(text);
+  while (match !== null) {
+    const file = match[1];
+    const line = Number.parseInt(match[2], 10);
+    const description = match[3].trim();
+    if (match[4] !== void 0 && match[5] !== void 0) {
+      fixes.push({ file, line, description, oldCode: match[4], newCode: match[5] });
+    } else if (match[6] !== void 0) {
+      fixes.push({ file, line, description, oldCode: "", newCode: match[6] });
+    }
+    match = fixPattern.exec(text);
+  }
+  return fixes;
+}
+function applyFix(fix, projectDir) {
+  const filePath = resolve(projectDir, fix.file);
+  const normalizedProject = resolve(projectDir) + (process.platform === "win32" ? "\\" : "/");
+  if (!resolve(filePath).startsWith(normalizedProject)) {
+    return false;
+  }
+  let content;
+  try {
+    content = readFileSync2(filePath, "utf-8");
+  } catch {
+    return false;
+  }
+  const lines = content.split("\n");
+  if (fix.oldCode) {
+    const trimmedOld = fix.oldCode.trim();
+    if (content.includes(trimmedOld)) {
+      const updated = content.replace(trimmedOld, fix.newCode.trim());
+      writeFileSync2(filePath, updated, "utf-8");
+      return true;
+    }
+    return false;
+  }
+  const lineIdx = fix.line - 1;
+  if (lineIdx < 0 || lineIdx >= lines.length) return false;
+  const newLines = fix.newCode.trim().split("\n");
+  const oldLineCount = Math.max(1, newLines.length);
+  lines.splice(lineIdx, oldLineCount, ...newLines);
+  writeFileSync2(filePath, lines.join("\n"), "utf-8");
+  return true;
+}
+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: mulep 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: mulep init"));
+    db.close();
+    process.exit(1);
+  }
+  const currentSession = sessionMgr.get(session2.id);
+  let threadId = currentSession?.codexThreadId ?? void 0;
+  const rounds = [];
+  let converged = false;
+  const stuckFingerprints = /* @__PURE__ */ new Set();
+  let prevFingerprints = /* @__PURE__ */ new Set();
+  console.error(
+    chalk9.cyan(
+      `Autofix loop: ${fileOrGlob} (max ${options.maxRounds} rounds, focus: ${options.focus})`
+    )
+  );
+  for (let round = 1; round <= options.maxRounds; round++) {
+    const roundStart = Date.now();
+    console.error(chalk9.dim(`
+\u2500\u2500 Round ${round}/${options.maxRounds} \u2500\u2500`));
+    let diffContent = "";
+    if (options.diff) {
+      try {
+        diffContent = execFileSync2("git", ["diff", "--", ...options.diff.split(/\s+/)], {
+          cwd: projectDir,
+          encoding: "utf-8",
+          maxBuffer: 1024 * 1024
+        });
+      } catch {
+        diffContent = "";
+      }
+    }
+    const fixOutputContract = [
+      "You are an autofix engine. For EVERY fixable issue, you MUST output this EXACT format:",
+      "",
+      "FIX: path/to/file.ts:42 Description of the bug",
+      "```old",
+      "exact old code copied from the file",
+      "```",
+      "```new",
+      "exact replacement code",
+      "```",
+      "",
+      "Then end with:",
+      "VERDICT: APPROVED or VERDICT: NEEDS_REVISION",
+      "SCORE: X/10",
+      "",
+      "Rules:",
+      "- The ```old block MUST be an exact substring copy from the file (whitespace-sensitive).",
+      "- One FIX block per issue.",
+      "- Issues without a FIX block are IGNORED by the autofix engine.",
+      "- If the code is clean, output VERDICT: APPROVED with no FIX blocks."
+    ].join("\n");
+    const reviewPrompt = buildHandoffEnvelope3({
+      command: "custom",
+      task: options.diff ? `Review and identify fixable issues in this diff.
+
+GIT DIFF (${options.diff}):
+${diffContent.slice(0, REVIEW_DIFF_MAX_CHARS2)}
+
+${fixOutputContract}` : `Review ${fileOrGlob} and identify fixable issues. Read the file(s) first, then report issues with exact line numbers and exact fixes.
+
+${fixOutputContract}`,
+      constraints: [
+        `Focus: ${options.focus}`,
+        round > 1 ? `This is re-review round ${round}. Previous fixes were applied by the host. Only report REMAINING unfixed issues.` : ""
+      ].filter(Boolean),
+      resumed: Boolean(threadId)
+    });
+    const timeoutMs = options.timeout * 1e3;
+    const progress = createProgressCallbacks("fix-review");
+    console.error(chalk9.dim("  GPT reviewing..."));
+    let reviewResult;
+    try {
+      reviewResult = await adapter.callWithResume(reviewPrompt, {
+        sessionId: threadId,
+        timeout: timeoutMs,
+        ...progress
+      });
+    } catch (err) {
+      if (threadId) {
+        console.error(chalk9.yellow("  Clearing stale codex thread ID after failure."));
+        sessionMgr.updateThreadId(session2.id, null);
+        threadId = void 0;
+      }
+      throw err;
+    }
+    const resumed = threadId && reviewResult.sessionId === threadId;
+    if (threadId && !resumed) {
+      threadId = void 0;
+      sessionMgr.updateThreadId(session2.id, null);
+    }
+    if (reviewResult.sessionId) {
+      threadId = reviewResult.sessionId;
+      sessionMgr.updateThreadId(session2.id, reviewResult.sessionId);
+    }
+    sessionMgr.addUsageFromResult(session2.id, reviewResult.usage, reviewPrompt, reviewResult.text);
+    sessionMgr.recordEvent({
+      sessionId: session2.id,
+      command: "fix",
+      subcommand: `review-round-${round}`,
+      promptPreview: `Fix review round ${round}: ${fileOrGlob}`,
+      responsePreview: reviewResult.text.slice(0, 500),
+      promptFull: reviewPrompt,
+      responseFull: reviewResult.text,
+      usageJson: JSON.stringify(reviewResult.usage),
+      durationMs: reviewResult.durationMs,
+      codexThreadId: reviewResult.sessionId
+    });
+    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,
+        fixesProposed: 0,
+        fixesApplied: 0,
+        fixesFailed: 0,
+        exitReason: "all_resolved",
+        durationMs: Date.now() - roundStart
+      });
+      converged = true;
+      console.error(chalk9.green("  APPROVED \u2014 all issues resolved."));
+      break;
+    }
+    const fixes = parseFixes(reviewResult.text);
+    console.error(chalk9.dim(`  Found ${fixes.length} fix proposal(s)`));
+    if (fixes.length === 0) {
+      rounds.push({
+        round,
+        reviewVerdict: verdict,
+        reviewScore: score,
+        criticalCount,
+        warningCount,
+        fixesProposed: 0,
+        fixesApplied: 0,
+        fixesFailed: 0,
+        exitReason: "no_fixes_proposed",
+        durationMs: Date.now() - roundStart
+      });
+      console.error(chalk9.yellow("  GPT found issues but proposed no structured fixes. Stopping."));
+      break;
+    }
+    if (options.dryRun) {
+      console.error(chalk9.yellow("  Dry-run: showing proposed fixes without applying."));
+      for (const fix of fixes) {
+        console.error(chalk9.dim(`    ${fix.file}:${fix.line} \u2014 ${fix.description}`));
+      }
+      rounds.push({
+        round,
+        reviewVerdict: verdict,
+        reviewScore: score,
+        criticalCount,
+        warningCount,
+        fixesProposed: fixes.length,
+        fixesApplied: 0,
+        fixesFailed: 0,
+        exitReason: "dry_run",
+        durationMs: Date.now() - roundStart
+      });
+      continue;
+    }
+    let applied = 0;
+    let failed = 0;
+    const currentFingerprints = /* @__PURE__ */ new Set();
+    for (const fix of fixes) {
+      const fingerprint = `${fix.file}:${fix.description}`;
+      currentFingerprints.add(fingerprint);
+      if (stuckFingerprints.has(fingerprint)) {
+        console.error(chalk9.dim(`    Skip (stuck): ${fix.file}:${fix.line}`));
+        continue;
+      }
+      if (prevFingerprints.has(fingerprint)) {
+        stuckFingerprints.add(fingerprint);
+        console.error(chalk9.yellow(`    Stuck (recurring): ${fix.file}:${fix.line} \u2014 ${fix.description}`));
+        failed++;
+        continue;
+      }
+      const success = applyFix(fix, projectDir);
+      if (success) {
+        applied++;
+        console.error(chalk9.green(`    Fixed: ${fix.file}:${fix.line} \u2014 ${fix.description}`));
+      } else {
+        failed++;
+        console.error(chalk9.red(`    Failed: ${fix.file}:${fix.line} \u2014 could not match old code`));
+      }
+    }
+    prevFingerprints = currentFingerprints;
+    if (applied > 0 && !options.noStage) {
+      try {
+        execFileSync2("git", ["add", "-A"], { cwd: projectDir, stdio: "pipe" });
+        console.error(chalk9.dim("  Changes staged."));
+      } catch {
+        console.error(chalk9.yellow("  Could not stage changes (not a git repo?)."));
+      }
+    }
+    const exitReason2 = applied === 0 ? "no_diff" : "continue";
+    rounds.push({
+      round,
+      reviewVerdict: verdict,
+      reviewScore: score,
+      criticalCount,
+      warningCount,
+      fixesProposed: fixes.length,
+      fixesApplied: applied,
+      fixesFailed: failed,
+      exitReason: exitReason2,
+      durationMs: Date.now() - roundStart
+    });
+    if (applied === 0) {
+      console.error(chalk9.yellow("  No fixes applied \u2014 stopping loop."));
+      break;
+    }
+    if (stuckFingerprints.size >= fixes.length) {
+      console.error(chalk9.yellow("  All remaining issues are stuck \u2014 stopping."));
+      break;
+    }
+    console.error(chalk9.dim(`  Applied ${applied}, failed ${failed}. Continuing to re-review...`));
+  }
+  const lastRound = rounds[rounds.length - 1];
+  const totalApplied = rounds.reduce((sum, r) => sum + r.fixesApplied, 0);
+  const totalProposed = rounds.reduce((sum, r) => sum + r.fixesProposed, 0);
+  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 exitReason = converged ? "all_resolved" : stuckFingerprints.size > 0 ? "all_stuck" : lastRound?.exitReason ?? "max_iterations";
+  const output = {
+    target: fileOrGlob,
+    converged,
+    exitReason,
+    rounds,
+    totalRounds: rounds.length,
+    totalFixesProposed: totalProposed,
+    totalFixesApplied: totalApplied,
+    stuckCount: stuckFingerprints.size,
+    finalVerdict: lastRound?.reviewVerdict ?? "unknown",
+    finalScore: lastRound?.reviewScore ?? null,
+    policy,
+    sessionId: session2.id,
+    codexThreadId: threadId
+  };
+  const color = converged ? chalk9.green : chalk9.red;
+  console.error(color(`
+Result: ${converged ? "CONVERGED" : "NOT CONVERGED"} (${exitReason})`));
+  console.error(`  Rounds: ${rounds.length}/${options.maxRounds}`);
+  console.error(`  Fixes: ${totalApplied} applied, ${totalProposed - totalApplied} failed/skipped`);
+  if (stuckFingerprints.size > 0) {
+    console.error(chalk9.yellow(`  Stuck issues: ${stuckFingerprints.size}`));
+  }
+  console.error(`  Final: ${lastRound?.reviewVerdict ?? "?"} (${lastRound?.reviewScore ?? "?"}/10)`);
+  console.log(JSON.stringify(output, null, 2));
+  db.close();
+}
+
+// src/commands/init.ts
+import { existsSync as existsSync2 } from "fs";
+import { basename, join as join5 } from "path";
+import { loadConfig as loadConfig5, writeConfig } from "@mulep/core";
+import chalk10 from "chalk";
+async function initCommand(options) {
+  const cwd = process.cwd();
+  const configPath = join5(cwd, ".mulep.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-N6ZYOVSU.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: mulep plan "describe your task"'));
+}
+
+// src/commands/install-skills.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname, join as join6 } 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 \`mulep 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
+mulep review <file-or-glob> --focus all
+\`\`\`
+
+**If the user specifies a diff:**
+\`\`\`bash
+mulep review --diff HEAD~3..HEAD
+\`\`\`
+
+**If the user gives a freeform description:**
+\`\`\`bash
+mulep 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
+mulep review <target> --preset security-audit
+mulep review <target> --preset quick-scan
+mulep 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 \`mulep 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.
+- **Output capped**: JSON \`review\` field is capped to 2KB to prevent terminal crashes. Full text is stored in session_events.
+- **Progress**: Heartbeat every 60s, throttled to 30s intervals. No agent_message dumps.
+`
+  },
+  {
+    path: ".claude/skills/plan-review/SKILL.md",
+    description: "/plan-review \u2014 GPT review of execution plans",
+    content: `---
+name: plan-review
+description: Send execution plans to GPT for structured review via Codex CLI. Use when you have a written plan and want independent validation before implementation.
+user-invocable: true
+---
+
+# /plan-review \u2014 GPT Review of Execution Plans
+
+## Usage
+\`/plan-review <plan-file-or-description>\`
+
+## Description
+Sends a Claude-authored execution plan to GPT via \`mulep plan review\` for structured critique. GPT returns ISSUE (HIGH/MEDIUM/LOW) and SUGGEST lines with file-level references.
+
+## Instructions
+
+### Step 1: Prepare the plan
+- If the user provides a file path, use it directly
+- If reviewing the current conversation's plan, write to a temp file first
+
+### Step 2: Run plan review
+\`\`\`bash
+mulep plan review <plan-file> [--phase N] [--build BUILD_ID] [--timeout ms] [--output file]
+\`\`\`
+
+### Step 3: Parse and present output
+JSON output includes: \`verdict\`, \`score\`, \`issues[]\` (severity + message), \`suggestions[]\`.
+
+Present as:
+\`\`\`
+## GPT Plan Review
+**Score**: X/10 | **Verdict**: APPROVED/NEEDS_REVISION
+### Issues
+- [HIGH] description
+### Suggestions
+- suggestion text
+\`\`\`
+
+### Step 4: If NEEDS_REVISION
+Fix HIGH issues, revise the plan, re-run. Session resume gives GPT context of prior review.
+
+### Important Notes
+- **Session resume**: GPT remembers prior reviews via thread resume
+- **Codebase access**: GPT reads actual project files to verify plan references
+- **Output capped**: JSON \`review\` field is capped to 2KB. Use \`--output\` for full text
+- **Zero API cost**: Uses ChatGPT subscription via Codex CLI
+`
+  },
+  {
+    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 mulep CLI with session persistence.
+
+## Instructions
+
+### Phase 0: Setup
+1. Parse topic from user's message
+2. Start debate:
+\`\`\`bash
+mulep 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
+mulep 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
+mulep 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
+6. JSON \`response\` field capped to 2KB \u2014 check \`responseTruncated\` boolean
+7. Progress heartbeat every 60s, throttled to 30s intervals
+`
+  },
+  {
+    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. \`mulep 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.25: Plan Review (Recommended)
+Before user approval, validate the plan with GPT:
+\`\`\`bash
+mulep plan review /path/to/plan.md --build BUILD_ID
+\`\`\`
+GPT reviews the plan against actual codebase, returns ISSUE/SUGGEST lines.
+Fix HIGH issues before presenting to user.
+
+### Phase 1.5: User Approval Gate
+Present agreed plan. Wait for explicit approval via AskUserQuestion.
+\`\`\`bash
+mulep build event BUILD_ID plan_approved
+mulep debate complete DEBATE_ID
+\`\`\`
+
+### Phase 2: Implement
+Write code. Run tests: \`pnpm run test\`
+Never send broken code to review.
+\`\`\`bash
+mulep build event BUILD_ID impl_completed
+\`\`\`
+
+### Phase 3: GPT Review
+\`\`\`bash
+mulep 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
+mulep 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
+mulep 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 mulep 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 mulep cleanup
+\`\`\`bash
+mulep 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 \`mulep 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 mulep CLI to get independent reviews and iterate until quality threshold is met.
+
+## How You Work
+1. Send content to GPT via \`mulep review\` or \`mulep plan review\`
+2. Parse JSON output for score, verdict, findings
+3. If NEEDS_REVISION: fix issues and re-submit (session resume retains context)
+4. Loop until APPROVED or max iterations
+5. Report final version back to team lead
+
+## Available Commands
+\`\`\`bash
+mulep review <file-or-glob>           # Code review
+mulep review --diff HEAD~3..HEAD      # Diff review
+mulep plan review <plan-file>         # Plan review
+mulep debate turn DEBATE_ID "prompt"  # Debate turn
+mulep fix <file-or-glob>              # Autofix loop
+\`\`\`
+
+## Important Rules
+- NEVER fabricate GPT's responses \u2014 always parse actual JSON output
+- NEVER skip iterations if GPT says NEEDS_REVISION
+- Use your own judgment when GPT's feedback conflicts with project requirements
+- JSON \`review\`/\`response\` fields are capped to 2KB; use \`--output\` for full text
+- All commands use session resume \u2014 GPT retains context across calls
+- Zero API cost (ChatGPT subscription via Codex CLI)
+`
+  }
+];
+var CLAUDE_MD_SECTION = `
+## MuleP \u2014 Multi-Model Collaboration
+
+This project uses [MuleP](https://github.com/katarmal-ram/mulep) for Claude + GPT collaboration. MuleP bridges Claude Code and Codex CLI so they work as partners \u2014 one plans, the other reviews.
+
+### How Sessions Work
+- Every \`mulep\` 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 \`.mulep/db/mulep.db\` (SQLite)
+- When a session's token budget fills up, it auto-rolls to a new thread
+- Run \`mulep session current\` to see the active session
+
+### Available Commands (use these, not raw codex)
+- \`mulep review <file-or-dir>\` \u2014 GPT reviews code with codebase access
+- \`mulep review --prompt "question"\` \u2014 GPT explores codebase to answer
+- \`mulep review --diff HEAD~3..HEAD\` \u2014 Review git changes
+- \`mulep review --preset security-audit\` \u2014 Specialized review presets
+- \`mulep fix <file>\` \u2014 Autofix loop: review \u2192 apply fixes \u2192 re-review
+- \`mulep debate start "topic"\` \u2014 Multi-round Claude vs GPT debate
+- \`mulep cleanup\` \u2014 Scan for unused deps, dead code, duplicates
+- \`mulep plan generate "task"\` \u2014 Generate plans via multi-model loop
+- \`mulep plan review <plan-file>\` \u2014 GPT review of execution plans
+- \`mulep shipit --profile safe\` \u2014 Composite workflow (lint+test+review)
+- \`mulep cost\` \u2014 Token usage dashboard
+- \`mulep doctor\` \u2014 Check prerequisites
+
+### Slash Commands
+- \`/codex-review\` \u2014 Quick GPT review (uses mulep review internally)
+- \`/debate\` \u2014 Start a Claude vs GPT debate
+- \`/plan-review\` \u2014 GPT review of execution plans
+- \`/build\` \u2014 Full build loop: debate \u2192 plan \u2192 implement \u2192 GPT review \u2192 fix
+- \`/cleanup\` \u2014 Bidirectional AI slop scanner
+
+### When to Use MuleP
+- After implementing a feature \u2192 \`mulep review src/\`
+- Before committing \u2192 \`mulep review --diff HEAD --preset pre-commit\`
+- Architecture decisions \u2192 \`/debate "REST vs GraphQL?"\`
+- Full feature build \u2192 \`/build "add user authentication"\`
+- After shipping \u2192 \`mulep shipit --profile safe\`
+
+### Session Tips
+- Sessions auto-resume \u2014 GPT retains context from prior commands
+- \`mulep session list\` shows all sessions with token usage
+- \`mulep cost --scope session\` shows current session spend
+- Start fresh with \`mulep session start --name "new-feature"\`
+`;
+var HOOKS_CONFIG = {
+  hooks: {
+    PostToolUse: [
+      {
+        matcher: "Bash",
+        pattern: "git commit",
+        command: 'echo "Tip: Run mulep 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 MuleP integration for Claude Code\n"));
+  console.error(chalk11.dim("  Skills & Agents:"));
+  for (const skill of SKILLS) {
+    const fullPath = join6(cwd, skill.path);
+    const dir = dirname(fullPath);
+    if (existsSync3(fullPath) && !options.force) {
+      console.error(chalk11.dim(`  SKIP ${skill.path} (exists)`));
+      skipped++;
+      continue;
+    }
+    mkdirSync3(dir, { recursive: true });
+    writeFileSync3(fullPath, skill.content, "utf-8");
+    console.error(chalk11.green(`  OK   ${skill.path}`));
+    installed++;
+  }
+  console.error("");
+  console.error(chalk11.dim("  CLAUDE.md:"));
+  const claudeMdPath = join6(cwd, "CLAUDE.md");
+  const marker = "## MuleP \u2014 Multi-Model Collaboration";
+  if (existsSync3(claudeMdPath)) {
+    const existing = readFileSync3(claudeMdPath, "utf-8");
+    if (existing.includes(marker)) {
+      if (options.force) {
+        const markerIdx = existing.indexOf(marker);
+        const before = existing.slice(0, markerIdx);
+        const sectionEnd = existing.indexOf(CLAUDE_MD_SECTION.trimEnd(), markerIdx);
+        const afterMarker = sectionEnd >= 0 ? existing.slice(sectionEnd + CLAUDE_MD_SECTION.trimEnd().length) : existing.slice(markerIdx + marker.length);
+        const nextHeadingMatch = sectionEnd >= 0 ? null : afterMarker.match(/\n#{1,6} (?!MuleP)/);
+        const after = nextHeadingMatch ? afterMarker.slice(nextHeadingMatch.index) : "";
+        writeFileSync3(claudeMdPath, before.trimEnd() + "\n" + CLAUDE_MD_SECTION + after, "utf-8");
+        console.error(chalk11.green("  OK   CLAUDE.md (updated MuleP section)"));
+        installed++;
+      } else {
+        console.error(chalk11.dim("  SKIP CLAUDE.md (MuleP section exists)"));
+        skipped++;
+      }
+    } else {
+      writeFileSync3(claudeMdPath, existing.trimEnd() + "\n" + CLAUDE_MD_SECTION, "utf-8");
+      console.error(chalk11.green("  OK   CLAUDE.md (appended MuleP section)"));
+      installed++;
+    }
+  } else {
+    writeFileSync3(claudeMdPath, `# Project Instructions
+${CLAUDE_MD_SECTION}`, "utf-8");
+    console.error(chalk11.green("  OK   CLAUDE.md (created with MuleP section)"));
+    installed++;
+  }
+  console.error("");
+  console.error(chalk11.dim("  Hooks:"));
+  const settingsDir = join6(cwd, ".claude");
+  const settingsPath = join6(settingsDir, "settings.json");
+  if (existsSync3(settingsPath)) {
+    try {
+      const existing = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+      const hasMulepHook = Array.isArray(existing.hooks?.PostToolUse) && existing.hooks.PostToolUse.some((h) => h.command?.includes("mulep"));
+      if (hasMulepHook && !options.force) {
+        console.error(chalk11.dim("  SKIP .claude/settings.json (mulep hook exists)"));
+        skipped++;
+      } else {
+        const otherHooks = Array.isArray(existing.hooks?.PostToolUse) ? existing.hooks.PostToolUse.filter((h) => !h.command?.includes("mulep")) : [];
+        existing.hooks = {
+          ...existing.hooks,
+          PostToolUse: [...otherHooks, ...HOOKS_CONFIG.hooks.PostToolUse]
+        };
+        writeFileSync3(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 {
+    mkdirSync3(settingsDir, { recursive: true });
+    writeFileSync3(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, /plan-review, /build, /cleanup"));
+  console.error(chalk11.dim("  CLAUDE.md: Claude now knows about mulep commands & sessions"));
+  console.error(chalk11.dim("  Hook: Post-commit hint to run mulep 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 "@mulep/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 "mulep session start" to create one.' }));
+      return;
+    }
+    const events = mgr.getEvents(session2.id, 5);
+    console.log(JSON.stringify({
+      sessionId: session2.id,
+      name: session2.name,
+      codexThreadId: session2.codexThreadId,
+      status: session2.status,
+      tokenUsage: session2.tokenUsage,
+      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);
+    console.log(JSON.stringify({
+      sessionId: session2.id,
+      name: session2.name,
+      codexThreadId: session2.codexThreadId,
+      status: session2.status,
+      tokenUsage: session2.tokenUsage,
+      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 "@mulep/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 { readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import {
+  ModelRegistry as ModelRegistry4,
+  Orchestrator,
+  SessionManager as SessionManager7,
+  buildHandoffEnvelope as buildHandoffEnvelope4,
+  loadConfig as loadConfig6,
+  openDatabase as openDatabase9
+} from "@mulep/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 planGenerateCommand(task, options) {
+  let db;
+  try {
+    const config = loadConfig6();
+    const projectDir = process.cwd();
+    const registry = ModelRegistry4.fromConfig(config, projectDir);
+    const dbPath = getDbPath();
+    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) {
+      writeFileSync4(options.output, result.finalOutput, "utf-8");
+      console.error(chalk15.green(`Plan saved to ${options.output}`));
+    }
+    printSessionSummary(result);
+    db.close();
+    process.exit(result.status === "completed" ? 0 : 2);
+  } catch (error) {
+    db?.close();
+    console.error(chalk15.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+    process.exit(1);
+  }
+}
+async function planReviewCommand(planFile, options) {
+  let db;
+  try {
+    let planContent;
+    if (planFile === "-") {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      planContent = Buffer.concat(chunks).toString("utf-8");
+    } else {
+      planContent = readFileSync4(planFile, "utf-8");
+    }
+    if (!planContent.trim()) {
+      console.error(chalk15.red("Plan file is empty."));
+      process.exit(1);
+    }
+    const config = loadConfig6();
+    const projectDir = process.cwd();
+    const registry = ModelRegistry4.fromConfig(config, projectDir);
+    const adapter = registry.tryGetAdapter("codex-reviewer") ?? registry.tryGetAdapter("codex-architect");
+    if (!adapter) {
+      console.error(chalk15.red("No codex adapter found in config. Run: mulep init"));
+      process.exit(1);
+    }
+    const dbPath = getDbPath();
+    db = openDatabase9(dbPath);
+    const sessionMgr = new SessionManager7(db);
+    const session2 = sessionMgr.resolveActive("plan-review");
+    const currentSession = sessionMgr.get(session2.id);
+    const threadId = currentSession?.codexThreadId ?? void 0;
+    const phaseContext = options.phase ? `
+This is Phase ${options.phase} of a multi-phase plan.` : "";
+    const buildContext = options.build ? `
+Build ID: ${options.build}` : "";
+    const prompt = buildHandoffEnvelope4({
+      command: "plan-review",
+      task: `Review the following execution plan for completeness, correctness, and feasibility. Read relevant codebase files to verify the plan's assumptions.${phaseContext}${buildContext}
+
+PLAN:
+${planContent.slice(0, 5e4)}
+
+Review criteria:
+1. Are all files/functions mentioned actually present in the codebase?
+2. Are there missing steps or dependencies between phases?
+3. Are there architectural concerns or better approaches?
+4. Is the scope realistic for the described phases?
+5. Are there security or performance concerns?
+
+Output format:
+- For each issue, output: ISSUE: [HIGH|MEDIUM|LOW] <description>
+- For each suggestion, output: SUGGEST: <description>
+- End with: VERDICT: APPROVED or VERDICT: NEEDS_REVISION
+- End with: SCORE: X/10`,
+      constraints: [
+        "Verify file paths and function names against the actual codebase before flagging issues.",
+        "Be specific \u2014 reference exact files and line numbers when possible.",
+        "Focus on feasibility, not style preferences."
+      ],
+      resumed: Boolean(threadId)
+    });
+    const timeoutMs = (options.timeout ?? 300) * 1e3;
+    const progress = createProgressCallbacks("plan-review");
+    console.error(chalk15.cyan("Sending plan to codex for review..."));
+    let result;
+    try {
+      result = await adapter.callWithResume(prompt, {
+        sessionId: threadId,
+        timeout: timeoutMs,
+        ...progress
+      });
+    } catch (err) {
+      if (threadId) {
+        console.error(chalk15.yellow("  Clearing stale codex thread ID after failure."));
+        sessionMgr.updateThreadId(session2.id, null);
+      }
+      throw err;
+    }
+    if (threadId && result.sessionId !== threadId) {
+      sessionMgr.updateThreadId(session2.id, null);
+    }
+    if (result.sessionId) {
+      sessionMgr.updateThreadId(session2.id, result.sessionId);
+    }
+    sessionMgr.addUsageFromResult(session2.id, result.usage, prompt, result.text);
+    sessionMgr.recordEvent({
+      sessionId: session2.id,
+      command: "plan",
+      subcommand: "review",
+      promptPreview: `Plan review: ${planFile}${options.phase ? ` (phase ${options.phase})` : ""}`,
+      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(/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 issues = [];
+    const suggestions = [];
+    for (const line of result.text.split("\n")) {
+      const issueMatch = line.match(/^[-*]?\s*ISSUE:\s*\[(HIGH|MEDIUM|LOW)]\s*(.*)/i);
+      if (issueMatch) {
+        issues.push({ severity: issueMatch[1].toLowerCase(), message: issueMatch[2].trim() });
+      }
+      const suggestMatch = line.match(/^[-*]?\s*SUGGEST:\s*(.*)/i);
+      if (suggestMatch) {
+        suggestions.push(suggestMatch[1].trim());
+      }
+    }
+    const verdictColor = verdict === "approved" ? chalk15.green : chalk15.red;
+    console.error(verdictColor(`
+Verdict: ${verdict.toUpperCase()} (${score ?? "?"}/10)`));
+    if (issues.length > 0) {
+      console.error(chalk15.yellow(`Issues (${issues.length}):`));
+      for (const issue of issues) {
+        const sevColor = issue.severity === "high" ? chalk15.red : issue.severity === "medium" ? chalk15.yellow : chalk15.dim;
+        console.error(`  ${sevColor(issue.severity.toUpperCase())} ${issue.message}`);
+      }
+    }
+    if (suggestions.length > 0) {
+      console.error(chalk15.cyan(`Suggestions (${suggestions.length}):`));
+      for (const s of suggestions) {
+        console.error(`  ${chalk15.dim("\u2192")} ${s}`);
+      }
+    }
+    console.error(chalk15.dim(`Duration: ${(result.durationMs / 1e3).toFixed(1)}s | Tokens: ${result.usage.totalTokens}`));
+    const output = {
+      planFile,
+      phase: options.phase ?? null,
+      buildId: options.build ?? null,
+      verdict,
+      score,
+      issues,
+      suggestions,
+      review: result.text.slice(0, 2e3),
+      sessionId: result.sessionId,
+      resumed: threadId ? result.sessionId === threadId : false,
+      usage: result.usage,
+      durationMs: result.durationMs
+    };
+    console.log(JSON.stringify(output, null, 2));
+    if (options.output) {
+      writeFileSync4(options.output, JSON.stringify(output, null, 2), "utf-8");
+      console.error(chalk15.green(`Review saved to ${options.output}`));
+    }
+    db.close();
+  } catch (error) {
+    db?.close();
+    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 SessionManager8, JobStore as JobStore3, openDatabase as openDatabase10, buildHandoffEnvelope as buildHandoffEnvelope5, getReviewPreset } from "@mulep/core";
+import chalk16 from "chalk";
+import { execFileSync as execFileSync3, execSync as execSync4 } from "child_process";
+import { closeSync, globSync, openSync, readFileSync as readFileSync5, readSync, statSync, existsSync as existsSync4 } from "fs";
+import { resolve as resolve2 } 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: mulep init"));
+        process.exit(1);
+      }
+      console.error(chalk16.red("No codex adapter found in config. Run: mulep init"));
+      console.error(chalk16.dim("Diagnose: mulep 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: mulep jobs status " + jobId }));
+      db2.close();
+      return;
+    }
+    const db = openDatabase10(getDbPath());
+    const sessionMgr = new SessionManager8(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: mulep init"));
+      db.close();
+      process.exit(1);
+    }
+    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 = buildHandoffEnvelope5({
+        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 = execFileSync3("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 = buildHandoffEnvelope5({
+        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 = resolve2(projectDir, globPattern);
+      if (existsSync4(resolvedInput) && statSync(resolvedInput).isDirectory()) {
+        globPattern = `${globPattern}/**/*`;
+        console.error(chalk16.dim(`  Expanding directory to: ${globPattern}`));
+      }
+      const projectRoot = resolve2(projectDir) + (process.platform === "win32" ? "\\" : "/");
+      const paths = globSync(globPattern, { cwd: projectDir }).map((p) => resolve2(projectDir, p)).filter((p) => p.startsWith(projectRoot) || p === resolve2(projectDir));
+      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 = readFileSync5(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 = buildHandoffEnvelope5({
+        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");
+    let result;
+    try {
+      result = await adapter.callWithResume(prompt, {
+        sessionId: sessionThreadId,
+        timeout: timeoutMs,
+        ...progress
+      });
+    } catch (err) {
+      if (sessionThreadId) {
+        sessionMgr.updateThreadId(session2.id, null);
+      }
+      throw err;
+    }
+    if (sessionThreadId && result.sessionId !== sessionThreadId) {
+      sessionMgr.updateThreadId(session2.id, null);
+    }
+    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.slice(0, 2e3),
+      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 "@mulep/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 "@mulep/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 = "mulep review --preset pre-commit --diff HEAD";
+        break;
+      case "cleanup":
+        cmd = "mulep 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 execFileSync4, execSync as execSync6 } from "child_process";
+import { join as join7, basename as basename2 } from "path";
+import chalk19 from "chalk";
+import { loadConfig as loadConfig9, writeConfig as writeConfig2 } from "@mulep/core";
+async function startCommand() {
+  const cwd = process.cwd();
+  console.error(chalk19.cyan("\n  MuleP \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: mulep start"));
+    process.exit(1);
+  }
+  console.error(chalk19.green(`  Codex CLI ${codexVersion} found.`));
+  console.error(chalk19.dim("  [2/4] Checking project config..."));
+  const configPath = join7(cwd, ".mulep.yml");
+  if (existsSync5(configPath)) {
+    console.error(chalk19.green("  .mulep.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 .mulep.yml with cli-first preset."));
+  }
+  console.error(chalk19.dim("  [3/4] Detecting project..."));
+  const hasGit = existsSync5(join7(cwd, ".git"));
+  const hasSrc = existsSync5(join7(cwd, "src"));
+  const hasPackageJson = existsSync5(join7(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: mulep review <path>"));
+      process.exit(0);
+    }
+  }
+  console.error(chalk19.dim("  [4/4] Running quick review..."));
+  console.error(chalk19.cyan(`
+  mulep review ${reviewTarget} --preset quick-scan
+`));
+  try {
+    const output = execFileSync4("mulep", ["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(`    mulep fix ${reviewTarget} --dry-run   # preview fixes`));
+        console.error(chalk19.dim(`    mulep fix ${reviewTarget}             # apply fixes`));
+        console.error(chalk19.dim("    mulep 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("    mulep review --preset security-audit  # security scan"));
+        console.error(chalk19.dim('    mulep debate start "your question"    # debate with GPT'));
+        console.error(chalk19.dim("    mulep 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: mulep review --preset quick-scan"));
+    } else {
+      console.error(chalk19.red(`  Review failed: ${msg.slice(0, 200)}`));
+    }
+  }
+  console.error(chalk19.dim("  Tip: Run mulep 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 "@mulep/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/**",
+    "**/.mulep/**",
+    "**/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 buildHandoffEnvelope6,
+  loadConfig as loadConfig10,
+  openDatabase as openDatabase13
+} from "@mulep/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: mulep 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: resolve6, normalize } = await import("path");
+      const payload = JSON.parse(job.payloadJson);
+      const rawCwd = resolve6(payload.path ?? payload.cwd ?? projectDir);
+      const cwd = normalize(rawCwd);
+      const sep = process.platform === "win32" ? "\\" : "/";
+      if (cwd !== normalize(projectDir) && !cwd.startsWith(normalize(projectDir) + sep)) {
+        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 = buildHandoffEnvelope6({
+            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: execFileSync5 } = 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 = execFileSync5("git", ["diff", ...diffArgs], {
+            cwd,
+            encoding: "utf-8",
+            maxBuffer: 1024 * 1024
+          });
+          prompt = buildHandoffEnvelope6({
+            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 = buildHandoffEnvelope6({
+            command: "review",
+            task: `Review these files: ${payload.files.join(", ")}. Read each file and report issues.`,
+            constraints: [focusConstraint],
+            resumed: false
+          });
+        } else {
+          prompt = buildHandoffEnvelope6({
+            command: "review",
+            task: "Review the codebase for issues. Start by listing key files.",
+            constraints: [focusConstraint],
+            resumed: false
+          });
+        }
+      } else if (job.type === "cleanup") {
+        prompt = buildHandoffEnvelope6({
+          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/commands/workspace.ts
+import chalk22 from "chalk";
+import { WorkspaceScanner, createLogger } from "@mulep/core";
+var logger = createLogger("workspace");
+async function workspaceInitCommand() {
+  const cwd = process.cwd();
+  console.log(chalk22.blue("Initializing MuleP workspace..."));
+  console.log(chalk22.dim(`Scanning ${cwd} for Mule projects...`));
+  const scanner = new WorkspaceScanner(cwd);
+  const registry = scanner.scan();
+  if (registry.totalProjects === 0) {
+    console.log(chalk22.yellow("\nNo Mule projects found in this directory."));
+    console.log(chalk22.dim("Mule projects are detected by pom.xml + src/main/mule/ structure"));
+    console.log(chalk22.dim("or by the presence of mule-maven-plugin in pom.xml"));
+    return;
+  }
+  printRegistrySummary(registry);
+  console.log(chalk22.green("\nWorkspace initialized successfully."));
+}
+async function workspaceListCommand() {
+  const cwd = process.cwd();
+  const scanner = new WorkspaceScanner(cwd);
+  const registry = scanner.scan();
+  if (registry.totalProjects === 0) {
+    console.log(chalk22.yellow("No Mule projects found. Run `mulep workspace init` first."));
+    return;
+  }
+  printRegistrySummary(registry);
+}
+async function workspaceValidateCommand() {
+  const cwd = process.cwd();
+  console.log(chalk22.blue("Validating workspace integrity..."));
+  const scanner = new WorkspaceScanner(cwd);
+  const registry = scanner.scan();
+  if (registry.totalProjects === 0) {
+    console.log(chalk22.yellow("No Mule projects found."));
+    return;
+  }
+  let issues = 0;
+  for (const project of registry.projects) {
+    if (!project.muleVersion) {
+      console.log(chalk22.yellow(`  [WARN] ${project.name}: Mule version not detected`));
+      issues++;
+    }
+    if (project.flowFiles.length > 0 && !project.hasMunitTests) {
+      console.log(chalk22.yellow(`  [WARN] ${project.name}: Has flows but no MUnit tests`));
+      issues++;
+    }
+    if (project.connectors.length === 0 && project.flowFiles.length > 0) {
+      console.log(chalk22.yellow(`  [WARN] ${project.name}: Has flows but no connectors detected`));
+      issues++;
+    }
+  }
+  const versionMap = /* @__PURE__ */ new Map();
+  for (const project of registry.projects) {
+    for (const connector2 of project.connectors) {
+      if (!versionMap.has(connector2.artifactId)) {
+        versionMap.set(connector2.artifactId, /* @__PURE__ */ new Set());
+      }
+      versionMap.get(connector2.artifactId).add(connector2.version);
+    }
+  }
+  for (const [artifact, versions] of versionMap) {
+    if (versions.size > 1) {
+      console.log(
+        chalk22.red(`  [ERROR] Connector version conflict: ${artifact} has versions: ${Array.from(versions).join(", ")}`)
+      );
+      issues++;
+    }
+  }
+  if (issues === 0) {
+    console.log(chalk22.green("\nWorkspace validation passed \u2014 no issues found."));
+  } else {
+    console.log(chalk22.yellow(`
+Workspace validation found ${issues} issue(s).`));
+  }
+}
+async function workspaceSyncCommand() {
+  const cwd = process.cwd();
+  console.log(chalk22.blue("Syncing workspace project registry..."));
+  const scanner = new WorkspaceScanner(cwd);
+  const registry = scanner.scan();
+  printRegistrySummary(registry);
+  console.log(chalk22.green("\nProject registry synced."));
+}
+function printRegistrySummary(registry) {
+  console.log(chalk22.bold(`
+Workspace: ${registry.workspaceRoot}`));
+  console.log(chalk22.dim(`Discovered at: ${registry.discoveredAt}`));
+  console.log(`Projects: ${chalk22.cyan(String(registry.totalProjects))}`);
+  console.log(`Flow files: ${chalk22.cyan(String(registry.totalFlowFiles))}`);
+  console.log(`DataWeave files: ${chalk22.cyan(String(registry.totalDataweaveFiles))}`);
+  console.log(chalk22.bold("\nProjects:"));
+  for (const project of registry.projects) {
+    const muleVer = project.muleVersion ? chalk22.dim(`(Mule ${project.muleVersion})`) : chalk22.dim("(version unknown)");
+    const edition = project.runtimeEdition !== "unknown" ? chalk22.dim(`[${project.runtimeEdition}]`) : "";
+    console.log(`  ${chalk22.green("\u25CF")} ${chalk22.bold(project.name)} ${muleVer} ${edition}`);
+    console.log(chalk22.dim(`    Path: ${project.relativePath || "."}`));
+    console.log(chalk22.dim(`    Flows: ${project.flowFiles.length} | DataWeave: ${project.dataweaveFiles.length} | Connectors: ${project.connectors.length}`));
+    if (project.hasMunitTests) {
+      console.log(chalk22.dim("    MUnit: yes"));
+    }
+  }
+}
+
+// src/commands/flow.ts
+import chalk23 from "chalk";
+import { FlowParser, WorkspaceScanner as WorkspaceScanner2 } from "@mulep/core";
+import { readFileSync as readFileSync6, existsSync as existsSync6, writeFileSync as writeFileSync5 } from "fs";
+import { join as join8, resolve as resolve3 } from "path";
+async function flowVisualizeCommand(flowName, options) {
+  const flowFile = findFlowFile(flowName, options.project);
+  if (!flowFile) return;
+  const parser = new FlowParser();
+  const complexity = parser.parse(flowFile);
+  const mermaid = parser.generateMermaid(complexity);
+  if (options.output) {
+    writeFileSync5(options.output, mermaid, "utf-8");
+    console.log(chalk23.green(`Mermaid diagram written to ${options.output}`));
+  } else {
+    console.log(chalk23.bold("\nMermaid Flow Diagram:"));
+    console.log(chalk23.dim("(Copy to https://mermaid.live to visualize)\n"));
+    console.log(mermaid);
+  }
+}
+async function flowAnalyzeCommand(flowName, options) {
+  const flowFile = findFlowFile(flowName, options.project);
+  if (!flowFile) return;
+  const parser = new FlowParser();
+  const complexity = parser.parse(flowFile);
+  printFlowReport(complexity);
+}
+async function flowTestGenCommand(flowName, options) {
+  const flowFile = findFlowFile(flowName, options.project);
+  if (!flowFile) return;
+  const parser = new FlowParser();
+  const complexity = parser.parse(flowFile);
+  console.log(chalk23.bold("\nMUnit Test Suggestions:"));
+  for (const flow2 of complexity.flows) {
+    console.log(chalk23.cyan(`
+  Flow: ${flow2.name}`));
+    console.log(chalk23.dim(`    Steps: ${flow2.steps.length}`));
+    console.log(chalk23.bold("    Suggested test cases:"));
+    console.log(chalk23.dim("    1. Happy path \u2014 verify end-to-end flow execution"));
+    if (flow2.errorHandlers.length > 0) {
+      console.log(chalk23.dim("    2. Error handling \u2014 verify error handlers trigger correctly"));
+    } else {
+      console.log(chalk23.yellow("    2. [MISSING] No error handlers \u2014 add on-error-propagate"));
+    }
+    const connectorSteps = flow2.steps.filter((s) => s.connectorType);
+    if (connectorSteps.length > 0) {
+      console.log(
+        chalk23.dim(
+          `    3. Connector mocking \u2014 mock ${connectorSteps.map((s) => s.connectorType).join(", ")} connectors`
+        )
+      );
+    }
+    if (flow2.steps.some((s) => s.type.includes("choice"))) {
+      console.log(chalk23.dim("    4. Branch coverage \u2014 test all choice router paths"));
+    }
+    if (flow2.steps.some((s) => s.type === "set-variable")) {
+      console.log(chalk23.dim("    5. Variable assertions \u2014 verify variable values after flow"));
+    }
+  }
+}
+function findFlowFile(flowName, projectName) {
+  if (existsSync6(flowName) && flowName.endsWith(".xml")) {
+    return resolve3(flowName);
+  }
+  const cwd = process.cwd();
+  const scanner = new WorkspaceScanner2(cwd);
+  const registry = scanner.scan();
+  if (registry.totalProjects === 0) {
+    console.log(chalk23.yellow("No Mule projects found in workspace."));
+    return null;
+  }
+  const projects = projectName ? registry.projects.filter((p) => p.name === projectName) : registry.projects;
+  for (const project of projects) {
+    for (const flowFile of project.flowFiles) {
+      const fullPath = join8(project.path, flowFile);
+      if (flowFile.includes(flowName) || flowFile.endsWith(`${flowName}.xml`)) {
+        return fullPath;
+      }
+      try {
+        const content = readFileSync6(fullPath, "utf-8");
+        if (content.includes(`name="${flowName}"`)) {
+          return fullPath;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  console.log(chalk23.yellow(`Flow "${flowName}" not found in workspace.`));
+  return null;
+}
+function printFlowReport(complexity) {
+  console.log(chalk23.bold(`
+Flow Analysis: ${complexity.file}`));
+  console.log(chalk23.dim("\u2500".repeat(60)));
+  console.log(chalk23.bold("\nMetrics:"));
+  console.log(`  Total Flows: ${chalk23.cyan(String(complexity.metrics.totalFlows))}`);
+  console.log(`  Sub-Flows: ${chalk23.cyan(String(complexity.metrics.totalSubFlows))}`);
+  console.log(`  Total Steps: ${chalk23.cyan(String(complexity.metrics.totalSteps))}`);
+  console.log(`  Max Nesting Depth: ${chalk23.cyan(String(complexity.metrics.maxNestingDepth))}`);
+  console.log(`  Avg Steps/Flow: ${chalk23.cyan(String(complexity.metrics.averageStepsPerFlow))}`);
+  console.log(`  Error Handler Coverage: ${colorCoverage(complexity.metrics.errorHandlerCoverage)}%`);
+  console.log(`  Connector Diversity: ${chalk23.cyan(String(complexity.metrics.connectorDiversity))}`);
+  console.log(`  Complexity Score: ${colorComplexity(complexity.metrics.complexityScore)}`);
+  if (complexity.findings.length > 0) {
+    console.log(chalk23.bold("\nFindings:"));
+    for (const finding of complexity.findings) {
+      const icon = finding.severity === "critical" ? "\u25CF" : finding.severity === "high" ? "\u25B2" : "\u25CB";
+      const color = finding.severity === "critical" ? chalk23.red : finding.severity === "high" ? chalk23.yellow : chalk23.dim;
+      console.log(`  ${color(icon)} [${finding.severity.toUpperCase()}] ${finding.message}`);
+      if (finding.suggestion) {
+        console.log(chalk23.dim(`    \u2192 ${finding.suggestion}`));
+      }
+    }
+  } else {
+    console.log(chalk23.green("\nNo issues found."));
+  }
+}
+function colorCoverage(pct) {
+  if (pct >= 80) return chalk23.green(String(pct));
+  if (pct >= 50) return chalk23.yellow(String(pct));
+  return chalk23.red(String(pct));
+}
+function colorComplexity(score) {
+  if (score <= 10) return chalk23.green(String(score));
+  if (score <= 25) return chalk23.yellow(String(score));
+  return chalk23.red(String(score));
+}
+
+// src/commands/dataweave.ts
+import chalk24 from "chalk";
+import { DataWeaveAnalyzer } from "@mulep/core";
+import { existsSync as existsSync7, readdirSync, statSync as statSync2 } from "fs";
+import { join as join9, resolve as resolve4 } from "path";
+async function dataWeaveLintCommand(fileOrGlob, options) {
+  const files = resolveDataWeaveFiles(fileOrGlob);
+  if (files.length === 0) {
+    console.log(chalk24.yellow("No DataWeave (.dwl) files found."));
+    return;
+  }
+  const analyzer = new DataWeaveAnalyzer();
+  let totalFindings = 0;
+  for (const file of files) {
+    const report = analyzer.analyze(file);
+    if (report.findings.length > 0) {
+      printDataWeaveReport(report);
+      totalFindings += report.findings.length;
+    }
+  }
+  if (totalFindings === 0) {
+    console.log(chalk24.green(`
+All ${files.length} DataWeave file(s) passed lint checks.`));
+  } else {
+    console.log(chalk24.yellow(`
+Found ${totalFindings} issue(s) across ${files.length} file(s).`));
+  }
+}
+async function dataWeaveOptimizeCommand(fileOrGlob, options) {
+  const files = resolveDataWeaveFiles(fileOrGlob);
+  if (files.length === 0) {
+    console.log(chalk24.yellow("No DataWeave (.dwl) files found."));
+    return;
+  }
+  const analyzer = new DataWeaveAnalyzer();
+  for (const file of files) {
+    const report = analyzer.analyze(file);
+    console.log(chalk24.bold(`
+Optimization Report: ${file}`));
+    console.log(chalk24.dim("\u2500".repeat(60)));
+    console.log(`  Lines: ${report.metrics.lineCount}`);
+    console.log(`  Functions: ${report.metrics.functionCount}`);
+    console.log(`  Complexity: ${colorComplexity2(report.metrics.complexityScore)}`);
+    const perfFindings = report.findings.filter((f) => f.rule === "performance");
+    if (perfFindings.length > 0) {
+      console.log(chalk24.bold("\n  Performance Suggestions:"));
+      for (const finding of perfFindings) {
+        console.log(chalk24.yellow(`    \u2192 ${finding.message}`));
+        if (finding.suggestion) {
+          console.log(chalk24.dim(`      Fix: ${finding.suggestion}`));
+        }
+      }
+    } else {
+      console.log(chalk24.green("\n  No performance issues detected."));
+    }
+  }
+}
+async function dataWeaveTestGenCommand(fileOrGlob, options) {
+  const files = resolveDataWeaveFiles(fileOrGlob);
+  if (files.length === 0) {
+    console.log(chalk24.yellow("No DataWeave (.dwl) files found."));
+    return;
+  }
+  const analyzer = new DataWeaveAnalyzer();
+  for (const file of files) {
+    const report = analyzer.analyze(file);
+    console.log(chalk24.bold(`
+MUnit Test Suggestions: ${file}`));
+    console.log(chalk24.dim("\u2500".repeat(60)));
+    console.log(chalk24.bold("  Suggested test cases:"));
+    console.log(chalk24.dim("  1. Happy path \u2014 valid input produces expected output"));
+    console.log(chalk24.dim("  2. Null payload \u2014 verify behavior with null input"));
+    console.log(chalk24.dim("  3. Empty collection \u2014 verify behavior with empty arrays/objects"));
+    if (report.metrics.hasNullSafetyIssues) {
+      console.log(chalk24.yellow("  4. [IMPORTANT] Null field access \u2014 test with missing fields"));
+    }
+    if (report.metrics.complexityScore > 10) {
+      console.log(chalk24.dim("  5. Edge cases \u2014 test boundary conditions for complex logic"));
+    }
+    if (report.findings.some((f) => f.rule === "hardcoded-value")) {
+      console.log(chalk24.dim("  6. Configuration variations \u2014 test with different property values"));
+    }
+  }
+}
+function resolveDataWeaveFiles(fileOrGlob) {
+  const resolved = resolve4(fileOrGlob);
+  if (existsSync7(resolved) && resolved.endsWith(".dwl")) {
+    return [resolved];
+  }
+  if (existsSync7(resolved) && statSync2(resolved).isDirectory()) {
+    return collectDwlFiles(resolved);
+  }
+  const cwd = process.cwd();
+  return collectDwlFiles(cwd);
+}
+function collectDwlFiles(dir) {
+  const files = [];
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry === "target" || entry === ".git") continue;
+      const fullPath = join9(dir, entry);
+      try {
+        const stat = statSync2(fullPath);
+        if (stat.isDirectory()) {
+          files.push(...collectDwlFiles(fullPath));
+        } else if (entry.endsWith(".dwl")) {
+          files.push(fullPath);
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function printDataWeaveReport(report) {
+  console.log(chalk24.bold(`
+${report.file}`));
+  for (const finding of report.findings) {
+    const icon = finding.severity === "critical" ? chalk24.red("\u25CF") : finding.severity === "high" ? chalk24.yellow("\u25B2") : finding.severity === "medium" ? chalk24.blue("\u25A0") : chalk24.dim("\u25CB");
+    console.log(`  ${icon} ${chalk24.dim(`L${finding.line}:`)} ${finding.message}`);
+    if (finding.suggestion) {
+      console.log(chalk24.dim(`    \u2192 ${finding.suggestion}`));
+    }
+    if (finding.codeSnippet) {
+      console.log(chalk24.dim(`    | ${finding.codeSnippet}`));
+    }
+  }
+}
+function colorComplexity2(score) {
+  if (score <= 5) return chalk24.green(String(score));
+  if (score <= 15) return chalk24.yellow(String(score));
+  return chalk24.red(String(score));
+}
+
+// src/commands/connector.ts
+import chalk25 from "chalk";
+import { ConnectorAuditor, WorkspaceScanner as WorkspaceScanner3 } from "@mulep/core";
+async function connectorAuditCommand(options) {
+  const cwd = process.cwd();
+  const scanner = new WorkspaceScanner3(cwd);
+  const registry = scanner.scan();
+  if (registry.totalProjects === 0) {
+    console.log(chalk25.yellow("No Mule projects found in workspace."));
+    return;
+  }
+  const projects = options.project ? registry.projects.filter((p) => p.name === options.project) : registry.projects;
+  if (projects.length === 0) {
+    console.log(chalk25.yellow(`Project "${options.project}" not found.`));
+    return;
+  }
+  const auditor = new ConnectorAuditor();
+  const result = auditor.audit(projects);
+  if (options.json) {
+    console.log(
+      JSON.stringify(
+        {
+          ...result,
+          versionMatrix: Object.fromEntries(
+            Array.from(result.versionMatrix.entries()).map(([k, v]) => [
+              k,
+              Object.fromEntries(v)
+            ])
+          )
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log(chalk25.bold("\nConnector Audit Report"));
+  console.log(chalk25.dim("\u2500".repeat(60)));
+  console.log(chalk25.bold("\nMetrics:"));
+  console.log(`  Total Connectors: ${chalk25.cyan(String(result.metrics.totalConnectors))}`);
+  console.log(`  Unique Types: ${chalk25.cyan(String(result.metrics.uniqueConnectors))}`);
+  console.log(
+    `  Version Conflicts: ${result.metrics.versionConflicts > 0 ? chalk25.red(String(result.metrics.versionConflicts)) : chalk25.green("0")}`
+  );
+  console.log(
+    `  Security Issues: ${result.metrics.securityIssues > 0 ? chalk25.red(String(result.metrics.securityIssues)) : chalk25.green("0")}`
+  );
+  console.log(
+    `  Missing Configs: ${result.metrics.missingConfigs > 0 ? chalk25.yellow(String(result.metrics.missingConfigs)) : chalk25.green("0")}`
+  );
+  if (result.findings.length > 0) {
+    console.log(chalk25.bold("\nFindings:"));
+    for (const finding of result.findings) {
+      const icon = finding.severity === "critical" ? chalk25.red("\u25CF") : finding.severity === "high" ? chalk25.yellow("\u25B2") : chalk25.dim("\u25CB");
+      console.log(
+        `  ${icon} [${finding.severity.toUpperCase()}] ${chalk25.dim(`(${finding.project})`)} ${finding.message}`
+      );
+      if (finding.suggestion) {
+        console.log(chalk25.dim(`    \u2192 ${finding.suggestion}`));
+      }
+    }
+  } else {
+    console.log(chalk25.green("\nNo issues found."));
+  }
+  if (result.versionMatrix.size > 0 && projects.length > 1) {
+    console.log(chalk25.bold("\nVersion Matrix:"));
+    for (const [artifact, versions] of result.versionMatrix) {
+      const versionStr = Array.from(versions.entries()).map(([proj, ver]) => `${proj}: ${ver}`).join(", ");
+      console.log(chalk25.dim(`  ${artifact}: ${versionStr}`));
+    }
+  }
+}
+async function connectorVersionsCommand(options) {
+  const cwd = process.cwd();
+  const scanner = new WorkspaceScanner3(cwd);
+  const registry = scanner.scan();
+  if (registry.totalProjects === 0) {
+    console.log(chalk25.yellow("No Mule projects found in workspace."));
+    return;
+  }
+  const projects = options.project ? registry.projects.filter((p) => p.name === options.project) : registry.projects;
+  console.log(chalk25.bold("\nConnector Version Matrix"));
+  console.log(chalk25.dim("\u2500".repeat(60)));
+  const allConnectors = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    for (const connector2 of project.connectors) {
+      if (!allConnectors.has(connector2.artifactId)) {
+        allConnectors.set(connector2.artifactId, /* @__PURE__ */ new Map());
+      }
+      allConnectors.get(connector2.artifactId).set(project.name, connector2.version);
+    }
+  }
+  if (allConnectors.size === 0) {
+    console.log(chalk25.yellow("No connectors found."));
+    return;
+  }
+  const projNames = projects.map((p) => p.name);
+  console.log(chalk25.bold(`
+  ${"Connector".padEnd(40)} ${projNames.join(" | ")}`));
+  console.log(chalk25.dim(`  ${"\u2500".repeat(40)} ${projNames.map(() => "\u2500".repeat(12)).join("\u2500\u253C\u2500")}`));
+  for (const [artifact, versions] of allConnectors) {
+    const cols = projNames.map((name) => {
+      const ver = versions.get(name);
+      return ver ? ver.padEnd(12) : chalk25.dim("\u2014".padEnd(12));
+    });
+    console.log(`  ${artifact.padEnd(40)} ${cols.join(" | ")}`);
+  }
+}
+
+// src/commands/validate.ts
+import chalk26 from "chalk";
+import { ScenarioValidator, WorkspaceScanner as WorkspaceScanner4 } from "@mulep/core";
+import { readFileSync as readFileSync7, existsSync as existsSync8 } from "fs";
+import { resolve as resolve5 } from "path";
+import YAML from "yaml";
+async function validateScenarioCommand(scenarioFile, options) {
+  const filePath = resolve5(scenarioFile);
+  if (!existsSync8(filePath)) {
+    console.log(chalk26.red(`Scenario file not found: ${filePath}`));
+    process.exitCode = 1;
+    return;
+  }
+  const content = readFileSync7(filePath, "utf-8");
+  let scenario;
+  try {
+    if (filePath.endsWith(".json")) {
+      scenario = JSON.parse(content);
+    } else {
+      scenario = YAML.parse(content);
+    }
+  } catch (err) {
+    console.log(chalk26.red(`Failed to parse scenario file: ${err}`));
+    process.exitCode = 1;
+    return;
+  }
+  const cwd = process.cwd();
+  const scanner = new WorkspaceScanner4(cwd);
+  const registry = scanner.scan();
+  if (registry.totalProjects === 0) {
+    console.log(chalk26.yellow("No Mule projects found in workspace."));
+    return;
+  }
+  const projects = options.project ? registry.projects.filter((p) => p.name === options.project) : registry.projects;
+  const validator = new ScenarioValidator(projects);
+  const result = validator.validate(scenario);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  printValidationResult(result);
+  if (result.verdict === "BLOCKED") {
+    process.exitCode = 1;
+  }
+}
+async function validateSpecCommand(specFile, options) {
+  const filePath = resolve5(specFile);
+  if (!existsSync8(filePath)) {
+    console.log(chalk26.red(`Spec file not found: ${filePath}`));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(chalk26.blue(`Validating spec compliance: ${filePath}`));
+  console.log(chalk26.dim("Spec validation checks RAML/OAS compliance against workspace..."));
+  const scenario = {
+    name: `Spec: ${specFile}`,
+    description: "Auto-generated from spec file",
+    project: options.project,
+    steps: []
+  };
+  const cwd = process.cwd();
+  const scanner = new WorkspaceScanner4(cwd);
+  const registry = scanner.scan();
+  const projects = options.project ? registry.projects.filter((p) => p.name === options.project) : registry.projects;
+  const validator = new ScenarioValidator(projects);
+  const tierResult = validator.validateTier(scenario, "spec-compliance");
+  console.log(chalk26.bold(`
+Spec Compliance: ${tierResult.status.toUpperCase()}`));
+  for (const finding of tierResult.findings) {
+    const icon = finding.severity === "critical" ? chalk26.red("\u25CF") : chalk26.yellow("\u25B2");
+    console.log(`  ${icon} ${finding.message}`);
+    if (finding.suggestion) {
+      console.log(chalk26.dim(`    \u2192 ${finding.suggestion}`));
+    }
+  }
+}
+async function validateFeasibilityCommand(scenarioFile, options) {
+  const filePath = resolve5(scenarioFile);
+  if (!existsSync8(filePath)) {
+    console.log(chalk26.red(`Scenario file not found: ${filePath}`));
+    process.exitCode = 1;
+    return;
+  }
+  const content = readFileSync7(filePath, "utf-8");
+  let scenario;
+  try {
+    if (filePath.endsWith(".json")) {
+      scenario = JSON.parse(content);
+    } else {
+      scenario = YAML.parse(content);
+    }
+  } catch (err) {
+    console.log(chalk26.red(`Failed to parse scenario file: ${err}`));
+    process.exitCode = 1;
+    return;
+  }
+  const cwd = process.cwd();
+  const scanner = new WorkspaceScanner4(cwd);
+  const registry = scanner.scan();
+  const projects = options.project ? registry.projects.filter((p) => p.name === options.project) : registry.projects;
+  const validator = new ScenarioValidator(projects);
+  const tierResult = validator.validateTier(scenario, "feasibility");
+  console.log(chalk26.bold(`
+Feasibility Analysis: ${tierResult.status.toUpperCase()}`));
+  for (const finding of tierResult.findings) {
+    const icon = finding.severity === "critical" ? chalk26.red("\u25CF") : chalk26.yellow("\u25B2");
+    console.log(`  ${icon} ${finding.message}`);
+    if (finding.suggestion) {
+      console.log(chalk26.dim(`    \u2192 ${finding.suggestion}`));
+    }
+  }
+}
+function printValidationResult(result) {
+  const verdictColor = result.verdict === "PASS" ? chalk26.green : result.verdict === "PARTIAL" ? chalk26.yellow : chalk26.red;
+  console.log(chalk26.bold(`
+Scenario Validation: ${result.scenario}`));
+  console.log(chalk26.dim("\u2500".repeat(60)));
+  console.log(`Verdict: ${verdictColor(result.verdict)}`);
+  for (const tier of result.tiers) {
+    const statusColor = tier.status === "pass" ? chalk26.green : tier.status === "partial" ? chalk26.yellow : chalk26.red;
+    console.log(chalk26.bold(`
+  ${tier.tier}: ${statusColor(tier.status)}`));
+    for (const finding of tier.findings) {
+      const icon = finding.severity === "critical" ? chalk26.red("\u25CF") : finding.severity === "high" ? chalk26.yellow("\u25B2") : chalk26.dim("\u25CB");
+      console.log(`    ${icon} ${finding.message}`);
+      if (finding.suggestion) {
+        console.log(chalk26.dim(`      \u2192 ${finding.suggestion}`));
+      }
+    }
+  }
+  if (result.actionItems.length > 0) {
+    console.log(chalk26.bold("\nAction Items:"));
+    for (const item of result.actionItems) {
+      console.log(`  \u2022 ${item}`);
+    }
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("mulep").description("Mule ESB AI development platform \u2014 multi-project workspace, DataWeave analysis, flow validation, and multi-model collaboration").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, /mulep-review, /cleanup)").option("--force", "Overwrite existing skill files", false).action(installSkillsCommand);
+program.command("init").description("Initialize MuleP in the current project").option("--preset <name>", "Use preset (cli-first)").option("--non-interactive", "Skip prompts, use defaults").option("--force", "Overwrite existing .mulep.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);
+var plan = program.command("plan").description("Plan generation and review \u2014 write plans, get GPT review");
+plan.command("generate").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(planGenerateCommand);
+plan.command("review").description("Send a host-authored plan to codex for review").argument("<plan-file>", "Plan file to review (use - for stdin)").option("--build <id>", "Link review to a build ID").option("--phase <id>", 'Phase identifier (e.g. "1", "setup")').option("--timeout <seconds>", "Review timeout", (v) => Number.parseInt(v, 10), 300).option("--output <file>", "Save review result to file").action(planReviewCommand);
+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).option("--timeout <seconds>", "Default timeout for debate turns 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;
+}).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)).option("--output <file>", "Write full untruncated response to file").option("--force", "Continue past token budget limit", false).option("--quiet", "Suppress non-error stderr output", false).option("--response-cap <bytes>", "Max response bytes in JSON output (default: 16384)", (v) => Number.parseInt(v, 10)).action(debateTurnCommand);
+debate.command("next").description("Continue debate with auto-generated prompt").argument("<debate-id>", "Debate ID").option("--timeout <seconds>", "Timeout in seconds", (v) => Number.parseInt(v, 10)).option("--output <file>", "Write full untruncated response to file").option("--force", "Continue past token budget limit", false).option("--quiet", "Suppress non-error stderr output", false).option("--response-cap <bytes>", "Max response bytes in JSON output (default: 16384)", (v) => Number.parseInt(v, 10)).action(debateNextCommand);
+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").option("--output <file>", "Write full untruncated history to file").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("--no-stage", "Do not git-stage applied fixes").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);
+var workspace = program.command("workspace").description("Multi-project workspace management \u2014 discover and manage Mule projects");
+workspace.command("init").description("Initialize multi-project workspace (discover all Mule apps)").action(workspaceInitCommand);
+workspace.command("list").description("List all discovered Mule projects").action(workspaceListCommand);
+workspace.command("validate").description("Check workspace integrity and dependency consistency").action(workspaceValidateCommand);
+workspace.command("sync").description("Refresh project registry").action(workspaceSyncCommand);
+var flow = program.command("flow").description("Mule flow analysis and visualization");
+flow.command("visualize").description("Generate Mermaid diagram from Mule flow XML").argument("<flow-name>", "Flow name or XML file path").option("--output <file>", "Write diagram to file").option("--project <name>", "Target specific project").action(flowVisualizeCommand);
+flow.command("analyze").description("Flow complexity and optimization report").argument("<flow-name>", "Flow name or XML file path").option("--project <name>", "Target specific project").action(flowAnalyzeCommand);
+flow.command("test-gen").description("Generate MUnit test case suggestions").argument("<flow-name>", "Flow name or XML file path").option("--output <file>", "Write test suggestions to file").option("--project <name>", "Target specific project").action(flowTestGenCommand);
+var dataweave = program.command("dataweave").description("DataWeave transformation analysis and linting");
+dataweave.command("lint").description("Check DataWeave files for null-safety, type errors, anti-patterns").argument("<file-or-dir>", "DataWeave file or directory to lint").option("--project <name>", "Target specific project").action(dataWeaveLintCommand);
+dataweave.command("optimize").description("Suggest performance improvements for DataWeave transforms").argument("<file-or-dir>", "DataWeave file or directory to optimize").option("--project <name>", "Target specific project").action(dataWeaveOptimizeCommand);
+dataweave.command("test-gen").description("Generate MUnit test cases with edge cases").argument("<file-or-dir>", "DataWeave file or directory").option("--output <file>", "Write test suggestions to file").option("--project <name>", "Target specific project").action(dataWeaveTestGenCommand);
+var connector = program.command("connector").description("Mule connector configuration audit and management");
+connector.command("audit").description("Audit all connector configurations across workspace").option("--project <name>", "Target specific project").option("--json", "Machine-readable JSON output", false).action(connectorAuditCommand);
+connector.command("versions").description("Show connector version matrix across projects").option("--project <name>", "Target specific project").action(connectorVersionsCommand);
+var validate = program.command("validate").description("Scenario and spec validation \u2014 three-tier analysis");
+validate.command("scenario").description("Full three-tier validation (spec + docs + feasibility)").argument("<file>", "Scenario YAML/JSON file").option("--project <name>", "Target specific project").option("--json", "Machine-readable JSON output", false).action(validateScenarioCommand);
+validate.command("spec").description("RAML/OAS spec compliance check").argument("<file>", "Spec file path").option("--project <name>", "Target specific project").action(validateSpecCommand);
+validate.command("feasibility").description("Workspace feasibility analysis for a scenario").argument("<file>", "Scenario YAML/JSON file").option("--project <name>", "Target specific project").action(validateFeasibilityCommand);
+var design = program.command("design").description("Architecture design discussions and debates");
+design.command("debate").description("Start a multi-model architecture debate").argument("<topic>", "Debate topic or question").option("--max-rounds <n>", "Max debate rounds", (v) => Number.parseInt(v, 10), 5).action(debateStartCommand);
+program.parse();
+export {
+  program
+};
+//# sourceMappingURL=index.js.map