majlis 0.5.0 → 0.5.2

package/dist/cli.js

@@ -29,6 +29,27 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/shutdown.ts
+var shutdown_exports = {};
+__export(shutdown_exports, {
+  isShutdownRequested: () => isShutdownRequested,
+  requestShutdown: () => requestShutdown
+});
+function requestShutdown() {
+  _requested = true;
+}
+function isShutdownRequested() {
+  return _requested;
+}
+var _requested;
+var init_shutdown = __esm({
+  "src/shutdown.ts"() {
+    "use strict";
+    _requested = false;
+  }
+});
 
 // src/db/migrations.ts
 function runMigrations(db) {
@@ -554,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.
@@ -717,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
 
@@ -796,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
@@ -1618,6 +1653,73 @@ var init_queries = __esm({
   }
 });
 
+// src/config.ts
+function loadConfig(projectRoot) {
+  if (_cachedConfig && _cachedRoot === projectRoot) return _cachedConfig;
+  const configPath = path3.join(projectRoot, ".majlis", "config.json");
+  if (!fs3.existsSync(configPath)) {
+    _cachedConfig = { ...DEFAULT_CONFIG2 };
+    _cachedRoot = projectRoot;
+    return _cachedConfig;
+  }
+  const loaded = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+  _cachedConfig = {
+    ...DEFAULT_CONFIG2,
+    ...loaded,
+    project: { ...DEFAULT_CONFIG2.project, ...loaded.project },
+    metrics: { ...DEFAULT_CONFIG2.metrics, ...loaded.metrics },
+    build: { ...DEFAULT_CONFIG2.build, ...loaded.build },
+    cycle: { ...DEFAULT_CONFIG2.cycle, ...loaded.cycle }
+  };
+  _cachedRoot = projectRoot;
+  return _cachedConfig;
+}
+function readFileOrEmpty(filePath) {
+  try {
+    return fs3.readFileSync(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function getFlagValue(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx < 0 || idx + 1 >= args.length) return void 0;
+  return args[idx + 1];
+}
+function truncateContext(content, limit) {
+  if (content.length <= limit) return content;
+  return content.slice(0, limit) + "\n[TRUNCATED]";
+}
+var fs3, path3, DEFAULT_CONFIG2, _cachedConfig, _cachedRoot, CONTEXT_LIMITS;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    fs3 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
+    DEFAULT_CONFIG2 = {
+      project: { name: "", description: "", objective: "" },
+      metrics: { command: "", fixtures: [], tracked: {} },
+      build: { pre_measure: null, post_measure: null },
+      cycle: {
+        compression_interval: 5,
+        circuit_breaker_threshold: 3,
+        require_doubt_before_verify: true,
+        require_challenge_before_verify: false,
+        auto_baseline_on_new_experiment: true
+      },
+      models: {}
+    };
+    _cachedConfig = null;
+    _cachedRoot = null;
+    CONTEXT_LIMITS = {
+      synthesis: 3e4,
+      fragility: 15e3,
+      experimentDoc: 15e3,
+      deadEnds: 15e3
+    };
+  }
+});
+
 // src/commands/status.ts
 var status_exports = {};
 __export(status_exports, {
@@ -1707,1122 +1809,1207 @@ function buildSummary(expCount, activeSession, sessionsSinceCompression, config)
   }
   return parts.join(". ");
 }
-function loadConfig(projectRoot) {
-  const configPath = path3.join(projectRoot, ".majlis", "config.json");
-  if (!fs3.existsSync(configPath)) {
-    throw new Error("Missing .majlis/config.json. Run `majlis init` first.");
-  }
-  return JSON.parse(fs3.readFileSync(configPath, "utf-8"));
-}
-var fs3, path3;
 var init_status = __esm({
   "src/commands/status.ts"() {
     "use strict";
-    fs3 = __toESM(require("fs"));
-    path3 = __toESM(require("path"));
     init_connection();
     init_queries();
+    init_config();
     init_format();
   }
 });
 
-// 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 = loadConfig2(root);
-  const expIdIdx = args.indexOf("--experiment");
-  let exp;
-  if (expIdIdx >= 0) {
-    exp = getExperimentById(db, Number(args[expIdIdx + 1]));
+// 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 = loadConfig2(root);
-  const expIdIdx = args.indexOf("--experiment");
-  let exp;
-  if (expIdIdx >= 0) {
-    exp = getExperimentById(db, Number(args[expIdIdx + 1]));
-  } 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 (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 (isJson) {
-    console.log(JSON.stringify({ experiment: exp.slug, comparisons }, null, 2));
-    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 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 (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;
 }
-function formatDelta(delta) {
-  const prefix = delta > 0 ? "+" : "";
-  return `${prefix}${delta.toFixed(4)}`;
-}
-function loadConfig2(projectRoot) {
-  const configPath = path4.join(projectRoot, ".majlis", "config.json");
-  if (!fs4.existsSync(configPath)) {
-    throw new Error("Missing .majlis/config.json. Run `majlis init` first.");
+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;
   }
-  return JSON.parse(fs4.readFileSync(configPath, "utf-8"));
 }
-var fs4, path4, import_node_child_process;
-var init_measure = __esm({
-  "src/commands/measure.ts"() {
+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"() {
     "use strict";
-    fs4 = __toESM(require("fs"));
-    path4 = __toESM(require("path"));
-    import_node_child_process = require("child_process");
-    init_connection();
-    init_queries();
-    init_metrics();
-    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 = loadConfig3(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 subTypeIdx = args.indexOf("--sub-type");
-  const subType = subTypeIdx >= 0 ? args[subTypeIdx + 1] : 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`);
+  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 reasonIdx = args.indexOf("--reason");
-  const reason = reasonIdx >= 0 ? args[reasonIdx + 1] : "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 loadConfig3(projectRoot) {
-  const configPath = path5.join(projectRoot, ".majlis", "config.json");
-  if (!fs5.existsSync(configPath)) {
-    return { cycle: { auto_baseline_on_new_experiment: false } };
-  }
-  return JSON.parse(fs5.readFileSync(configPath, "utf-8"));
+function extractYamlField(yaml, field) {
+  const match = yaml.match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
+  return match ? match[1].trim() : null;
 }
-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_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 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 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 accomplishedIdx = args.indexOf("--accomplished");
-    const accomplished = accomplishedIdx >= 0 ? args[accomplishedIdx + 1] : null;
-    const unfinishedIdx = args.indexOf("--unfinished");
-    const unfinished = unfinishedIdx >= 0 ? args[unfinishedIdx + 1] : null;
-    const fragilityIdx = args.indexOf("--fragility");
-    const fragility = fragilityIdx >= 0 ? args[fragilityIdx + 1] : 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_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 levelIdx = args.indexOf("--level");
-  const level = levelIdx >= 0 ? args[levelIdx + 1] : void 0;
-  const expIdx = args.indexOf("--experiment");
-  const experimentId = expIdx >= 0 ? Number(args[expIdx + 1]) : 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 subTypeIdx = args.indexOf("--sub-type");
-  const subType = subTypeIdx >= 0 ? args[subTypeIdx + 1] : void 0;
-  const searchIdx = args.indexOf("--search");
-  const searchTerm = searchIdx >= 0 ? args[searchIdx + 1] : void 0;
-  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 = 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;
+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;
-  }
-  if (history.length === 0) {
-    info(`No metric history for fixture: ${fixture}`);
-    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 "";
   }
-  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 = loadConfig4(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;
+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("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));
+  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 checkCommit(db) {
-  let stdinData = "";
-  try {
-    stdinData = fs6.readFileSync(0, "utf-8");
-  } catch {
+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 (stdinData) {
-    try {
-      const hookInput = JSON.parse(stdinData);
-      const command = hookInput?.tool_input?.command ?? "";
-      if (!command.includes("git commit")) {
-        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
+        });
       }
-    } 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 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 loadConfig4(projectRoot) {
-  const configPath = path6.join(projectRoot, ".majlis", "config.json");
-  if (!fs6.existsSync(configPath)) {
-    return { cycle: { circuit_breaker_threshold: 3 } };
+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 JSON.parse(fs6.readFileSync(configPath, "utf-8"));
+  return results;
 }
-var fs6, path6;
-var init_query = __esm({
-  "src/commands/query.ts"() {
+var init_metrics = __esm({
+  "src/metrics.ts"() {
     "use strict";
-    fs6 = __toESM(require("fs"));
-    path6 = __toESM(require("path"));
-    init_connection();
     init_queries();
-    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/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];
+  }
+});
+
+// src/commands/measure.ts
+var measure_exports = {};
+__export(measure_exports, {
+  baseline: () => baseline,
+  compare: () => compare,
+  measure: () => measure
+});
+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"');
     }
-    return tryParseJson(resultText.trim());
-  } catch (err) {
-    console.warn(`[majlis] Haiku extraction failed for ${role}: ${err instanceof Error ? err.message : String(err)}`);
-    return null;
+    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}`);
   }
 }
-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 = path7.join(root, ".majlis", "agents", `${role}.md`);
-  if (!fs7.existsSync(filePath)) {
-    throw new Error(`Agent definition not found: ${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);
+  }
+}
+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));
+}
+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;
+  }
+  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 = path6.join(root, "docs", "synthesis", "fragility.md");
+  if (!fs6.existsSync(fragPath)) {
+    info("No fragility map found.");
+    return;
   }
-  const content = fs7.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 content = fs6.readFileSync(fragPath, "utf-8");
+  if (isJson) {
+    console.log(JSON.stringify({ content }, null, 2));
+    return;
   }
-  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;
+  header("Fragility Map");
+  console.log(content);
 }
-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, null, 2);
-  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 queryHistory(db, args, isJson) {
+  const fixture = args.filter((a) => !a.startsWith("--"))[0];
+  if (!fixture) {
+    throw new Error("Usage: majlis history <fixture>");
   }
-  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 history = getMetricHistoryByFixture(db, fixture);
+  if (isJson) {
+    console.log(JSON.stringify(history, null, 2));
+    return;
   }
-  return { output: markdown, structured, truncated };
-}
-async function spawnSynthesiser(context, projectRoot) {
-  const root = projectRoot ?? findProjectRoot() ?? process.cwd();
-  const contextJson = JSON.stringify(context, null, 2);
-  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: "opus",
-    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 };
+  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));
 }
-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 = path7.join(
-    root,
-    "docs",
-    "experiments",
-    `${String(context.experiment?.id ?? 0).padStart(3, "0")}-${expSlug}.md`
-  );
-  const templatePath = path7.join(root, "docs", "experiments", "_TEMPLATE.md");
-  const template = fs7.existsSync(templatePath) ? fs7.readFileSync(templatePath, "utf-8") : "";
-  const currentDoc = fs7.existsSync(expDocPath) ? fs7.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}.`);
+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));
 }
-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}`);
+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 {
     }
   }
-  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 "";
+  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 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 = path7.join(projectRoot, dir);
-  if (!fs7.existsSync(fullDir)) {
-    fs7.mkdirSync(fullDir, { recursive: true });
+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";
+    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/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 expSlug = context.experiment?.slug ?? "general";
-  const nextNum = String(context.experiment?.id ?? 1).padStart(3, "0");
-  const filename = `${nextNum}-${role}-${expSlug}.md`;
-  const target = path7.join(fullDir, filename);
-  fs7.writeFileSync(target, markdown);
   return target;
 }
-var fs7, path7, import_claude_agent_sdk2, ROLE_MAX_TURNS, DIM2, RESET2, CYAN2;
-var init_spawn = __esm({
-  "src/agents/spawn.ts"() {
+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";
-    fs7 = __toESM(require("fs"));
-    path7 = __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();
   }
 });
 
@@ -2880,11 +3067,13 @@ async function resolve(db, exp, projectRoot) {
         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;
-      storeBuilderGuidance(db, exp.id, guidanceText);
-      updateExperimentStatus(db, exp.id, "building");
-      if (exp.sub_type) {
-        incrementSubTypeFailure(db, exp.sub_type, exp.id, "weak");
-      }
+      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 for builder.`);
       break;
     }
@@ -2892,19 +3081,21 @@ async function resolve(db, exp, projectRoot) {
       gitRevert(exp.branch, projectRoot);
       const rejectedComponents = grades.filter((g) => g.grade === "rejected");
       const whyFailed = rejectedComponents.map((r) => r.notes ?? "rejected").join("; ");
-      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");
-      }
+      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;
     }
@@ -2943,24 +3134,24 @@ function gitRevert(branch, cwd) {
   }
 }
 function appendToFragilityMap(projectRoot, expSlug, gaps) {
-  const fragPath = path8.join(projectRoot, "docs", "synthesis", "fragility.md");
+  const fragPath = path7.join(projectRoot, "docs", "synthesis", "fragility.md");
   let content = "";
-  if (fs8.existsSync(fragPath)) {
-    content = fs8.readFileSync(fragPath, "utf-8");
+  if (fs7.existsSync(fragPath)) {
+    content = fs7.readFileSync(fragPath, "utf-8");
   }
   const entry = `
 ## From experiment: ${expSlug}
 ${gaps}
 `;
-  fs8.writeFileSync(fragPath, content + entry);
+  fs7.writeFileSync(fragPath, content + entry);
 }
-var fs8, path8, import_node_child_process3;
+var fs7, path7, import_node_child_process3;
 var init_resolve = __esm({
   "src/resolve.ts"() {
     "use strict";
-    fs8 = __toESM(require("fs"));
-    path8 = __toESM(require("path"));
-    init_types();
+    fs7 = __toESM(require("fs"));
+    path7 = __toESM(require("path"));
+    init_types2();
     init_queries();
     init_spawn();
     import_node_child_process3 = require("child_process");
@@ -3003,12 +3194,11 @@ 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 */);
-  const synthesis = readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md"));
-  const fragility = readFileOrEmpty(path9.join(root, "docs", "synthesis", "fragility.md"));
+  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
   const structuralDeadEnds = exp.sub_type ? listStructuralDeadEndsBySubType(db, exp.sub_type) : listStructuralDeadEnds(db);
   const result = await spawnAgent("gatekeeper", {
     experiment: {
@@ -3052,13 +3242,12 @@ async function doBuild(db, exp, root) {
   transition(exp.status, "building" /* BUILDING */);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
   const builderGuidance = getBuilderGuidance(db, exp.id);
-  const fragilityPath = path9.join(root, "docs", "synthesis", "fragility.md");
-  const fragility = fs9.existsSync(fragilityPath) ? fs9.readFileSync(fragilityPath, "utf-8") : "";
-  const synthesisPath = path9.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs9.existsSync(synthesisPath) ? fs9.readFileSync(synthesisPath, "utf-8") : "";
+  const fragility = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
   const confirmedDoubts = getConfirmedDoubts(db, exp.id);
-  const config = loadConfig5(root);
-  if (config.metrics?.command) {
+  const config = loadConfig(root);
+  const existingBaseline = getMetricsByExperimentAndPhase(db, exp.id, "before");
+  if (config.metrics?.command && existingBaseline.length === 0) {
     try {
       const output = (0, import_node_child_process4.execSync)(config.metrics.command, {
         cwd: root,
@@ -3149,7 +3338,7 @@ async function doChallenge(db, exp, root) {
   } catch {
   }
   if (gitDiff.length > 8e3) gitDiff = gitDiff.slice(0, 8e3) + "\n[DIFF TRUNCATED]";
-  const synthesis = readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md"));
+  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
   let taskPrompt = `Construct adversarial test cases for experiment ${exp.slug}: ${exp.hypothesis}`;
   if (gitDiff) {
     taskPrompt += `
@@ -3182,9 +3371,9 @@ ${gitDiff}
 async function doDoubt(db, exp, root) {
   transition(exp.status, "doubted" /* DOUBTED */);
   const paddedNum = String(exp.id).padStart(3, "0");
-  const expDocPath = path9.join(root, "docs", "experiments", `${paddedNum}-${exp.slug}.md`);
-  const experimentDoc = readFileOrEmpty(expDocPath);
-  const synthesis = readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md"));
+  const expDocPath = path8.join(root, "docs", "experiments", `${paddedNum}-${exp.slug}.md`);
+  const experimentDoc = truncateContext(readFileOrEmpty(expDocPath), CONTEXT_LIMITS.experimentDoc);
+  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
   let taskPrompt = `Doubt the work in experiment ${exp.slug}: ${exp.hypothesis}. Produce a doubt document with evidence for each doubt.`;
   if (experimentDoc) {
@@ -3223,8 +3412,8 @@ ${experimentDoc}
 }
 async function doScout(db, exp, root) {
   transition(exp.status, "scouted" /* SCOUTED */);
-  const synthesis = readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md"));
-  const fragility = readFileOrEmpty(path9.join(root, "docs", "synthesis", "fragility.md"));
+  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
   const deadEndsSummary = deadEnds.map(
     (d) => `- [${d.category ?? "structural"}] ${d.approach}: ${d.why_failed}`
@@ -3271,12 +3460,12 @@ ${fragility}`;
 async function doVerify(db, exp, root) {
   transition(exp.status, "verifying" /* VERIFYING */);
   const doubts = getDoubtsByExperiment(db, exp.id);
-  const challengeDir = path9.join(root, "docs", "challenges");
+  const challengeDir = path8.join(root, "docs", "challenges");
   let challenges = "";
-  if (fs9.existsSync(challengeDir)) {
-    const files = fs9.readdirSync(challengeDir).filter((f) => f.includes(exp.slug) && f.endsWith(".md"));
+  if (fs8.existsSync(challengeDir)) {
+    const files = fs8.readdirSync(challengeDir).filter((f) => f.includes(exp.slug) && f.endsWith(".md"));
     for (const f of files) {
-      challenges += fs9.readFileSync(path9.join(challengeDir, f), "utf-8") + "\n\n";
+      challenges += fs8.readFileSync(path8.join(challengeDir, f), "utf-8") + "\n\n";
     }
   }
   const beforeMetrics = getMetricsByExperimentAndPhase(db, exp.id, "before");
@@ -3344,14 +3533,14 @@ async function doVerify(db, exp, root) {
   success(`Verification complete for ${exp.slug}. Run \`majlis resolve\` next.`);
 }
 async function doCompress(db, root) {
-  const synthesisPath = path9.join(root, "docs", "synthesis", "current.md");
-  const sizeBefore = fs9.existsSync(synthesisPath) ? fs9.statSync(synthesisPath).size : 0;
+  const synthesisPath = path8.join(root, "docs", "synthesis", "current.md");
+  const sizeBefore = fs8.existsSync(synthesisPath) ? fs8.statSync(synthesisPath).size : 0;
   const sessionCount = getSessionsSinceCompression(db);
   const dbExport = exportForCompressor(db);
   const result = await spawnAgent("compressor", {
     taskPrompt: "## Structured Data (CANONICAL \u2014 from SQLite database)\nThe database export below is the source of truth. docs/ files are agent artifacts that may contain stale or incorrect information. Cross-reference everything against this data.\n\n" + dbExport + "\n\n## Your Task\nRead ALL experiments, decisions, doubts, challenges, verification reports, reframes, and recent diffs. Cross-reference for contradictions, redundancies, and patterns. REWRITE docs/synthesis/current.md \u2014 shorter and denser. Update docs/synthesis/fragility.md with current weak areas. Update docs/synthesis/dead-ends.md with structural constraints from rejected experiments."
   }, root);
-  const sizeAfter = fs9.existsSync(synthesisPath) ? fs9.statSync(synthesisPath).size : 0;
+  const sizeAfter = fs8.existsSync(synthesisPath) ? fs8.statSync(synthesisPath).size : 0;
   recordCompression(db, sessionCount, sizeBefore, sizeAfter);
   success(`Compression complete. Synthesis: ${sizeBefore}B \u2192 ${sizeAfter}B`);
 }
@@ -3442,42 +3631,20 @@ function ingestStructuredOutput(db, experimentId, structured) {
     info(`Ingested ${structured.findings.length} finding(s)`);
   }
 }
-function readFileOrEmpty(filePath) {
-  try {
-    return fs9.readFileSync(filePath, "utf-8");
-  } catch {
-    return "";
-  }
-}
-function loadConfig5(projectRoot) {
-  const configPath = path9.join(projectRoot, ".majlis", "config.json");
-  if (!fs9.existsSync(configPath)) {
-    return {
-      project: { name: "", description: "", objective: "" },
-      cycle: {
-        compression_interval: 5,
-        circuit_breaker_threshold: 3,
-        require_doubt_before_verify: true,
-        require_challenge_before_verify: false,
-        auto_baseline_on_new_experiment: true
-      }
-    };
-  }
-  return JSON.parse(fs9.readFileSync(configPath, "utf-8"));
-}
-var fs9, path9, import_node_child_process4;
+var fs8, path8, import_node_child_process4;
 var init_cycle = __esm({
   "src/commands/cycle.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs"));
-    path9 = __toESM(require("path"));
+    fs8 = __toESM(require("fs"));
+    path8 = __toESM(require("path"));
     import_node_child_process4 = require("child_process");
     init_connection();
     init_queries();
     init_machine();
-    init_types();
+    init_types2();
     init_spawn();
     init_resolve();
+    init_config();
     init_metrics();
     init_format();
   }
@@ -3496,10 +3663,10 @@ async function classify(args) {
   if (!domain) {
     throw new Error('Usage: majlis classify "domain description"');
   }
-  const synthesisPath = path10.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs10.existsSync(synthesisPath) ? fs10.readFileSync(synthesisPath, "utf-8") : "";
-  const deadEndsPath = path10.join(root, "docs", "synthesis", "dead-ends.md");
-  const deadEnds = fs10.existsSync(deadEndsPath) ? fs10.readFileSync(deadEndsPath, "utf-8") : "";
+  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,
@@ -3517,22 +3684,22 @@ Write the classification to docs/classification/ following the template.`
 async function reframe(args) {
   const root = findProjectRoot();
   if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const classificationDir = path10.join(root, "docs", "classification");
+  const classificationDir = path9.join(root, "docs", "classification");
   let classificationContent = "";
-  if (fs10.existsSync(classificationDir)) {
-    const files = fs10.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+  if (fs9.existsSync(classificationDir)) {
+    const files = fs9.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
     for (const f of files) {
-      classificationContent += fs10.readFileSync(path10.join(classificationDir, f), "utf-8") + "\n\n";
+      classificationContent += fs9.readFileSync(path9.join(classificationDir, f), "utf-8") + "\n\n";
     }
   }
-  const synthesisPath = path10.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs10.existsSync(synthesisPath) ? fs10.readFileSync(synthesisPath, "utf-8") : "";
-  const deadEndsPath = path10.join(root, "docs", "synthesis", "dead-ends.md");
-  const deadEnds = fs10.existsSync(deadEndsPath) ? fs10.readFileSync(deadEndsPath, "utf-8") : "";
-  const configPath = path10.join(root, ".majlis", "config.json");
+  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 (fs10.existsSync(configPath)) {
-    const config = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
+  if (fs9.existsSync(configPath)) {
+    const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
     problemStatement = `${config.project?.description ?? ""}
 Objective: ${config.project?.objective ?? ""}`;
   }
@@ -3556,12 +3723,12 @@ Write to docs/reframes/.`
   }, root);
   success("Reframe complete. Check docs/reframes/ for the output.");
 }
-var fs10, path10;
+var fs9, path9;
 var init_classify = __esm({
   "src/commands/classify.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
+    fs9 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
     init_connection();
     init_spawn();
     init_format();
@@ -3578,20 +3745,19 @@ async function audit(args) {
   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 = loadConfig6(root);
+  const config = loadConfig(root);
   const experiments = listAllExperiments(db);
   const deadEnds = listAllDeadEnds(db);
   const circuitBreakers = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
-  const classificationDir = path11.join(root, "docs", "classification");
+  const classificationDir = path10.join(root, "docs", "classification");
   let classification = "";
-  if (fs11.existsSync(classificationDir)) {
-    const files = fs11.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+  if (fs10.existsSync(classificationDir)) {
+    const files = fs10.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
     for (const f of files) {
-      classification += fs11.readFileSync(path11.join(classificationDir, f), "utf-8") + "\n\n";
+      classification += fs10.readFileSync(path10.join(classificationDir, f), "utf-8") + "\n\n";
     }
   }
-  const synthesisPath = path11.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs11.existsSync(synthesisPath) ? fs11.readFileSync(synthesisPath, "utf-8") : "";
+  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) {
@@ -3635,22 +3801,16 @@ Output: either "classification confirmed \u2014 continue" or "re-classify from X
   }, root);
   success("Purpose audit complete. Review the output above.");
 }
-function loadConfig6(projectRoot) {
-  const configPath = path11.join(projectRoot, ".majlis", "config.json");
-  if (!fs11.existsSync(configPath)) {
-    return { project: { name: "", description: "", objective: "" }, cycle: { circuit_breaker_threshold: 3 } };
-  }
-  return JSON.parse(fs11.readFileSync(configPath, "utf-8"));
-}
-var fs11, path11;
+var fs10, path10;
 var init_audit = __esm({
   "src/commands/audit.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
+    fs10 = __toESM(require("fs"));
+    path10 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_spawn();
+    init_config();
     init_format();
   }
 });
@@ -3664,7 +3824,7 @@ 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 = loadConfig7(root);
+  const config = loadConfig(root);
   const slugArg = args.filter((a) => !a.startsWith("--"))[0];
   let exp;
   if (slugArg) {
@@ -3696,7 +3856,17 @@ async function runNextStep(db, exp, config, root, isJson) {
   }
   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.`);
-    warn("Triggering Maqasid Check (purpose audit).");
+    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;
   }
@@ -3736,6 +3906,16 @@ async function runAutoLoop(db, exp, config, root, isJson) {
     }
     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;
     }
@@ -3784,37 +3964,26 @@ 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}`);
   }
 }
-function loadConfig7(projectRoot) {
-  const configPath = path12.join(projectRoot, ".majlis", "config.json");
-  if (!fs12.existsSync(configPath)) {
-    return {
-      project: { name: "", description: "", objective: "" },
-      cycle: {
-        compression_interval: 5,
-        circuit_breaker_threshold: 3,
-        require_doubt_before_verify: true,
-        require_challenge_before_verify: false,
-        auto_baseline_on_new_experiment: true
-      }
-    };
-  }
-  return JSON.parse(fs12.readFileSync(configPath, "utf-8"));
-}
-var fs12, path12;
 var init_next = __esm({
   "src/commands/next.ts"() {
     "use strict";
-    fs12 = __toESM(require("fs"));
-    path12 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_machine();
-    init_types();
+    init_types2();
     init_queries();
+    init_config();
     init_cycle();
     init_audit();
     init_format();
@@ -3834,13 +4003,19 @@ async function run(args) {
     throw new Error('Usage: majlis run "goal description"');
   }
   const db = getDb(root);
-  const config = loadConfig8(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) {
@@ -3860,8 +4035,13 @@ async function run(args) {
         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);
+      exp = await createNewExperiment(db, root, hypothesis);
       success(`Created experiment #${exp.id}: ${exp.slug}`);
     }
     if (isTerminal(exp.status)) {
@@ -3875,7 +4055,9 @@ async function run(args) {
     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 {
@@ -3889,7 +4071,13 @@ async function run(args) {
           "procedural"
         );
         updateExperimentStatus(db, exp.id, "dead_end");
-      } catch {
+      } 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;
       }
     }
   }
@@ -3902,11 +4090,11 @@ async function run(args) {
   info("Run `majlis status` to see final state.");
 }
 async function deriveNextHypothesis(goal, root, db) {
-  const synthesis = readFileOrEmpty2(path13.join(root, "docs", "synthesis", "current.md"));
-  const fragility = readFileOrEmpty2(path13.join(root, "docs", "synthesis", "fragility.md"));
-  const deadEndsDoc = readFileOrEmpty2(path13.join(root, "docs", "synthesis", "dead-ends.md"));
+  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 = loadConfig8(root);
+  const config = loadConfig(root);
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
@@ -3991,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)) {
@@ -4016,49 +4204,23 @@ function createNewExperiment(db, root, hypothesis) {
   const exp = createExperiment(db, finalSlug, branch, hypothesis, null, null);
   updateExperimentStatus(db, exp.id, "reframed");
   exp.status = "reframed";
-  const docsDir = path13.join(root, "docs", "experiments");
-  const templatePath = path13.join(docsDir, "_TEMPLATE.md");
-  if (fs13.existsSync(templatePath)) {
-    const template = fs13.readFileSync(templatePath, "utf-8");
+  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 = path13.join(docsDir, `${paddedNum}-${finalSlug}.md`);
-    fs13.writeFileSync(logPath, logContent);
+    const logPath = path11.join(docsDir, `${paddedNum}-${finalSlug}.md`);
+    fs11.writeFileSync(logPath, logContent);
     info(`Created experiment log: docs/experiments/${paddedNum}-${finalSlug}.md`);
   }
   return exp;
 }
-function readFileOrEmpty2(filePath) {
-  try {
-    return fs13.readFileSync(filePath, "utf-8");
-  } catch {
-    return "";
-  }
-}
-function slugify2(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
-}
-function loadConfig8(projectRoot) {
-  const configPath = path13.join(projectRoot, ".majlis", "config.json");
-  if (!fs13.existsSync(configPath)) {
-    return {
-      project: { name: "", description: "", objective: "" },
-      cycle: {
-        compression_interval: 5,
-        circuit_breaker_threshold: 3,
-        require_doubt_before_verify: true,
-        require_challenge_before_verify: false,
-        auto_baseline_on_new_experiment: true
-      }
-    };
-  }
-  return JSON.parse(fs13.readFileSync(configPath, "utf-8"));
-}
-var fs13, path13, import_node_child_process5;
+var fs11, path11, import_node_child_process5;
 var init_run = __esm({
   "src/commands/run.ts"() {
     "use strict";
-    fs13 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path11 = __toESM(require("path"));
     import_node_child_process5 = require("child_process");
     init_connection();
     init_queries();
@@ -4066,17 +4228,27 @@ var init_run = __esm({
     init_next();
     init_cycle();
     init_spawn();
+    init_config();
+    init_shutdown();
     init_format();
   }
 });
 
 // src/cli.ts
-var fs14 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
 var VERSION = JSON.parse(
-  fs14.readFileSync(path14.join(__dirname, "..", "package.json"), "utf-8")
+  fs12.readFileSync(path12.join(__dirname, "..", "package.json"), "utf-8")
 ).version;
 async function main() {
+  let sigintCount = 0;
+  process.on("SIGINT", () => {
+    sigintCount++;
+    if (sigintCount >= 2) process.exit(130);
+    const { requestShutdown: requestShutdown2 } = (init_shutdown(), __toCommonJS(shutdown_exports));
+    requestShutdown2();
+    console.error("\n\x1B[33m[majlis] Interrupt received. Finishing current step...\x1B[0m");
+  });
   const args = process.argv.slice(2);
   if (args.includes("--version") || args.includes("-v")) {
     console.log(VERSION);