majlis 0.4.5 → 0.5.1

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) {
@@ -170,6 +191,34 @@ var init_migrations = __esm({
         created_at DATETIME DEFAULT CURRENT_TIMESTAMP
       );
       CREATE INDEX idx_challenges_experiment ON challenges(experiment_id);
+    `);
+      },
+      // Migration 004: v3 → v4 — Reframes, findings tables; dead-end classification
+      (db) => {
+        db.exec(`
+      CREATE TABLE reframes (
+        id INTEGER PRIMARY KEY,
+        experiment_id INTEGER REFERENCES experiments(id),
+        decomposition TEXT NOT NULL,
+        divergences TEXT NOT NULL,
+        recommendation TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE INDEX idx_reframes_experiment ON reframes(experiment_id);
+
+      CREATE TABLE findings (
+        id INTEGER PRIMARY KEY,
+        experiment_id INTEGER REFERENCES experiments(id),
+        approach TEXT NOT NULL,
+        source TEXT NOT NULL,
+        relevance TEXT NOT NULL,
+        contradicts_current BOOLEAN NOT NULL DEFAULT 0,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE INDEX idx_findings_experiment ON findings(experiment_id);
+
+      ALTER TABLE dead_ends ADD COLUMN category TEXT DEFAULT 'structural'
+        CHECK(category IN ('structural', 'procedural'));
     `);
       }
     ];
@@ -552,11 +601,20 @@ and write up what you learned.
 - \`scripts/benchmark.py\` \u2014 the measurement tool. Never change how you're measured.
 - \`.majlis/\` \u2014 framework config. Not your concern.
 
+## Confirmed Doubts
+If your context includes confirmedDoubts, these are weaknesses that the verifier has
+confirmed from a previous cycle. You MUST address each one. Do not ignore them \u2014
+the verifier will check again.
+
+## Metrics
+The framework captures baseline and post-build metrics automatically. Do NOT claim
+specific metric numbers unless quoting framework output. Do NOT run the benchmark
+yourself unless instructed to. If you need to verify your change works, do a minimal
+targeted test, not a full benchmark run.
+
 ## During building:
 - Tag EVERY decision: proof / test / strong-consensus / consensus / analogy / judgment
 - When making judgment-level decisions, state: "This is judgment \u2014 reasoning without precedent"
-- Run baseline metrics BEFORE making changes
-- Run comparison metrics AFTER making changes (once)
 
 You may NOT verify your own work or mark your own decisions as proven.
 Output your decisions in structured format so they can be recorded in the database.
@@ -579,8 +637,14 @@ tools: [Read, Glob, Grep]
 ---
 You are the Critic. You practise constructive doubt.
 
-You receive the builder's OUTPUT only \u2014 never its reasoning chain.
-Read the experiment log, related prior experiments, classification, and synthesis.
+You receive:
+- The builder's experiment document (the artifact, not the reasoning chain)
+- The current synthesis (project state)
+- Dead-ends (approaches that have been tried and failed)
+- The hypothesis and experiment metadata
+
+You do NOT see the builder's reasoning chain \u2014 only their documented output.
+Use the experiment doc, synthesis, and dead-ends to find weaknesses.
 
 For each doubt:
 - What specific claim, decision, or assumption you doubt
@@ -611,6 +675,13 @@ tools: [Read, Glob, Grep]
 You are the Adversary. You do NOT review code for bugs.
 You reason about problem structure to CONSTRUCT pathological cases.
 
+You receive:
+- The git diff of the builder's code changes (the actual code, not prose)
+- The current synthesis (project state)
+- The hypothesis and experiment metadata
+
+Study the CODE DIFF carefully \u2014 that is where the builder's assumptions are exposed.
+
 For each approach the builder takes, ask:
 - What input would make this fail?
 - What boundary condition was not tested?
@@ -637,6 +708,12 @@ tools: [Read, Glob, Grep, Bash]
 ---
 You are the Verifier. Perform dual verification:
 
+You receive:
+- All doubts with explicit DOUBT-{id} identifiers (use these in your doubt_resolutions)
+- Challenge documents from the adversary
+- Framework-captured metrics (baseline vs post-build) \u2014 this is GROUND TRUTH
+- The hypothesis and experiment metadata
+
 ## Scope Constraint (CRITICAL)
 
 You must produce your structured output (grades + doubt resolutions) within your turn budget.
@@ -646,6 +723,11 @@ Reserve your final turns for writing the structured majlis-json output.
 
 The framework saves your output automatically. Do NOT attempt to write files.
 
+## Metrics (GROUND TRUTH)
+If framework-captured metrics are in your context, these are the canonical before/after numbers.
+Do NOT trust numbers claimed by the builder \u2014 compare against the framework metrics.
+If the builder claims improvement but the framework metrics show regression, flag this.
+
 ## PROVENANCE CHECK:
 - Can every piece of code trace to an experiment or decision?
 - Is the chain unbroken from requirement -> classification -> experiment -> code?
@@ -660,13 +742,17 @@ Grade each component: sound / good / weak / rejected
 Grade each doubt/challenge: confirmed / dismissed (with evidence) / inconclusive
 
 ## Structured Output Format
+IMPORTANT: For doubt_resolutions, use the DOUBT-{id} numbers from your context.
+Example: if your context lists "DOUBT-7: [critical] The algorithm fails on X",
+use doubt_id: 7 in your output.
+
 <!-- majlis-json
 {
   "grades": [
     { "component": "...", "grade": "sound|good|weak|rejected", "provenance_intact": true, "content_correct": true, "notes": "..." }
   ],
   "doubt_resolutions": [
-    { "doubt_id": 0, "resolution": "confirmed|dismissed|inconclusive" }
+    { "doubt_id": 7, "resolution": "confirmed|dismissed|inconclusive" }
   ]
 }
 -->`,
@@ -692,7 +778,18 @@ Compare your decomposition with the existing classification.
 Flag structural divergences \u2014 these are the most valuable signals.
 
 Produce your reframe document as output. Do NOT attempt to write files.
-The framework saves your output automatically.`,
+The framework saves your output automatically.
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "reframe": {
+    "decomposition": "How you decomposed the problem",
+    "divergences": ["List of structural divergences from current classification"],
+    "recommendation": "What should change based on your independent analysis"
+  }
+}
+-->`,
       compressor: `---
 name: compressor
 model: opus
@@ -700,23 +797,36 @@ tools: [Read, Write, Edit, Glob, Grep]
 ---
 You are the Compressor. Hold the entire project in view and compress it.
 
-1. Read ALL experiments, decisions, doubts, challenges, verification reports,
-   reframes, and recent diffs.
-2. Cross-reference: same question in different language? contradicting decisions?
+Your taskPrompt includes a "Structured Data (CANONICAL)" section exported directly
+from the SQLite database. This is the source of truth. docs/ files are agent artifacts
+that may contain stale or incorrect information. Cross-reference everything against
+the database export.
+
+1. Read the database export in your context FIRST \u2014 it has all experiments, decisions,
+   doubts (with resolutions), verifications (with grades), challenges, and dead-ends.
+2. Read docs/ files for narrative context, but trust the database when they conflict.
+3. Cross-reference: same question in different language? contradicting decisions?
    workaround masking root cause?
-3. Update fragility map: thin coverage, weak components, untested judgment
+4. Update fragility map: thin coverage, weak components, untested judgment
    decisions, broken provenance.
-4. Update dead-end registry: compress rejected experiments into structural constraints.
-5. REWRITE synthesis \u2014 shorter and denser. If it's growing, you're accumulating,
-   not compressing.
-6. Review classification: new sub-types? resolved sub-types?
+5. Update dead-end registry: compress rejected experiments into structural constraints.
+   Mark each dead-end as [structural] or [procedural].
+6. REWRITE synthesis using the Write tool \u2014 shorter and denser. If it's growing,
+   you're accumulating, not compressing. You MUST use the Write tool to update
+   docs/synthesis/current.md, docs/synthesis/fragility.md, and docs/synthesis/dead-ends.md.
+   The framework does NOT auto-save your output for these files.
+7. Review classification: new sub-types? resolved sub-types?
 
 You may NOT write code, make decisions, or run experiments.
 
 ## Structured Output Format
 <!-- majlis-json
 {
-  "guidance": "Summary of compression findings and updated state"
+  "compression_report": {
+    "synthesis_delta": "What changed in synthesis and why",
+    "new_dead_ends": ["List of newly identified dead-end constraints"],
+    "fragility_changes": ["List of changes to the fragility map"]
+  }
 }
 -->`,
       scout: `---
@@ -729,6 +839,11 @@ You are the Scout. You practise rihla \u2014 travel in search of knowledge.
 Your job is to search externally for alternative approaches, contradictory evidence,
 and perspectives from other fields that could inform the current experiment.
 
+You receive:
+- The current synthesis and fragility map
+- Dead-ends (approaches that have been tried and failed) \u2014 search for alternatives that circumvent these
+- The hypothesis and experiment metadata
+
 For the given experiment:
 1. Describe the problem in domain-neutral terms
 2. Search for alternative approaches in other fields or frameworks
@@ -739,13 +854,60 @@ For the given experiment:
 Rules:
 - Present findings neutrally. Report each approach on its own terms.
 - Note where external approaches contradict the current one \u2014 these are the most valuable signals.
+- Focus on approaches that CIRCUMVENT known dead-ends \u2014 these are the most valuable.
 - You may NOT modify code or make decisions. Produce your rihla document as output only.
 - Do NOT attempt to write files. The framework saves your output automatically.
 
 ## Structured Output Format
 <!-- majlis-json
 {
-  "decisions": []
+  "findings": [
+    { "approach": "Name of alternative approach", "source": "Where you found it", "relevance": "How it applies", "contradicts_current": true }
+  ]
+}
+-->`,
+      gatekeeper: `---
+name: gatekeeper
+model: sonnet
+tools: [Read, Glob, Grep]
+---
+You are the Gatekeeper. You check hypotheses before expensive build cycles.
+
+Your job is a fast quality gate \u2014 prevent wasted Opus builds on hypotheses that
+are stale, redundant with dead-ends, or too vague to produce a focused change.
+
+## Checks (in order)
+
+### 1. Stale References
+Does the hypothesis reference specific functions, line numbers, or structures that
+may not exist in the current code? Read the relevant files to verify.
+- If references are stale, list them in stale_references.
+
+### 2. Dead-End Overlap
+Does this hypothesis repeat an approach already ruled out by structural dead-ends?
+Check each structural dead-end in your context \u2014 if the hypothesis matches the
+approach or violates the structural_constraint, flag it.
+- If overlapping, list the dead-end IDs in overlapping_dead_ends.
+
+### 3. Scope Check
+Is this a single focused change? A good hypothesis names ONE function, mechanism,
+or parameter to change. A bad hypothesis says "improve X and also Y and also Z."
+- Flag if the hypothesis tries to do multiple things.
+
+## Output
+
+gate_decision:
+- **approve** \u2014 all checks pass, proceed to build
+- **flag** \u2014 concerns found but not blocking (warnings only)
+- **reject** \u2014 hypothesis must be revised (stale refs, dead-end repeat, or too vague)
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "gate_decision": "approve|reject|flag",
+  "reason": "Brief explanation of decision",
+  "stale_references": ["list of stale references found, if any"],
+  "overlapping_dead_ends": [0]
 }
 -->`
     };
@@ -1235,12 +1397,12 @@ function getMetricHistoryByFixture(db, fixture) {
     ORDER BY m.captured_at
   `).all(fixture);
 }
-function insertDeadEnd(db, experimentId, approach, whyFailed, structuralConstraint, subType) {
+function insertDeadEnd(db, experimentId, approach, whyFailed, structuralConstraint, subType, category = "structural") {
   const stmt = db.prepare(`
-    INSERT INTO dead_ends (experiment_id, approach, why_failed, structural_constraint, sub_type)
-    VALUES (?, ?, ?, ?, ?)
+    INSERT INTO dead_ends (experiment_id, approach, why_failed, structural_constraint, sub_type, category)
+    VALUES (?, ?, ?, ?, ?, ?)
   `);
-  const result = stmt.run(experimentId, approach, whyFailed, structuralConstraint, subType);
+  const result = stmt.run(experimentId, approach, whyFailed, structuralConstraint, subType, category);
   return db.prepare("SELECT * FROM dead_ends WHERE id = ?").get(result.lastInsertRowid);
 }
 function listDeadEndsBySubType(db, subType) {
@@ -1315,6 +1477,9 @@ function insertChallenge(db, experimentId, description, reasoning) {
   const result = stmt.run(experimentId, description, reasoning);
   return db.prepare("SELECT * FROM challenges WHERE id = ?").get(result.lastInsertRowid);
 }
+function getChallengesByExperiment(db, experimentId) {
+  return db.prepare("SELECT * FROM challenges WHERE experiment_id = ? ORDER BY created_at").all(experimentId);
+}
 function incrementSubTypeFailure(db, subType, experimentId, grade) {
   db.prepare(`
     INSERT INTO sub_type_failures (sub_type, experiment_id, grade)
@@ -1380,12 +1545,167 @@ function recordCompression(db, sessionCountSinceLast, synthesisSizeBefore, synth
   const result = stmt.run(sessionCountSinceLast, synthesisSizeBefore, synthesisSizeAfter);
   return db.prepare("SELECT * FROM compressions WHERE id = ?").get(result.lastInsertRowid);
 }
+function listStructuralDeadEnds(db) {
+  return db.prepare(`
+    SELECT * FROM dead_ends WHERE category = 'structural' ORDER BY created_at
+  `).all();
+}
+function listStructuralDeadEndsBySubType(db, subType) {
+  return db.prepare(`
+    SELECT * FROM dead_ends WHERE category = 'structural' AND sub_type = ? ORDER BY created_at
+  `).all(subType);
+}
+function insertReframe(db, experimentId, decomposition, divergences, recommendation) {
+  db.prepare(`
+    INSERT INTO reframes (experiment_id, decomposition, divergences, recommendation)
+    VALUES (?, ?, ?, ?)
+  `).run(experimentId, decomposition, divergences, recommendation);
+}
+function insertFinding(db, experimentId, approach, source, relevance, contradictsCurrent) {
+  db.prepare(`
+    INSERT INTO findings (experiment_id, approach, source, relevance, contradicts_current)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(experimentId, approach, source, relevance, contradictsCurrent ? 1 : 0);
+}
+function exportForCompressor(db, maxLength = 3e4) {
+  const experiments = listAllExperiments(db);
+  const sections = ["# Structured Data Export (from SQLite)\n"];
+  sections.push("## Experiments");
+  for (const exp of experiments) {
+    sections.push(`### EXP-${String(exp.id).padStart(3, "0")}: ${exp.slug}`);
+    sections.push(`- Status: ${exp.status} | Sub-type: ${exp.sub_type ?? "(none)"}`);
+    sections.push(`- Hypothesis: ${exp.hypothesis ?? "(none)"}`);
+    const decisions = listDecisionsByExperiment(db, exp.id);
+    if (decisions.length > 0) {
+      sections.push(`#### Decisions (${decisions.length})`);
+      for (const d of decisions) {
+        sections.push(`- [${d.evidence_level}] ${d.description} \u2014 ${d.justification} (${d.status})`);
+      }
+    }
+    const doubts = getDoubtsByExperiment(db, exp.id);
+    if (doubts.length > 0) {
+      sections.push(`#### Doubts (${doubts.length})`);
+      for (const d of doubts) {
+        sections.push(`- [${d.severity}] ${d.claim_doubted} (resolution: ${d.resolution ?? "pending"})`);
+      }
+    }
+    const verifications = getVerificationsByExperiment(db, exp.id);
+    if (verifications.length > 0) {
+      sections.push(`#### Verifications (${verifications.length})`);
+      for (const v of verifications) {
+        sections.push(`- ${v.component}: ${v.grade}${v.notes ? ` \u2014 ${v.notes}` : ""}`);
+      }
+    }
+    const challenges = getChallengesByExperiment(db, exp.id);
+    if (challenges.length > 0) {
+      sections.push(`#### Challenges (${challenges.length})`);
+      for (const c of challenges) {
+        sections.push(`- ${c.description}`);
+      }
+    }
+    sections.push("");
+  }
+  const deadEnds = listAllDeadEnds(db);
+  if (deadEnds.length > 0) {
+    sections.push("## Dead Ends");
+    for (const de of deadEnds) {
+      sections.push(`- [${de.category ?? "structural"}] ${de.approach}: ${de.why_failed} \u2192 ${de.structural_constraint}`);
+    }
+    sections.push("");
+  }
+  const unresolvedDoubts = db.prepare(`
+    SELECT d.*, e.slug as experiment_slug
+    FROM doubts d JOIN experiments e ON d.experiment_id = e.id
+    WHERE d.resolution IS NULL
+    ORDER BY d.severity DESC, d.created_at
+  `).all();
+  if (unresolvedDoubts.length > 0) {
+    sections.push("## Unresolved Doubts");
+    for (const d of unresolvedDoubts) {
+      sections.push(`- [${d.severity}] ${d.claim_doubted} (exp: ${d.experiment_slug})`);
+    }
+  }
+  const full = sections.join("\n");
+  if (full.length > maxLength) {
+    return full.slice(0, maxLength) + `
+
+[TRUNCATED \u2014 full export was ${full.length} chars]`;
+  }
+  return full;
+}
 var init_queries = __esm({
   "src/db/queries.ts"() {
     "use strict";
   }
 });
 
+// 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, {
@@ -1475,21 +1795,12 @@ 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();
   }
 });
@@ -1571,11 +1882,11 @@ 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");
+  const config = loadConfig(root);
+  const expIdStr = getFlagValue(args, "--experiment");
   let exp;
-  if (expIdIdx >= 0) {
-    exp = getExperimentById(db, Number(args[expIdIdx + 1]));
+  if (expIdStr !== void 0) {
+    exp = getExperimentById(db, Number(expIdStr));
   } else {
     exp = getLatestExperiment(db);
   }
@@ -1623,11 +1934,11 @@ 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");
+  const config = loadConfig(root);
+  const expIdStr = getFlagValue(args, "--experiment");
   let exp;
-  if (expIdIdx >= 0) {
-    exp = getExperimentById(db, Number(args[expIdIdx + 1]));
+  if (expIdStr !== void 0) {
+    exp = getExperimentById(db, Number(expIdStr));
   } else {
     exp = getLatestExperiment(db);
   }
@@ -1664,23 +1975,15 @@ 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.");
-  }
-  return JSON.parse(fs4.readFileSync(configPath, "utf-8"));
-}
-var fs4, path4, import_node_child_process;
+var import_node_child_process;
 var init_measure = __esm({
   "src/commands/measure.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_config();
     init_format();
   }
 });
@@ -1699,7 +2002,7 @@ async function newExperiment(args) {
     throw new Error('Usage: majlis new "hypothesis"');
   }
   const db = getDb(root);
-  const config = loadConfig3(root);
+  const config = loadConfig(root);
   const slug = slugify(hypothesis);
   if (getExperimentBySlug(db, slug)) {
     throw new Error(`Experiment with slug "${slug}" already exists.`);
@@ -1718,17 +2021,16 @@ async function newExperiment(args) {
   } catch (err) {
     warn(`Could not create branch ${branch} \u2014 continuing without git branch.`);
   }
-  const subTypeIdx = args.indexOf("--sub-type");
-  const subType = subTypeIdx >= 0 ? args[subTypeIdx + 1] : null;
+  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 docsDir = path4.join(root, "docs", "experiments");
+  const templatePath = path4.join(docsDir, "_TEMPLATE.md");
+  if (fs4.existsSync(templatePath)) {
+    const template = fs4.readFileSync(templatePath, "utf-8");
     const logContent = template.replace(/\{\{title\}\}/g, hypothesis).replace(/\{\{hypothesis\}\}/g, hypothesis).replace(/\{\{branch\}\}/g, branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, subType ?? "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    const logPath = path5.join(docsDir, `${paddedNum}-${slug}.md`);
-    fs5.writeFileSync(logPath, logContent);
+    const logPath = path4.join(docsDir, `${paddedNum}-${slug}.md`);
+    fs4.writeFileSync(logPath, logContent);
     info(`Created experiment log: docs/experiments/${paddedNum}-${slug}.md`);
   }
   if (config.cycle.auto_baseline_on_new_experiment && config.metrics.command) {
@@ -1754,15 +2056,16 @@ async function revert(args) {
     exp = getLatestExperiment(db);
     if (!exp) throw new Error("No active experiments to revert.");
   }
-  const reasonIdx = args.indexOf("--reason");
-  const reason = reasonIdx >= 0 ? args[reasonIdx + 1] : "Manually reverted";
+  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
+    exp.sub_type,
+    category
   );
   updateExperimentStatus(db, exp.id, "dead_end");
   try {
@@ -1785,22 +2088,16 @@ async function revert(args) {
 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"));
-}
-var fs5, path5, import_node_child_process2;
+var fs4, path4, import_node_child_process2;
 var init_experiment = __esm({
   "src/commands/experiment.ts"() {
     "use strict";
-    fs5 = __toESM(require("fs"));
-    path5 = __toESM(require("path"));
+    fs4 = __toESM(require("fs"));
+    path4 = __toESM(require("path"));
     import_node_child_process2 = require("child_process");
     init_connection();
     init_queries();
+    init_config();
     init_format();
   }
 });
@@ -1840,12 +2137,9 @@ async function session(args) {
     if (!active) {
       throw new Error("No active session to end.");
     }
-    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;
+    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}`);
@@ -1858,6 +2152,7 @@ var init_session = __esm({
     "use strict";
     init_connection();
     init_queries();
+    init_config();
     init_format();
   }
 });
@@ -1887,10 +2182,9 @@ async function query(command, args, isJson) {
   }
 }
 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 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));
@@ -1911,10 +2205,8 @@ function queryDecisions(db, args, isJson) {
   console.log(table(["ID", "Exp", "Level", "Description", "Status"], rows));
 }
 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;
+  const subType = getFlagValue(args, "--sub-type");
+  const searchTerm = getFlagValue(args, "--search");
   let deadEnds;
   if (subType) {
     deadEnds = listDeadEndsBySubType(db, subType);
@@ -1941,12 +2233,12 @@ function queryDeadEnds(db, args, isJson) {
   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)) {
+  const fragPath = path5.join(root, "docs", "synthesis", "fragility.md");
+  if (!fs5.existsSync(fragPath)) {
     info("No fragility map found.");
     return;
   }
-  const content = fs6.readFileSync(fragPath, "utf-8");
+  const content = fs5.readFileSync(fragPath, "utf-8");
   if (isJson) {
     console.log(JSON.stringify({ content }, null, 2));
     return;
@@ -1980,7 +2272,7 @@ function queryHistory(db, args, isJson) {
   console.log(table(["Exp", "Slug", "Phase", "Metric", "Value", "Captured"], rows));
 }
 function queryCircuitBreakers(db, root, isJson) {
-  const config = loadConfig4(root);
+  const config = loadConfig(root);
   const states = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
   if (isJson) {
     console.log(JSON.stringify(states, null, 2));
@@ -2002,7 +2294,7 @@ function queryCircuitBreakers(db, root, isJson) {
 function checkCommit(db) {
   let stdinData = "";
   try {
-    stdinData = fs6.readFileSync(0, "utf-8");
+    stdinData = fs5.readFileSync(0, "utf-8");
   } catch {
   }
   if (stdinData) {
@@ -2027,21 +2319,15 @@ function checkCommit(db) {
     process.exit(1);
   }
 }
-function loadConfig4(projectRoot) {
-  const configPath = path6.join(projectRoot, ".majlis", "config.json");
-  if (!fs6.existsSync(configPath)) {
-    return { cycle: { circuit_breaker_threshold: 3 } };
-  }
-  return JSON.parse(fs6.readFileSync(configPath, "utf-8"));
-}
-var fs6, path6;
+var fs5, path5;
 var init_query = __esm({
   "src/commands/query.ts"() {
     "use strict";
-    fs6 = __toESM(require("fs"));
-    path6 = __toESM(require("path"));
+    fs5 = __toESM(require("fs"));
+    path5 = __toESM(require("path"));
     init_connection();
     init_queries();
+    init_config();
     init_format();
   }
 });
@@ -2052,8 +2338,10 @@ var init_types = __esm({
   "src/state/types.ts"() {
     "use strict";
     TRANSITIONS = {
-      ["classified" /* CLASSIFIED */]: ["reframed" /* REFRAMED */, "building" /* BUILDING */],
-      ["reframed" /* REFRAMED */]: ["building" /* BUILDING */],
+      ["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 */],
@@ -2063,7 +2351,9 @@ var init_types = __esm({
       ["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 */]: []
     };
@@ -2092,7 +2382,10 @@ function determineNextStep(exp, valid, hasDoubts2, hasChallenges2) {
     throw new Error(`Experiment ${exp.slug} is terminal (${exp.status})`);
   }
   const status2 = exp.status;
-  if (status2 === "classified" /* CLASSIFIED */) {
+  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) {
@@ -2116,7 +2409,29 @@ var init_machine = __esm({
 });
 
 // src/agents/types.ts
-var EXTRACTION_SCHEMA;
+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;
+  }
+}
+var EXTRACTION_SCHEMA, ROLE_REQUIRED_FIELDS;
 var init_types2 = __esm({
   "src/agents/types.ts"() {
     "use strict";
@@ -2127,6 +2442,16 @@ var init_types2 = __esm({
   "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"]
+    };
   }
 });
 
@@ -2214,7 +2539,8 @@ function extractViaPatterns(role, markdown) {
   while ((match = doubtPattern.exec(markdown)) !== null) {
     doubts.push({
       claim_doubted: match[1].trim(),
-      evidence_level_of_claim: "judgment",
+      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()
     });
@@ -2225,7 +2551,8 @@ function extractViaPatterns(role, markdown) {
 async function extractViaHaiku(role, markdown) {
   try {
     const truncated = markdown.length > 8e3 ? markdown.slice(0, 8e3) + "\n[truncated]" : markdown;
-    const prompt = `Extract all decisions, evidence levels, grades, doubts, and guidance from this ${role} document as JSON. Follow this schema exactly: ${EXTRACTION_SCHEMA}
+    const schema = getExtractionSchema(role);
+    const prompt = `Extract structured data from this ${role} document as JSON. Follow this schema exactly: ${schema}
 
 Document:
 ${truncated}`;
@@ -2258,7 +2585,18 @@ ${truncated}`;
   }
 }
 function hasData(output) {
-  return !!(output.decisions && output.decisions.length > 0 || output.grades && output.grades.length > 0 || output.doubts && output.doubts.length > 0 || output.guidance);
+  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({
@@ -2272,11 +2610,11 @@ var init_parse = __esm({
 // 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)) {
+  const filePath = path6.join(root, ".majlis", "agents", `${role}.md`);
+  if (!fs6.existsSync(filePath)) {
     throw new Error(`Agent definition not found: ${filePath}`);
   }
-  const content = fs7.readFileSync(filePath, "utf-8");
+  const content = fs6.readFileSync(filePath, "utf-8");
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!frontmatterMatch) {
     throw new Error(`Invalid agent definition (missing YAML frontmatter): ${filePath}`);
@@ -2297,7 +2635,7 @@ 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 contextJson = JSON.stringify(context);
   const prompt = `Here is your context:
 
 \`\`\`json
@@ -2322,11 +2660,17 @@ ${taskPrompt}`;
     console.log(`[${role}] Artifact written to ${artifactPath}`);
   }
   const structured = await extractStructuredData(role, markdown);
+  if (structured) {
+    const { valid, missing } = validateForRole(role, structured);
+    if (!valid) {
+      console.warn(`[${role}] Output missing expected fields: ${missing.join(", ")}`);
+    }
+  }
   return { output: markdown, structured, truncated };
 }
 async function spawnSynthesiser(context, projectRoot) {
   const root = projectRoot ?? findProjectRoot() ?? process.cwd();
-  const contextJson = JSON.stringify(context, null, 2);
+  const contextJson = JSON.stringify(context);
   const taskPrompt = context.taskPrompt ?? "Synthesise the findings into actionable builder guidance.";
   const prompt = `Here is your context:
 
@@ -2339,7 +2683,7 @@ ${taskPrompt}`;
   console.log(`[synthesiser] Spawning (maxTurns: 5)...`);
   const { text: markdown, costUsd, truncated } = await runQuery({
     prompt,
-    model: "opus",
+    model: "sonnet",
     tools: ["Read", "Glob", "Grep"],
     systemPrompt,
     cwd: root,
@@ -2353,15 +2697,15 @@ 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(
+  const expDocPath = path6.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 templatePath = path6.join(root, "docs", "experiments", "_TEMPLATE.md");
+  const template = fs6.existsSync(templatePath) ? fs6.readFileSync(templatePath, "utf-8") : "";
+  const currentDoc = fs6.existsSync(expDocPath) ? fs6.readFileSync(expDocPath, "utf-8") : "";
   const prompt = `The ${role} agent was truncated (hit max turns) while working on experiment "${expSlug}".
 
 Here is the partial agent output (reasoning + tool calls):
@@ -2498,23 +2842,23 @@ function writeArtifact(role, context, markdown, projectRoot) {
   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 });
+  const fullDir = path6.join(projectRoot, dir);
+  if (!fs6.existsSync(fullDir)) {
+    fs6.mkdirSync(fullDir, { recursive: true });
   }
   const expSlug = context.experiment?.slug ?? "general";
   const nextNum = String(context.experiment?.id ?? 1).padStart(3, "0");
   const filename = `${nextNum}-${role}-${expSlug}.md`;
-  const target = path7.join(fullDir, filename);
-  fs7.writeFileSync(target, markdown);
+  const target = path6.join(fullDir, filename);
+  fs6.writeFileSync(target, markdown);
   return target;
 }
-var fs7, path7, import_claude_agent_sdk2, ROLE_MAX_TURNS, DIM2, RESET2, CYAN2;
+var fs6, path6, import_claude_agent_sdk2, ROLE_MAX_TURNS, DIM2, RESET2, CYAN2;
 var init_spawn = __esm({
   "src/agents/spawn.ts"() {
     "use strict";
-    fs7 = __toESM(require("fs"));
-    path7 = __toESM(require("path"));
+    fs6 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
     import_claude_agent_sdk2 = require("@anthropic-ai/claude-agent-sdk");
     init_parse();
     init_connection();
@@ -2525,7 +2869,8 @@ var init_spawn = __esm({
       verifier: 50,
       compressor: 30,
       reframer: 20,
-      scout: 20
+      scout: 20,
+      gatekeeper: 10
     };
     DIM2 = "\x1B[2m";
     RESET2 = "\x1B[0m";
@@ -2587,11 +2932,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;
     }
@@ -2599,18 +2946,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
-      );
-      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;
     }
@@ -2649,23 +2999,23 @@ 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"));
+    fs7 = __toESM(require("fs"));
+    path7 = __toESM(require("path"));
     init_types();
     init_queries();
     init_spawn();
@@ -2696,6 +3046,8 @@ async function cycle(step, args) {
       return doScout(db, exp, root);
     case "verify":
       return doVerify(db, exp, root);
+    case "gate":
+      return doGate(db, exp, root);
     case "compress":
       return doCompress(db, root);
   }
@@ -2709,15 +3061,88 @@ async function resolveCmd(args) {
   await resolve(db, exp, root);
   updateExperimentStatus(db, exp.id, "resolved");
 }
+async function doGate(db, exp, root) {
+  transition(exp.status, "gated" /* GATED */);
+  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  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: {
+      id: exp.id,
+      slug: exp.slug,
+      hypothesis: exp.hypothesis,
+      status: exp.status,
+      sub_type: exp.sub_type,
+      builder_guidance: null
+    },
+    deadEnds: structuralDeadEnds.map((d) => ({
+      approach: d.approach,
+      why_failed: d.why_failed,
+      structural_constraint: d.structural_constraint
+    })),
+    fragility,
+    synthesis,
+    taskPrompt: `Gate-check hypothesis for experiment ${exp.slug}:
+"${exp.hypothesis}"
+
+Check: (a) stale references \u2014 does the hypothesis reference specific lines, functions, or structures that may not exist? (b) dead-end overlap \u2014 does this hypothesis repeat an approach already ruled out by structural dead-ends? (c) scope \u2014 is this a single focused change, or does it try to do multiple things?
+
+Output your gate_decision as "approve", "reject", or "flag" with reasoning.`
+  }, root);
+  ingestStructuredOutput(db, exp.id, result.structured);
+  const decision = result.structured?.gate_decision ?? "approve";
+  const reason = result.structured?.reason ?? "";
+  if (decision === "reject") {
+    updateExperimentStatus(db, exp.id, "gated");
+    warn(`Gate REJECTED for ${exp.slug}: ${reason}`);
+    warn(`Revise the hypothesis or run \`majlis revert\` to abandon.`);
+  } else {
+    if (decision === "flag") {
+      warn(`Gate flagged concerns for ${exp.slug}: ${reason}`);
+    }
+    updateExperimentStatus(db, exp.id, "gated");
+    success(`Gate passed for ${exp.slug}. Run \`majlis build\` next.`);
+  }
+}
 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 = 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,
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const parsed = parseMetricsOutput(output);
+      for (const m of parsed) {
+        insertMetric(db, exp.id, "before", m.fixture, m.metric_name, m.metric_value);
+      }
+      if (parsed.length > 0) info(`Captured ${parsed.length} baseline metric(s).`);
+    } catch {
+      warn("Could not capture baseline metrics.");
+    }
+  }
   updateExperimentStatus(db, exp.id, "building");
+  let taskPrompt = builderGuidance ? `Previous attempt was weak. Here is guidance for this attempt:
+${builderGuidance}
+
+Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothesis}`;
+  if (confirmedDoubts.length > 0) {
+    taskPrompt += "\n\n## Confirmed Doubts (MUST address)\nThese weaknesses were confirmed by the verifier. Your build MUST address each one:\n";
+    for (const d of confirmedDoubts) {
+      taskPrompt += `- [${d.severity}] ${d.claim_doubted}: ${d.evidence_for_doubt}
+`;
+    }
+  }
+  taskPrompt += "\n\nNote: The framework captures metrics automatically. Do NOT claim specific numbers unless quoting framework output.";
   const result = await spawnAgent("builder", {
     experiment: {
       id: exp.id,
@@ -2734,10 +3159,8 @@ async function doBuild(db, exp, root) {
     })),
     fragility,
     synthesis,
-    taskPrompt: builderGuidance ? `Previous attempt was weak. Here is guidance for this attempt:
-${builderGuidance}
-
-Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothesis}`
+    confirmedDoubts,
+    taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
   if (result.truncated && !result.structured) {
@@ -2747,6 +3170,23 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
     }, root);
     warn(`Experiment stays at 'building'. Run \`majlis build\` to retry or \`majlis revert\` to abandon.`);
   } else {
+    if (config.metrics?.command) {
+      try {
+        const output = (0, import_node_child_process4.execSync)(config.metrics.command, {
+          cwd: root,
+          encoding: "utf-8",
+          timeout: 6e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        }).trim();
+        const parsed = parseMetricsOutput(output);
+        for (const m of parsed) {
+          insertMetric(db, exp.id, "after", m.fixture, m.metric_name, m.metric_value);
+        }
+        if (parsed.length > 0) info(`Captured ${parsed.length} post-build metric(s).`);
+      } catch {
+        warn("Could not capture post-build metrics.");
+      }
+    }
     gitCommitBuild(exp, root);
     updateExperimentStatus(db, exp.id, "built");
     success(`Build complete for ${exp.slug}. Run \`majlis doubt\` or \`majlis challenge\` next.`);
@@ -2754,6 +3194,26 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
 }
 async function doChallenge(db, exp, root) {
   transition(exp.status, "challenged" /* CHALLENGED */);
+  let gitDiff = "";
+  try {
+    gitDiff = (0, import_node_child_process4.execSync)('git diff main -- . ":!.majlis/"', {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+  }
+  if (gitDiff.length > 8e3) gitDiff = gitDiff.slice(0, 8e3) + "\n[DIFF TRUNCATED]";
+  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 += `
+
+## Code Changes (git diff main)
+\`\`\`diff
+${gitDiff}
+\`\`\``;
+  }
   const result = await spawnAgent("adversary", {
     experiment: {
       id: exp.id,
@@ -2763,7 +3223,8 @@ async function doChallenge(db, exp, root) {
       sub_type: exp.sub_type,
       builder_guidance: null
     },
-    taskPrompt: `Construct adversarial test cases for experiment ${exp.slug}: ${exp.hypothesis}`
+    synthesis,
+    taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
   if (result.truncated && !result.structured) {
@@ -2775,6 +3236,20 @@ async function doChallenge(db, exp, root) {
 }
 async function doDoubt(db, exp, root) {
   transition(exp.status, "doubted" /* DOUBTED */);
+  const paddedNum = String(exp.id).padStart(3, "0");
+  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) {
+    taskPrompt += `
+
+## Experiment Document (builder's artifact)
+<experiment_doc>
+${experimentDoc}
+</experiment_doc>`;
+  }
   const result = await spawnAgent("critic", {
     experiment: {
       id: exp.id,
@@ -2785,7 +3260,13 @@ async function doDoubt(db, exp, root) {
       builder_guidance: null
       // Critic does NOT see builder reasoning
     },
-    taskPrompt: `Doubt the work in experiment ${exp.slug}: ${exp.hypothesis}. Produce a doubt document with evidence for each doubt.`
+    synthesis,
+    deadEnds: deadEnds.map((d) => ({
+      approach: d.approach,
+      why_failed: d.why_failed,
+      structural_constraint: d.structural_constraint
+    })),
+    taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
   if (result.truncated && !result.structured) {
@@ -2797,35 +3278,91 @@ async function doDoubt(db, exp, root) {
 }
 async function doScout(db, exp, root) {
   transition(exp.status, "scouted" /* SCOUTED */);
-  const synthesisPath = path9.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs9.existsSync(synthesisPath) ? fs9.readFileSync(synthesisPath, "utf-8") : "";
-  updateExperimentStatus(db, exp.id, "scouted");
+  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}`
+  ).join("\n");
+  let taskPrompt = `Search for alternative approaches to the problem in experiment ${exp.slug}: ${exp.hypothesis}. Look for contradictory approaches, solutions from other fields, and known limitations of the current approach.`;
+  if (deadEndsSummary) {
+    taskPrompt += `
+
+## Known Dead Ends (avoid these approaches)
+${deadEndsSummary}`;
+  }
+  if (fragility) {
+    taskPrompt += `
+
+## Fragility Map (target these weak areas)
+${fragility}`;
+  }
   const result = await spawnAgent("scout", {
     experiment: {
       id: exp.id,
       slug: exp.slug,
       hypothesis: exp.hypothesis,
-      status: "scouted",
+      status: exp.status,
       sub_type: exp.sub_type,
       builder_guidance: null
     },
     synthesis,
-    taskPrompt: `Search for alternative approaches to the problem in experiment ${exp.slug}: ${exp.hypothesis}. Look for contradictory approaches, solutions from other fields, and known limitations of the current approach.`
+    fragility,
+    deadEnds: deadEnds.map((d) => ({
+      approach: d.approach,
+      why_failed: d.why_failed,
+      structural_constraint: d.structural_constraint
+    })),
+    taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
+  if (result.truncated && !result.structured) {
+    warn(`Scout was truncated without structured output. Experiment stays at current status.`);
+    return;
+  }
+  updateExperimentStatus(db, exp.id, "scouted");
   success(`Scout pass complete for ${exp.slug}. Run \`majlis verify\` next.`);
 }
 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");
+  const afterMetrics = getMetricsByExperimentAndPhase(db, exp.id, "after");
+  let metricsSection = "";
+  if (beforeMetrics.length > 0 || afterMetrics.length > 0) {
+    metricsSection = "\n\n## Framework-Captured Metrics (GROUND TRUTH \u2014 not self-reported by builder)\n";
+    if (beforeMetrics.length > 0) {
+      metricsSection += "### Before Build\n";
+      for (const m of beforeMetrics) {
+        metricsSection += `- ${m.fixture} / ${m.metric_name}: ${m.metric_value}
+`;
+      }
+    }
+    if (afterMetrics.length > 0) {
+      metricsSection += "### After Build\n";
+      for (const m of afterMetrics) {
+        metricsSection += `- ${m.fixture} / ${m.metric_name}: ${m.metric_value}
+`;
+      }
+    }
+  }
+  let doubtReference = "";
+  if (doubts.length > 0) {
+    doubtReference = "\n\n## Doubt Reference (use these IDs in doubt_resolutions)\n";
+    for (const d of doubts) {
+      doubtReference += `- DOUBT-${d.id}: [${d.severity}] ${d.claim_doubted}
+`;
+    }
+    doubtReference += "\nWhen resolving doubts, use the DOUBT-{id} number as the doubt_id value in your doubt_resolutions output.";
+  }
   updateExperimentStatus(db, exp.id, "verifying");
   const result = await spawnAgent("verifier", {
     experiment: {
@@ -2838,7 +3375,7 @@ async function doVerify(db, exp, root) {
     },
     doubts,
     challenges,
-    taskPrompt: `Verify experiment ${exp.slug}: ${exp.hypothesis}. Check provenance and content. Test the ${doubts.length} doubt(s) and any adversarial challenges.`
+    taskPrompt: `Verify experiment ${exp.slug}: ${exp.hypothesis}. Check provenance and content. Test the ${doubts.length} doubt(s) and any adversarial challenges.` + metricsSection + doubtReference
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
   if (result.truncated && !result.structured) {
@@ -2846,9 +3383,15 @@ async function doVerify(db, exp, root) {
     return;
   }
   if (result.structured?.doubt_resolutions) {
-    for (const dr of result.structured.doubt_resolutions) {
-      if (dr.doubt_id && dr.resolution) {
+    const knownDoubtIds = new Set(doubts.map((d) => d.id));
+    for (let i = 0; i < result.structured.doubt_resolutions.length; i++) {
+      const dr = result.structured.doubt_resolutions[i];
+      if (!dr.resolution) continue;
+      if (dr.doubt_id && knownDoubtIds.has(dr.doubt_id)) {
         updateDoubtResolution(db, dr.doubt_id, dr.resolution);
+      } else if (doubts[i]) {
+        warn(`Doubt resolution ID ${dr.doubt_id} not found. Using ordinal fallback \u2192 DOUBT-${doubts[i].id}.`);
+        updateDoubtResolution(db, doubts[i].id, dr.resolution);
       }
     }
   }
@@ -2856,13 +3399,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: "Read 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."
+    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`);
 }
@@ -2936,13 +3480,29 @@ function ingestStructuredOutput(db, experimentId, structured) {
     }
     info(`Ingested ${structured.challenges.length} challenge(s)`);
   }
+  if (structured.reframe) {
+    insertReframe(
+      db,
+      experimentId,
+      structured.reframe.decomposition,
+      JSON.stringify(structured.reframe.divergences),
+      structured.reframe.recommendation
+    );
+    info(`Ingested reframe`);
+  }
+  if (structured.findings) {
+    for (const f of structured.findings) {
+      insertFinding(db, experimentId, f.approach, f.source, f.relevance, f.contradicts_current);
+    }
+    info(`Ingested ${structured.findings.length} finding(s)`);
+  }
 }
-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();
@@ -2950,7 +3510,8 @@ var init_cycle = __esm({
     init_types();
     init_spawn();
     init_resolve();
-    init_queries();
+    init_config();
+    init_metrics();
     init_format();
   }
 });
@@ -2968,10 +3529,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,
@@ -2989,22 +3550,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 ?? ""}`;
   }
@@ -3028,12 +3589,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();
@@ -3050,20 +3611,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 = loadConfig5(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) {
@@ -3107,22 +3667,16 @@ Output: either "classification confirmed \u2014 continue" or "re-classify from X
   }, root);
   success("Purpose audit complete. Review the output above.");
 }
-function loadConfig5(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();
   }
 });
@@ -3136,7 +3690,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 = loadConfig6(root);
+  const config = loadConfig(root);
   const slugArg = args.filter((a) => !a.startsWith("--"))[0];
   let exp;
   if (slugArg) {
@@ -3168,7 +3722,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;
   }
@@ -3208,6 +3772,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;
     }
@@ -3249,41 +3823,26 @@ async function executeStep(step, exp, root) {
       updateExperimentStatus(getDb(root), exp.id, "compressed");
       info(`Experiment ${exp.slug} compressed.`);
       break;
+    case "gated" /* GATED */:
+      await cycle("gate", expArgs);
+      break;
     case "reframed" /* REFRAMED */:
       updateExperimentStatus(getDb(root), exp.id, "reframed");
-      info(`Reframe acknowledged for ${exp.slug}. Proceeding to build.`);
+      info(`Reframe acknowledged for ${exp.slug}. Proceeding to gate.`);
       break;
     default:
       warn(`Don't know how to execute step: ${step}`);
   }
 }
-function loadConfig6(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_queries();
+    init_config();
     init_cycle();
     init_audit();
     init_format();
@@ -3303,13 +3862,19 @@ async function run(args) {
     throw new Error('Usage: majlis run "goal description"');
   }
   const db = getDb(root);
-  const config = loadConfig7(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) {
@@ -3329,6 +3894,11 @@ 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);
       success(`Created experiment #${exp.id}: ${exp.slug}`);
@@ -3344,12 +3914,29 @@ 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 {
+        insertDeadEnd(
+          db,
+          exp.id,
+          exp.hypothesis ?? exp.slug,
+          message,
+          `Process failure: ${message}`,
+          exp.sub_type,
+          "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;
       }
     }
   }
@@ -3362,11 +3949,11 @@ async function run(args) {
   info("Run `majlis status` to see final state.");
 }
 async function deriveNextHypothesis(goal, root, db) {
-  const synthesis = readFileOrEmpty(path13.join(root, "docs", "synthesis", "current.md"));
-  const fragility = readFileOrEmpty(path13.join(root, "docs", "synthesis", "fragility.md"));
-  const deadEndsDoc = readFileOrEmpty(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 = loadConfig7(root);
+  const config = loadConfig(root);
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
@@ -3399,7 +3986,10 @@ ${fragility || "(none)"}
 ${deadEndsDoc || "(none)"}
 
 ## Dead Ends (from DB \u2014 ${deadEnds.length} total)
-${deadEnds.map((d) => `- ${d.approach}: ${d.why_failed} [constraint: ${d.structural_constraint}]`).join("\n") || "(none)"}
+${deadEnds.map((d) => `- [${d.category ?? "structural"}] ${d.approach}: ${d.why_failed} [constraint: ${d.structural_constraint}]`).join("\n") || "(none)"}
+
+Note: [structural] dead ends are HARD CONSTRAINTS \u2014 your hypothesis MUST NOT repeat these approaches.
+[procedural] dead ends are process failures \u2014 the approach may still be valid if executed differently.
 
 ## Your Task
 1. Assess: based on the metrics and synthesis, has the goal been met? Be specific.
@@ -3473,49 +4063,26 @@ 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 readFileOrEmpty(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 loadConfig7(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();
@@ -3523,17 +4090,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);