majlis 0.5.1 → 0.5.2

package/dist/cli.js

@@ -575,6 +575,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 +742,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 +824,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
@@ -1805,1076 +1819,1197 @@ 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"]}}';
     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"]
+    };
   }
 });
 
-// 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"]
-    });
-  } 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;
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
   }
-  for (const m of parsed) {
-    insertMetric(db, exp.id, phase, m.fixture, m.metric_name, m.metric_value);
+}
+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"
+    });
   }
-  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 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"
+      });
     }
   }
-}
-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 (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 (!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;
+  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()
+      });
+    }
   }
-  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);
 }
-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.`);
-  }
-  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.`);
+// 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 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 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}`);
   }
-  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.");
-    }
+  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/.`;
+    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] }
+    ];
   }
+  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);
+function extractYamlField(yaml, field) {
+  const match = yaml.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
+  return match ? match[1].trim() : null;
 }
-var fs4, path4, import_node_child_process2;
-var init_experiment = __esm({
-  "src/commands/experiment.ts"() {
-    "use strict";
-    fs4 = __toESM(require("fs"));
-    path4 = __toESM(require("path"));
-    import_node_child_process2 = require("child_process");
-    init_connection();
-    init_queries();
-    init_config();
-    init_format();
-  }
-});
+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:
 
-// 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');
+\`\`\`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 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 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 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 { output: markdown, structured, truncated };
 }
-var init_session = __esm({
-  "src/commands/session.ts"() {
-    "use strict";
-    init_connection();
-    init_queries();
-    init_config();
-    init_format();
-  }
-});
+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:
 
-// src/commands/query.ts
-var query_exports = {};
-__export(query_exports, {
-  query: () => query
-});
-async function query(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);
-  }
+\`\`\`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 };
 }
-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;
-  }
-  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));
+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}.`);
 }
-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 (isJson) {
-    console.log(JSON.stringify(deadEnds, null, 2));
-    return;
-  }
-  if (deadEnds.length === 0) {
-    info("No dead-ends recorded.");
-    return;
+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}`);
+      }
+    }
   }
-  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));
+  return { text: textParts.join("\n\n"), costUsd, truncated };
 }
-function queryFragility(root, isJson) {
-  const fragPath = path5.join(root, "docs", "synthesis", "fragility.md");
-  if (!fs5.existsSync(fragPath)) {
-    info("No fragility map found.");
-    return;
-  }
-  const content = fs5.readFileSync(fragPath, "utf-8");
-  if (isJson) {
-    console.log(JSON.stringify({ content }, null, 2));
-    return;
+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;
   }
-  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>");
-  }
-  const history = getMetricHistoryByFixture(db, fixture);
-  if (isJson) {
-    console.log(JSON.stringify(history, null, 2));
-    return;
+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 (history.length === 0) {
-    info(`No metric history for fixture: ${fixture}`);
-    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") return null;
+  const fullDir = path4.join(projectRoot, dir);
+  if (!fs4.existsSync(fullDir)) {
+    fs4.mkdirSync(fullDir, { recursive: true });
   }
-  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));
+  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;
 }
-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;
+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_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
+    };
+    CHECKPOINT_INTERVAL = {
+      builder: 15,
+      verifier: 12,
+      critic: 15,
+      adversary: 15,
+      compressor: 15
+    };
+    DIM2 = "\x1B[2m";
+    RESET2 = "\x1B[0m";
+    CYAN2 = "\x1B[36m";
   }
-  if (states.length === 0) {
-    info("No circuit breaker data.");
-    return;
+});
+
+// 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
+        });
+      }
+    }
   }
-  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));
+  return comparisons;
 }
-function checkCommit(db) {
-  let stdinData = "";
-  try {
-    stdinData = fs5.readFileSync(0, "utf-8");
-  } catch {
+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;
   }
-  if (stdinData) {
-    try {
-      const hookInput = JSON.parse(stdinData);
-      const command = hookInput?.tool_input?.command ?? "";
-      if (!command.includes("git commit")) {
-        return;
+}
+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 });
+        }
       }
-    } catch {
-    }
-  }
-  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);
   }
+  return results;
 }
-var fs5, path5;
-var init_query = __esm({
-  "src/commands/query.ts"() {
+var init_metrics = __esm({
+  "src/metrics.ts"() {
     "use strict";
-    fs5 = __toESM(require("fs"));
-    path5 = __toESM(require("path"));
-    init_connection();
     init_queries();
-    init_config();
-    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/measure.ts
+var measure_exports = {};
+__export(measure_exports, {
+  baseline: () => baseline,
+  compare: () => compare,
+  measure: () => measure
 });
-
-// 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];
+async function baseline(args) {
+  await captureMetrics("before", args);
 }
-function isTerminal(status2) {
-  return TRANSITIONS[status2].length === 0;
+async function measure(args) {
+  await captureMetrics("after", args);
 }
-function determineNextStep(exp, valid, hasDoubts2, hasChallenges2) {
-  if (valid.length === 0) {
-    throw new Error(`Experiment ${exp.slug} is terminal (${exp.status})`);
+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));
+  } else {
+    exp = getLatestExperiment(db);
   }
-  const status2 = exp.status;
-  if (status2 === "classified" /* CLASSIFIED */ || status2 === "reframed" /* REFRAMED */) {
-    return valid.includes("gated" /* GATED */) ? "gated" /* GATED */ : valid[0];
+  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.");
+    }
   }
-  if (status2 === "gated" /* GATED */) {
-    return valid.includes("building" /* BUILDING */) ? "building" /* BUILDING */ : valid[0];
+  if (!config.metrics.command) {
+    throw new Error("No metrics.command configured in .majlis/config.json");
   }
-  if (status2 === "built" /* BUILT */ && !hasDoubts2) {
-    return valid.includes("doubted" /* DOUBTED */) ? "doubted" /* DOUBTED */ : valid[0];
+  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 (status2 === "doubted" /* DOUBTED */ && !hasChallenges2) {
-    return valid.includes("challenged" /* CHALLENGED */) ? "challenged" /* CHALLENGED */ : valid[0];
+  const parsed = parseMetricsOutput(metricsOutput);
+  if (parsed.length === 0) {
+    warn("Metrics command returned no data.");
+    return;
   }
-  if (status2 === "doubted" /* DOUBTED */ || status2 === "challenged" /* CHALLENGED */) {
-    if (valid.includes("verifying" /* VERIFYING */)) {
-      return "verifying" /* VERIFYING */;
+  for (const m of parsed) {
+    insertMetric(db, exp.id, phase, m.fixture, m.metric_name, m.metric_value);
+  }
+  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.");
     }
   }
-  return valid[0];
 }
-var init_machine = __esm({
-  "src/state/machine.ts"() {
-    "use strict";
-    init_types();
+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);
   }
-});
-
-// 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;
+  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;
+  }
+  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.");
   }
 }
-var EXTRACTION_SCHEMA, ROLE_REQUIRED_FIELDS;
-var init_types2 = __esm({
-  "src/agents/types.ts"() {
+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";
-    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"]
-    };
+    import_node_child_process = require("child_process");
+    init_connection();
+    init_queries();
+    init_metrics();
+    init_config();
+    init_format();
   }
 });
 
-// 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 {
-    console.warn(`[majlis] No <!-- majlis-json --> block found in ${role} output. Falling back.`);
+// 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 tier2 = extractViaPatterns(role, markdown);
-  if (tier2 && hasData(tier2)) {
-    console.warn(`[majlis] Used regex fallback for ${role}. Review extracted data.`);
-    return tier2;
+  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.`);
   }
-  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) {
+  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 {
-    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"
+    (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 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 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 { 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 (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()
-    });
+}
+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 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()
+  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.");
   }
-  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 (doubts.length > 0) result.doubts = doubts;
-  return result;
+  info(`Experiment ${exp.slug} reverted to dead-end. Reason: ${reason}`);
 }
-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}
+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();
+  }
+});
 
-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;
-          }
-        }
-      }
+// 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})`);
+    }
+  } else {
+    const active = getActiveSession(db);
+    if (!active) {
+      throw new Error("No active session to end.");
     }
-    return tryParseJson(resultText.trim());
-  } catch (err) {
-    console.warn(`[majlis] Haiku extraction failed for ${role}: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
+    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}`);
   }
 }
-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 init_session = __esm({
+  "src/commands/session.ts"() {
     "use strict";
-    init_types2();
-    import_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
+    init_connection();
+    init_queries();
+    init_config();
+    init_format();
   }
 });
 
-// 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/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);
   }
-  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 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
-  });
-  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 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;
   }
-  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(", ")}`);
-    }
+  if (decisions.length === 0) {
+    info("No decisions found.");
+    return;
   }
-  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}`);
-      }
-    }
+  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);
   }
-  return { text: textParts.join("\n\n"), costUsd, truncated };
+  if (isJson) {
+    console.log(JSON.stringify(deadEnds, null, 2));
+    return;
+  }
+  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 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 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 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 });
+function queryHistory(db, args, isJson) {
+  const fixture = args.filter((a) => !a.startsWith("--"))[0];
+  if (!fixture) {
+    throw new Error("Usage: majlis history <fixture>");
   }
-  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;
+  const history = getMetricHistoryByFixture(db, fixture);
+  if (isJson) {
+    console.log(JSON.stringify(history, null, 2));
+    return;
+  }
+  if (history.length === 0) {
+    info(`No metric history for fixture: ${fixture}`);
+    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
+  ]);
+  console.log(table(["Exp", "Slug", "Phase", "Metric", "Value", "Captured"], rows));
 }
-var fs6, path6, import_claude_agent_sdk2, ROLE_MAX_TURNS, DIM2, RESET2, CYAN2;
-var init_spawn = __esm({
-  "src/agents/spawn.ts"() {
+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 (states.length === 0) {
+    info("No circuit breaker data.");
+    return;
+  }
+  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 = "";
+  try {
+    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 {
+    }
+  }
+  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);
+  }
+}
+var fs6, path6;
+var init_query = __esm({
+  "src/commands/query.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
+    init_queries();
+    init_config();
+    init_format();
+  }
+});
+
+// src/state/types.ts
+var TRANSITIONS, GRADE_ORDER;
+var init_types2 = __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 */]: []
     };
-    DIM2 = "\x1B[2m";
-    RESET2 = "\x1B[0m";
-    CYAN2 = "\x1B[36m";
+    GRADE_ORDER = ["rejected", "weak", "good", "sound"];
+  }
+});
+
+// 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];
+  }
+  if (status2 === "doubted" /* DOUBTED */ || status2 === "challenged" /* CHALLENGED */) {
+    if (valid.includes("verifying" /* VERIFYING */)) {
+      return "verifying" /* VERIFYING */;
+    }
+  }
+  if (status2 === "compressed" /* COMPRESSED */) {
+    return valid.includes("merged" /* MERGED */) ? "merged" /* MERGED */ : valid[0];
+  }
+  return valid[0];
+}
+var init_machine = __esm({
+  "src/state/machine.ts"() {
+    "use strict";
+    init_types2();
   }
 });
 
@@ -3016,7 +3151,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");
@@ -3059,7 +3194,6 @@ 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 doGate(db, exp, root) {
   transition(exp.status, "gated" /* GATED */);
@@ -3507,7 +3641,7 @@ var init_cycle = __esm({
     init_connection();
     init_queries();
     init_machine();
-    init_types();
+    init_types2();
     init_spawn();
     init_resolve();
     init_config();
@@ -3830,6 +3964,13 @@ async function executeStep(step, exp, root) {
       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}`);
   }
@@ -3840,7 +3981,7 @@ var init_next = __esm({
     init_connection();
     init_queries();
     init_machine();
-    init_types();
+    init_types2();
     init_queries();
     init_config();
     init_cycle();
@@ -3900,7 +4041,7 @@ async function run(args) {
       }
       usedHypotheses.add(hypothesis);
       info(`Next hypothesis: ${hypothesis}`);
-      exp = createNewExperiment(db, root, hypothesis);
+      exp = await createNewExperiment(db, root, hypothesis);
       success(`Created experiment #${exp.id}: ${exp.slug}`);
     }
     if (isTerminal(exp.status)) {
@@ -4038,8 +4179,8 @@ ${result.output.slice(-2e3)}
   warn("Could not extract hypothesis. Using goal as fallback.");
   return goal;
 }
-function createNewExperiment(db, root, hypothesis) {
-  const slug = slugify2(hypothesis);
+async function createNewExperiment(db, root, hypothesis) {
+  const slug = await generateSlug(hypothesis, root);
   let finalSlug = slug;
   let attempt = 0;
   while (getExperimentBySlug(db, finalSlug)) {
@@ -4074,9 +4215,6 @@ function createNewExperiment(db, root, hypothesis) {
   }
   return exp;
 }
-function slugify2(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
-}
 var fs11, path11, import_node_child_process5;
 var init_run = __esm({
   "src/commands/run.ts"() {