majlis 0.5.1 → 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));
@@ -575,6 +617,10 @@ Read as much code as you need to understand the problem. Reading is free \u2014
 as many turns as necessary on Read, Grep, and Glob to build full context before
 you touch anything.
 
+Do NOT read raw data files (fixtures/, ground truth JSON/STL). The synthesis
+has the relevant facts. Reading raw data wastes turns re-deriving what the
+doubt/challenge/verify cycle already established.
+
 ## The Rule: ONE Change, Then Document
 
 You make ONE code change per cycle. Not two, not "one more quick fix." ONE.
@@ -738,6 +784,9 @@ If the builder claims improvement but the framework metrics show regression, fla
 - Run at most 3-5 targeted diagnostic scripts, focused on the critical doubts/challenges.
 - Do NOT run exhaustive diagnostics on every claim.
 
+Framework-captured metrics are ground truth \u2014 if they show regression, that
+alone justifies a "rejected" grade. Do not re-derive from raw fixture data.
+
 Grade each component: sound / good / weak / rejected
 Grade each doubt/challenge: confirmed / dismissed (with evidence) / inconclusive
 
@@ -817,6 +866,13 @@ the database export.
    The framework does NOT auto-save your output for these files.
 7. Review classification: new sub-types? resolved sub-types?
 
+You may ONLY write to these three files:
+- docs/synthesis/current.md
+- docs/synthesis/fragility.md
+- docs/synthesis/dead-ends.md
+
+Do NOT modify MEMORY.md, .claude/, classification/, experiments/, or any other paths.
+
 You may NOT write code, make decisions, or run experiments.
 
 ## Structured Output Format
@@ -909,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: {
@@ -969,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 = {
@@ -1567,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"];
@@ -1629,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;
@@ -1805,1076 +2032,1238 @@ var init_status = __esm({
   }
 });
 
-// src/metrics.ts
-function compareMetrics(db, experimentId, config) {
-  const before = getMetricsByExperimentAndPhase(db, experimentId, "before");
-  const after = getMetricsByExperimentAndPhase(db, experimentId, "after");
-  const fixtures = new Set([...before, ...after].map((m) => m.fixture));
-  const trackedMetrics = Object.keys(config.metrics.tracked);
-  const comparisons = [];
-  for (const fixture of fixtures) {
-    for (const metric of trackedMetrics) {
-      const b = before.find((m) => m.fixture === fixture && m.metric_name === metric);
-      const a = after.find((m) => m.fixture === fixture && m.metric_name === metric);
-      if (b && a) {
-        const direction = config.metrics.tracked[metric]?.direction ?? "lower_is_better";
-        const regression = isRegression(b.metric_value, a.metric_value, direction);
-        comparisons.push({
-          fixture,
-          metric,
-          before: b.metric_value,
-          after: a.metric_value,
-          delta: a.metric_value - b.metric_value,
-          regression
-        });
-      }
-    }
-  }
-  return comparisons;
-}
-function isRegression(before, after, direction) {
-  switch (direction) {
-    case "lower_is_better":
-      return after > before;
-    case "higher_is_better":
-      return after < before;
-    case "closer_to_gt":
-      return false;
+// src/agents/types.ts
+function getExtractionSchema(role) {
+  switch (role) {
+    case "builder":
+      return '{"decisions": [{"description": "string", "evidence_level": "proof|test|strong_consensus|consensus|analogy|judgment", "justification": "string"}]}';
+    case "critic":
+      return '{"doubts": [{"claim_doubted": "string", "evidence_level_of_claim": "string", "evidence_for_doubt": "string", "severity": "minor|moderate|critical"}]}';
+    case "adversary":
+      return '{"challenges": [{"description": "string", "reasoning": "string"}]}';
+    case "verifier":
+      return '{"grades": [{"component": "string", "grade": "sound|good|weak|rejected", "provenance_intact": true, "content_correct": true, "notes": "string"}], "doubt_resolutions": [{"doubt_id": 0, "resolution": "confirmed|dismissed|inconclusive"}]}';
+    case "gatekeeper":
+      return '{"gate_decision": "approve|reject|flag", "reason": "string", "stale_references": ["string"], "overlapping_dead_ends": [0]}';
+    case "reframer":
+      return '{"reframe": {"decomposition": "string", "divergences": ["string"], "recommendation": "string"}}';
+    case "scout":
+      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 false;
-  }
-}
-function parseMetricsOutput(jsonStr) {
-  const data = JSON.parse(jsonStr);
-  const results = [];
-  if (data.fixtures && typeof data.fixtures === "object") {
-    for (const [fixture, metrics] of Object.entries(data.fixtures)) {
-      for (const [metricName, metricValue] of Object.entries(metrics)) {
-        if (typeof metricValue === "number") {
-          results.push({ fixture, metric_name: metricName, metric_value: metricValue });
-        }
-      }
-    }
+      return EXTRACTION_SCHEMA;
   }
-  return results;
 }
-var init_metrics = __esm({
-  "src/metrics.ts"() {
+var EXTRACTION_SCHEMA, ROLE_REQUIRED_FIELDS;
+var init_types = __esm({
+  "src/agents/types.ts"() {
     "use strict";
-    init_queries();
+    EXTRACTION_SCHEMA = `{
+  "decisions": [{ "description": "string", "evidence_level": "proof|test|strong_consensus|consensus|analogy|judgment", "justification": "string" }],
+  "grades": [{ "component": "string", "grade": "sound|good|weak|rejected", "provenance_intact": true, "content_correct": true, "notes": "string" }],
+  "doubts": [{ "claim_doubted": "string", "evidence_level_of_claim": "string", "evidence_for_doubt": "string", "severity": "minor|moderate|critical" }],
+  "guidance": "string (actionable builder guidance)",
+  "doubt_resolutions": [{ "doubt_id": 0, "resolution": "confirmed|dismissed|inconclusive" }]
+}`;
+    ROLE_REQUIRED_FIELDS = {
+      builder: ["decisions"],
+      critic: ["doubts"],
+      adversary: ["challenges"],
+      verifier: ["grades"],
+      gatekeeper: ["gate_decision"],
+      reframer: ["reframe"],
+      scout: ["findings"],
+      compressor: ["compression_report"],
+      diagnostician: ["diagnosis"]
+    };
   }
 });
 
-// src/commands/measure.ts
-var measure_exports = {};
-__export(measure_exports, {
-  baseline: () => baseline,
-  compare: () => compare,
-  measure: () => measure
-});
-async function baseline(args) {
-  await captureMetrics("before", args);
-}
-async function measure(args) {
-  await captureMetrics("after", args);
-}
-async function captureMetrics(phase, args) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const db = getDb(root);
-  const config = loadConfig(root);
-  const expIdStr = getFlagValue(args, "--experiment");
-  let exp;
-  if (expIdStr !== void 0) {
-    exp = getExperimentById(db, Number(expIdStr));
+// src/agents/parse.ts
+async function extractStructuredData(role, markdown) {
+  const tier1 = extractMajlisJsonBlock(markdown);
+  if (tier1) {
+    const parsed = tryParseJson(tier1);
+    if (parsed) return parsed;
+    console.warn(`[majlis] Malformed JSON in <!-- majlis-json --> block for ${role}. Falling back.`);
   } else {
-    exp = getLatestExperiment(db);
-  }
-  if (!exp) throw new Error('No active experiment. Run `majlis new "hypothesis"` first.');
-  if (config.build.pre_measure) {
-    info(`Running pre-measure: ${config.build.pre_measure}`);
-    try {
-      (0, import_node_child_process.execSync)(config.build.pre_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
-    } catch {
-      warn("Pre-measure command failed \u2014 continuing anyway.");
-    }
+    console.warn(`[majlis] No <!-- majlis-json --> block found in ${role} output. Falling back.`);
   }
-  if (!config.metrics.command) {
-    throw new Error("No metrics.command configured in .majlis/config.json");
+  const tier2 = extractViaPatterns(role, markdown);
+  if (tier2 && hasData(tier2)) {
+    console.warn(`[majlis] Used regex fallback for ${role}. Review extracted data.`);
+    return tier2;
   }
-  info(`Running metrics: ${config.metrics.command}`);
-  let metricsOutput;
+  console.warn(`[majlis] Regex fallback insufficient for ${role}. Using Haiku extraction.`);
+  const tier3 = await extractViaHaiku(role, markdown);
+  if (tier3) return tier3;
+  console.error(
+    `[majlis] FAILED to extract structured data from ${role} output. State machine will continue but data is missing. Manual review required.`
+  );
+  return null;
+}
+function extractMajlisJsonBlock(markdown) {
+  const match = markdown.match(/<!--\s*majlis-json\s*\n([\s\S]*?)-->/);
+  if (!match) return null;
+  return match[1].trim();
+}
+function tryParseJson(jsonStr) {
   try {
-    metricsOutput = (0, import_node_child_process.execSync)(config.metrics.command, {
-      cwd: root,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
+  }
+}
+function extractViaPatterns(role, markdown) {
+  const result = {};
+  const decisionPattern = /\[(?:decision|Decision)\].*?(?:description|Description):\s*(.+?)(?:\n|$).*?(?:evidence.?level|Evidence.?Level|level):\s*(proof|test|strong_consensus|consensus|analogy|judgment).*?(?:justification|Justification):\s*(.+?)(?:\n|$)/gis;
+  const decisions = [];
+  const evidenceMarkers = /(?:^|\n)\s*[-*]\s*\*?\*?(?:Decision|DECISION)\*?\*?:\s*(.+?)(?:\n|$).*?(?:Evidence|EVIDENCE|Level):\s*(proof|test|strong_consensus|consensus|analogy|judgment)/gim;
+  let match;
+  while ((match = evidenceMarkers.exec(markdown)) !== null) {
+    decisions.push({
+      description: match[1].trim(),
+      evidence_level: match[2].toLowerCase().trim(),
+      justification: "Extracted via regex \u2014 review"
     });
-  } catch (err) {
-    throw new Error(`Metrics command failed: ${err instanceof Error ? err.message : String(err)}`);
   }
-  const parsed = parseMetricsOutput(metricsOutput);
-  if (parsed.length === 0) {
-    warn("Metrics command returned no data.");
-    return;
+  const inlineTagPattern = /\[(proof|test|strong_consensus|consensus|analogy|judgment)\]\s*(.+?)(?:\n|$)/gi;
+  while ((match = inlineTagPattern.exec(markdown)) !== null) {
+    const desc = match[2].trim();
+    if (!decisions.some((d) => d.description === desc)) {
+      decisions.push({
+        description: desc,
+        evidence_level: match[1].toLowerCase(),
+        justification: "Extracted via regex \u2014 review"
+      });
+    }
   }
-  for (const m of parsed) {
-    insertMetric(db, exp.id, phase, m.fixture, m.metric_name, m.metric_value);
+  if (decisions.length > 0) result.decisions = decisions;
+  const grades = [];
+  const gradePattern = /(?:^|\n)\s*[-*]?\s*\*?\*?(?:Grade|GRADE|Component)\*?\*?.*?(?:component|Component)?\s*[:=]\s*(.+?)(?:\n|,).*?(?:grade|Grade)\s*[:=]\s*(sound|good|weak|rejected)/gim;
+  while ((match = gradePattern.exec(markdown)) !== null) {
+    grades.push({
+      component: match[1].trim(),
+      grade: match[2].toLowerCase().trim()
+    });
   }
-  success(`Captured ${parsed.length} metric(s) for ${exp.slug} (phase: ${phase})`);
-  if (config.build.post_measure) {
-    try {
-      (0, import_node_child_process.execSync)(config.build.post_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
-    } catch {
-      warn("Post-measure command failed.");
+  const simpleGradePattern = /(?:^|\n)\s*[-*]\s*\*?\*?(.+?)\*?\*?\s*[:—–-]\s*\*?\*?(sound|good|weak|rejected)\*?\*?/gim;
+  while ((match = simpleGradePattern.exec(markdown)) !== null) {
+    const comp = match[1].trim();
+    if (!grades.some((g) => g.component === comp)) {
+      grades.push({
+        component: comp,
+        grade: match[2].toLowerCase().trim()
+      });
     }
   }
-}
-async function compare(args, isJson) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const db = getDb(root);
-  const config = loadConfig(root);
-  const expIdStr = getFlagValue(args, "--experiment");
-  let exp;
-  if (expIdStr !== void 0) {
-    exp = getExperimentById(db, Number(expIdStr));
-  } else {
-    exp = getLatestExperiment(db);
-  }
-  if (!exp) throw new Error("No active experiment.");
-  const comparisons = compareMetrics(db, exp.id, config);
-  if (comparisons.length === 0) {
-    warn(`No before/after metrics to compare for ${exp.slug}. Run baseline and measure first.`);
-    return;
-  }
-  if (isJson) {
-    console.log(JSON.stringify({ experiment: exp.slug, comparisons }, null, 2));
-    return;
+  if (grades.length > 0) result.grades = grades;
+  const doubts = [];
+  const doubtPattern = /(?:Doubt|DOUBT|Claim doubted|CLAIM)\s*(?:\d+)?[:.]?\s*(.+?)(?:\n|$)[\s\S]*?(?:Severity|SEVERITY)\s*[:=]\s*(minor|moderate|critical)/gim;
+  while ((match = doubtPattern.exec(markdown)) !== null) {
+    doubts.push({
+      claim_doubted: match[1].trim(),
+      evidence_level_of_claim: "unknown",
+      // Don't fabricate — mark as unknown for review
+      evidence_for_doubt: "Extracted via regex \u2014 review original document",
+      severity: match[2].toLowerCase().trim()
+    });
   }
-  header(`Metric Comparison \u2014 ${exp.slug}`);
-  const regressions = comparisons.filter((c) => c.regression);
-  const rows = comparisons.map((c) => [
-    c.fixture,
-    c.metric,
-    String(c.before),
-    String(c.after),
-    formatDelta(c.delta),
-    c.regression ? red("REGRESSION") : green("OK")
-  ]);
-  console.log(table(["Fixture", "Metric", "Before", "After", "Delta", "Status"], rows));
-  if (regressions.length > 0) {
-    console.log();
-    warn(`${regressions.length} regression(s) detected!`);
-  } else {
-    console.log();
-    success("No regressions detected.");
+  if (doubts.length > 0) result.doubts = doubts;
+  return result;
+}
+async function extractViaHaiku(role, markdown) {
+  try {
+    const truncated = markdown.length > 8e3 ? markdown.slice(0, 8e3) + "\n[truncated]" : markdown;
+    const schema = getExtractionSchema(role);
+    const prompt = `Extract structured data from this ${role} document as JSON. Follow this schema exactly: ${schema}
+
+Document:
+${truncated}`;
+    const conversation = (0, import_claude_agent_sdk.query)({
+      prompt,
+      options: {
+        model: "haiku",
+        tools: [],
+        systemPrompt: "You are a JSON extraction assistant. Output only valid JSON matching the requested schema. No markdown, no explanation, just JSON.",
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        maxTurns: 1,
+        persistSession: false
+      }
+    });
+    let resultText = "";
+    for await (const message of conversation) {
+      if (message.type === "assistant") {
+        for (const block of message.message.content) {
+          if (block.type === "text") {
+            resultText += block.text;
+          }
+        }
+      }
+    }
+    return tryParseJson(resultText.trim());
+  } catch (err) {
+    console.warn(`[majlis] Haiku extraction failed for ${role}: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
   }
 }
-function formatDelta(delta) {
-  const prefix = delta > 0 ? "+" : "";
-  return `${prefix}${delta.toFixed(4)}`;
+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 || output.diagnosis);
 }
-var import_node_child_process;
-var init_measure = __esm({
-  "src/commands/measure.ts"() {
+function validateForRole(role, output) {
+  const required = ROLE_REQUIRED_FIELDS[role];
+  if (!required) return { valid: true, missing: [] };
+  const missing = required.filter((field) => {
+    const value = output[field];
+    if (value === void 0 || value === null) return true;
+    if (Array.isArray(value) && value.length === 0) return true;
+    return false;
+  });
+  return { valid: missing.length === 0, missing };
+}
+var import_claude_agent_sdk;
+var init_parse = __esm({
+  "src/agents/parse.ts"() {
     "use strict";
-    import_node_child_process = require("child_process");
-    init_connection();
-    init_queries();
-    init_metrics();
-    init_config();
-    init_format();
+    init_types();
+    import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
   }
 });
 
-// src/commands/experiment.ts
-var experiment_exports = {};
-__export(experiment_exports, {
-  newExperiment: () => newExperiment,
-  revert: () => revert
-});
-async function newExperiment(args) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const hypothesis = args.filter((a) => !a.startsWith("--")).join(" ");
-  if (!hypothesis) {
-    throw new Error('Usage: majlis new "hypothesis"');
-  }
-  const db = getDb(root);
-  const config = loadConfig(root);
-  const slug = slugify(hypothesis);
-  if (getExperimentBySlug(db, slug)) {
-    throw new Error(`Experiment with slug "${slug}" already exists.`);
+// src/agents/spawn.ts
+function loadAgentDefinition(role, projectRoot) {
+  const root = projectRoot ?? findProjectRoot() ?? process.cwd();
+  const filePath = path4.join(root, ".majlis", "agents", `${role}.md`);
+  if (!fs4.existsSync(filePath)) {
+    throw new Error(`Agent definition not found: ${filePath}`);
   }
-  const allExps = db.prepare("SELECT COUNT(*) as count FROM experiments").get();
-  const num = allExps.count + 1;
-  const paddedNum = String(num).padStart(3, "0");
-  const branch = `exp/${paddedNum}-${slug}`;
-  try {
-    (0, import_node_child_process2.execSync)(`git checkout -b ${branch}`, {
-      cwd: root,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    info(`Created branch: ${branch}`);
-  } catch (err) {
-    warn(`Could not create branch ${branch} \u2014 continuing without git branch.`);
+  const content = fs4.readFileSync(filePath, "utf-8");
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    throw new Error(`Invalid agent definition (missing YAML frontmatter): ${filePath}`);
   }
-  const subType = getFlagValue(args, "--sub-type") ?? null;
-  const exp = createExperiment(db, slug, branch, hypothesis, subType, null);
-  success(`Created experiment #${exp.id}: ${exp.slug}`);
-  const docsDir = path4.join(root, "docs", "experiments");
-  const templatePath = path4.join(docsDir, "_TEMPLATE.md");
-  if (fs4.existsSync(templatePath)) {
-    const template = fs4.readFileSync(templatePath, "utf-8");
-    const logContent = template.replace(/\{\{title\}\}/g, hypothesis).replace(/\{\{hypothesis\}\}/g, hypothesis).replace(/\{\{branch\}\}/g, branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, subType ?? "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    const logPath = path4.join(docsDir, `${paddedNum}-${slug}.md`);
-    fs4.writeFileSync(logPath, logContent);
-    info(`Created experiment log: docs/experiments/${paddedNum}-${slug}.md`);
+  const frontmatter = frontmatterMatch[1];
+  const body = frontmatterMatch[2].trim();
+  const name = extractYamlField(frontmatter, "name") ?? role;
+  const model = extractYamlField(frontmatter, "model") ?? "opus";
+  const toolsStr = extractYamlField(frontmatter, "tools") ?? "[]";
+  const tools = toolsStr.replace(/[\[\]]/g, "").split(",").map((t) => t.trim()).filter(Boolean);
+  return { name, model, tools, systemPrompt: body };
+}
+function buildCheckpointMessage(role, toolUseCount, maxTurns) {
+  const approxTurn = Math.round(toolUseCount / 2);
+  const header2 = `[MAJLIS CHECKPOINT \u2014 ~${approxTurn} of ${maxTurns} turns used]`;
+  switch (role) {
+    case "builder":
+      return `${header2}
+Reminder: ONE code change per cycle.
+- Have you run the benchmark? YES \u2192 document results + output JSON + STOP.
+- If NO \u2192 run it now, then wrap up.
+Do NOT start a second change or investigate unrelated failures.`;
+    case "verifier":
+      return `${header2}
+AT MOST 3 diagnostic scripts total.
+- If \u22653 scripts run \u2192 produce grades + output JSON now.
+- Trust framework metrics. Do not re-derive from raw data.`;
+    case "critic":
+      return `${header2}
+Focus on the SINGLE weakest assumption.
+- Have you identified the core doubt? YES \u2192 write it up + output JSON.
+- Do not enumerate every possible concern \u2014 pick the most dangerous one.`;
+    case "adversary":
+      return `${header2}
+Design ONE targeted challenge, not a test suite.
+- Have you defined the challenge? YES \u2192 write it up + output JSON.
+- Focus on what would DISPROVE the hypothesis, not general testing.`;
+    case "compressor":
+      return `${header2}
+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.`;
+  }
+}
+function buildPreToolUseGuards(role) {
+  if (role === "compressor") {
+    const guardHook = async (input) => {
+      const toolInput = input.tool_input ?? {};
+      const filePath = toolInput.file_path ?? "";
+      if (filePath && !filePath.includes("/docs/synthesis/")) {
+        return {
+          decision: "block",
+          reason: `Compressor may only write to docs/synthesis/. Blocked: ${filePath}`
+        };
+      }
+      return {};
+    };
+    return [
+      { matcher: "Write", hooks: [guardHook] },
+      { matcher: "Edit", hooks: [guardHook] }
+    ];
   }
-  if (config.cycle.auto_baseline_on_new_experiment && config.metrics.command) {
-    info("Auto-baselining... (run `majlis baseline` to do this manually)");
-    try {
-      const { baseline: baseline2 } = await Promise.resolve().then(() => (init_measure(), measure_exports));
-      await baseline2(["--experiment", String(exp.id)]);
-    } catch (err) {
-      warn("Auto-baseline failed \u2014 run `majlis baseline` manually.");
-    }
+  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;
 }
-async function revert(args) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const db = getDb(root);
-  let exp;
-  const slugArg = args.filter((a) => !a.startsWith("--"))[0];
-  if (slugArg) {
-    exp = getExperimentBySlug(db, slugArg);
-    if (!exp) throw new Error(`Experiment not found: ${slugArg}`);
-  } else {
-    exp = getLatestExperiment(db);
-    if (!exp) throw new Error("No active experiments to revert.");
+function buildAgentHooks(role, maxTurns) {
+  const result = {};
+  let hasHooks = false;
+  const interval = CHECKPOINT_INTERVAL[role];
+  if (interval) {
+    let toolUseCount = 0;
+    const checkpointHook = async () => {
+      toolUseCount++;
+      if (toolUseCount % interval === 0) {
+        const msg = buildCheckpointMessage(role, toolUseCount, maxTurns);
+        return {
+          hookSpecificOutput: {
+            hookEventName: "PostToolUse",
+            additionalContext: msg
+          }
+        };
+      }
+      return {};
+    };
+    result.PostToolUse = [{ hooks: [checkpointHook] }];
+    hasHooks = true;
   }
-  const reason = getFlagValue(args, "--reason") ?? "Manually reverted";
-  const category = args.includes("--structural") ? "structural" : "procedural";
-  insertDeadEnd(
-    db,
-    exp.id,
-    exp.hypothesis ?? exp.slug,
-    reason,
-    `Reverted: ${reason}`,
-    exp.sub_type,
-    category
-  );
-  updateExperimentStatus(db, exp.id, "dead_end");
-  try {
-    const currentBranch = (0, import_node_child_process2.execSync)("git rev-parse --abbrev-ref HEAD", {
-      cwd: root,
-      encoding: "utf-8"
-    }).trim();
-    if (currentBranch === exp.branch) {
-      (0, import_node_child_process2.execSync)("git checkout main 2>/dev/null || git checkout master", {
-        cwd: root,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    }
-  } catch {
-    warn("Could not switch git branches \u2014 do this manually.");
+  const guards = buildPreToolUseGuards(role);
+  if (guards) {
+    result.PreToolUse = guards;
+    hasHooks = true;
   }
-  info(`Experiment ${exp.slug} reverted to dead-end. Reason: ${reason}`);
+  return hasHooks ? result : void 0;
 }
-function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
-}
-var fs4, path4, import_node_child_process2;
-var init_experiment = __esm({
-  "src/commands/experiment.ts"() {
+function extractYamlField(yaml, field) {
+  const match = yaml.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
+  return match ? match[1].trim() : null;
+}
+async function spawnAgent(role, context, projectRoot) {
+  const agentDef = loadAgentDefinition(role, projectRoot);
+  const root = projectRoot ?? findProjectRoot() ?? process.cwd();
+  const taskPrompt = context.taskPrompt ?? `Perform your role as ${agentDef.name}.`;
+  const contextJson = JSON.stringify(context);
+  const prompt = `Here is your context:
+
+\`\`\`json
+${contextJson}
+\`\`\`
+
+${taskPrompt}`;
+  const turns = ROLE_MAX_TURNS[role] ?? 15;
+  console.log(`[${role}] Spawning (model: ${agentDef.model}, maxTurns: ${turns})...`);
+  const { text: markdown, costUsd, truncated } = await runQuery({
+    prompt,
+    model: agentDef.model,
+    tools: agentDef.tools,
+    systemPrompt: agentDef.systemPrompt,
+    cwd: root,
+    maxTurns: turns,
+    label: role,
+    role
+  });
+  console.log(`[${role}] Complete (cost: $${costUsd.toFixed(4)}${truncated ? ", TRUNCATED" : ""})`);
+  const artifactPath = writeArtifact(role, context, markdown, root);
+  if (artifactPath) {
+    console.log(`[${role}] Artifact written to ${artifactPath}`);
+  }
+  const structured = await extractStructuredData(role, markdown);
+  if (structured) {
+    const { valid, missing } = validateForRole(role, structured);
+    if (!valid) {
+      console.warn(`[${role}] Output missing expected fields: ${missing.join(", ")}`);
+    }
+  }
+  return { output: markdown, structured, truncated };
+}
+async function spawnSynthesiser(context, projectRoot) {
+  const root = projectRoot ?? findProjectRoot() ?? process.cwd();
+  const contextJson = JSON.stringify(context);
+  const taskPrompt = context.taskPrompt ?? "Synthesise the findings into actionable builder guidance.";
+  const prompt = `Here is your context:
+
+\`\`\`json
+${contextJson}
+\`\`\`
+
+${taskPrompt}`;
+  const systemPrompt = 'You are a Synthesis Agent. Be concrete: which decisions failed, which assumptions broke, what constraints must the next approach satisfy. CRITICAL: Your LAST line of output MUST be a <!-- majlis-json --> block. The framework parses this programmatically \u2014 if you omit it, the pipeline breaks. Format: <!-- majlis-json {"guidance": "your guidance here"} -->';
+  console.log(`[synthesiser] Spawning (maxTurns: 5)...`);
+  const { text: markdown, costUsd, truncated } = await runQuery({
+    prompt,
+    model: "sonnet",
+    tools: ["Read", "Glob", "Grep"],
+    systemPrompt,
+    cwd: root,
+    maxTurns: 5,
+    label: "synthesiser",
+    role: "synthesiser"
+  });
+  console.log(`[synthesiser] Complete (cost: $${costUsd.toFixed(4)})`);
+  return { output: markdown, structured: { guidance: markdown }, truncated };
+}
+async function spawnRecovery(role, partialOutput, context, projectRoot) {
+  const root = projectRoot ?? findProjectRoot() ?? process.cwd();
+  const expSlug = context.experiment?.slug ?? "unknown";
+  console.log(`[recovery] Cleaning up after truncated ${role} for ${expSlug}...`);
+  const expDocPath = path4.join(
+    root,
+    "docs",
+    "experiments",
+    `${String(context.experiment?.id ?? 0).padStart(3, "0")}-${expSlug}.md`
+  );
+  const templatePath = path4.join(root, "docs", "experiments", "_TEMPLATE.md");
+  const template = fs4.existsSync(templatePath) ? fs4.readFileSync(templatePath, "utf-8") : "";
+  const currentDoc = fs4.existsSync(expDocPath) ? fs4.readFileSync(expDocPath, "utf-8") : "";
+  const prompt = `The ${role} agent was truncated (hit max turns) while working on experiment "${expSlug}".
+
+Here is the partial agent output (reasoning + tool calls):
+<partial_output>
+${partialOutput.slice(-3e3)}
+</partial_output>
+
+Here is the current experiment doc:
+<current_doc>
+${currentDoc}
+</current_doc>
+
+Here is the template that the experiment doc should follow:
+<template>
+${template}
+</template>
+
+Your job: Write a CLEAN experiment doc to ${expDocPath} using the Write tool.
+- Keep any valid content from the current doc
+- Fill in what you can infer from the partial output
+- Mark incomplete sections with "[TRUNCATED \u2014 ${role} did not finish]"
+- The doc MUST have the <!-- majlis-json --> block, even if decisions are empty
+- Do NOT include agent reasoning or thinking \u2014 only structured experiment content
+- Be concise. This is cleanup, not new work.`;
+  const { text: _markdown } = await runQuery({
+    prompt,
+    model: "haiku",
+    tools: ["Read", "Write"],
+    systemPrompt: `You are a Recovery Agent. You clean up experiment docs after truncated agent runs. Write clean, structured docs. Never include agent reasoning or monologue.`,
+    cwd: root,
+    maxTurns: 5,
+    label: "recovery",
+    role: "recovery"
+  });
+  console.log(`[recovery] Cleanup complete for ${expSlug}.`);
+}
+async function runQuery(opts) {
+  let truncated = false;
+  const tag = opts.label ?? "majlis";
+  const hooks = opts.role ? buildAgentHooks(opts.role, opts.maxTurns ?? 15) : void 0;
+  const conversation = (0, import_claude_agent_sdk2.query)({
+    prompt: opts.prompt,
+    options: {
+      model: opts.model,
+      tools: opts.tools,
+      systemPrompt: {
+        type: "preset",
+        preset: "claude_code",
+        append: opts.systemPrompt
+      },
+      cwd: opts.cwd,
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      maxTurns: opts.maxTurns ?? 15,
+      persistSession: false,
+      settingSources: ["project"],
+      hooks
+    }
+  });
+  const textParts = [];
+  let costUsd = 0;
+  let turnCount = 0;
+  for await (const message of conversation) {
+    if (message.type === "assistant") {
+      turnCount++;
+      let hasText = false;
+      for (const block of message.message.content) {
+        if (block.type === "text") {
+          textParts.push(block.text);
+          hasText = true;
+        } else if (block.type === "tool_use") {
+          const toolName = block.name ?? "tool";
+          const input = block.input ?? {};
+          const detail = formatToolDetail(toolName, input);
+          process.stderr.write(`${DIM2}[${tag}]   ${CYAN2}${toolName}${RESET2}${DIM2}${detail}${RESET2}
+`);
+        }
+      }
+      if (hasText) {
+        const preview = textParts[textParts.length - 1].slice(0, 120).replace(/\n/g, " ").trim();
+        if (preview) {
+          process.stderr.write(`${DIM2}[${tag}]   writing: ${preview}${preview.length >= 120 ? "..." : ""}${RESET2}
+`);
+        }
+      }
+    } else if (message.type === "tool_progress") {
+      const elapsed = Math.round(message.elapsed_time_seconds);
+      if (elapsed > 0 && elapsed % 5 === 0) {
+        process.stderr.write(`${DIM2}[${tag}]   ${message.tool_name} running (${elapsed}s)...${RESET2}
+`);
+      }
+    } else if (message.type === "result") {
+      if (message.subtype === "success") {
+        costUsd = message.total_cost_usd;
+      } else if (message.subtype === "error_max_turns") {
+        truncated = true;
+        costUsd = "total_cost_usd" in message ? message.total_cost_usd : 0;
+        console.warn(`[${tag}] Hit max turns (${turnCount}). Returning partial output.`);
+      } else {
+        const errors = "errors" in message ? message.errors?.join("; ") ?? "Unknown error" : "Unknown error";
+        throw new Error(`Agent query failed (${message.subtype}): ${errors}`);
+      }
+    }
+  }
+  return { text: textParts.join("\n\n"), costUsd, truncated };
+}
+async function generateSlug(hypothesis, projectRoot) {
+  const fallback = hypothesis.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 30).replace(/-$/, "");
+  try {
+    const { text } = await runQuery({
+      prompt: `Generate a short, descriptive git branch slug (2-4 words, lowercase, hyphen-separated) for this experiment hypothesis:
+
+"${hypothesis.slice(0, 500)}"
+
+Output ONLY the slug, nothing else. Examples: uv-containment-filter, skip-degenerate-faces, fix-edge-sewing-order`,
+      model: "haiku",
+      tools: [],
+      systemPrompt: "Output only a short hyphenated slug. No explanation, no quotes, no punctuation except hyphens.",
+      cwd: projectRoot,
+      maxTurns: 1,
+      label: "slug",
+      role: "slug"
+    });
+    const slug = text.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "").replace(/^-|-$/g, "").slice(0, 40);
+    return slug.length >= 3 ? slug : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function formatToolDetail(toolName, input) {
+  switch (toolName) {
+    case "Read":
+      return input.file_path ? ` ${input.file_path}` : "";
+    case "Write":
+      return input.file_path ? ` \u2192 ${input.file_path}` : "";
+    case "Edit":
+      return input.file_path ? ` ${input.file_path}` : "";
+    case "Glob":
+      return input.pattern ? ` ${input.pattern}` : "";
+    case "Grep":
+      return input.pattern ? ` /${input.pattern}/` : "";
+    case "Bash":
+      return input.command ? ` $ ${input.command.slice(0, 80)}` : "";
+    case "WebSearch":
+      return input.query ? ` "${input.query}"` : "";
+    default:
+      return "";
+  }
+}
+function writeArtifact(role, context, markdown, projectRoot) {
+  const dirMap = {
+    builder: "docs/experiments",
+    critic: "docs/doubts",
+    adversary: "docs/challenges",
+    verifier: "docs/verification",
+    reframer: "docs/reframes",
+    compressor: "docs/synthesis",
+    scout: "docs/rihla"
+  };
+  const dir = dirMap[role];
+  if (!dir) 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 });
+  }
+  const expSlug = context.experiment?.slug ?? "general";
+  const nextNum = String(context.experiment?.id ?? 1).padStart(3, "0");
+  const filename = `${nextNum}-${role}-${expSlug}.md`;
+  const target = path4.join(fullDir, filename);
+  fs4.writeFileSync(target, markdown);
+  return target;
+}
+var fs4, path4, import_claude_agent_sdk2, ROLE_MAX_TURNS, CHECKPOINT_INTERVAL, DIM2, RESET2, CYAN2;
+var init_spawn = __esm({
+  "src/agents/spawn.ts"() {
     "use strict";
     fs4 = __toESM(require("fs"));
     path4 = __toESM(require("path"));
-    import_node_child_process2 = require("child_process");
+    import_claude_agent_sdk2 = require("@anthropic-ai/claude-agent-sdk");
+    init_parse();
     init_connection();
-    init_queries();
-    init_config();
-    init_format();
+    ROLE_MAX_TURNS = {
+      builder: 50,
+      critic: 30,
+      adversary: 30,
+      verifier: 50,
+      compressor: 30,
+      reframer: 20,
+      scout: 20,
+      gatekeeper: 10,
+      diagnostician: 60
+    };
+    CHECKPOINT_INTERVAL = {
+      builder: 15,
+      verifier: 12,
+      critic: 15,
+      adversary: 15,
+      compressor: 15,
+      diagnostician: 20
+    };
+    DIM2 = "\x1B[2m";
+    RESET2 = "\x1B[0m";
+    CYAN2 = "\x1B[36m";
   }
 });
 
-// src/commands/session.ts
-var session_exports = {};
-__export(session_exports, {
-  session: () => session
-});
-async function session(args) {
-  const subcommand = args[0];
-  if (!subcommand || subcommand !== "start" && subcommand !== "end") {
-    throw new Error('Usage: majlis session start "intent" | majlis session end');
-  }
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const db = getDb(root);
-  if (subcommand === "start") {
-    const intent = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
-    if (!intent) {
-      throw new Error('Usage: majlis session start "intent"');
-    }
-    const existing = getActiveSession(db);
-    if (existing) {
-      warn(`Session already active: "${existing.intent}" (started ${existing.started_at})`);
-      warn("End it first with `majlis session end`.");
-      return;
-    }
-    const latestExp = getLatestExperiment(db);
-    const sess = startSession(db, intent, latestExp?.id ?? null);
-    success(`Session started: "${intent}" (id: ${sess.id})`);
-    if (latestExp) {
-      info(`Linked to experiment: ${latestExp.slug} (${latestExp.status})`);
+// src/metrics.ts
+function compareMetrics(db, experimentId, config) {
+  const before = getMetricsByExperimentAndPhase(db, experimentId, "before");
+  const after = getMetricsByExperimentAndPhase(db, experimentId, "after");
+  const fixtures = new Set([...before, ...after].map((m) => m.fixture));
+  const trackedMetrics = Object.keys(config.metrics.tracked);
+  const comparisons = [];
+  for (const fixture of fixtures) {
+    for (const metric of trackedMetrics) {
+      const b = before.find((m) => m.fixture === fixture && m.metric_name === metric);
+      const a = after.find((m) => m.fixture === fixture && m.metric_name === metric);
+      if (b && a) {
+        const direction = config.metrics.tracked[metric]?.direction ?? "lower_is_better";
+        const regression = isRegression(b.metric_value, a.metric_value, direction);
+        comparisons.push({
+          fixture,
+          metric,
+          before: b.metric_value,
+          after: a.metric_value,
+          delta: a.metric_value - b.metric_value,
+          regression
+        });
+      }
     }
-  } else {
-    const active = getActiveSession(db);
-    if (!active) {
-      throw new Error("No active session to end.");
+  }
+  return comparisons;
+}
+function isRegression(before, after, direction) {
+  switch (direction) {
+    case "lower_is_better":
+      return after > before;
+    case "higher_is_better":
+      return after < before;
+    case "closer_to_gt":
+      return false;
+    default:
+      return false;
+  }
+}
+function parseMetricsOutput(jsonStr) {
+  const data = JSON.parse(jsonStr);
+  const results = [];
+  if (data.fixtures && typeof data.fixtures === "object") {
+    for (const [fixture, metrics] of Object.entries(data.fixtures)) {
+      for (const [metricName, metricValue] of Object.entries(metrics)) {
+        if (typeof metricValue === "number") {
+          results.push({ fixture, metric_name: metricName, metric_value: metricValue });
+        }
+      }
     }
-    const accomplished = getFlagValue(args, "--accomplished") ?? null;
-    const unfinished = getFlagValue(args, "--unfinished") ?? null;
-    const fragility = getFlagValue(args, "--fragility") ?? null;
-    endSession(db, active.id, accomplished, unfinished, fragility);
-    success(`Session ended: "${active.intent}"`);
-    if (accomplished) info(`Accomplished: ${accomplished}`);
-    if (unfinished) info(`Unfinished: ${unfinished}`);
-    if (fragility) warn(`New fragility: ${fragility}`);
   }
+  return results;
 }
-var init_session = __esm({
-  "src/commands/session.ts"() {
+var init_metrics = __esm({
+  "src/metrics.ts"() {
     "use strict";
-    init_connection();
     init_queries();
-    init_config();
-    init_format();
   }
 });
 
-// src/commands/query.ts
-var query_exports = {};
-__export(query_exports, {
-  query: () => query
+// src/commands/measure.ts
+var measure_exports = {};
+__export(measure_exports, {
+  baseline: () => baseline,
+  compare: () => compare,
+  measure: () => measure
 });
-async function query(command, args, isJson) {
+async function baseline(args) {
+  await captureMetrics("before", args);
+}
+async function measure(args) {
+  await captureMetrics("after", args);
+}
+async function captureMetrics(phase, args) {
   const root = findProjectRoot();
   if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
   const db = getDb(root);
-  switch (command) {
-    case "decisions":
-      return queryDecisions(db, args, isJson);
-    case "dead-ends":
-      return queryDeadEnds(db, args, isJson);
-    case "fragility":
-      return queryFragility(root, isJson);
-    case "history":
-      return queryHistory(db, args, isJson);
-    case "circuit-breakers":
-      return queryCircuitBreakers(db, root, isJson);
-    case "check-commit":
-      return checkCommit(db);
-  }
-}
-function queryDecisions(db, args, isJson) {
-  const level = getFlagValue(args, "--level");
+  const config = loadConfig(root);
   const expIdStr = getFlagValue(args, "--experiment");
-  const experimentId = expIdStr !== void 0 ? Number(expIdStr) : void 0;
-  const decisions = listAllDecisions(db, level, experimentId);
-  if (isJson) {
-    console.log(JSON.stringify(decisions, null, 2));
-    return;
+  let exp;
+  if (expIdStr !== void 0) {
+    exp = getExperimentById(db, Number(expIdStr));
+  } else {
+    exp = getLatestExperiment(db);
   }
-  if (decisions.length === 0) {
-    info("No decisions found.");
-    return;
+  if (!exp) throw new Error('No active experiment. Run `majlis new "hypothesis"` first.');
+  if (config.build.pre_measure) {
+    info(`Running pre-measure: ${config.build.pre_measure}`);
+    try {
+      (0, import_node_child_process.execSync)(config.build.pre_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
+    } catch {
+      warn("Pre-measure command failed \u2014 continuing anyway.");
+    }
   }
-  header("Decisions");
-  const rows = decisions.map((d) => [
-    String(d.id),
-    String(d.experiment_id),
-    evidenceColor(d.evidence_level),
-    d.description.slice(0, 60) + (d.description.length > 60 ? "..." : ""),
-    d.status
-  ]);
-  console.log(table(["ID", "Exp", "Level", "Description", "Status"], rows));
-}
-function queryDeadEnds(db, args, isJson) {
-  const subType = getFlagValue(args, "--sub-type");
-  const searchTerm = getFlagValue(args, "--search");
-  let deadEnds;
-  if (subType) {
-    deadEnds = listDeadEndsBySubType(db, subType);
-  } else if (searchTerm) {
-    deadEnds = searchDeadEnds(db, searchTerm);
-  } else {
-    deadEnds = listAllDeadEnds(db);
+  if (!config.metrics.command) {
+    throw new Error("No metrics.command configured in .majlis/config.json");
   }
-  if (isJson) {
-    console.log(JSON.stringify(deadEnds, null, 2));
-    return;
+  info(`Running metrics: ${config.metrics.command}`);
+  let metricsOutput;
+  try {
+    metricsOutput = (0, import_node_child_process.execSync)(config.metrics.command, {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (err) {
+    throw new Error(`Metrics command failed: ${err instanceof Error ? err.message : String(err)}`);
   }
-  if (deadEnds.length === 0) {
-    info("No dead-ends recorded.");
+  const parsed = parseMetricsOutput(metricsOutput);
+  if (parsed.length === 0) {
+    warn("Metrics command returned no data.");
     return;
   }
-  header("Dead-End Registry");
-  const rows = deadEnds.map((d) => [
-    String(d.id),
-    d.sub_type ?? "\u2014",
-    d.approach.slice(0, 40) + (d.approach.length > 40 ? "..." : ""),
-    d.structural_constraint.slice(0, 40) + (d.structural_constraint.length > 40 ? "..." : "")
-  ]);
-  console.log(table(["ID", "Sub-Type", "Approach", "Constraint"], rows));
-}
-function queryFragility(root, isJson) {
-  const fragPath = path5.join(root, "docs", "synthesis", "fragility.md");
-  if (!fs5.existsSync(fragPath)) {
-    info("No fragility map found.");
-    return;
+  for (const m of parsed) {
+    insertMetric(db, exp.id, phase, m.fixture, m.metric_name, m.metric_value);
   }
-  const content = fs5.readFileSync(fragPath, "utf-8");
-  if (isJson) {
-    console.log(JSON.stringify({ content }, null, 2));
-    return;
+  success(`Captured ${parsed.length} metric(s) for ${exp.slug} (phase: ${phase})`);
+  if (config.build.post_measure) {
+    try {
+      (0, import_node_child_process.execSync)(config.build.post_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
+    } catch {
+      warn("Post-measure command failed.");
+    }
   }
-  header("Fragility Map");
-  console.log(content);
 }
-function queryHistory(db, args, isJson) {
-  const fixture = args.filter((a) => !a.startsWith("--"))[0];
-  if (!fixture) {
-    throw new Error("Usage: majlis history <fixture>");
+async function compare(args, isJson) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  const config = loadConfig(root);
+  const expIdStr = getFlagValue(args, "--experiment");
+  let exp;
+  if (expIdStr !== void 0) {
+    exp = getExperimentById(db, Number(expIdStr));
+  } else {
+    exp = getLatestExperiment(db);
   }
-  const history = getMetricHistoryByFixture(db, fixture);
-  if (isJson) {
-    console.log(JSON.stringify(history, null, 2));
+  if (!exp) throw new Error("No active experiment.");
+  const comparisons = compareMetrics(db, exp.id, config);
+  if (comparisons.length === 0) {
+    warn(`No before/after metrics to compare for ${exp.slug}. Run baseline and measure first.`);
     return;
   }
-  if (history.length === 0) {
-    info(`No metric history for fixture: ${fixture}`);
+  if (isJson) {
+    console.log(JSON.stringify({ experiment: exp.slug, comparisons }, null, 2));
     return;
   }
-  header(`Metric History \u2014 ${fixture}`);
-  const rows = history.map((h) => [
-    String(h.experiment_id),
-    h.experiment_slug ?? "\u2014",
-    h.phase,
-    h.metric_name,
-    String(h.metric_value),
-    h.captured_at
+  header(`Metric Comparison \u2014 ${exp.slug}`);
+  const regressions = comparisons.filter((c) => c.regression);
+  const rows = comparisons.map((c) => [
+    c.fixture,
+    c.metric,
+    String(c.before),
+    String(c.after),
+    formatDelta(c.delta),
+    c.regression ? red("REGRESSION") : green("OK")
   ]);
-  console.log(table(["Exp", "Slug", "Phase", "Metric", "Value", "Captured"], rows));
+  console.log(table(["Fixture", "Metric", "Before", "After", "Delta", "Status"], rows));
+  if (regressions.length > 0) {
+    console.log();
+    warn(`${regressions.length} regression(s) detected!`);
+  } else {
+    console.log();
+    success("No regressions detected.");
+  }
 }
-function queryCircuitBreakers(db, root, isJson) {
-  const config = loadConfig(root);
-  const states = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
-  if (isJson) {
-    console.log(JSON.stringify(states, null, 2));
-    return;
+function formatDelta(delta) {
+  const prefix = delta > 0 ? "+" : "";
+  return `${prefix}${delta.toFixed(4)}`;
+}
+var import_node_child_process;
+var init_measure = __esm({
+  "src/commands/measure.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+    init_connection();
+    init_queries();
+    init_metrics();
+    init_config();
+    init_format();
   }
-  if (states.length === 0) {
-    info("No circuit breaker data.");
-    return;
+});
+
+// src/commands/experiment.ts
+var experiment_exports = {};
+__export(experiment_exports, {
+  newExperiment: () => newExperiment,
+  revert: () => revert
+});
+async function newExperiment(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const hypothesis = args.filter((a) => !a.startsWith("--")).join(" ");
+  if (!hypothesis) {
+    throw new Error('Usage: majlis new "hypothesis"');
   }
-  header("Circuit Breakers");
-  const rows = states.map((s) => [
-    s.sub_type,
-    String(s.failure_count),
-    String(config.cycle.circuit_breaker_threshold),
-    s.tripped ? red("TRIPPED") : green("OK")
-  ]);
-  console.log(table(["Sub-Type", "Failures", "Threshold", "Status"], rows));
-}
-function checkCommit(db) {
-  let stdinData = "";
+  const db = getDb(root);
+  const config = loadConfig(root);
+  const slug = getFlagValue(args, "--slug") ?? await generateSlug(hypothesis, root);
+  if (getExperimentBySlug(db, slug)) {
+    throw new Error(`Experiment with slug "${slug}" already exists.`);
+  }
+  const allExps = db.prepare("SELECT COUNT(*) as count FROM experiments").get();
+  const num = allExps.count + 1;
+  const paddedNum = String(num).padStart(3, "0");
+  const branch = `exp/${paddedNum}-${slug}`;
   try {
-    stdinData = fs5.readFileSync(0, "utf-8");
-  } catch {
+    (0, import_node_child_process2.execSync)(`git checkout -b ${branch}`, {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    info(`Created branch: ${branch}`);
+  } catch (err) {
+    warn(`Could not create branch ${branch} \u2014 continuing without git branch.`);
   }
-  if (stdinData) {
+  const subType = getFlagValue(args, "--sub-type") ?? null;
+  const exp = createExperiment(db, slug, branch, hypothesis, subType, null);
+  success(`Created experiment #${exp.id}: ${exp.slug}`);
+  const docsDir = path5.join(root, "docs", "experiments");
+  const templatePath = path5.join(docsDir, "_TEMPLATE.md");
+  if (fs5.existsSync(templatePath)) {
+    const template = fs5.readFileSync(templatePath, "utf-8");
+    const logContent = template.replace(/\{\{title\}\}/g, hypothesis).replace(/\{\{hypothesis\}\}/g, hypothesis).replace(/\{\{branch\}\}/g, branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, subType ?? "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
+    const logPath = path5.join(docsDir, `${paddedNum}-${slug}.md`);
+    fs5.writeFileSync(logPath, logContent);
+    info(`Created experiment log: docs/experiments/${paddedNum}-${slug}.md`);
+  }
+  if (config.cycle.auto_baseline_on_new_experiment && config.metrics.command) {
+    info("Auto-baselining... (run `majlis baseline` to do this manually)");
     try {
-      const hookInput = JSON.parse(stdinData);
-      const command = hookInput?.tool_input?.command ?? "";
-      if (!command.includes("git commit")) {
-        return;
-      }
-    } catch {
+      const { baseline: baseline2 } = await Promise.resolve().then(() => (init_measure(), measure_exports));
+      await baseline2(["--experiment", String(exp.id)]);
+    } catch (err) {
+      warn("Auto-baseline failed \u2014 run `majlis baseline` manually.");
     }
   }
-  const active = listActiveExperiments(db);
-  const unverified = active.filter(
-    (e) => !["merged", "dead_end", "verified", "resolved", "compressed"].includes(e.status)
+}
+async function revert(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  let exp;
+  const slugArg = args.filter((a) => !a.startsWith("--"))[0];
+  if (slugArg) {
+    exp = getExperimentBySlug(db, slugArg);
+    if (!exp) throw new Error(`Experiment not found: ${slugArg}`);
+  } else {
+    exp = getLatestExperiment(db);
+    if (!exp) throw new Error("No active experiments to revert.");
+  }
+  const reason = getFlagValue(args, "--reason") ?? "Manually reverted";
+  const category = args.includes("--structural") ? "structural" : "procedural";
+  insertDeadEnd(
+    db,
+    exp.id,
+    exp.hypothesis ?? exp.slug,
+    reason,
+    `Reverted: ${reason}`,
+    exp.sub_type,
+    category
   );
-  if (unverified.length > 0) {
-    console.error(`[majlis] ${unverified.length} unverified experiment(s):`);
-    for (const e of unverified) {
-      console.error(`  - ${e.slug} (${e.status})`);
+  updateExperimentStatus(db, exp.id, "dead_end");
+  try {
+    const currentBranch = (0, import_node_child_process2.execSync)("git rev-parse --abbrev-ref HEAD", {
+      cwd: root,
+      encoding: "utf-8"
+    }).trim();
+    if (currentBranch === exp.branch) {
+      (0, import_node_child_process2.execSync)("git checkout main 2>/dev/null || git checkout master", {
+        cwd: root,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
     }
-    process.exit(1);
+  } catch {
+    warn("Could not switch git branches \u2014 do this manually.");
   }
+  info(`Experiment ${exp.slug} reverted to dead-end. Reason: ${reason}`);
 }
-var fs5, path5;
-var init_query = __esm({
-  "src/commands/query.ts"() {
+var fs5, path5, import_node_child_process2;
+var init_experiment = __esm({
+  "src/commands/experiment.ts"() {
     "use strict";
     fs5 = __toESM(require("fs"));
     path5 = __toESM(require("path"));
+    import_node_child_process2 = require("child_process");
     init_connection();
     init_queries();
     init_config();
+    init_spawn();
     init_format();
   }
 });
 
-// src/state/types.ts
-var TRANSITIONS, GRADE_ORDER;
-var init_types = __esm({
-  "src/state/types.ts"() {
-    "use strict";
-    TRANSITIONS = {
-      ["classified" /* CLASSIFIED */]: ["reframed" /* REFRAMED */, "gated" /* GATED */],
-      ["reframed" /* REFRAMED */]: ["gated" /* GATED */],
-      ["gated" /* GATED */]: ["building" /* BUILDING */, "gated" /* GATED */],
-      // self-loop for rejected hypotheses
-      ["building" /* BUILDING */]: ["built" /* BUILT */, "building" /* BUILDING */],
-      // self-loop for retry after truncation
-      ["built" /* BUILT */]: ["challenged" /* CHALLENGED */, "doubted" /* DOUBTED */],
-      ["challenged" /* CHALLENGED */]: ["doubted" /* DOUBTED */, "verifying" /* VERIFYING */],
-      ["doubted" /* DOUBTED */]: ["challenged" /* CHALLENGED */, "scouted" /* SCOUTED */, "verifying" /* VERIFYING */],
-      ["scouted" /* SCOUTED */]: ["verifying" /* VERIFYING */],
-      ["verifying" /* VERIFYING */]: ["verified" /* VERIFIED */],
-      ["verified" /* VERIFIED */]: ["resolved" /* RESOLVED */],
-      ["resolved" /* RESOLVED */]: ["compressed" /* COMPRESSED */, "building" /* BUILDING */],
-      // cycle-back skips gate
-      ["compressed" /* COMPRESSED */]: ["merged" /* MERGED */, "building" /* BUILDING */],
-      // cycle-back skips gate
-      ["merged" /* MERGED */]: [],
-      ["dead_end" /* DEAD_END */]: []
-    };
-    GRADE_ORDER = ["rejected", "weak", "good", "sound"];
-  }
+// src/commands/session.ts
+var session_exports = {};
+__export(session_exports, {
+  session: () => session
 });
-
-// src/state/machine.ts
-function transition(current, target) {
-  const valid = TRANSITIONS[current];
-  if (!valid.includes(target)) {
-    throw new Error(
-      `Invalid transition: ${current} \u2192 ${target}. Valid: [${valid.join(", ")}]`
-    );
-  }
-  return target;
-}
-function validNext(current) {
-  return TRANSITIONS[current];
-}
-function isTerminal(status2) {
-  return TRANSITIONS[status2].length === 0;
-}
-function determineNextStep(exp, valid, hasDoubts2, hasChallenges2) {
-  if (valid.length === 0) {
-    throw new Error(`Experiment ${exp.slug} is terminal (${exp.status})`);
-  }
-  const status2 = exp.status;
-  if (status2 === "classified" /* CLASSIFIED */ || status2 === "reframed" /* REFRAMED */) {
-    return valid.includes("gated" /* GATED */) ? "gated" /* GATED */ : valid[0];
-  }
-  if (status2 === "gated" /* GATED */) {
-    return valid.includes("building" /* BUILDING */) ? "building" /* BUILDING */ : valid[0];
-  }
-  if (status2 === "built" /* BUILT */ && !hasDoubts2) {
-    return valid.includes("doubted" /* DOUBTED */) ? "doubted" /* DOUBTED */ : valid[0];
-  }
-  if (status2 === "doubted" /* DOUBTED */ && !hasChallenges2) {
-    return valid.includes("challenged" /* CHALLENGED */) ? "challenged" /* CHALLENGED */ : valid[0];
+async function session(args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand !== "start" && subcommand !== "end") {
+    throw new Error('Usage: majlis session start "intent" | majlis session end');
   }
-  if (status2 === "doubted" /* DOUBTED */ || status2 === "challenged" /* CHALLENGED */) {
-    if (valid.includes("verifying" /* VERIFYING */)) {
-      return "verifying" /* VERIFYING */;
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  if (subcommand === "start") {
+    const intent = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+    if (!intent) {
+      throw new Error('Usage: majlis session start "intent"');
+    }
+    const existing = getActiveSession(db);
+    if (existing) {
+      warn(`Session already active: "${existing.intent}" (started ${existing.started_at})`);
+      warn("End it first with `majlis session end`.");
+      return;
     }
+    const latestExp = getLatestExperiment(db);
+    const sess = startSession(db, intent, latestExp?.id ?? null);
+    success(`Session started: "${intent}" (id: ${sess.id})`);
+    if (latestExp) {
+      info(`Linked to experiment: ${latestExp.slug} (${latestExp.status})`);
+    }
+  } else {
+    const active = getActiveSession(db);
+    if (!active) {
+      throw new Error("No active session to end.");
+    }
+    const accomplished = getFlagValue(args, "--accomplished") ?? null;
+    const unfinished = getFlagValue(args, "--unfinished") ?? null;
+    const fragility = getFlagValue(args, "--fragility") ?? null;
+    endSession(db, active.id, accomplished, unfinished, fragility);
+    success(`Session ended: "${active.intent}"`);
+    if (accomplished) info(`Accomplished: ${accomplished}`);
+    if (unfinished) info(`Unfinished: ${unfinished}`);
+    if (fragility) warn(`New fragility: ${fragility}`);
   }
-  return valid[0];
 }
-var init_machine = __esm({
-  "src/state/machine.ts"() {
+var init_session = __esm({
+  "src/commands/session.ts"() {
     "use strict";
-    init_types();
+    init_connection();
+    init_queries();
+    init_config();
+    init_format();
   }
 });
 
-// src/agents/types.ts
-function getExtractionSchema(role) {
-  switch (role) {
-    case "builder":
-      return '{"decisions": [{"description": "string", "evidence_level": "proof|test|strong_consensus|consensus|analogy|judgment", "justification": "string"}]}';
-    case "critic":
-      return '{"doubts": [{"claim_doubted": "string", "evidence_level_of_claim": "string", "evidence_for_doubt": "string", "severity": "minor|moderate|critical"}]}';
-    case "adversary":
-      return '{"challenges": [{"description": "string", "reasoning": "string"}]}';
-    case "verifier":
-      return '{"grades": [{"component": "string", "grade": "sound|good|weak|rejected", "provenance_intact": true, "content_correct": true, "notes": "string"}], "doubt_resolutions": [{"doubt_id": 0, "resolution": "confirmed|dismissed|inconclusive"}]}';
-    case "gatekeeper":
-      return '{"gate_decision": "approve|reject|flag", "reason": "string", "stale_references": ["string"], "overlapping_dead_ends": [0]}';
-    case "reframer":
-      return '{"reframe": {"decomposition": "string", "divergences": ["string"], "recommendation": "string"}}';
-    case "scout":
-      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"]}}';
-    default:
-      return EXTRACTION_SCHEMA;
+// src/commands/query.ts
+var query_exports = {};
+__export(query_exports, {
+  query: () => query3
+});
+async function query3(command, args, isJson) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  switch (command) {
+    case "decisions":
+      return queryDecisions(db, args, isJson);
+    case "dead-ends":
+      return queryDeadEnds(db, args, isJson);
+    case "fragility":
+      return queryFragility(root, isJson);
+    case "history":
+      return queryHistory(db, args, isJson);
+    case "circuit-breakers":
+      return queryCircuitBreakers(db, root, isJson);
+    case "check-commit":
+      return checkCommit(db);
   }
 }
-var EXTRACTION_SCHEMA, ROLE_REQUIRED_FIELDS;
-var init_types2 = __esm({
-  "src/agents/types.ts"() {
-    "use strict";
-    EXTRACTION_SCHEMA = `{
-  "decisions": [{ "description": "string", "evidence_level": "proof|test|strong_consensus|consensus|analogy|judgment", "justification": "string" }],
-  "grades": [{ "component": "string", "grade": "sound|good|weak|rejected", "provenance_intact": true, "content_correct": true, "notes": "string" }],
-  "doubts": [{ "claim_doubted": "string", "evidence_level_of_claim": "string", "evidence_for_doubt": "string", "severity": "minor|moderate|critical" }],
-  "guidance": "string (actionable builder guidance)",
-  "doubt_resolutions": [{ "doubt_id": 0, "resolution": "confirmed|dismissed|inconclusive" }]
-}`;
-    ROLE_REQUIRED_FIELDS = {
-      builder: ["decisions"],
-      critic: ["doubts"],
-      adversary: ["challenges"],
-      verifier: ["grades"],
-      gatekeeper: ["gate_decision"],
-      reframer: ["reframe"],
-      scout: ["findings"],
-      compressor: ["compression_report"]
-    };
+function queryDecisions(db, args, isJson) {
+  const level = getFlagValue(args, "--level");
+  const expIdStr = getFlagValue(args, "--experiment");
+  const experimentId = expIdStr !== void 0 ? Number(expIdStr) : void 0;
+  const decisions = listAllDecisions(db, level, experimentId);
+  if (isJson) {
+    console.log(JSON.stringify(decisions, null, 2));
+    return;
   }
-});
-
-// src/agents/parse.ts
-async function extractStructuredData(role, markdown) {
-  const tier1 = extractMajlisJsonBlock(markdown);
-  if (tier1) {
-    const parsed = tryParseJson(tier1);
-    if (parsed) return parsed;
-    console.warn(`[majlis] Malformed JSON in <!-- majlis-json --> block for ${role}. Falling back.`);
+  if (decisions.length === 0) {
+    info("No decisions found.");
+    return;
+  }
+  header("Decisions");
+  const rows = decisions.map((d) => [
+    String(d.id),
+    String(d.experiment_id),
+    evidenceColor(d.evidence_level),
+    d.description.slice(0, 60) + (d.description.length > 60 ? "..." : ""),
+    d.status
+  ]);
+  console.log(table(["ID", "Exp", "Level", "Description", "Status"], rows));
+}
+function queryDeadEnds(db, args, isJson) {
+  const subType = getFlagValue(args, "--sub-type");
+  const searchTerm = getFlagValue(args, "--search");
+  let deadEnds;
+  if (subType) {
+    deadEnds = listDeadEndsBySubType(db, subType);
+  } else if (searchTerm) {
+    deadEnds = searchDeadEnds(db, searchTerm);
   } else {
-    console.warn(`[majlis] No <!-- majlis-json --> block found in ${role} output. Falling back.`);
+    deadEnds = listAllDeadEnds(db);
   }
-  const tier2 = extractViaPatterns(role, markdown);
-  if (tier2 && hasData(tier2)) {
-    console.warn(`[majlis] Used regex fallback for ${role}. Review extracted data.`);
-    return tier2;
+  if (isJson) {
+    console.log(JSON.stringify(deadEnds, null, 2));
+    return;
   }
-  console.warn(`[majlis] Regex fallback insufficient for ${role}. Using Haiku extraction.`);
-  const tier3 = await extractViaHaiku(role, markdown);
-  if (tier3) return tier3;
-  console.error(
-    `[majlis] FAILED to extract structured data from ${role} output. State machine will continue but data is missing. Manual review required.`
-  );
-  return null;
-}
-function extractMajlisJsonBlock(markdown) {
-  const match = markdown.match(/<!--\s*majlis-json\s*\n([\s\S]*?)-->/);
-  if (!match) return null;
-  return match[1].trim();
+  if (deadEnds.length === 0) {
+    info("No dead-ends recorded.");
+    return;
+  }
+  header("Dead-End Registry");
+  const rows = deadEnds.map((d) => [
+    String(d.id),
+    d.sub_type ?? "\u2014",
+    d.approach.slice(0, 40) + (d.approach.length > 40 ? "..." : ""),
+    d.structural_constraint.slice(0, 40) + (d.structural_constraint.length > 40 ? "..." : "")
+  ]);
+  console.log(table(["ID", "Sub-Type", "Approach", "Constraint"], rows));
 }
-function tryParseJson(jsonStr) {
-  try {
-    return JSON.parse(jsonStr);
-  } catch {
-    return null;
+function queryFragility(root, isJson) {
+  const fragPath = path6.join(root, "docs", "synthesis", "fragility.md");
+  if (!fs6.existsSync(fragPath)) {
+    info("No fragility map found.");
+    return;
+  }
+  const content = fs6.readFileSync(fragPath, "utf-8");
+  if (isJson) {
+    console.log(JSON.stringify({ content }, null, 2));
+    return;
   }
+  header("Fragility Map");
+  console.log(content);
 }
-function extractViaPatterns(role, markdown) {
-  const result = {};
-  const decisionPattern = /\[(?:decision|Decision)\].*?(?:description|Description):\s*(.+?)(?:\n|$).*?(?:evidence.?level|Evidence.?Level|level):\s*(proof|test|strong_consensus|consensus|analogy|judgment).*?(?:justification|Justification):\s*(.+?)(?:\n|$)/gis;
-  const decisions = [];
-  const evidenceMarkers = /(?:^|\n)\s*[-*]\s*\*?\*?(?:Decision|DECISION)\*?\*?:\s*(.+?)(?:\n|$).*?(?:Evidence|EVIDENCE|Level):\s*(proof|test|strong_consensus|consensus|analogy|judgment)/gim;
-  let match;
-  while ((match = evidenceMarkers.exec(markdown)) !== null) {
-    decisions.push({
-      description: match[1].trim(),
-      evidence_level: match[2].toLowerCase().trim(),
-      justification: "Extracted via regex \u2014 review"
-    });
+function queryHistory(db, args, isJson) {
+  const fixture = args.filter((a) => !a.startsWith("--"))[0];
+  if (!fixture) {
+    throw new Error("Usage: majlis history <fixture>");
   }
-  const inlineTagPattern = /\[(proof|test|strong_consensus|consensus|analogy|judgment)\]\s*(.+?)(?:\n|$)/gi;
-  while ((match = inlineTagPattern.exec(markdown)) !== null) {
-    const desc = match[2].trim();
-    if (!decisions.some((d) => d.description === desc)) {
-      decisions.push({
-        description: desc,
-        evidence_level: match[1].toLowerCase(),
-        justification: "Extracted via regex \u2014 review"
-      });
-    }
+  const history = getMetricHistoryByFixture(db, fixture);
+  if (isJson) {
+    console.log(JSON.stringify(history, null, 2));
+    return;
   }
-  if (decisions.length > 0) result.decisions = decisions;
-  const grades = [];
-  const gradePattern = /(?:^|\n)\s*[-*]?\s*\*?\*?(?:Grade|GRADE|Component)\*?\*?.*?(?:component|Component)?\s*[:=]\s*(.+?)(?:\n|,).*?(?:grade|Grade)\s*[:=]\s*(sound|good|weak|rejected)/gim;
-  while ((match = gradePattern.exec(markdown)) !== null) {
-    grades.push({
-      component: match[1].trim(),
-      grade: match[2].toLowerCase().trim()
-    });
+  if (history.length === 0) {
+    info(`No metric history for fixture: ${fixture}`);
+    return;
   }
-  const simpleGradePattern = /(?:^|\n)\s*[-*]\s*\*?\*?(.+?)\*?\*?\s*[:—–-]\s*\*?\*?(sound|good|weak|rejected)\*?\*?/gim;
-  while ((match = simpleGradePattern.exec(markdown)) !== null) {
-    const comp = match[1].trim();
-    if (!grades.some((g) => g.component === comp)) {
-      grades.push({
-        component: comp,
-        grade: match[2].toLowerCase().trim()
-      });
-    }
+  header(`Metric History \u2014 ${fixture}`);
+  const rows = history.map((h) => [
+    String(h.experiment_id),
+    h.experiment_slug ?? "\u2014",
+    h.phase,
+    h.metric_name,
+    String(h.metric_value),
+    h.captured_at
+  ]);
+  console.log(table(["Exp", "Slug", "Phase", "Metric", "Value", "Captured"], rows));
+}
+function queryCircuitBreakers(db, root, isJson) {
+  const config = loadConfig(root);
+  const states = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
+  if (isJson) {
+    console.log(JSON.stringify(states, null, 2));
+    return;
   }
-  if (grades.length > 0) result.grades = grades;
-  const doubts = [];
-  const doubtPattern = /(?:Doubt|DOUBT|Claim doubted|CLAIM)\s*(?:\d+)?[:.]?\s*(.+?)(?:\n|$)[\s\S]*?(?:Severity|SEVERITY)\s*[:=]\s*(minor|moderate|critical)/gim;
-  while ((match = doubtPattern.exec(markdown)) !== null) {
-    doubts.push({
-      claim_doubted: match[1].trim(),
-      evidence_level_of_claim: "unknown",
-      // Don't fabricate — mark as unknown for review
-      evidence_for_doubt: "Extracted via regex \u2014 review original document",
-      severity: match[2].toLowerCase().trim()
-    });
+  if (states.length === 0) {
+    info("No circuit breaker data.");
+    return;
   }
-  if (doubts.length > 0) result.doubts = doubts;
-  return result;
+  header("Circuit Breakers");
+  const rows = states.map((s) => [
+    s.sub_type,
+    String(s.failure_count),
+    String(config.cycle.circuit_breaker_threshold),
+    s.tripped ? red("TRIPPED") : green("OK")
+  ]);
+  console.log(table(["Sub-Type", "Failures", "Threshold", "Status"], rows));
 }
-async function extractViaHaiku(role, markdown) {
+function checkCommit(db) {
+  let stdinData = "";
   try {
-    const truncated = markdown.length > 8e3 ? markdown.slice(0, 8e3) + "\n[truncated]" : markdown;
-    const schema = getExtractionSchema(role);
-    const prompt = `Extract structured data from this ${role} document as JSON. Follow this schema exactly: ${schema}
-
-Document:
-${truncated}`;
-    const conversation = (0, import_claude_agent_sdk.query)({
-      prompt,
-      options: {
-        model: "haiku",
-        tools: [],
-        systemPrompt: "You are a JSON extraction assistant. Output only valid JSON matching the requested schema. No markdown, no explanation, just JSON.",
-        permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true,
-        maxTurns: 1,
-        persistSession: false
-      }
-    });
-    let resultText = "";
-    for await (const message of conversation) {
-      if (message.type === "assistant") {
-        for (const block of message.message.content) {
-          if (block.type === "text") {
-            resultText += block.text;
-          }
-        }
+    stdinData = fs6.readFileSync(0, "utf-8");
+  } catch {
+  }
+  if (stdinData) {
+    try {
+      const hookInput = JSON.parse(stdinData);
+      const command = hookInput?.tool_input?.command ?? "";
+      if (!command.includes("git commit")) {
+        return;
       }
+    } catch {
     }
-    return tryParseJson(resultText.trim());
-  } catch (err) {
-    console.warn(`[majlis] Haiku extraction failed for ${role}: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
+  }
+  const active = listActiveExperiments(db);
+  const unverified = active.filter(
+    (e) => !["merged", "dead_end", "verified", "resolved", "compressed"].includes(e.status)
+  );
+  if (unverified.length > 0) {
+    console.error(`[majlis] ${unverified.length} unverified experiment(s):`);
+    for (const e of unverified) {
+      console.error(`  - ${e.slug} (${e.status})`);
+    }
+    process.exit(1);
   }
 }
-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);
-}
-function validateForRole(role, output) {
-  const required = ROLE_REQUIRED_FIELDS[role];
-  if (!required) return { valid: true, missing: [] };
-  const missing = required.filter((field) => {
-    const value = output[field];
-    if (value === void 0 || value === null) return true;
-    if (Array.isArray(value) && value.length === 0) return true;
-    return false;
-  });
-  return { valid: missing.length === 0, missing };
-}
-var import_claude_agent_sdk;
-var init_parse = __esm({
-  "src/agents/parse.ts"() {
+var fs6, path6;
+var init_query = __esm({
+  "src/commands/query.ts"() {
+    "use strict";
+    fs6 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
+    init_connection();
+    init_queries();
+    init_config();
+    init_format();
+  }
+});
+
+// src/state/types.ts
+var TRANSITIONS, GRADE_ORDER;
+var init_types2 = __esm({
+  "src/state/types.ts"() {
     "use strict";
-    init_types2();
-    import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
+    TRANSITIONS = {
+      ["classified" /* CLASSIFIED */]: ["reframed" /* REFRAMED */, "gated" /* GATED */],
+      ["reframed" /* REFRAMED */]: ["gated" /* GATED */],
+      ["gated" /* GATED */]: ["building" /* BUILDING */, "gated" /* GATED */],
+      // self-loop for rejected hypotheses
+      ["building" /* BUILDING */]: ["built" /* BUILT */, "building" /* BUILDING */],
+      // self-loop for retry after truncation
+      ["built" /* BUILT */]: ["challenged" /* CHALLENGED */, "doubted" /* DOUBTED */],
+      ["challenged" /* CHALLENGED */]: ["doubted" /* DOUBTED */, "verifying" /* VERIFYING */],
+      ["doubted" /* DOUBTED */]: ["challenged" /* CHALLENGED */, "scouted" /* SCOUTED */, "verifying" /* VERIFYING */],
+      ["scouted" /* SCOUTED */]: ["verifying" /* VERIFYING */],
+      ["verifying" /* VERIFYING */]: ["verified" /* VERIFIED */],
+      ["verified" /* VERIFIED */]: ["resolved" /* RESOLVED */],
+      ["resolved" /* RESOLVED */]: ["compressed" /* COMPRESSED */, "building" /* BUILDING */],
+      // cycle-back skips gate
+      ["compressed" /* COMPRESSED */]: ["merged" /* MERGED */, "building" /* BUILDING */],
+      // cycle-back skips gate
+      ["merged" /* MERGED */]: [],
+      ["dead_end" /* DEAD_END */]: []
+    };
+    GRADE_ORDER = ["rejected", "weak", "good", "sound"];
   }
 });
 
-// src/agents/spawn.ts
-function loadAgentDefinition(role, projectRoot) {
-  const root = projectRoot ?? findProjectRoot() ?? process.cwd();
-  const filePath = path6.join(root, ".majlis", "agents", `${role}.md`);
-  if (!fs6.existsSync(filePath)) {
-    throw new Error(`Agent definition not found: ${filePath}`);
-  }
-  const content = fs6.readFileSync(filePath, "utf-8");
-  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!frontmatterMatch) {
-    throw new Error(`Invalid agent definition (missing YAML frontmatter): ${filePath}`);
+// src/state/machine.ts
+function transition(current, target) {
+  const valid = TRANSITIONS[current];
+  if (!valid.includes(target)) {
+    throw new Error(
+      `Invalid transition: ${current} \u2192 ${target}. Valid: [${valid.join(", ")}]`
+    );
   }
-  const frontmatter = frontmatterMatch[1];
-  const body = frontmatterMatch[2].trim();
-  const name = extractYamlField(frontmatter, "name") ?? role;
-  const model = extractYamlField(frontmatter, "model") ?? "opus";
-  const toolsStr = extractYamlField(frontmatter, "tools") ?? "[]";
-  const tools = toolsStr.replace(/[\[\]]/g, "").split(",").map((t) => t.trim()).filter(Boolean);
-  return { name, model, tools, systemPrompt: body };
+  return target;
 }
-function extractYamlField(yaml, field) {
-  const match = yaml.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
-  return match ? match[1].trim() : null;
+function validNext(current) {
+  return TRANSITIONS[current];
 }
-async function spawnAgent(role, context, projectRoot) {
-  const agentDef = loadAgentDefinition(role, projectRoot);
-  const root = projectRoot ?? findProjectRoot() ?? process.cwd();
-  const taskPrompt = context.taskPrompt ?? `Perform your role as ${agentDef.name}.`;
-  const contextJson = JSON.stringify(context);
-  const prompt = `Here is your context:
-
-\`\`\`json
-${contextJson}
-\`\`\`
-
-${taskPrompt}`;
-  const turns = ROLE_MAX_TURNS[role] ?? 15;
-  console.log(`[${role}] Spawning (model: ${agentDef.model}, maxTurns: ${turns})...`);
-  const { text: markdown, costUsd, truncated } = await runQuery({
-    prompt,
-    model: agentDef.model,
-    tools: agentDef.tools,
-    systemPrompt: agentDef.systemPrompt,
-    cwd: root,
-    maxTurns: turns,
-    label: role
-  });
-  console.log(`[${role}] Complete (cost: $${costUsd.toFixed(4)}${truncated ? ", TRUNCATED" : ""})`);
-  const artifactPath = writeArtifact(role, context, markdown, root);
-  if (artifactPath) {
-    console.log(`[${role}] Artifact written to ${artifactPath}`);
+function isTerminal(status2) {
+  return TRANSITIONS[status2].length === 0;
+}
+function determineNextStep(exp, valid, hasDoubts2, hasChallenges2) {
+  if (valid.length === 0) {
+    throw new Error(`Experiment ${exp.slug} is terminal (${exp.status})`);
   }
-  const structured = await extractStructuredData(role, markdown);
-  if (structured) {
-    const { valid, missing } = validateForRole(role, structured);
-    if (!valid) {
-      console.warn(`[${role}] Output missing expected fields: ${missing.join(", ")}`);
-    }
+  const status2 = exp.status;
+  if (status2 === "classified" /* CLASSIFIED */ || status2 === "reframed" /* REFRAMED */) {
+    return valid.includes("gated" /* GATED */) ? "gated" /* GATED */ : valid[0];
   }
-  return { output: markdown, structured, truncated };
-}
-async function spawnSynthesiser(context, projectRoot) {
-  const root = projectRoot ?? findProjectRoot() ?? process.cwd();
-  const contextJson = JSON.stringify(context);
-  const taskPrompt = context.taskPrompt ?? "Synthesise the findings into actionable builder guidance.";
-  const prompt = `Here is your context:
-
-\`\`\`json
-${contextJson}
-\`\`\`
-
-${taskPrompt}`;
-  const systemPrompt = 'You are a Synthesis Agent. Be concrete: which decisions failed, which assumptions broke, what constraints must the next approach satisfy. CRITICAL: Your LAST line of output MUST be a <!-- majlis-json --> block. The framework parses this programmatically \u2014 if you omit it, the pipeline breaks. Format: <!-- majlis-json {"guidance": "your guidance here"} -->';
-  console.log(`[synthesiser] Spawning (maxTurns: 5)...`);
-  const { text: markdown, costUsd, truncated } = await runQuery({
-    prompt,
-    model: "sonnet",
-    tools: ["Read", "Glob", "Grep"],
-    systemPrompt,
-    cwd: root,
-    maxTurns: 5,
-    label: "synthesiser"
-  });
-  console.log(`[synthesiser] Complete (cost: $${costUsd.toFixed(4)})`);
-  return { output: markdown, structured: { guidance: markdown }, truncated };
-}
-async function spawnRecovery(role, partialOutput, context, projectRoot) {
-  const root = projectRoot ?? findProjectRoot() ?? process.cwd();
-  const expSlug = context.experiment?.slug ?? "unknown";
-  console.log(`[recovery] Cleaning up after truncated ${role} for ${expSlug}...`);
-  const expDocPath = path6.join(
-    root,
-    "docs",
-    "experiments",
-    `${String(context.experiment?.id ?? 0).padStart(3, "0")}-${expSlug}.md`
-  );
-  const templatePath = path6.join(root, "docs", "experiments", "_TEMPLATE.md");
-  const template = fs6.existsSync(templatePath) ? fs6.readFileSync(templatePath, "utf-8") : "";
-  const currentDoc = fs6.existsSync(expDocPath) ? fs6.readFileSync(expDocPath, "utf-8") : "";
-  const prompt = `The ${role} agent was truncated (hit max turns) while working on experiment "${expSlug}".
-
-Here is the partial agent output (reasoning + tool calls):
-<partial_output>
-${partialOutput.slice(-3e3)}
-</partial_output>
-
-Here is the current experiment doc:
-<current_doc>
-${currentDoc}
-</current_doc>
-
-Here is the template that the experiment doc should follow:
-<template>
-${template}
-</template>
-
-Your job: Write a CLEAN experiment doc to ${expDocPath} using the Write tool.
-- Keep any valid content from the current doc
-- Fill in what you can infer from the partial output
-- Mark incomplete sections with "[TRUNCATED \u2014 ${role} did not finish]"
-- The doc MUST have the <!-- majlis-json --> block, even if decisions are empty
-- Do NOT include agent reasoning or thinking \u2014 only structured experiment content
-- Be concise. This is cleanup, not new work.`;
-  const { text: _markdown } = await runQuery({
-    prompt,
-    model: "haiku",
-    tools: ["Read", "Write"],
-    systemPrompt: `You are a Recovery Agent. You clean up experiment docs after truncated agent runs. Write clean, structured docs. Never include agent reasoning or monologue.`,
-    cwd: root,
-    maxTurns: 5,
-    label: "recovery"
-  });
-  console.log(`[recovery] Cleanup complete for ${expSlug}.`);
-}
-async function runQuery(opts) {
-  let truncated = false;
-  const tag = opts.label ?? "majlis";
-  const conversation = (0, import_claude_agent_sdk2.query)({
-    prompt: opts.prompt,
-    options: {
-      model: opts.model,
-      tools: opts.tools,
-      systemPrompt: {
-        type: "preset",
-        preset: "claude_code",
-        append: opts.systemPrompt
-      },
-      cwd: opts.cwd,
-      permissionMode: "bypassPermissions",
-      allowDangerouslySkipPermissions: true,
-      maxTurns: opts.maxTurns ?? 15,
-      persistSession: false,
-      settingSources: ["project"]
-    }
-  });
-  const textParts = [];
-  let costUsd = 0;
-  let turnCount = 0;
-  for await (const message of conversation) {
-    if (message.type === "assistant") {
-      turnCount++;
-      let hasText = false;
-      for (const block of message.message.content) {
-        if (block.type === "text") {
-          textParts.push(block.text);
-          hasText = true;
-        } else if (block.type === "tool_use") {
-          const toolName = block.name ?? "tool";
-          const input = block.input ?? {};
-          const detail = formatToolDetail(toolName, input);
-          process.stderr.write(`${DIM2}[${tag}]   ${CYAN2}${toolName}${RESET2}${DIM2}${detail}${RESET2}
-`);
-        }
-      }
-      if (hasText) {
-        const preview = textParts[textParts.length - 1].slice(0, 120).replace(/\n/g, " ").trim();
-        if (preview) {
-          process.stderr.write(`${DIM2}[${tag}]   writing: ${preview}${preview.length >= 120 ? "..." : ""}${RESET2}
-`);
-        }
-      }
-    } else if (message.type === "tool_progress") {
-      const elapsed = Math.round(message.elapsed_time_seconds);
-      if (elapsed > 0 && elapsed % 5 === 0) {
-        process.stderr.write(`${DIM2}[${tag}]   ${message.tool_name} running (${elapsed}s)...${RESET2}
-`);
-      }
-    } else if (message.type === "result") {
-      if (message.subtype === "success") {
-        costUsd = message.total_cost_usd;
-      } else if (message.subtype === "error_max_turns") {
-        truncated = true;
-        costUsd = "total_cost_usd" in message ? message.total_cost_usd : 0;
-        console.warn(`[${tag}] Hit max turns (${turnCount}). Returning partial output.`);
-      } else {
-        const errors = "errors" in message ? message.errors?.join("; ") ?? "Unknown error" : "Unknown error";
-        throw new Error(`Agent query failed (${message.subtype}): ${errors}`);
-      }
-    }
+  if (status2 === "gated" /* GATED */) {
+    return valid.includes("building" /* BUILDING */) ? "building" /* BUILDING */ : valid[0];
   }
-  return { text: textParts.join("\n\n"), costUsd, truncated };
-}
-function formatToolDetail(toolName, input) {
-  switch (toolName) {
-    case "Read":
-      return input.file_path ? ` ${input.file_path}` : "";
-    case "Write":
-      return input.file_path ? ` \u2192 ${input.file_path}` : "";
-    case "Edit":
-      return input.file_path ? ` ${input.file_path}` : "";
-    case "Glob":
-      return input.pattern ? ` ${input.pattern}` : "";
-    case "Grep":
-      return input.pattern ? ` /${input.pattern}/` : "";
-    case "Bash":
-      return input.command ? ` $ ${input.command.slice(0, 80)}` : "";
-    case "WebSearch":
-      return input.query ? ` "${input.query}"` : "";
-    default:
-      return "";
+  if (status2 === "built" /* BUILT */ && !hasDoubts2) {
+    return valid.includes("doubted" /* DOUBTED */) ? "doubted" /* DOUBTED */ : valid[0];
+  }
+  if (status2 === "doubted" /* DOUBTED */ && !hasChallenges2) {
+    return valid.includes("challenged" /* CHALLENGED */) ? "challenged" /* CHALLENGED */ : valid[0];
+  }
+  if (status2 === "doubted" /* DOUBTED */ || status2 === "challenged" /* CHALLENGED */) {
+    if (valid.includes("verifying" /* VERIFYING */)) {
+      return "verifying" /* VERIFYING */;
+    }
   }
-}
-function writeArtifact(role, context, markdown, projectRoot) {
-  const dirMap = {
-    builder: "docs/experiments",
-    critic: "docs/doubts",
-    adversary: "docs/challenges",
-    verifier: "docs/verification",
-    reframer: "docs/reframes",
-    compressor: "docs/synthesis",
-    scout: "docs/rihla"
-  };
-  const dir = dirMap[role];
-  if (!dir) return null;
-  if (role === "builder" || role === "compressor") return null;
-  const fullDir = path6.join(projectRoot, dir);
-  if (!fs6.existsSync(fullDir)) {
-    fs6.mkdirSync(fullDir, { recursive: true });
+  if (status2 === "compressed" /* COMPRESSED */) {
+    return valid.includes("merged" /* MERGED */) ? "merged" /* MERGED */ : valid[0];
   }
-  const expSlug = context.experiment?.slug ?? "general";
-  const nextNum = String(context.experiment?.id ?? 1).padStart(3, "0");
-  const filename = `${nextNum}-${role}-${expSlug}.md`;
-  const target = path6.join(fullDir, filename);
-  fs6.writeFileSync(target, markdown);
-  return target;
+  return valid[0];
 }
-var fs6, path6, import_claude_agent_sdk2, ROLE_MAX_TURNS, DIM2, RESET2, CYAN2;
-var init_spawn = __esm({
-  "src/agents/spawn.ts"() {
+var init_machine = __esm({
+  "src/state/machine.ts"() {
     "use strict";
-    fs6 = __toESM(require("fs"));
-    path6 = __toESM(require("path"));
-    import_claude_agent_sdk2 = require("@anthropic-ai/claude-agent-sdk");
-    init_parse();
-    init_connection();
-    ROLE_MAX_TURNS = {
-      builder: 50,
-      critic: 30,
-      adversary: 30,
-      verifier: 50,
-      compressor: 30,
-      reframer: 20,
-      scout: 20,
-      gatekeeper: 10
-    };
-    DIM2 = "\x1B[2m";
-    RESET2 = "\x1B[0m";
-    CYAN2 = "\x1B[36m";
+    init_types2();
   }
 });
 
@@ -2966,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}"`, {
@@ -3016,7 +3483,7 @@ var init_resolve = __esm({
     "use strict";
     fs7 = __toESM(require("fs"));
     path7 = __toESM(require("path"));
-    init_types();
+    init_types2();
     init_queries();
     init_spawn();
     import_node_child_process3 = require("child_process");
@@ -3028,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();
@@ -3059,7 +3528,28 @@ async function resolveCmd(args) {
   const exp = resolveExperimentArg(db, args);
   transition(exp.status, "resolved" /* RESOLVED */);
   await resolve(db, exp, root);
-  updateExperimentStatus(db, exp.id, "resolved");
+}
+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 */);
@@ -3494,470 +3984,1155 @@ function ingestStructuredOutput(db, experimentId, structured) {
     for (const f of structured.findings) {
       insertFinding(db, experimentId, f.approach, f.source, f.relevance, f.contradicts_current);
     }
-    info(`Ingested ${structured.findings.length} finding(s)`);
+    info(`Ingested ${structured.findings.length} finding(s)`);
+  }
+}
+var fs8, path8, import_node_child_process4;
+var init_cycle = __esm({
+  "src/commands/cycle.ts"() {
+    "use strict";
+    fs8 = __toESM(require("fs"));
+    path8 = __toESM(require("path"));
+    import_node_child_process4 = require("child_process");
+    init_connection();
+    init_queries();
+    init_machine();
+    init_types2();
+    init_spawn();
+    init_resolve();
+    init_config();
+    init_metrics();
+    init_format();
+  }
+});
+
+// src/commands/classify.ts
+var classify_exports = {};
+__export(classify_exports, {
+  classify: () => classify,
+  reframe: () => reframe
+});
+async function classify(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const domain = args.filter((a) => !a.startsWith("--")).join(" ");
+  if (!domain) {
+    throw new Error('Usage: majlis classify "domain description"');
+  }
+  const synthesisPath = path9.join(root, "docs", "synthesis", "current.md");
+  const synthesis = fs9.existsSync(synthesisPath) ? fs9.readFileSync(synthesisPath, "utf-8") : "";
+  const deadEndsPath = path9.join(root, "docs", "synthesis", "dead-ends.md");
+  const deadEnds = fs9.existsSync(deadEndsPath) ? fs9.readFileSync(deadEndsPath, "utf-8") : "";
+  info(`Classifying problem domain: ${domain}`);
+  const result = await spawnAgent("builder", {
+    synthesis,
+    taskPrompt: `Classify the following problem domain into canonical sub-types (Al-Khwarizmi method). For each sub-type: describe it, identify its canonical form, and list known constraints.
+
+Domain: ${domain}
+
+Dead-ends for context:
+${deadEnds}
+
+Write the classification to docs/classification/ following the template.`
+  }, root);
+  success("Classification complete. Check docs/classification/ for the output.");
+}
+async function reframe(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const classificationDir = path9.join(root, "docs", "classification");
+  let classificationContent = "";
+  if (fs9.existsSync(classificationDir)) {
+    const files = fs9.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+    for (const f of files) {
+      classificationContent += fs9.readFileSync(path9.join(classificationDir, f), "utf-8") + "\n\n";
+    }
+  }
+  const synthesisPath = path9.join(root, "docs", "synthesis", "current.md");
+  const synthesis = fs9.existsSync(synthesisPath) ? fs9.readFileSync(synthesisPath, "utf-8") : "";
+  const deadEndsPath = path9.join(root, "docs", "synthesis", "dead-ends.md");
+  const deadEnds = fs9.existsSync(deadEndsPath) ? fs9.readFileSync(deadEndsPath, "utf-8") : "";
+  const configPath = path9.join(root, ".majlis", "config.json");
+  let problemStatement = "";
+  if (fs9.existsSync(configPath)) {
+    const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+    problemStatement = `${config.project?.description ?? ""}
+Objective: ${config.project?.objective ?? ""}`;
+  }
+  const target = args.filter((a) => !a.startsWith("--")).join(" ") || "current classification";
+  info(`Reframing: ${target}`);
+  const result = await spawnAgent("reframer", {
+    synthesis,
+    taskPrompt: `You are the Reframer. You receive ONLY the problem statement and classification \u2014 NOT builder code.
+
+Problem Statement:
+${problemStatement}
+
+Current Classification:
+${classificationContent}
+
+Dead-End Registry:
+${deadEnds}
+
+Independently propose a decomposition. Compare with the existing classification. Flag structural divergences \u2014 these are the most valuable signals.
+Write to docs/reframes/.`
+  }, root);
+  success("Reframe complete. Check docs/reframes/ for the output.");
+}
+var fs9, path9;
+var init_classify = __esm({
+  "src/commands/classify.ts"() {
+    "use strict";
+    fs9 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    init_connection();
+    init_spawn();
+    init_format();
+  }
+});
+
+// src/commands/audit.ts
+var audit_exports = {};
+__export(audit_exports, {
+  audit: () => audit
+});
+async function audit(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  const objective = args.filter((a) => !a.startsWith("--")).join(" ");
+  const config = loadConfig(root);
+  const experiments = listAllExperiments(db);
+  const deadEnds = listAllDeadEnds(db);
+  const circuitBreakers = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
+  const classificationDir = path10.join(root, "docs", "classification");
+  let classification = "";
+  if (fs10.existsSync(classificationDir)) {
+    const files = fs10.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+    for (const f of files) {
+      classification += fs10.readFileSync(path10.join(classificationDir, f), "utf-8") + "\n\n";
+    }
   }
+  const synthesis = readFileOrEmpty(path10.join(root, "docs", "synthesis", "current.md"));
+  header("Maqasid Check \u2014 Purpose Audit");
+  const trippedBreakers = circuitBreakers.filter((cb) => cb.tripped);
+  if (trippedBreakers.length > 0) {
+    warn(`Circuit breaker(s) tripped: ${trippedBreakers.map((cb) => cb.sub_type).join(", ")}`);
+  }
+  const auditPrompt = `You are performing a Maqasid Check (purpose audit).
+
+ORIGINAL OBJECTIVE: ${objective || config.project?.objective || "Not specified"}
+
+CURRENT CLASSIFICATION:
+${classification}
+
+PROJECT SYNTHESIS:
+${synthesis}
+
+DEAD-ENDS (${deadEnds.length} total):
+${deadEnds.map(
+    (d) => `- ${d.approach}: ${d.structural_constraint}`
+  ).join("\n")}
+
+EXPERIMENT HISTORY (${experiments.length} total):
+${experiments.map(
+    (e) => `- #${e.id} ${e.slug}: ${e.status} (sub-type: ${e.sub_type ?? "none"})`
+  ).join("\n")}
+
+TRIPPED CIRCUIT BREAKERS:
+${trippedBreakers.map(
+    (cb) => `- ${cb.sub_type}: ${cb.failure_count} failures`
+  ).join("\n") || "None"}
+
+Answer these questions:
+1. What is the actual objective? Trace back from current experiments to the root goal.
+2. Is the current classification serving that objective? Or has the taxonomy become self-referential?
+3. What would we do differently if we started from scratch with what we now know?
+4. Is there a simpler formulation? If the classification has grown complex, something may be wrong.
+
+Output: either "classification confirmed \u2014 continue" or "re-classify from X" with a specific proposal.`;
+  const result = await spawnAgent("builder", {
+    synthesis,
+    taskPrompt: auditPrompt
+  }, root);
+  success("Purpose audit complete. Review the output above.");
 }
-var fs8, path8, import_node_child_process4;
-var init_cycle = __esm({
-  "src/commands/cycle.ts"() {
+var fs10, path10;
+var init_audit = __esm({
+  "src/commands/audit.ts"() {
     "use strict";
-    fs8 = __toESM(require("fs"));
-    path8 = __toESM(require("path"));
-    import_node_child_process4 = require("child_process");
+    fs10 = __toESM(require("fs"));
+    path10 = __toESM(require("path"));
     init_connection();
     init_queries();
-    init_machine();
-    init_types();
     init_spawn();
-    init_resolve();
     init_config();
-    init_metrics();
     init_format();
   }
 });
 
-// src/commands/classify.ts
-var classify_exports = {};
-__export(classify_exports, {
-  classify: () => classify,
-  reframe: () => reframe
+// src/commands/next.ts
+var next_exports = {};
+__export(next_exports, {
+  next: () => next
 });
-async function classify(args) {
+async function next(args, isJson) {
   const root = findProjectRoot();
   if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const domain = args.filter((a) => !a.startsWith("--")).join(" ");
-  if (!domain) {
-    throw new Error('Usage: majlis classify "domain description"');
+  const db = getDb(root);
+  const config = loadConfig(root);
+  const slugArg = args.filter((a) => !a.startsWith("--"))[0];
+  let exp;
+  if (slugArg) {
+    const found = getExperimentBySlug(db, slugArg);
+    if (!found) throw new Error(`Experiment not found: ${slugArg}`);
+    exp = found;
+  } else {
+    const found = getLatestExperiment(db);
+    if (!found) throw new Error('No active experiments. Run `majlis new "hypothesis"` first.');
+    exp = found;
+  }
+  const auto = args.includes("--auto");
+  if (auto) {
+    await runAutoLoop(db, exp, config, root, isJson);
+  } else {
+    await runNextStep(db, exp, config, root, isJson);
   }
-  const synthesisPath = path9.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs9.existsSync(synthesisPath) ? fs9.readFileSync(synthesisPath, "utf-8") : "";
-  const deadEndsPath = path9.join(root, "docs", "synthesis", "dead-ends.md");
-  const deadEnds = fs9.existsSync(deadEndsPath) ? fs9.readFileSync(deadEndsPath, "utf-8") : "";
-  info(`Classifying problem domain: ${domain}`);
-  const result = await spawnAgent("builder", {
-    synthesis,
-    taskPrompt: `Classify the following problem domain into canonical sub-types (Al-Khwarizmi method). For each sub-type: describe it, identify its canonical form, and list known constraints.
-
-Domain: ${domain}
-
-Dead-ends for context:
-${deadEnds}
-
-Write the classification to docs/classification/ following the template.`
-  }, root);
-  success("Classification complete. Check docs/classification/ for the output.");
 }
-async function reframe(args) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const classificationDir = path9.join(root, "docs", "classification");
-  let classificationContent = "";
-  if (fs9.existsSync(classificationDir)) {
-    const files = fs9.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
-    for (const f of files) {
-      classificationContent += fs9.readFileSync(path9.join(classificationDir, f), "utf-8") + "\n\n";
+async function runNextStep(db, exp, config, root, isJson) {
+  const currentStatus = exp.status;
+  const valid = validNext(currentStatus);
+  if (valid.length === 0) {
+    if (isJson) {
+      console.log(JSON.stringify({ experiment: exp.slug, status: exp.status, terminal: true }));
+    } else {
+      info(`Experiment ${exp.slug} is terminal (${exp.status}).`);
     }
+    return;
   }
-  const synthesisPath = path9.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs9.existsSync(synthesisPath) ? fs9.readFileSync(synthesisPath, "utf-8") : "";
-  const deadEndsPath = path9.join(root, "docs", "synthesis", "dead-ends.md");
-  const deadEnds = fs9.existsSync(deadEndsPath) ? fs9.readFileSync(deadEndsPath, "utf-8") : "";
-  const configPath = path9.join(root, ".majlis", "config.json");
-  let problemStatement = "";
-  if (fs9.existsSync(configPath)) {
-    const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
-    problemStatement = `${config.project?.description ?? ""}
-Objective: ${config.project?.objective ?? ""}`;
+  if (exp.sub_type && checkCircuitBreaker(db, exp.sub_type, config.cycle.circuit_breaker_threshold)) {
+    warn(`Circuit breaker: ${exp.sub_type} has ${config.cycle.circuit_breaker_threshold}+ failures.`);
+    insertDeadEnd(
+      db,
+      exp.id,
+      exp.hypothesis ?? exp.slug,
+      `Circuit breaker tripped for ${exp.sub_type}`,
+      `Sub-type ${exp.sub_type} exceeded ${config.cycle.circuit_breaker_threshold} failures`,
+      exp.sub_type,
+      "procedural"
+    );
+    updateExperimentStatus(db, exp.id, "dead_end");
+    warn("Experiment dead-ended. Triggering Maqasid Check (purpose audit).");
+    await audit([config.project?.objective ?? ""]);
+    return;
+  }
+  const sessionsSinceCompression = getSessionsSinceCompression(db);
+  if (sessionsSinceCompression >= config.cycle.compression_interval) {
+    warn(
+      `${sessionsSinceCompression} sessions since last compression. Consider running: majlis compress`
+    );
+  }
+  const expHasDoubts = hasDoubts(db, exp.id);
+  const expHasChallenges = hasChallenges(db, exp.id);
+  const nextStep = determineNextStep(exp, valid, expHasDoubts, expHasChallenges);
+  if (isJson) {
+    console.log(JSON.stringify({
+      experiment: exp.slug,
+      current_status: exp.status,
+      next_step: nextStep,
+      valid_transitions: valid
+    }));
+    return;
+  }
+  info(`${exp.slug}: ${exp.status} \u2192 ${nextStep}`);
+  await executeStep(nextStep, exp, root);
+}
+async function runAutoLoop(db, exp, config, root, isJson) {
+  const MAX_ITERATIONS = 20;
+  let iteration = 0;
+  header(`Auto mode \u2014 ${exp.slug}`);
+  while (iteration < MAX_ITERATIONS) {
+    iteration++;
+    const freshExp = getExperimentBySlug(db, exp.slug);
+    if (!freshExp) break;
+    exp = freshExp;
+    if (isTerminal(exp.status)) {
+      success(`Experiment ${exp.slug} reached terminal state: ${exp.status}`);
+      break;
+    }
+    if (exp.sub_type && checkCircuitBreaker(db, exp.sub_type, config.cycle.circuit_breaker_threshold)) {
+      warn(`Circuit breaker tripped for ${exp.sub_type}. Stopping auto mode.`);
+      insertDeadEnd(
+        db,
+        exp.id,
+        exp.hypothesis ?? exp.slug,
+        `Circuit breaker tripped for ${exp.sub_type}`,
+        `Sub-type ${exp.sub_type} exceeded ${config.cycle.circuit_breaker_threshold} failures`,
+        exp.sub_type,
+        "procedural"
+      );
+      updateExperimentStatus(db, exp.id, "dead_end");
+      await audit([config.project?.objective ?? ""]);
+      break;
+    }
+    const valid = validNext(exp.status);
+    if (valid.length === 0) break;
+    const expHasDoubts = hasDoubts(db, exp.id);
+    const expHasChallenges = hasChallenges(db, exp.id);
+    const nextStep = determineNextStep(exp, valid, expHasDoubts, expHasChallenges);
+    info(`[${iteration}/${MAX_ITERATIONS}] ${exp.slug}: ${exp.status} \u2192 ${nextStep}`);
+    await executeStep(nextStep, exp, root);
+  }
+  if (iteration >= MAX_ITERATIONS) {
+    warn(`Reached maximum iterations (${MAX_ITERATIONS}). Stopping auto mode.`);
+  }
+}
+async function executeStep(step, exp, root) {
+  const expArgs = [exp.slug];
+  switch (step) {
+    case "building" /* BUILDING */:
+      await cycle("build", expArgs);
+      break;
+    case "challenged" /* CHALLENGED */:
+      await cycle("challenge", expArgs);
+      break;
+    case "doubted" /* DOUBTED */:
+      await cycle("doubt", expArgs);
+      break;
+    case "scouted" /* SCOUTED */:
+      await cycle("scout", expArgs);
+      break;
+    case "verifying" /* VERIFYING */:
+      await cycle("verify", expArgs);
+      break;
+    case "resolved" /* RESOLVED */:
+      await resolveCmd(expArgs);
+      break;
+    case "compressed" /* COMPRESSED */:
+      await cycle("compress", []);
+      updateExperimentStatus(getDb(root), exp.id, "compressed");
+      info(`Experiment ${exp.slug} compressed.`);
+      break;
+    case "gated" /* GATED */:
+      await cycle("gate", expArgs);
+      break;
+    case "reframed" /* REFRAMED */:
+      updateExperimentStatus(getDb(root), exp.id, "reframed");
+      info(`Reframe acknowledged for ${exp.slug}. Proceeding to gate.`);
+      break;
+    case "merged" /* MERGED */:
+      updateExperimentStatus(getDb(root), exp.id, "merged");
+      success(`Experiment ${exp.slug} merged.`);
+      break;
+    case "dead_end" /* DEAD_END */:
+      info(`Experiment ${exp.slug} is dead-ended. No further action.`);
+      break;
+    default:
+      warn(`Don't know how to execute step: ${step}`);
   }
-  const target = args.filter((a) => !a.startsWith("--")).join(" ") || "current classification";
-  info(`Reframing: ${target}`);
-  const result = await spawnAgent("reframer", {
-    synthesis,
-    taskPrompt: `You are the Reframer. You receive ONLY the problem statement and classification \u2014 NOT builder code.
-
-Problem Statement:
-${problemStatement}
-
-Current Classification:
-${classificationContent}
-
-Dead-End Registry:
-${deadEnds}
-
-Independently propose a decomposition. Compare with the existing classification. Flag structural divergences \u2014 these are the most valuable signals.
-Write to docs/reframes/.`
-  }, root);
-  success("Reframe complete. Check docs/reframes/ for the output.");
 }
-var fs9, path9;
-var init_classify = __esm({
-  "src/commands/classify.ts"() {
+var init_next = __esm({
+  "src/commands/next.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs"));
-    path9 = __toESM(require("path"));
     init_connection();
-    init_spawn();
+    init_queries();
+    init_machine();
+    init_types2();
+    init_queries();
+    init_config();
+    init_cycle();
+    init_audit();
     init_format();
   }
 });
 
-// src/commands/audit.ts
-var audit_exports = {};
-__export(audit_exports, {
-  audit: () => audit
+// src/commands/run.ts
+var run_exports = {};
+__export(run_exports, {
+  run: () => run
 });
-async function audit(args) {
+async function run(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 run "goal description"');
+  }
   const db = getDb(root);
-  const objective = args.filter((a) => !a.startsWith("--")).join(" ");
   const config = loadConfig(root);
-  const experiments = listAllExperiments(db);
-  const deadEnds = listAllDeadEnds(db);
-  const circuitBreakers = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
-  const classificationDir = path10.join(root, "docs", "classification");
-  let classification = "";
-  if (fs10.existsSync(classificationDir)) {
-    const files = fs10.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
-    for (const f of files) {
-      classification += fs10.readFileSync(path10.join(classificationDir, f), "utf-8") + "\n\n";
+  const MAX_EXPERIMENTS = 10;
+  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_STEPS2 && experimentCount < MAX_EXPERIMENTS) {
+    if (isShutdownRequested()) {
+      warn("Shutdown requested. Stopping autonomous mode.");
+      break;
+    }
+    stepCount++;
+    let exp = getLatestExperiment(db);
+    if (!exp) {
+      experimentCount++;
+      if (experimentCount > MAX_EXPERIMENTS) {
+        warn(`Reached max experiments (${MAX_EXPERIMENTS}). Stopping.`);
+        break;
+      }
+      const sessionsSinceCompression = getSessionsSinceCompression(db);
+      if (sessionsSinceCompression >= config.cycle.compression_interval) {
+        info("Compressing before next experiment...");
+        await cycle("compress", []);
+      }
+      info(`[Experiment ${experimentCount}/${MAX_EXPERIMENTS}] Planning next experiment...`);
+      const hypothesis = await deriveNextHypothesis(goal, root, db);
+      if (!hypothesis) {
+        success("Planner says the goal has been met. Stopping.");
+        break;
+      }
+      if (usedHypotheses.has(hypothesis)) {
+        warn(`Planner returned duplicate hypothesis: "${hypothesis.slice(0, 80)}". Stopping.`);
+        break;
+      }
+      usedHypotheses.add(hypothesis);
+      info(`Next hypothesis: ${hypothesis}`);
+      exp = await createNewExperiment(db, root, hypothesis);
+      success(`Created experiment #${exp.id}: ${exp.slug}`);
+    }
+    if (isTerminal(exp.status)) {
+      if (exp.status === "merged") {
+        success(`Experiment ${exp.slug} merged.`);
+      } else if (exp.status === "dead_end") {
+        info(`Experiment ${exp.slug} dead-ended.`);
+      }
+      continue;
+    }
+    info(`[Step ${stepCount}] ${exp.slug}: ${exp.status}`);
+    try {
+      await next([exp.slug], false);
+      consecutiveFailures = 0;
+    } catch (err) {
+      consecutiveFailures++;
+      const message = err instanceof Error ? err.message : String(err);
+      warn(`Step failed for ${exp.slug}: ${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 (innerErr) {
+        const innerMsg = innerErr instanceof Error ? innerErr.message : String(innerErr);
+        warn(`Could not record dead-end: ${innerMsg}`);
+      }
+      if (consecutiveFailures >= 3) {
+        warn(`${consecutiveFailures} consecutive failures. Stopping autonomous mode.`);
+        break;
+      }
     }
   }
-  const synthesis = readFileOrEmpty(path10.join(root, "docs", "synthesis", "current.md"));
-  header("Maqasid Check \u2014 Purpose Audit");
-  const trippedBreakers = circuitBreakers.filter((cb) => cb.tripped);
-  if (trippedBreakers.length > 0) {
-    warn(`Circuit breaker(s) tripped: ${trippedBreakers.map((cb) => cb.sub_type).join(", ")}`);
+  if (stepCount >= MAX_STEPS2) {
+    warn(`Reached max steps (${MAX_STEPS2}). Stopping autonomous mode.`);
   }
-  const auditPrompt = `You are performing a Maqasid Check (purpose audit).
+  header("Autonomous Mode Complete");
+  info(`Goal: ${goal}`);
+  info(`Experiments: ${experimentCount}, Steps: ${stepCount}`);
+  info("Run `majlis status` to see final state.");
+}
+async function deriveNextHypothesis(goal, root, db) {
+  const synthesis = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const deadEndsDoc = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "dead-ends.md")), CONTEXT_LIMITS.deadEnds);
+  const deadEnds = listAllDeadEnds(db);
+  const config = loadConfig(root);
+  let metricsOutput = "";
+  if (config.metrics?.command) {
+    try {
+      metricsOutput = (0, import_node_child_process5.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 an autonomous Majlis run.
 
-ORIGINAL OBJECTIVE: ${objective || config.project?.objective || "Not specified"}
+## Goal
+${goal}
 
-CURRENT CLASSIFICATION:
-${classification}
+## Current Metrics
+${metricsOutput || "(no metrics configured)"}
 
-PROJECT SYNTHESIS:
-${synthesis}
+## Synthesis (what we know so far)
+${synthesis || "(empty \u2014 first experiment)"}
 
-DEAD-ENDS (${deadEnds.length} total):
-${deadEnds.map(
-    (d) => `- ${d.approach}: ${d.structural_constraint}`
-  ).join("\n")}
+## Fragility Map (known weak areas)
+${fragility || "(none)"}
 
-EXPERIMENT HISTORY (${experiments.length} total):
-${experiments.map(
-    (e) => `- #${e.id} ${e.slug}: ${e.status} (sub-type: ${e.sub_type ?? "none"})`
-  ).join("\n")}
+## Dead-End Registry
+${deadEndsDoc || "(none)"}
 
-TRIPPED CIRCUIT BREAKERS:
-${trippedBreakers.map(
-    (cb) => `- ${cb.sub_type}: ${cb.failure_count} failures`
-  ).join("\n") || "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)"}
 
-Answer these questions:
-1. What is the actual objective? Trace back from current experiments to the root goal.
-2. Is the current classification serving that objective? Or has the taxonomy become self-referential?
-3. What would we do differently if we started from scratch with what we now know?
-4. Is there a simpler formulation? If the classification has grown complex, something may be wrong.
+Note: [structural] dead ends are HARD CONSTRAINTS \u2014 your hypothesis MUST NOT repeat these approaches.
+[procedural] dead ends are process failures \u2014 the approach may still be valid if executed differently.
 
-Output: either "classification confirmed \u2014 continue" or "re-classify from X" with a specific proposal.`;
-  const result = await spawnAgent("builder", {
-    synthesis,
-    taskPrompt: auditPrompt
+## 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 propose the SINGLE most promising next experiment hypothesis.
+   - It must NOT repeat a dead-ended approach (check the dead-end registry!)
+   - It should attack the weakest point revealed by synthesis/fragility
+   - It must be specific and actionable \u2014 name the function or mechanism to change
+   - Do NOT reference specific line numbers \u2014 they shift between experiments
+   - The hypothesis should be a single sentence describing what to do, e.g.:
+     "Activate addSeamEdges() in the runEdgeFirst pipeline for full-revolution cylinder faces"
+
+CRITICAL: Your LAST line of output MUST be EXACTLY this format (on its own line, nothing after it):
+<!-- majlis-json {"goal_met": false, "hypothesis": "your single-sentence hypothesis here"} -->
+
+If the goal is met:
+<!-- majlis-json {"goal_met": true, "hypothesis": null} -->`
   }, root);
-  success("Purpose audit complete. Review the output above.");
+  const structured = result.structured;
+  if (structured?.goal_met === true) {
+    return null;
+  }
+  if (structured?.hypothesis) {
+    return structured.hypothesis;
+  }
+  const jsonMatch = result.output.match(/"hypothesis"\s*:\s*"([^"]+)"/);
+  if (jsonMatch && jsonMatch[1].length > 10) return jsonMatch[1].trim();
+  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 null;
+      if (parsed.hypothesis) return parsed.hypothesis;
+    } catch {
+    }
+  }
+  warn("Planner did not return structured output. Retrying with focused prompt...");
+  const retry = await spawnSynthesiser({
+    taskPrompt: `Based on this analysis, output ONLY a single-line JSON block:
+
+${result.output.slice(-2e3)}
+
+<!-- majlis-json {"goal_met": false, "hypothesis": "your hypothesis"} -->`
+  }, root);
+  if (retry.structured?.hypothesis) return retry.structured.hypothesis;
+  warn("Could not extract hypothesis. Using goal as fallback.");
+  return goal;
+}
+async function createNewExperiment(db, root, hypothesis) {
+  const slug = await generateSlug(hypothesis, root);
+  let finalSlug = slug;
+  let attempt = 0;
+  while (getExperimentBySlug(db, finalSlug)) {
+    attempt++;
+    finalSlug = `${slug}-${attempt}`;
+  }
+  const allExps = db.prepare("SELECT COUNT(*) as count FROM experiments").get();
+  const num = allExps.count + 1;
+  const paddedNum = String(num).padStart(3, "0");
+  const branch = `exp/${paddedNum}-${finalSlug}`;
+  try {
+    (0, import_node_child_process5.execSync)(`git checkout -b ${branch}`, {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    info(`Created branch: ${branch}`);
+  } catch {
+    warn(`Could not create branch ${branch} \u2014 continuing without git branch.`);
+  }
+  const exp = createExperiment(db, finalSlug, branch, hypothesis, null, null);
+  updateExperimentStatus(db, exp.id, "reframed");
+  exp.status = "reframed";
+  const docsDir = path11.join(root, "docs", "experiments");
+  const templatePath = path11.join(docsDir, "_TEMPLATE.md");
+  if (fs11.existsSync(templatePath)) {
+    const template = fs11.readFileSync(templatePath, "utf-8");
+    const logContent = template.replace(/\{\{title\}\}/g, hypothesis).replace(/\{\{hypothesis\}\}/g, hypothesis).replace(/\{\{branch\}\}/g, branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
+    const logPath = path11.join(docsDir, `${paddedNum}-${finalSlug}.md`);
+    fs11.writeFileSync(logPath, logContent);
+    info(`Created experiment log: docs/experiments/${paddedNum}-${finalSlug}.md`);
+  }
+  return exp;
 }
-var fs10, path10;
-var init_audit = __esm({
-  "src/commands/audit.ts"() {
+var fs11, path11, import_node_child_process5;
+var init_run = __esm({
+  "src/commands/run.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path11 = __toESM(require("path"));
+    import_node_child_process5 = require("child_process");
     init_connection();
     init_queries();
+    init_machine();
+    init_next();
+    init_cycle();
     init_spawn();
     init_config();
+    init_shutdown();
     init_format();
   }
 });
 
-// src/commands/next.ts
-var next_exports = {};
-__export(next_exports, {
-  next: () => next
-});
-async function next(args, isJson) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const db = getDb(root);
-  const config = loadConfig(root);
-  const slugArg = args.filter((a) => !a.startsWith("--"))[0];
-  let exp;
-  if (slugArg) {
-    const found = getExperimentBySlug(db, slugArg);
-    if (!found) throw new Error(`Experiment not found: ${slugArg}`);
-    exp = found;
-  } else {
-    const found = getLatestExperiment(db);
-    if (!found) throw new Error('No active experiments. Run `majlis new "hypothesis"` first.');
-    exp = found;
-  }
-  const auto = args.includes("--auto");
-  if (auto) {
-    await runAutoLoop(db, exp, config, root, isJson);
-  } else {
-    await runNextStep(db, exp, config, root, isJson);
-  }
+// 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
+  };
 }
-async function runNextStep(db, exp, config, root, isJson) {
-  const currentStatus = exp.status;
-  const valid = validNext(currentStatus);
-  if (valid.length === 0) {
-    if (isJson) {
-      console.log(JSON.stringify({ experiment: exp.slug, status: exp.status, terminal: true }));
-    } else {
-      info(`Experiment ${exp.slug} is terminal (${exp.status}).`);
+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));
     }
-    return;
   }
-  if (exp.sub_type && checkCircuitBreaker(db, exp.sub_type, config.cycle.circuit_breaker_threshold)) {
-    warn(`Circuit breaker: ${exp.sub_type} has ${config.cycle.circuit_breaker_threshold}+ failures.`);
-    insertDeadEnd(
-      db,
-      exp.id,
-      exp.hypothesis ?? exp.slug,
-      `Circuit breaker tripped for ${exp.sub_type}`,
-      `Sub-type ${exp.sub_type} exceeded ${config.cycle.circuit_breaker_threshold} failures`,
-      exp.sub_type,
-      "procedural"
-    );
-    updateExperimentStatus(db, exp.id, "dead_end");
-    warn("Experiment dead-ended. Triggering Maqasid Check (purpose audit).");
-    await audit([config.project?.objective ?? ""]);
-    return;
+  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 sessionsSinceCompression = getSessionsSinceCompression(db);
-  if (sessionsSinceCompression >= config.cycle.compression_interval) {
-    warn(
-      `${sessionsSinceCompression} sessions since last compression. Consider running: majlis compress`
-    );
+  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 expHasDoubts = hasDoubts(db, exp.id);
-  const expHasChallenges = hasChallenges(db, exp.id);
-  const nextStep = determineNextStep(exp, valid, expHasDoubts, expHasChallenges);
-  if (isJson) {
-    console.log(JSON.stringify({
-      experiment: exp.slug,
-      current_status: exp.status,
-      next_step: nextStep,
-      valid_transitions: valid
-    }));
-    return;
+  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 {
   }
-  info(`${exp.slug}: ${exp.status} \u2192 ${nextStep}`);
-  await executeStep(nextStep, exp, root);
 }
-async function runAutoLoop(db, exp, config, root, isJson) {
-  const MAX_ITERATIONS = 20;
-  let iteration = 0;
-  header(`Auto mode \u2014 ${exp.slug}`);
-  while (iteration < MAX_ITERATIONS) {
-    iteration++;
-    const freshExp = getExperimentBySlug(db, exp.slug);
-    if (!freshExp) break;
-    exp = freshExp;
-    if (isTerminal(exp.status)) {
-      success(`Experiment ${exp.slug} reached terminal state: ${exp.status}`);
-      break;
+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);
     }
-    if (exp.sub_type && checkCircuitBreaker(db, exp.sub_type, config.cycle.circuit_breaker_threshold)) {
-      warn(`Circuit breaker tripped for ${exp.sub_type}. Stopping auto mode.`);
-      insertDeadEnd(
-        db,
-        exp.id,
-        exp.hypothesis ?? exp.slug,
-        `Circuit breaker tripped for ${exp.sub_type}`,
-        `Sub-type ${exp.sub_type} exceeded ${config.cycle.circuit_breaker_threshold} failures`,
-        exp.sub_type,
-        "procedural"
+    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)
       );
-      updateExperimentStatus(db, exp.id, "dead_end");
-      await audit([config.project?.objective ?? ""]);
-      break;
+      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 {
+      }
     }
-    const valid = validNext(exp.status);
-    if (valid.length === 0) break;
-    const expHasDoubts = hasDoubts(db, exp.id);
-    const expHasChallenges = hasChallenges(db, exp.id);
-    const nextStep = determineNextStep(exp, valid, expHasDoubts, expHasChallenges);
-    info(`[${iteration}/${MAX_ITERATIONS}] ${exp.slug}: ${exp.status} \u2192 ${nextStep}`);
-    await executeStep(nextStep, exp, root);
-  }
-  if (iteration >= MAX_ITERATIONS) {
-    warn(`Reached maximum iterations (${MAX_ITERATIONS}). Stopping auto mode.`);
   }
 }
-async function executeStep(step, exp, root) {
-  const expArgs = [exp.slug];
-  switch (step) {
+function statusToStepName(status2) {
+  switch (status2) {
+    case "gated" /* GATED */:
+      return "gate";
     case "building" /* BUILDING */:
-      await cycle("build", expArgs);
-      break;
+      return "build";
     case "challenged" /* CHALLENGED */:
-      await cycle("challenge", expArgs);
-      break;
+      return "challenge";
     case "doubted" /* DOUBTED */:
-      await cycle("doubt", expArgs);
-      break;
+      return "doubt";
     case "scouted" /* SCOUTED */:
-      await cycle("scout", expArgs);
-      break;
+      return "scout";
     case "verifying" /* VERIFYING */:
-      await cycle("verify", expArgs);
-      break;
-    case "resolved" /* RESOLVED */:
-      await resolveCmd(expArgs);
-      break;
-    case "compressed" /* COMPRESSED */:
-      await cycle("compress", []);
-      updateExperimentStatus(getDb(root), exp.id, "compressed");
-      info(`Experiment ${exp.slug} compressed.`);
-      break;
-    case "gated" /* GATED */:
-      await cycle("gate", expArgs);
-      break;
-    case "reframed" /* REFRAMED */:
-      updateExperimentStatus(getDb(root), exp.id, "reframed");
-      info(`Reframe acknowledged for ${exp.slug}. Proceeding to gate.`);
-      break;
+      return "verify";
     default:
-      warn(`Don't know how to execute step: ${step}`);
+      return null;
   }
 }
-var init_next = __esm({
-  "src/commands/next.ts"() {
+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_types();
-    init_queries();
-    init_config();
+    init_types2();
     init_cycle();
-    init_audit();
+    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/run.ts
-var run_exports = {};
-__export(run_exports, {
-  run: () => run
+// src/commands/swarm.ts
+var swarm_exports = {};
+__export(swarm_exports, {
+  swarm: () => swarm
 });
-async function run(args) {
+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 run "goal description"');
+  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 config = loadConfig(root);
-  const MAX_EXPERIMENTS = 10;
-  const MAX_STEPS = 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) {
-    if (isShutdownRequested()) {
-      warn("Shutdown requested. Stopping autonomous mode.");
-      break;
-    }
-    stepCount++;
-    let exp = getLatestExperiment(db);
-    if (!exp) {
-      experimentCount++;
-      if (experimentCount > MAX_EXPERIMENTS) {
-        warn(`Reached max experiments (${MAX_EXPERIMENTS}). Stopping.`);
-        break;
-      }
-      const sessionsSinceCompression = getSessionsSinceCompression(db);
-      if (sessionsSinceCompression >= config.cycle.compression_interval) {
-        info("Compressing before next experiment...");
-        await cycle("compress", []);
-      }
-      info(`[Experiment ${experimentCount}/${MAX_EXPERIMENTS}] Planning next experiment...`);
-      const hypothesis = await deriveNextHypothesis(goal, root, db);
-      if (!hypothesis) {
-        success("Planner says the goal has been met. Stopping.");
-        break;
-      }
-      if (usedHypotheses.has(hypothesis)) {
-        warn(`Planner returned duplicate hypothesis: "${hypothesis.slice(0, 80)}". Stopping.`);
-        break;
-      }
-      usedHypotheses.add(hypothesis);
-      info(`Next hypothesis: ${hypothesis}`);
-      exp = createNewExperiment(db, root, hypothesis);
-      success(`Created experiment #${exp.id}: ${exp.slug}`);
-    }
-    if (isTerminal(exp.status)) {
-      if (exp.status === "merged") {
-        success(`Experiment ${exp.slug} merged.`);
-      } else if (exp.status === "dead_end") {
-        info(`Experiment ${exp.slug} dead-ended.`);
-      }
-      continue;
-    }
-    info(`[Step ${stepCount}] ${exp.slug}: ${exp.status}`);
+  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 {
-      await next([exp.slug], false);
-      consecutiveFailures = 0;
+      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) {
-      consecutiveFailures++;
-      const message = err instanceof Error ? err.message : String(err);
-      warn(`Step failed for ${exp.slug}: ${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 (innerErr) {
-        const innerMsg = innerErr instanceof Error ? innerErr.message : String(innerErr);
-        warn(`Could not record dead-end: ${innerMsg}`);
-      }
-      if (consecutiveFailures >= 3) {
-        warn(`${consecutiveFailures} consecutive failures. Stopping autonomous mode.`);
-        break;
-      }
+      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.");
   }
-  if (stepCount >= MAX_STEPS) {
-    warn(`Reached max steps (${MAX_STEPS}). Stopping autonomous mode.`);
+  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");
+    }
   }
-  header("Autonomous Mode Complete");
+  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(`Experiments: ${experimentCount}, Steps: ${stepCount}`);
-  info("Run `majlis status` to see final state.");
-}
-async function deriveNextHypothesis(goal, root, db) {
-  const synthesis = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
-  const fragility = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
-  const deadEndsDoc = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "dead-ends.md")), CONTEXT_LIMITS.deadEnds);
+  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_process5.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process7.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -3968,7 +5143,7 @@ async function deriveNextHypothesis(goal, root, db) {
     }
   }
   const result = await spawnSynthesiser({
-    taskPrompt: `You are the Planner for an autonomous Majlis run.
+    taskPrompt: `You are the Planner for a parallel Majlis swarm.
 
 ## Goal
 ${goal}
@@ -3988,119 +5163,195 @@ ${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 your hypothesis MUST NOT repeat these approaches.
+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 propose the SINGLE most promising next experiment hypothesis.
-   - It must NOT repeat a dead-ended approach (check the dead-end registry!)
-   - It should attack the weakest point revealed by synthesis/fragility
-   - It must be specific and actionable \u2014 name the function or mechanism to change
-   - Do NOT reference specific line numbers \u2014 they shift between experiments
-   - The hypothesis should be a single sentence describing what to do, e.g.:
-     "Activate addSeamEdges() in the runEdgeFirst pipeline for full-revolution cylinder faces"
+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, "hypothesis": "your single-sentence hypothesis here"} -->
+<!-- majlis-json {"goal_met": false, "hypotheses": ["hypothesis 1", "hypothesis 2", "hypothesis 3"]} -->
 
 If the goal is met:
-<!-- majlis-json {"goal_met": true, "hypothesis": null} -->`
+<!-- majlis-json {"goal_met": true, "hypotheses": []} -->`
   }, root);
-  const structured = result.structured;
-  if (structured?.goal_met === true) {
-    return null;
-  }
-  if (structured?.hypothesis) {
-    return structured.hypothesis;
+  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 jsonMatch = result.output.match(/"hypothesis"\s*:\s*"([^"]+)"/);
-  if (jsonMatch && jsonMatch[1].length > 10) return jsonMatch[1].trim();
   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 null;
-      if (parsed.hypothesis) return parsed.hypothesis;
+      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 output. Retrying with focused prompt...");
-  const retry = await spawnSynthesiser({
-    taskPrompt: `Based on this analysis, output ONLY a single-line JSON block:
+  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;
+  }
+});
 
-${result.output.slice(-2e3)}
+// 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}
 
-<!-- majlis-json {"goal_met": false, "hypothesis": "your hypothesis"} -->`
-  }, root);
-  if (retry.structured?.hypothesis) return retry.structured.hypothesis;
-  warn("Could not extract hypothesis. Using goal as fallback.");
-  return goal;
-}
-function createNewExperiment(db, root, hypothesis) {
-  const slug = slugify2(hypothesis);
-  let finalSlug = slug;
-  let attempt = 0;
-  while (getExperimentBySlug(db, finalSlug)) {
-    attempt++;
-    finalSlug = `${slug}-${attempt}`;
+`;
+  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}
+
+`;
   }
-  const allExps = db.prepare("SELECT COUNT(*) as count FROM experiments").get();
-  const num = allExps.count + 1;
-  const paddedNum = String(num).padStart(3, "0");
-  const branch = `exp/${paddedNum}-${finalSlug}`;
-  try {
-    (0, import_node_child_process5.execSync)(`git checkout -b ${branch}`, {
-      cwd: root,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    info(`Created branch: ${branch}`);
-  } catch {
-    warn(`Could not create branch ${branch} \u2014 continuing without git branch.`);
+  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}`);
+    }
   }
-  const exp = createExperiment(db, finalSlug, branch, hypothesis, null, null);
-  updateExperimentStatus(db, exp.id, "reframed");
-  exp.status = "reframed";
-  const docsDir = path11.join(root, "docs", "experiments");
-  const templatePath = path11.join(docsDir, "_TEMPLATE.md");
-  if (fs11.existsSync(templatePath)) {
-    const template = fs11.readFileSync(templatePath, "utf-8");
-    const logContent = template.replace(/\{\{title\}\}/g, hypothesis).replace(/\{\{hypothesis\}\}/g, hypothesis).replace(/\{\{branch\}\}/g, branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    const logPath = path11.join(docsDir, `${paddedNum}-${finalSlug}.md`);
-    fs11.writeFileSync(logPath, logContent);
-    info(`Created experiment log: docs/experiments/${paddedNum}-${finalSlug}.md`);
+  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)");
   }
-  return exp;
-}
-function slugify2(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+  if (result.truncated) {
+    warn("Diagnostician was truncated (hit 60 turn limit).");
+  }
+  success("Diagnosis complete.");
 }
-var fs11, path11, import_node_child_process5;
-var init_run = __esm({
-  "src/commands/run.ts"() {
+var fs14, path15, import_node_child_process8;
+var init_diagnose = __esm({
+  "src/commands/diagnose.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
-    import_node_child_process5 = require("child_process");
+    fs14 = __toESM(require("fs"));
+    path15 = __toESM(require("path"));
+    import_node_child_process8 = require("child_process");
     init_connection();
     init_queries();
-    init_machine();
-    init_next();
-    init_cycle();
     init_spawn();
     init_config();
-    init_shutdown();
     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;
@@ -4210,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();
@@ -4267,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
@@ -4274,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