majlis 0.5.2 → 0.6.0

package/dist/cli.js

@@ -219,6 +219,36 @@ var init_migrations = __esm({
 
       ALTER TABLE dead_ends ADD COLUMN category TEXT DEFAULT 'structural'
         CHECK(category IN ('structural', 'procedural'));
+    `);
+      },
+      // Migration 005: v4 → v5 — Swarm tracking tables
+      (db) => {
+        db.exec(`
+      CREATE TABLE swarm_runs (
+        id INTEGER PRIMARY KEY,
+        goal TEXT NOT NULL,
+        parallel_count INTEGER NOT NULL,
+        status TEXT NOT NULL DEFAULT 'running'
+          CHECK(status IN ('running', 'completed', 'failed')),
+        total_cost_usd REAL DEFAULT 0,
+        best_experiment_slug TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        completed_at DATETIME
+      );
+
+      CREATE TABLE swarm_members (
+        id INTEGER PRIMARY KEY,
+        swarm_run_id INTEGER REFERENCES swarm_runs(id),
+        experiment_slug TEXT NOT NULL,
+        worktree_path TEXT NOT NULL,
+        final_status TEXT,
+        overall_grade TEXT,
+        cost_usd REAL DEFAULT 0,
+        error TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE INDEX idx_swarm_members_run ON swarm_members(swarm_run_id);
     `);
       }
     ];
@@ -273,6 +303,17 @@ function closeDb() {
 function resetDb() {
   _db = null;
 }
+function openDbAt(projectRoot) {
+  const majlisDir = path.join(projectRoot, ".majlis");
+  if (!fs.existsSync(majlisDir)) {
+    fs.mkdirSync(majlisDir, { recursive: true });
+  }
+  const db = new import_better_sqlite3.default(path.join(majlisDir, "majlis.db"));
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  runMigrations(db);
+  return db;
+}
 var import_better_sqlite3, path, fs, _db;
 var init_connection = __esm({
   "src/db/connection.ts"() {
@@ -469,7 +510,8 @@ ${cmd.body}
     "verification",
     "reframes",
     "rihla",
-    "synthesis"
+    "synthesis",
+    "diagnosis"
   ];
   for (const dir of docDirs) {
     mkdirSafe(path2.join(docsDir, dir));
@@ -923,7 +965,74 @@ gate_decision:
   "stale_references": ["list of stale references found, if any"],
   "overlapping_dead_ends": [0]
 }
--->`
+-->`,
+      diagnostician: `---
+name: diagnostician
+model: opus
+tools: [Read, Write, Bash, Glob, Grep, WebSearch]
+---
+You are the Diagnostician. You perform deep project-wide analysis.
+
+You have the highest turn budget of any agent. Use it for depth, not breadth.
+Your job is pure insight \u2014 you do NOT fix code, you do NOT build, you do NOT
+make decisions. You diagnose.
+
+## What You Receive
+- Full database export: every experiment, decision, doubt, challenge, verification,
+  dead-end, metric, and compression across the entire project history
+- Current synthesis, fragility map, and dead-end registry
+- Full read access to the entire project codebase
+- Bash access to run tests, profiling, git archaeology, and analysis scripts
+
+## What You Can Do
+1. **Read everything** \u2014 source code, docs, git history, test output
+2. **Run analysis** \u2014 execute tests, profilers, git log/blame/bisect, custom scripts
+3. **Write analysis scripts** \u2014 you may write scripts ONLY to \`.majlis/scripts/\`
+4. **Search externally** \u2014 WebSearch for patterns, known issues, relevant techniques
+
+## What You CANNOT Do
+- Modify any project files outside \`.majlis/scripts/\`
+- Make code changes, fixes, or patches
+- Create experiments or make decisions
+- Write to docs/, src/, or any other project directory
+
+## Your Approach
+
+Phase 1: Orientation (turns 1-10)
+- Read the full database export in your context
+- Read synthesis, fragility, dead-ends
+- Identify patterns: recurring failures, unresolved doubts, evidence gaps
+
+Phase 2: Deep Investigation (turns 11-40)
+- Read source code at critical points identified in Phase 1
+- Run targeted tests, profiling, git archaeology
+- Write and execute analysis scripts in .majlis/scripts/
+- Cross-reference findings across experiments
+
+Phase 3: Synthesis (turns 41-60)
+- Compile findings into a diagnostic report
+- Identify root causes, not symptoms
+- Rank issues by structural impact
+- Suggest investigation directions (not fixes)
+
+## Output Format
+Produce a diagnostic report as markdown. At the end, include:
+
+<!-- majlis-json
+{
+  "diagnosis": {
+    "root_causes": ["List of identified root causes"],
+    "patterns": ["Recurring patterns across experiments"],
+    "evidence_gaps": ["What we don't know but should"],
+    "investigation_directions": ["Suggested directions for next experiments"]
+  }
+}
+-->
+
+## Safety Reminders
+- You are READ-ONLY for project code. Write ONLY to .majlis/scripts/.
+- Focus on diagnosis, not fixing. Your value is insight, not implementation.
+- Trust the database export over docs/ files when they conflict.`
     };
     SLASH_COMMANDS = {
       classify: {
@@ -983,6 +1092,14 @@ Produce a rihla document at docs/rihla/.`
 If the CLI is not installed, review: original objective, current classification,
 recent failures, dead-ends. Ask: is the classification serving the objective?
 Would we decompose differently with what we now know?`
+      },
+      diagnose: {
+        description: "Deep project-wide diagnostic analysis",
+        body: `Run \`majlis diagnose $ARGUMENTS\` for deep diagnosis.
+If the CLI is not installed, perform a deep diagnostic analysis.
+Read docs/synthesis/current.md, fragility.md, dead-ends.md, and all experiments.
+Identify root causes, recurring patterns, evidence gaps, and investigation directions.
+Do NOT modify project code \u2014 analysis only.`
       }
     };
     HOOKS_CONFIG = {
@@ -1581,6 +1698,29 @@ function insertFinding(db, experimentId, approach, source, relevance, contradict
     VALUES (?, ?, ?, ?, ?)
   `).run(experimentId, approach, source, relevance, contradictsCurrent ? 1 : 0);
 }
+function createSwarmRun(db, goal, parallelCount) {
+  const result = db.prepare(`
+    INSERT INTO swarm_runs (goal, parallel_count) VALUES (?, ?)
+  `).run(goal, parallelCount);
+  return { id: result.lastInsertRowid };
+}
+function updateSwarmRun(db, id, status2, totalCostUsd, bestSlug) {
+  db.prepare(`
+    UPDATE swarm_runs SET status = ?, total_cost_usd = ?, best_experiment_slug = ?,
+      completed_at = CURRENT_TIMESTAMP WHERE id = ?
+  `).run(status2, totalCostUsd, bestSlug, id);
+}
+function addSwarmMember(db, swarmRunId, slug, worktreePath) {
+  db.prepare(`
+    INSERT INTO swarm_members (swarm_run_id, experiment_slug, worktree_path) VALUES (?, ?, ?)
+  `).run(swarmRunId, slug, worktreePath);
+}
+function updateSwarmMember(db, swarmRunId, slug, finalStatus, overallGrade, costUsd, error) {
+  db.prepare(`
+    UPDATE swarm_members SET final_status = ?, overall_grade = ?, cost_usd = ?, error = ?
+    WHERE swarm_run_id = ? AND experiment_slug = ?
+  `).run(finalStatus, overallGrade, costUsd, error, swarmRunId, slug);
+}
 function exportForCompressor(db, maxLength = 3e4) {
   const experiments = listAllExperiments(db);
   const sections = ["# Structured Data Export (from SQLite)\n"];
@@ -1643,6 +1783,79 @@ function exportForCompressor(db, maxLength = 3e4) {
   if (full.length > maxLength) {
     return full.slice(0, maxLength) + `
 
+[TRUNCATED \u2014 full export was ${full.length} chars]`;
+  }
+  return full;
+}
+function exportForDiagnostician(db, maxLength = 6e4) {
+  const base = exportForCompressor(db, maxLength);
+  const sections = [base];
+  const metrics = db.prepare(`
+    SELECT m.*, e.slug FROM metrics m
+    JOIN experiments e ON m.experiment_id = e.id
+    ORDER BY m.captured_at
+  `).all();
+  if (metrics.length > 0) {
+    sections.push("\n## Metric History (all experiments)");
+    for (const m of metrics) {
+      sections.push(`- ${m.slug} [${m.phase}] ${m.fixture}/${m.metric_name}: ${m.metric_value}`);
+    }
+  }
+  const sessions = db.prepare("SELECT * FROM sessions ORDER BY started_at").all();
+  if (sessions.length > 0) {
+    sections.push("\n## Session History");
+    for (const s of sessions) {
+      sections.push(`- #${s.id}: "${s.intent}" (${s.ended_at ? "ended" : "active"})`);
+      if (s.accomplished) sections.push(`  accomplished: ${s.accomplished}`);
+      if (s.unfinished) sections.push(`  unfinished: ${s.unfinished}`);
+      if (s.new_fragility) sections.push(`  fragility: ${s.new_fragility}`);
+    }
+  }
+  const compressions = db.prepare("SELECT * FROM compressions ORDER BY created_at").all();
+  if (compressions.length > 0) {
+    sections.push("\n## Compression History");
+    for (const c of compressions) {
+      sections.push(`- #${c.id}: ${c.synthesis_size_before}B \u2192 ${c.synthesis_size_after}B (${c.session_count_since_last} sessions)`);
+    }
+  }
+  try {
+    const swarmRuns = db.prepare("SELECT * FROM swarm_runs ORDER BY created_at").all();
+    if (swarmRuns.length > 0) {
+      sections.push("\n## Swarm History");
+      for (const sr of swarmRuns) {
+        sections.push(`- #${sr.id}: "${sr.goal}" (${sr.status}, best: ${sr.best_experiment_slug ?? "none"})`);
+      }
+    }
+  } catch {
+  }
+  const reframes = db.prepare(`
+    SELECT r.*, e.slug FROM reframes r
+    JOIN experiments e ON r.experiment_id = e.id
+    ORDER BY r.created_at
+  `).all();
+  if (reframes.length > 0) {
+    sections.push("\n## Reframe History");
+    for (const r of reframes) {
+      const decomp = String(r.decomposition ?? "").slice(0, 200);
+      sections.push(`- ${r.slug}: ${decomp}`);
+      if (r.recommendation) sections.push(`  recommendation: ${String(r.recommendation).slice(0, 200)}`);
+    }
+  }
+  const findings = db.prepare(`
+    SELECT f.*, e.slug FROM findings f
+    JOIN experiments e ON f.experiment_id = e.id
+    ORDER BY f.created_at
+  `).all();
+  if (findings.length > 0) {
+    sections.push("\n## Scout Findings");
+    for (const f of findings) {
+      sections.push(`- ${f.slug}: ${f.approach} (${f.source}) ${f.contradicts_current ? "[CONTRADICTS CURRENT]" : ""}`);
+    }
+  }
+  const full = sections.join("\n");
+  if (full.length > maxLength) {
+    return full.slice(0, maxLength) + `
+
 [TRUNCATED \u2014 full export was ${full.length} chars]`;
   }
   return full;
@@ -1838,6 +2051,8 @@ function getExtractionSchema(role) {
       return '{"findings": [{"approach": "string", "source": "string", "relevance": "string", "contradicts_current": true}]}';
     case "compressor":
       return '{"compression_report": {"synthesis_delta": "string", "new_dead_ends": ["string"], "fragility_changes": ["string"]}}';
+    case "diagnostician":
+      return '{"diagnosis": {"root_causes": ["string"], "patterns": ["string"], "evidence_gaps": ["string"], "investigation_directions": ["string"]}}';
     default:
       return EXTRACTION_SCHEMA;
   }
@@ -1861,7 +2076,8 @@ var init_types = __esm({
       gatekeeper: ["gate_decision"],
       reframer: ["reframe"],
       scout: ["findings"],
-      compressor: ["compression_report"]
+      compressor: ["compression_report"],
+      diagnostician: ["diagnosis"]
     };
   }
 });
@@ -1996,7 +2212,7 @@ ${truncated}`;
   }
 }
 function hasData(output) {
-  return !!(output.decisions && output.decisions.length > 0 || output.grades && output.grades.length > 0 || output.doubts && output.doubts.length > 0 || output.challenges && output.challenges.length > 0 || output.findings && output.findings.length > 0 || output.guidance || output.reframe || output.compression_report || output.gate_decision);
+  return !!(output.decisions && output.decisions.length > 0 || output.grades && output.grades.length > 0 || output.doubts && output.doubts.length > 0 || output.challenges && output.challenges.length > 0 || output.findings && output.findings.length > 0 || output.guidance || output.reframe || output.compression_report || output.gate_decision || output.diagnosis);
 }
 function validateForRole(role, output) {
   const required = ROLE_REQUIRED_FIELDS[role];
@@ -2069,6 +2285,12 @@ You may ONLY write to docs/synthesis/.
 - Have you updated current.md, fragility.md, dead-ends.md?
 - If yes \u2192 output compression report JSON.
 - Do NOT write to MEMORY.md or files outside docs/synthesis/.`;
+    case "diagnostician":
+      return `${header2}
+You are READ-ONLY for project code. Write ONLY to .majlis/scripts/.
+Focus on diagnosis, not fixing. Your value is insight, not implementation.
+Phase 1 (1-10): orientation. Phase 2 (11-40): deep investigation. Phase 3 (41-60): synthesis.
+If you are past turn 40, begin compiling your diagnostic report.`;
     default:
       return `${header2}
 Check: is your core task done? If yes, wrap up and output JSON.`;
@@ -2092,6 +2314,36 @@ function buildPreToolUseGuards(role) {
       { matcher: "Edit", hooks: [guardHook] }
     ];
   }
+  if (role === "diagnostician") {
+    const writeGuard = async (input) => {
+      const toolInput = input.tool_input ?? {};
+      const filePath = toolInput.file_path ?? "";
+      if (filePath && !filePath.includes("/.majlis/scripts/")) {
+        return {
+          decision: "block",
+          reason: `Diagnostician may only write to .majlis/scripts/. Blocked: ${filePath}`
+        };
+      }
+      return {};
+    };
+    const bashGuard = async (input) => {
+      const toolInput = input.tool_input ?? {};
+      const command = toolInput.command ?? "";
+      const destructive = /\b(rm\s+-rf|git\s+(checkout|reset|stash|clean|push)|chmod|chown|mkfs|dd\s+if=)\b/i;
+      if (destructive.test(command)) {
+        return {
+          decision: "block",
+          reason: `Diagnostician blocked destructive command: ${command.slice(0, 100)}`
+        };
+      }
+      return {};
+    };
+    return [
+      { matcher: "Write", hooks: [writeGuard] },
+      { matcher: "Edit", hooks: [writeGuard] },
+      { matcher: "Bash", hooks: [bashGuard] }
+    ];
+  }
   return void 0;
 }
 function buildAgentHooks(role, maxTurns) {
@@ -2365,7 +2617,7 @@ function writeArtifact(role, context, markdown, projectRoot) {
   };
   const dir = dirMap[role];
   if (!dir) return null;
-  if (role === "builder" || role === "compressor") return null;
+  if (role === "builder" || role === "compressor" || role === "diagnostician") return null;
   const fullDir = path4.join(projectRoot, dir);
   if (!fs4.existsSync(fullDir)) {
     fs4.mkdirSync(fullDir, { recursive: true });
@@ -2394,14 +2646,16 @@ var init_spawn = __esm({
       compressor: 30,
       reframer: 20,
       scout: 20,
-      gatekeeper: 10
+      gatekeeper: 10,
+      diagnostician: 60
     };
     CHECKPOINT_INTERVAL = {
       builder: 15,
       verifier: 12,
       critic: 15,
       adversary: 15,
-      compressor: 15
+      compressor: 15,
+      diagnostician: 20
     };
     DIM2 = "\x1B[2m";
     RESET2 = "\x1B[0m";
@@ -3101,6 +3355,84 @@ async function resolve(db, exp, projectRoot) {
     }
   }
 }
+async function resolveDbOnly(db, exp, projectRoot) {
+  let grades = getVerificationsByExperiment(db, exp.id);
+  if (grades.length === 0) {
+    warn(`No verification records for ${exp.slug}. Defaulting to weak.`);
+    insertVerification(
+      db,
+      exp.id,
+      "auto-default",
+      "weak",
+      null,
+      null,
+      "No structured verification output. Auto-defaulted to weak."
+    );
+    grades = getVerificationsByExperiment(db, exp.id);
+  }
+  const overallGrade = worstGrade(grades);
+  switch (overallGrade) {
+    case "sound":
+      updateExperimentStatus(db, exp.id, "merged");
+      success(`Experiment ${exp.slug} RESOLVED (sound) \u2014 git merge deferred.`);
+      break;
+    case "good": {
+      const gaps = grades.filter((g) => g.grade === "good").map((g) => `- **${g.component}**: ${g.notes ?? "minor gaps"}`).join("\n");
+      appendToFragilityMap(projectRoot, exp.slug, gaps);
+      updateExperimentStatus(db, exp.id, "merged");
+      success(`Experiment ${exp.slug} RESOLVED (good) \u2014 git merge deferred.`);
+      break;
+    }
+    case "weak": {
+      const confirmedDoubts = getConfirmedDoubts(db, exp.id);
+      const guidance = await spawnSynthesiser({
+        experiment: {
+          id: exp.id,
+          slug: exp.slug,
+          hypothesis: exp.hypothesis,
+          status: exp.status,
+          sub_type: exp.sub_type,
+          builder_guidance: exp.builder_guidance
+        },
+        verificationReport: grades,
+        confirmedDoubts,
+        taskPrompt: "Synthesise the verification report, confirmed doubts, and adversarial case results into specific, actionable guidance for the builder's next attempt. Be concrete: which specific decisions need revisiting, which assumptions broke, and what constraints must the next approach satisfy."
+      }, projectRoot);
+      const guidanceText = guidance.structured?.guidance ?? guidance.output;
+      db.transaction(() => {
+        storeBuilderGuidance(db, exp.id, guidanceText);
+        updateExperimentStatus(db, exp.id, "building");
+        if (exp.sub_type) {
+          incrementSubTypeFailure(db, exp.sub_type, exp.id, "weak");
+        }
+      })();
+      warn(`Experiment ${exp.slug} CYCLING BACK (weak). Guidance generated.`);
+      break;
+    }
+    case "rejected": {
+      const rejectedComponents = grades.filter((g) => g.grade === "rejected");
+      const whyFailed = rejectedComponents.map((r) => r.notes ?? "rejected").join("; ");
+      db.transaction(() => {
+        insertDeadEnd(
+          db,
+          exp.id,
+          exp.hypothesis ?? exp.slug,
+          whyFailed,
+          `Approach rejected: ${whyFailed}`,
+          exp.sub_type,
+          "structural"
+        );
+        updateExperimentStatus(db, exp.id, "dead_end");
+        if (exp.sub_type) {
+          incrementSubTypeFailure(db, exp.sub_type, exp.id, "rejected");
+        }
+      })();
+      info(`Experiment ${exp.slug} DEAD-ENDED (rejected). Constraint recorded.`);
+      break;
+    }
+  }
+  return overallGrade;
+}
 function gitMerge(branch, cwd) {
   try {
     (0, import_node_child_process3.execSync)(`git merge ${branch} --no-ff -m "Merge experiment branch ${branch}"`, {
@@ -3163,7 +3495,9 @@ var init_resolve = __esm({
 var cycle_exports = {};
 __export(cycle_exports, {
   cycle: () => cycle,
-  resolveCmd: () => resolveCmd
+  resolveCmd: () => resolveCmd,
+  runResolve: () => runResolve,
+  runStep: () => runStep
 });
 async function cycle(step, args) {
   const root = findProjectRoot();
@@ -3195,6 +3529,28 @@ async function resolveCmd(args) {
   transition(exp.status, "resolved" /* RESOLVED */);
   await resolve(db, exp, root);
 }
+async function runStep(step, db, exp, root) {
+  switch (step) {
+    case "build":
+      return doBuild(db, exp, root);
+    case "challenge":
+      return doChallenge(db, exp, root);
+    case "doubt":
+      return doDoubt(db, exp, root);
+    case "scout":
+      return doScout(db, exp, root);
+    case "verify":
+      return doVerify(db, exp, root);
+    case "gate":
+      return doGate(db, exp, root);
+    case "compress":
+      return doCompress(db, root);
+  }
+}
+async function runResolve(db, exp, root) {
+  transition(exp.status, "resolved" /* RESOLVED */);
+  await resolve(db, exp, root);
+}
 async function doGate(db, exp, root) {
   transition(exp.status, "gated" /* GATED */);
   const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
@@ -4005,13 +4361,13 @@ async function run(args) {
   const db = getDb(root);
   const config = loadConfig(root);
   const MAX_EXPERIMENTS = 10;
-  const MAX_STEPS = 200;
+  const MAX_STEPS2 = 200;
   let experimentCount = 0;
   let stepCount = 0;
   let consecutiveFailures = 0;
   const usedHypotheses = /* @__PURE__ */ new Set();
   header(`Autonomous Mode \u2014 ${goal}`);
-  while (stepCount < MAX_STEPS && experimentCount < MAX_EXPERIMENTS) {
+  while (stepCount < MAX_STEPS2 && experimentCount < MAX_EXPERIMENTS) {
     if (isShutdownRequested()) {
       warn("Shutdown requested. Stopping autonomous mode.");
       break;
@@ -4081,8 +4437,8 @@ async function run(args) {
       }
     }
   }
-  if (stepCount >= MAX_STEPS) {
-    warn(`Reached max steps (${MAX_STEPS}). Stopping autonomous mode.`);
+  if (stepCount >= MAX_STEPS2) {
+    warn(`Reached max steps (${MAX_STEPS2}). Stopping autonomous mode.`);
   }
   header("Autonomous Mode Complete");
   info(`Goal: ${goal}`);
@@ -4234,11 +4590,768 @@ var init_run = __esm({
   }
 });
 
+// src/swarm/worktree.ts
+function createWorktree(mainRoot, slug, paddedNum) {
+  const projectName = path12.basename(mainRoot);
+  const worktreeName = `${projectName}-swarm-${paddedNum}-${slug}`;
+  const worktreePath = path12.join(path12.dirname(mainRoot), worktreeName);
+  const branch = `swarm/${paddedNum}-${slug}`;
+  (0, import_node_child_process6.execSync)(`git worktree add ${JSON.stringify(worktreePath)} -b ${branch}`, {
+    cwd: mainRoot,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return {
+    path: worktreePath,
+    branch,
+    slug,
+    hypothesis: "",
+    // filled in by caller
+    paddedNum
+  };
+}
+function initializeWorktree(mainRoot, worktreePath) {
+  const majlisDir = path12.join(worktreePath, ".majlis");
+  fs12.mkdirSync(majlisDir, { recursive: true });
+  const configSrc = path12.join(mainRoot, ".majlis", "config.json");
+  if (fs12.existsSync(configSrc)) {
+    fs12.copyFileSync(configSrc, path12.join(majlisDir, "config.json"));
+  }
+  const agentsSrc = path12.join(mainRoot, ".majlis", "agents");
+  if (fs12.existsSync(agentsSrc)) {
+    const agentsDst = path12.join(majlisDir, "agents");
+    fs12.mkdirSync(agentsDst, { recursive: true });
+    for (const file of fs12.readdirSync(agentsSrc)) {
+      fs12.copyFileSync(path12.join(agentsSrc, file), path12.join(agentsDst, file));
+    }
+  }
+  const synthSrc = path12.join(mainRoot, "docs", "synthesis");
+  if (fs12.existsSync(synthSrc)) {
+    const synthDst = path12.join(worktreePath, "docs", "synthesis");
+    fs12.mkdirSync(synthDst, { recursive: true });
+    for (const file of fs12.readdirSync(synthSrc)) {
+      const srcFile = path12.join(synthSrc, file);
+      if (fs12.statSync(srcFile).isFile()) {
+        fs12.copyFileSync(srcFile, path12.join(synthDst, file));
+      }
+    }
+  }
+  const templateSrc = path12.join(mainRoot, "docs", "experiments", "_TEMPLATE.md");
+  if (fs12.existsSync(templateSrc)) {
+    const expDir = path12.join(worktreePath, "docs", "experiments");
+    fs12.mkdirSync(expDir, { recursive: true });
+    fs12.copyFileSync(templateSrc, path12.join(expDir, "_TEMPLATE.md"));
+  }
+  const db = openDbAt(worktreePath);
+  db.close();
+}
+function cleanupWorktree(mainRoot, wt) {
+  try {
+    (0, import_node_child_process6.execSync)(`git worktree remove ${JSON.stringify(wt.path)} --force`, {
+      cwd: mainRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    warn(`Could not remove worktree ${wt.path} \u2014 remove manually.`);
+  }
+  try {
+    (0, import_node_child_process6.execSync)(`git branch -D ${wt.branch}`, {
+      cwd: mainRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  try {
+    (0, import_node_child_process6.execSync)("git worktree prune", {
+      cwd: mainRoot,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+}
+var fs12, path12, import_node_child_process6;
+var init_worktree = __esm({
+  "src/swarm/worktree.ts"() {
+    "use strict";
+    fs12 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
+    import_node_child_process6 = require("child_process");
+    init_connection();
+    init_format();
+  }
+});
+
+// src/swarm/runner.ts
+async function runExperimentInWorktree(wt) {
+  const label = `[swarm:${wt.paddedNum}]`;
+  let db;
+  let exp = null;
+  let overallGrade = null;
+  let stepCount = 0;
+  try {
+    db = openDbAt(wt.path);
+    exp = createExperiment(db, wt.slug, wt.branch, wt.hypothesis, null, null);
+    updateExperimentStatus(db, exp.id, "reframed");
+    exp.status = "reframed";
+    const templatePath = path13.join(wt.path, "docs", "experiments", "_TEMPLATE.md");
+    if (fs13.existsSync(templatePath)) {
+      const template = fs13.readFileSync(templatePath, "utf-8");
+      const logContent = template.replace(/\{\{title\}\}/g, wt.hypothesis).replace(/\{\{hypothesis\}\}/g, wt.hypothesis).replace(/\{\{branch\}\}/g, wt.branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
+      const logPath = path13.join(wt.path, "docs", "experiments", `${wt.paddedNum}-${wt.slug}.md`);
+      fs13.writeFileSync(logPath, logContent);
+    }
+    info(`${label} Starting: ${wt.hypothesis}`);
+    while (stepCount < MAX_STEPS) {
+      if (isShutdownRequested()) {
+        warn(`${label} Shutdown requested. Stopping.`);
+        break;
+      }
+      stepCount++;
+      const fresh = getExperimentBySlug(db, wt.slug);
+      if (!fresh) break;
+      exp = fresh;
+      if (isTerminal(exp.status)) {
+        success(`${label} Reached terminal: ${exp.status}`);
+        break;
+      }
+      const valid = validNext(exp.status);
+      if (valid.length === 0) break;
+      const nextStep = determineNextStep(
+        exp,
+        valid,
+        hasDoubts(db, exp.id),
+        hasChallenges(db, exp.id)
+      );
+      info(`${label} [${stepCount}/${MAX_STEPS}] ${exp.status} -> ${nextStep}`);
+      if (nextStep === "resolved" /* RESOLVED */) {
+        overallGrade = await resolveDbOnly(db, exp, wt.path);
+        continue;
+      }
+      if (nextStep === "compressed" /* COMPRESSED */) {
+        await runStep("compress", db, exp, wt.path);
+        updateExperimentStatus(db, exp.id, "compressed");
+        continue;
+      }
+      if (nextStep === "merged" /* MERGED */) {
+        updateExperimentStatus(db, exp.id, "merged");
+        success(`${label} Merged.`);
+        break;
+      }
+      if (nextStep === "reframed" /* REFRAMED */) {
+        updateExperimentStatus(db, exp.id, "reframed");
+        continue;
+      }
+      const stepName = statusToStepName(nextStep);
+      if (!stepName) {
+        warn(`${label} Unknown step: ${nextStep}`);
+        break;
+      }
+      try {
+        await runStep(stepName, db, exp, wt.path);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        warn(`${label} Step failed: ${message}`);
+        try {
+          insertDeadEnd(
+            db,
+            exp.id,
+            exp.hypothesis ?? exp.slug,
+            message,
+            `Process failure: ${message}`,
+            exp.sub_type,
+            "procedural"
+          );
+          updateExperimentStatus(db, exp.id, "dead_end");
+        } catch {
+        }
+        break;
+      }
+    }
+    if (stepCount >= MAX_STEPS) {
+      warn(`${label} Hit max steps (${MAX_STEPS}).`);
+    }
+    const finalExp = getExperimentBySlug(db, wt.slug);
+    if (finalExp) exp = finalExp;
+    const finalStatus = exp?.status ?? "error";
+    return {
+      worktree: wt,
+      experiment: exp,
+      finalStatus,
+      overallGrade,
+      costUsd: 0,
+      // TODO: track via SDK when available
+      stepCount
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`${label} Fatal error: ${message}`);
+    return {
+      worktree: wt,
+      experiment: exp,
+      finalStatus: "error",
+      overallGrade: null,
+      costUsd: 0,
+      stepCount,
+      error: message
+    };
+  } finally {
+    if (db) {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+  }
+}
+function statusToStepName(status2) {
+  switch (status2) {
+    case "gated" /* GATED */:
+      return "gate";
+    case "building" /* BUILDING */:
+      return "build";
+    case "challenged" /* CHALLENGED */:
+      return "challenge";
+    case "doubted" /* DOUBTED */:
+      return "doubt";
+    case "scouted" /* SCOUTED */:
+      return "scout";
+    case "verifying" /* VERIFYING */:
+      return "verify";
+    default:
+      return null;
+  }
+}
+var fs13, path13, MAX_STEPS;
+var init_runner = __esm({
+  "src/swarm/runner.ts"() {
+    "use strict";
+    fs13 = __toESM(require("fs"));
+    path13 = __toESM(require("path"));
+    init_connection();
+    init_queries();
+    init_machine();
+    init_types2();
+    init_cycle();
+    init_resolve();
+    init_shutdown();
+    init_format();
+    MAX_STEPS = 20;
+  }
+});
+
+// src/swarm/aggregate.ts
+function importExperimentFromWorktree(sourceDb, targetDb, slug) {
+  const sourceExp = sourceDb.prepare(
+    "SELECT * FROM experiments WHERE slug = ?"
+  ).get(slug);
+  if (!sourceExp) {
+    throw new Error(`Experiment ${slug} not found in source DB`);
+  }
+  const sourceId = sourceExp.id;
+  const insertExp = targetDb.prepare(`
+    INSERT INTO experiments (slug, branch, status, classification_ref, sub_type,
+      hypothesis, builder_guidance, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const result = insertExp.run(
+    sourceExp.slug,
+    sourceExp.branch,
+    sourceExp.status,
+    sourceExp.classification_ref,
+    sourceExp.sub_type,
+    sourceExp.hypothesis,
+    sourceExp.builder_guidance,
+    sourceExp.created_at,
+    sourceExp.updated_at
+  );
+  const targetId = result.lastInsertRowid;
+  for (const table2 of CHILD_TABLES) {
+    importChildTable(sourceDb, targetDb, table2, sourceId, targetId);
+  }
+  const stfRows = sourceDb.prepare(
+    "SELECT * FROM sub_type_failures WHERE experiment_id = ?"
+  ).all(sourceId);
+  for (const row of stfRows) {
+    targetDb.prepare(`
+      INSERT INTO sub_type_failures (sub_type, experiment_id, grade, created_at)
+      VALUES (?, ?, ?, ?)
+    `).run(row.sub_type, targetId, row.grade, row.created_at);
+  }
+  return targetId;
+}
+function importChildTable(sourceDb, targetDb, table2, sourceExpId, targetExpId) {
+  const rows = sourceDb.prepare(
+    `SELECT * FROM ${table2} WHERE experiment_id = ?`
+  ).all(sourceExpId);
+  if (rows.length === 0) return;
+  const cols = Object.keys(rows[0]).filter((c) => c !== "id");
+  const placeholders = cols.map(() => "?").join(", ");
+  const insert = targetDb.prepare(
+    `INSERT INTO ${table2} (${cols.join(", ")}) VALUES (${placeholders})`
+  );
+  for (const row of rows) {
+    const values = cols.map(
+      (c) => c === "experiment_id" ? targetExpId : row[c]
+    );
+    insert.run(...values);
+  }
+}
+function aggregateSwarmResults(mainRoot, mainDb, results) {
+  let mergedCount = 0;
+  let deadEndCount = 0;
+  let errorCount = 0;
+  let totalCostUsd = 0;
+  for (const r of results) {
+    totalCostUsd += r.costUsd;
+    if (r.error || !r.experiment) {
+      errorCount++;
+      continue;
+    }
+    try {
+      const sourceDb = openDbAt(r.worktree.path);
+      mainDb.transaction(() => {
+        importExperimentFromWorktree(sourceDb, mainDb, r.worktree.slug);
+      })();
+      sourceDb.close();
+      if (r.finalStatus === "merged") mergedCount++;
+      else if (r.finalStatus === "dead_end") deadEndCount++;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warn(`Failed to import ${r.worktree.slug}: ${msg}`);
+      errorCount++;
+    }
+  }
+  const ranked = results.filter((r) => r.overallGrade && !r.error).sort((a, b) => {
+    const aRank = GRADE_RANK[a.overallGrade] ?? 99;
+    const bRank = GRADE_RANK[b.overallGrade] ?? 99;
+    return aRank - bRank;
+  });
+  const best = ranked.length > 0 ? ranked[0] : null;
+  return {
+    goal: "",
+    // filled by caller
+    parallelCount: results.length,
+    results,
+    bestExperiment: best,
+    totalCostUsd,
+    mergedCount,
+    deadEndCount,
+    errorCount
+  };
+}
+var CHILD_TABLES, GRADE_RANK;
+var init_aggregate = __esm({
+  "src/swarm/aggregate.ts"() {
+    "use strict";
+    init_connection();
+    init_format();
+    CHILD_TABLES = [
+      "decisions",
+      "doubts",
+      "challenges",
+      "verifications",
+      "metrics",
+      "dead_ends",
+      "reframes",
+      "findings"
+    ];
+    GRADE_RANK = {
+      sound: 0,
+      good: 1,
+      weak: 2,
+      rejected: 3
+    };
+  }
+});
+
+// src/commands/swarm.ts
+var swarm_exports = {};
+__export(swarm_exports, {
+  swarm: () => swarm
+});
+async function swarm(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const goal = args.filter((a) => !a.startsWith("--")).join(" ");
+  if (!goal) throw new Error('Usage: majlis swarm "goal description" [--parallel N]');
+  const parallelStr = getFlagValue(args, "--parallel");
+  const parallelCount = Math.min(
+    Math.max(2, parseInt(parallelStr ?? String(DEFAULT_PARALLEL), 10) || DEFAULT_PARALLEL),
+    MAX_PARALLEL
+  );
+  try {
+    const status2 = (0, import_node_child_process7.execSync)("git status --porcelain", {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (status2) {
+      warn("Working tree has uncommitted changes. Commit or stash before swarming.");
+      throw new Error("Dirty working tree. Commit or stash first.");
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Dirty working tree")) throw err;
+    warn("Could not check git status.");
+  }
+  const db = getDb(root);
+  const swarmRun = createSwarmRun(db, goal, parallelCount);
+  header(`Swarm Mode \u2014 ${goal}`);
+  info(`Generating ${parallelCount} diverse hypotheses...`);
+  const hypotheses = await deriveMultipleHypotheses(goal, root, parallelCount);
+  if (hypotheses.length === 0) {
+    success("Planner says the goal has been met. Nothing to swarm.");
+    updateSwarmRun(db, swarmRun.id, "completed", 0, null);
+    return;
+  }
+  info(`Got ${hypotheses.length} hypotheses:`);
+  for (let i = 0; i < hypotheses.length; i++) {
+    info(`  ${i + 1}. ${hypotheses[i]}`);
+  }
+  const worktrees = [];
+  for (let i = 0; i < hypotheses.length; i++) {
+    const paddedNum = String(i + 1).padStart(3, "0");
+    const slug = await generateSlug(hypotheses[i], root);
+    try {
+      const wt = createWorktree(root, slug, paddedNum);
+      wt.hypothesis = hypotheses[i];
+      initializeWorktree(root, wt.path);
+      worktrees.push(wt);
+      addSwarmMember(db, swarmRun.id, slug, wt.path);
+      info(`Created worktree ${paddedNum}: ${slug}`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warn(`Failed to create worktree for hypothesis ${i + 1}: ${msg}`);
+    }
+  }
+  if (worktrees.length === 0) {
+    warn("No worktrees created. Aborting swarm.");
+    updateSwarmRun(db, swarmRun.id, "failed", 0, null);
+    return;
+  }
+  info(`Running ${worktrees.length} experiments in parallel...`);
+  info("");
+  const settled = await Promise.allSettled(
+    worktrees.map((wt) => runExperimentInWorktree(wt))
+  );
+  const results = settled.map((s, i) => {
+    if (s.status === "fulfilled") return s.value;
+    return {
+      worktree: worktrees[i],
+      experiment: null,
+      finalStatus: "error",
+      overallGrade: null,
+      costUsd: 0,
+      stepCount: 0,
+      error: s.reason instanceof Error ? s.reason.message : String(s.reason)
+    };
+  });
+  for (const r of results) {
+    updateSwarmMember(
+      db,
+      swarmRun.id,
+      r.worktree.slug,
+      r.finalStatus,
+      r.overallGrade,
+      r.costUsd,
+      r.error ?? null
+    );
+  }
+  info("");
+  header("Aggregation");
+  const summary = aggregateSwarmResults(root, db, results);
+  summary.goal = goal;
+  if (summary.bestExperiment && isMergeable(summary.bestExperiment.overallGrade)) {
+    const best = summary.bestExperiment;
+    info(`Best experiment: ${best.worktree.slug} (${best.overallGrade})`);
+    try {
+      (0, import_node_child_process7.execSync)(
+        `git merge ${best.worktree.branch} --no-ff -m "Merge swarm winner: ${best.worktree.slug}"`,
+        { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+      );
+      success(`Merged ${best.worktree.slug} into main.`);
+    } catch {
+      warn(`Git merge of ${best.worktree.slug} failed. Merge manually with:`);
+      info(`  git merge ${best.worktree.branch} --no-ff`);
+    }
+  } else {
+    info("No experiment achieved sound/good grade. Nothing merged.");
+  }
+  for (const r of results) {
+    if (r === summary.bestExperiment || r.error || !r.experiment) continue;
+    const mainExp = getExperimentBySlug(db, r.worktree.slug);
+    if (mainExp && mainExp.status !== "dead_end") {
+      updateExperimentStatus(db, mainExp.id, "dead_end");
+    }
+  }
+  updateSwarmRun(
+    db,
+    swarmRun.id,
+    summary.errorCount === results.length ? "failed" : "completed",
+    summary.totalCostUsd,
+    summary.bestExperiment?.worktree.slug ?? null
+  );
+  info("Cleaning up worktrees...");
+  for (const wt of worktrees) {
+    cleanupWorktree(root, wt);
+  }
+  info("");
+  header("Swarm Summary");
+  info(`Goal: ${goal}`);
+  info(`Parallel: ${worktrees.length}`);
+  info(`Results:`);
+  for (const r of results) {
+    const grade = r.overallGrade ?? "n/a";
+    const status2 = r.error ? `ERROR: ${r.error.slice(0, 60)}` : r.finalStatus;
+    const marker = r === summary.bestExperiment ? " <-- BEST" : "";
+    info(`  ${r.worktree.paddedNum} ${r.worktree.slug}: ${grade} (${status2})${marker}`);
+  }
+  info(`Merged: ${summary.mergedCount} | Dead-ends: ${summary.deadEndCount} | Errors: ${summary.errorCount}`);
+}
+function isMergeable(grade) {
+  return grade === "sound" || grade === "good";
+}
+async function deriveMultipleHypotheses(goal, root, count) {
+  const synthesis = truncateContext(
+    readFileOrEmpty(path14.join(root, "docs", "synthesis", "current.md")),
+    CONTEXT_LIMITS.synthesis
+  );
+  const fragility = truncateContext(
+    readFileOrEmpty(path14.join(root, "docs", "synthesis", "fragility.md")),
+    CONTEXT_LIMITS.fragility
+  );
+  const deadEndsDoc = truncateContext(
+    readFileOrEmpty(path14.join(root, "docs", "synthesis", "dead-ends.md")),
+    CONTEXT_LIMITS.deadEnds
+  );
+  const db = getDb(root);
+  const deadEnds = listAllDeadEnds(db);
+  const config = loadConfig(root);
+  let metricsOutput = "";
+  if (config.metrics?.command) {
+    try {
+      metricsOutput = (0, import_node_child_process7.execSync)(config.metrics.command, {
+        cwd: root,
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    } catch {
+      metricsOutput = "(metrics command failed)";
+    }
+  }
+  const result = await spawnSynthesiser({
+    taskPrompt: `You are the Planner for a parallel Majlis swarm.
+
+## Goal
+${goal}
+
+## Current Metrics
+${metricsOutput || "(no metrics configured)"}
+
+## Synthesis (what we know so far)
+${synthesis || "(empty \u2014 first experiment)"}
+
+## Fragility Map (known weak areas)
+${fragility || "(none)"}
+
+## Dead-End Registry
+${deadEndsDoc || "(none)"}
+
+## Dead Ends (from DB \u2014 ${deadEnds.length} total)
+${deadEnds.map((d) => `- [${d.category ?? "structural"}] ${d.approach}: ${d.why_failed} [constraint: ${d.structural_constraint}]`).join("\n") || "(none)"}
+
+Note: [structural] dead ends are HARD CONSTRAINTS \u2014 hypotheses MUST NOT repeat these approaches.
+[procedural] dead ends are process failures \u2014 the approach may still be valid if executed differently.
+
+## Your Task
+1. Assess: based on the metrics and synthesis, has the goal been met? Be specific.
+2. If YES \u2014 output the JSON block below with goal_met: true.
+3. If NO \u2014 generate exactly ${count} DIVERSE hypotheses for parallel testing.
+
+Requirements for hypotheses:
+- Each must attack the problem from a DIFFERENT angle
+- They must NOT share the same mechanism, function target, or strategy
+- At least one should be an unconventional or indirect approach
+- None may repeat a dead-ended structural approach
+- Each must be specific and actionable \u2014 name the function or mechanism to change
+- Do NOT reference specific line numbers \u2014 they shift between experiments
+
+CRITICAL: Your LAST line of output MUST be EXACTLY this format (on its own line, nothing after it):
+<!-- majlis-json {"goal_met": false, "hypotheses": ["hypothesis 1", "hypothesis 2", "hypothesis 3"]} -->
+
+If the goal is met:
+<!-- majlis-json {"goal_met": true, "hypotheses": []} -->`
+  }, root);
+  if (result.structured?.goal_met === true) return [];
+  if (result.structured?.hypotheses && Array.isArray(result.structured.hypotheses)) {
+    return result.structured.hypotheses.filter(
+      (h) => typeof h === "string" && h.length > 10
+    );
+  }
+  const blockMatch = result.output.match(/<!--\s*majlis-json\s*(\{[\s\S]*?\})\s*-->/);
+  if (blockMatch) {
+    try {
+      const parsed = JSON.parse(blockMatch[1]);
+      if (parsed.goal_met === true) return [];
+      if (Array.isArray(parsed.hypotheses)) {
+        return parsed.hypotheses.filter(
+          (h) => typeof h === "string" && h.length > 10
+        );
+      }
+    } catch {
+    }
+  }
+  warn("Planner did not return structured hypotheses. Using goal as single hypothesis.");
+  return [goal];
+}
+var path14, import_node_child_process7, MAX_PARALLEL, DEFAULT_PARALLEL;
+var init_swarm = __esm({
+  "src/commands/swarm.ts"() {
+    "use strict";
+    path14 = __toESM(require("path"));
+    import_node_child_process7 = require("child_process");
+    init_connection();
+    init_queries();
+    init_spawn();
+    init_config();
+    init_worktree();
+    init_runner();
+    init_aggregate();
+    init_format();
+    MAX_PARALLEL = 8;
+    DEFAULT_PARALLEL = 3;
+  }
+});
+
+// src/commands/diagnose.ts
+var diagnose_exports = {};
+__export(diagnose_exports, {
+  diagnose: () => diagnose
+});
+async function diagnose(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  const focus = args.filter((a) => !a.startsWith("--")).join(" ");
+  const keepScripts = args.includes("--keep-scripts");
+  const scriptsDir = path15.join(root, ".majlis", "scripts");
+  if (!fs14.existsSync(scriptsDir)) {
+    fs14.mkdirSync(scriptsDir, { recursive: true });
+  }
+  header("Deep Diagnosis");
+  if (focus) info(`Focus: ${focus}`);
+  const dbExport = exportForDiagnostician(db);
+  const synthesis = readFileOrEmpty(path15.join(root, "docs", "synthesis", "current.md"));
+  const fragility = readFileOrEmpty(path15.join(root, "docs", "synthesis", "fragility.md"));
+  const deadEndsDoc = readFileOrEmpty(path15.join(root, "docs", "synthesis", "dead-ends.md"));
+  const config = loadConfig(root);
+  let metricsOutput = "";
+  if (config.metrics?.command) {
+    try {
+      metricsOutput = (0, import_node_child_process8.execSync)(config.metrics.command, {
+        cwd: root,
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    } catch {
+      metricsOutput = "(metrics command failed)";
+    }
+  }
+  let taskPrompt = `## Full Database Export (CANONICAL \u2014 source of truth)
+${dbExport}
+
+`;
+  taskPrompt += `## Current Synthesis
+${synthesis || "(empty \u2014 no experiments yet)"}
+
+`;
+  taskPrompt += `## Fragility Map
+${fragility || "(none)"}
+
+`;
+  taskPrompt += `## Dead-End Registry
+${deadEndsDoc || "(none)"}
+
+`;
+  taskPrompt += `## Current Metrics
+${metricsOutput || "(no metrics configured)"}
+
+`;
+  taskPrompt += `## Project Objective
+${config.project?.objective || "(not specified)"}
+
+`;
+  if (focus) {
+    taskPrompt += `## Focus Area
+The user has asked you to focus your diagnosis on: ${focus}
+
+`;
+  }
+  taskPrompt += `## Your Task
+Perform a deep diagnostic analysis of this project. Identify root causes, recurring patterns, evidence gaps, and investigation directions. You have 60 turns \u2014 use them for depth. Write analysis scripts to .majlis/scripts/ as needed.
+
+Remember: you may write files ONLY to .majlis/scripts/. You cannot modify project code.`;
+  info("Spawning diagnostician (60 turns, full DB access)...");
+  const result = await spawnAgent("diagnostician", { taskPrompt }, root);
+  const diagnosisDir = path15.join(root, "docs", "diagnosis");
+  if (!fs14.existsSync(diagnosisDir)) {
+    fs14.mkdirSync(diagnosisDir, { recursive: true });
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const artifactPath = path15.join(diagnosisDir, `diagnosis-${timestamp}.md`);
+  fs14.writeFileSync(artifactPath, result.output);
+  info(`Diagnostic report: docs/diagnosis/diagnosis-${timestamp}.md`);
+  if (result.structured?.diagnosis) {
+    const d = result.structured.diagnosis;
+    if (d.root_causes?.length) {
+      info(`Root causes identified: ${d.root_causes.length}`);
+    }
+    if (d.investigation_directions?.length) {
+      info(`Investigation directions: ${d.investigation_directions.length}`);
+    }
+  }
+  if (!keepScripts) {
+    try {
+      const files = fs14.readdirSync(scriptsDir);
+      for (const f of files) {
+        fs14.unlinkSync(path15.join(scriptsDir, f));
+      }
+      fs14.rmdirSync(scriptsDir);
+      info("Cleaned up .majlis/scripts/");
+    } catch {
+    }
+  } else {
+    info("Scripts preserved in .majlis/scripts/ (--keep-scripts)");
+  }
+  if (result.truncated) {
+    warn("Diagnostician was truncated (hit 60 turn limit).");
+  }
+  success("Diagnosis complete.");
+}
+var fs14, path15, import_node_child_process8;
+var init_diagnose = __esm({
+  "src/commands/diagnose.ts"() {
+    "use strict";
+    fs14 = __toESM(require("fs"));
+    path15 = __toESM(require("path"));
+    import_node_child_process8 = require("child_process");
+    init_connection();
+    init_queries();
+    init_spawn();
+    init_config();
+    init_format();
+  }
+});
+
 // src/cli.ts
-var fs12 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 var VERSION = JSON.parse(
-  fs12.readFileSync(path12.join(__dirname, "..", "package.json"), "utf-8")
+  fs15.readFileSync(path16.join(__dirname, "..", "package.json"), "utf-8")
 ).version;
 async function main() {
   let sigintCount = 0;
@@ -4348,11 +5461,21 @@ async function main() {
         await run2(rest);
         break;
       }
+      case "swarm": {
+        const { swarm: swarm2 } = await Promise.resolve().then(() => (init_swarm(), swarm_exports));
+        await swarm2(rest);
+        break;
+      }
       case "audit": {
         const { audit: audit2 } = await Promise.resolve().then(() => (init_audit(), audit_exports));
         await audit2(rest);
         break;
       }
+      case "diagnose": {
+        const { diagnose: diagnose2 } = await Promise.resolve().then(() => (init_diagnose(), diagnose_exports));
+        await diagnose2(rest);
+        break;
+      }
       default:
         console.error(`Unknown command: ${command}`);
         printHelp();
@@ -4405,6 +5528,7 @@ Queries:
 
 Audit:
   audit "objective"          Maqasid check \u2014 is the frame right?
+  diagnose ["focus area"]    Deep diagnosis \u2014 root causes, patterns, gaps
 
 Sessions:
   session start "intent"     Declare session intent
@@ -4412,6 +5536,7 @@ Sessions:
 
 Orchestration:
   run "goal"                 Autonomous orchestration until goal met
+  swarm "goal" [--parallel N] Run N experiments in parallel worktrees
 
 Flags:
   --json                     Output as JSON

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "majlis",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Multi-agent workflow CLI for structured doubt, independent verification, and compressed knowledge",
   "bin": {
     "majlis": "./dist/cli.js"