majlis 0.4.4 → 0.5.0

package/dist/cli.js

@@ -170,6 +170,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 +580,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 +616,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 +654,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 +687,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 +702,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 +721,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 +757,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 +776,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 +818,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 +833,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 +1376,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 +1456,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,6 +1524,94 @@ 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";
@@ -1756,13 +1988,15 @@ async function revert(args) {
   }
   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
+    exp.sub_type,
+    category
   );
   updateExperimentStatus(db, exp.id, "dead_end");
   try {
@@ -2052,8 +2286,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 +2299,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 +2330,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 +2357,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 +2390,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 +2487,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 +2499,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 +2533,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({
@@ -2322,6 +2608,12 @@ ${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) {
@@ -2525,7 +2817,8 @@ var init_spawn = __esm({
       verifier: 50,
       compressor: 30,
       reframer: 20,
-      scout: 20
+      scout: 20,
+      gatekeeper: 10
     };
     DIM2 = "\x1B[2m";
     RESET2 = "\x1B[0m";
@@ -2605,7 +2898,8 @@ async function resolve(db, exp, projectRoot) {
         exp.hypothesis ?? exp.slug,
         whyFailed,
         `Approach rejected: ${whyFailed}`,
-        exp.sub_type
+        exp.sub_type,
+        "structural"
       );
       updateExperimentStatus(db, exp.id, "dead_end");
       if (exp.sub_type) {
@@ -2634,6 +2928,10 @@ function gitRevert(branch, cwd) {
       encoding: "utf-8"
     }).trim();
     if (currentBranch === branch) {
+      try {
+        (0, import_node_child_process3.execSync)("git checkout -- .", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+      } catch {
+      }
       (0, import_node_child_process3.execSync)("git checkout main 2>/dev/null || git checkout master", {
         cwd,
         encoding: "utf-8",
@@ -2692,6 +2990,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);
   }
@@ -2705,6 +3005,49 @@ 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 = readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md"));
+  const fragility = readFileOrEmpty(path9.join(root, "docs", "synthesis", "fragility.md"));
+  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);
@@ -2713,7 +3056,38 @@ async function doBuild(db, exp, root) {
   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 confirmedDoubts = getConfirmedDoubts(db, exp.id);
+  const config = loadConfig5(root);
+  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, "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,
@@ -2730,10 +3104,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) {
@@ -2743,12 +3115,50 @@ 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.`);
   }
 }
 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 = readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md"));
+  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,
@@ -2758,7 +3168,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) {
@@ -2770,6 +3181,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 = path9.join(root, "docs", "experiments", `${paddedNum}-${exp.slug}.md`);
+  const experimentDoc = readFileOrEmpty(expDocPath);
+  const synthesis = readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md"));
+  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,
@@ -2780,7 +3205,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) {
@@ -2792,22 +3223,49 @@ 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 = readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md"));
+  const fragility = readFileOrEmpty(path9.join(root, "docs", "synthesis", "fragility.md"));
+  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) {
@@ -2821,6 +3279,35 @@ async function doVerify(db, exp, root) {
       challenges += fs9.readFileSync(path9.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: {
@@ -2833,7 +3320,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) {
@@ -2841,9 +3328,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);
       }
     }
   }
@@ -2854,13 +3347,31 @@ 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 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;
   recordCompression(db, sessionCount, sizeBefore, sizeAfter);
   success(`Compression complete. Synthesis: ${sizeBefore}B \u2192 ${sizeAfter}B`);
 }
+function gitCommitBuild(exp, cwd) {
+  try {
+    (0, import_node_child_process4.execSync)('git add -A -- ":!.majlis/"', { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const diff = (0, import_node_child_process4.execSync)("git diff --cached --stat", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (!diff) {
+      info("No code changes to commit.");
+      return;
+    }
+    const msg = `EXP-${String(exp.id).padStart(3, "0")}: ${exp.slug}
+
+${exp.hypothesis ?? ""}`;
+    (0, import_node_child_process4.execSync)(`git commit -m ${JSON.stringify(msg)}`, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    info(`Committed builder changes on ${exp.branch}.`);
+  } catch {
+    warn("Could not auto-commit builder changes \u2014 commit manually before resolving.");
+  }
+}
 function resolveExperimentArg(db, args) {
   const slugArg = args.filter((a) => !a.startsWith("--"))[0];
   let exp;
@@ -2914,20 +3425,60 @@ 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)`);
+  }
+}
+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;
+var fs9, path9, import_node_child_process4;
 var init_cycle = __esm({
   "src/commands/cycle.ts"() {
     "use strict";
     fs9 = __toESM(require("fs"));
     path9 = __toESM(require("path"));
+    import_node_child_process4 = require("child_process");
     init_connection();
     init_queries();
     init_machine();
     init_types();
     init_spawn();
     init_resolve();
-    init_queries();
+    init_metrics();
     init_format();
   }
 });
@@ -3027,7 +3578,7 @@ 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 = loadConfig6(root);
   const experiments = listAllExperiments(db);
   const deadEnds = listAllDeadEnds(db);
   const circuitBreakers = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
@@ -3084,7 +3635,7 @@ Output: either "classification confirmed \u2014 continue" or "re-classify from X
   }, root);
   success("Purpose audit complete. Review the output above.");
 }
-function loadConfig5(projectRoot) {
+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 } };
@@ -3113,7 +3664,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 = loadConfig7(root);
   const slugArg = args.filter((a) => !a.startsWith("--"))[0];
   let exp;
   if (slugArg) {
@@ -3226,15 +3777,18 @@ 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) {
+function loadConfig7(projectRoot) {
   const configPath = path12.join(projectRoot, ".majlis", "config.json");
   if (!fs12.existsSync(configPath)) {
     return {
@@ -3280,7 +3834,7 @@ async function run(args) {
     throw new Error('Usage: majlis run "goal description"');
   }
   const db = getDb(root);
-  const config = loadConfig7(root);
+  const config = loadConfig8(root);
   const MAX_EXPERIMENTS = 10;
   const MAX_STEPS = 200;
   let experimentCount = 0;
@@ -3325,6 +3879,15 @@ async function run(args) {
       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 {
       }
@@ -3339,15 +3902,15 @@ 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 = 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 deadEnds = listAllDeadEnds(db);
-  const config = loadConfig7(root);
+  const config = loadConfig8(root);
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
-      metricsOutput = (0, import_node_child_process4.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process5.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -3376,7 +3939,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.
@@ -3438,7 +4004,7 @@ function createNewExperiment(db, root, hypothesis) {
   const paddedNum = String(num).padStart(3, "0");
   const branch = `exp/${paddedNum}-${finalSlug}`;
   try {
-    (0, import_node_child_process4.execSync)(`git checkout -b ${branch}`, {
+    (0, import_node_child_process5.execSync)(`git checkout -b ${branch}`, {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3461,7 +4027,7 @@ function createNewExperiment(db, root, hypothesis) {
   }
   return exp;
 }
-function readFileOrEmpty(filePath) {
+function readFileOrEmpty2(filePath) {
   try {
     return fs13.readFileSync(filePath, "utf-8");
   } catch {
@@ -3471,7 +4037,7 @@ function readFileOrEmpty(filePath) {
 function slugify2(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
 }
-function loadConfig7(projectRoot) {
+function loadConfig8(projectRoot) {
   const configPath = path13.join(projectRoot, ".majlis", "config.json");
   if (!fs13.existsSync(configPath)) {
     return {
@@ -3487,13 +4053,13 @@ function loadConfig7(projectRoot) {
   }
   return JSON.parse(fs13.readFileSync(configPath, "utf-8"));
 }
-var fs13, path13, import_node_child_process4;
+var fs13, path13, import_node_child_process5;
 var init_run = __esm({
   "src/commands/run.ts"() {
     "use strict";
     fs13 = __toESM(require("fs"));
     path13 = __toESM(require("path"));
-    import_node_child_process4 = require("child_process");
+    import_node_child_process5 = require("child_process");
     init_connection();
     init_queries();
     init_machine();

package/package.json

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