majlis 0.7.0 → 0.7.2

package/dist/cli.js

@@ -249,6 +249,13 @@ var init_migrations = __esm({
       );
 
       CREATE INDEX idx_swarm_members_run ON swarm_members(swarm_run_id);
+    `);
+      },
+      // Migration 006: v5 → v6 — Experiment dependencies and scoped context
+      (db) => {
+        db.exec(`
+      ALTER TABLE experiments ADD COLUMN depends_on TEXT;
+      ALTER TABLE experiments ADD COLUMN context_files TEXT;
     `);
       }
     ];
@@ -442,7 +449,7 @@ var init_format = __esm({
 function getExtractionSchema(role) {
   switch (role) {
     case "builder":
-      return '{"decisions": [{"description": "string", "evidence_level": "proof|test|strong_consensus|consensus|analogy|judgment", "justification": "string"}]}';
+      return '{"decisions": [{"description": "string", "evidence_level": "proof|test|strong_consensus|consensus|analogy|judgment", "justification": "string"}], "abandon": {"reason": "string", "structural_constraint": "string"}}';
     case "critic":
       return '{"doubts": [{"claim_doubted": "string", "evidence_level_of_claim": "string", "evidence_for_doubt": "string", "severity": "minor|moderate|critical"}]}';
     case "adversary":
@@ -499,7 +506,7 @@ async function extractStructuredData(role, markdown) {
   const tier1 = extractMajlisJsonBlock(markdown);
   if (tier1) {
     const parsed = tryParseJson(tier1);
-    if (parsed) return parsed;
+    if (parsed) return { data: parsed, tier: 1 };
     console.warn(`[majlis] Malformed JSON in <!-- majlis-json --> block for ${role}. Falling back.`);
   } else {
     console.warn(`[majlis] No <!-- majlis-json --> block found in ${role} output. Falling back.`);
@@ -507,15 +514,18 @@ async function extractStructuredData(role, markdown) {
   const tier2 = extractViaPatterns(role, markdown);
   if (tier2 && hasData(tier2)) {
     console.warn(`[majlis] Used regex fallback for ${role}. Review extracted data.`);
-    return tier2;
+    return { data: tier2, tier: 2 };
   }
   console.warn(`[majlis] Regex fallback insufficient for ${role}. Using Haiku extraction.`);
   const tier3 = await extractViaHaiku(role, markdown);
-  if (tier3) return tier3;
+  if (tier3) {
+    console.warn(`[majlis] Tier 3 (Haiku) extraction used for ${role}. Data provenance degraded.`);
+    return { data: tier3, tier: 3 };
+  }
   console.error(
     `[majlis] FAILED to extract structured data from ${role} output. State machine will continue but data is missing. Manual review required.`
   );
-  return null;
+  return { data: null, tier: null };
 }
 function extractMajlisJsonBlock(markdown) {
   const match = markdown.match(/<!--\s*majlis-json\s*\n?([\s\S]*?)-->/);
@@ -585,6 +595,23 @@ function extractViaPatterns(role, markdown) {
     });
   }
   if (doubts.length > 0) result.doubts = doubts;
+  if (role === "builder") {
+    const abandonPattern = /\[ABANDON\]\s*(.+?)(?:\n|$)[\s\S]*?(?:structural.?constraint|Constraint|CONSTRAINT)\s*[:=]\s*(.+?)(?:\n|$)/im;
+    const abandonMatch = markdown.match(abandonPattern);
+    if (abandonMatch) {
+      result.abandon = {
+        reason: abandonMatch[1].trim(),
+        structural_constraint: abandonMatch[2].trim()
+      };
+    }
+    const invalidMatch = markdown.match(/(?:HYPOTHESIS\s+INVALID|HYPOTHESIS\s+IMPOSSIBLE)\s*[:.\-—]\s*(.+?)(?:\n|$)/im);
+    if (invalidMatch && !result.abandon) {
+      result.abandon = {
+        reason: invalidMatch[1].trim(),
+        structural_constraint: "Extracted via regex \u2014 review original document"
+      };
+    }
+  }
   return result;
 }
 async function extractViaHaiku(role, markdown) {
@@ -624,7 +651,7 @@ ${truncated}`;
   }
 }
 function hasData(output) {
-  return !!(output.decisions && output.decisions.length > 0 || output.grades && output.grades.length > 0 || output.doubts && output.doubts.length > 0 || output.challenges && output.challenges.length > 0 || output.findings && output.findings.length > 0 || output.guidance || output.reframe || output.compression_report || output.gate_decision || output.diagnosis);
+  return !!(output.decisions && output.decisions.length > 0 || output.grades && output.grades.length > 0 || output.doubts && output.doubts.length > 0 || output.challenges && output.challenges.length > 0 || output.findings && output.findings.length > 0 || output.guidance || output.reframe || output.compression_report || output.gate_decision || output.diagnosis || output.abandon);
 }
 function validateForRole(role, output) {
   const required = ROLE_REQUIRED_FIELDS[role];
@@ -839,6 +866,8 @@ function buildPreToolUseGuards(role, cwd) {
     const configFile = path2.resolve(cwd, ".majlis", "config.json");
     const dbFile = path2.resolve(cwd, ".majlis", "majlis.db");
     const settingsFile = path2.resolve(cwd, ".claude", "settings.json");
+    const claudeDir = path2.resolve(cwd, ".claude");
+    const agentsDir = path2.resolve(cwd, ".majlis", "agents");
     const configGuard = async (input) => {
       const toolInput = input.tool_input ?? {};
       const filePath = toolInput.file_path ?? "";
@@ -847,6 +876,9 @@ function buildPreToolUseGuards(role, cwd) {
         if (resolved === configFile || resolved === dbFile || resolved === settingsFile) {
           return { decision: "block", reason: `Builder may not modify framework files: ${filePath}` };
         }
+        if (isInsideDir(resolved, claudeDir) || isInsideDir(resolved, agentsDir)) {
+          return { decision: "block", reason: `Builder may not modify agent definitions or framework settings: ${filePath}` };
+        }
       }
       return {};
     };
@@ -860,6 +892,8 @@ function buildPreToolUseGuards(role, cwd) {
     const configFile = path2.resolve(cwd, ".majlis", "config.json");
     const dbFile = path2.resolve(cwd, ".majlis", "majlis.db");
     const settingsFile = path2.resolve(cwd, ".claude", "settings.json");
+    const claudeDir = path2.resolve(cwd, ".claude");
+    const agentsDir = path2.resolve(cwd, ".majlis", "agents");
     const configGuard = async (input) => {
       const toolInput = input.tool_input ?? {};
       const filePath = toolInput.file_path ?? "";
@@ -868,6 +902,9 @@ function buildPreToolUseGuards(role, cwd) {
         if (resolved === configFile || resolved === dbFile || resolved === settingsFile) {
           return { decision: "block", reason: `Verifier may not modify framework files: ${filePath}` };
         }
+        if (isInsideDir(resolved, claudeDir) || isInsideDir(resolved, agentsDir)) {
+          return { decision: "block", reason: `Verifier may not modify agent definitions or framework settings: ${filePath}` };
+        }
       }
       return {};
     };
@@ -940,14 +977,17 @@ ${taskPrompt}`;
   if (artifactPath) {
     console.log(`[${role}] Artifact written to ${artifactPath}`);
   }
-  const structured = await extractStructuredData(role, markdown);
+  const { data: structured, tier: extractionTier } = 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 };
+  if (extractionTier === 3) {
+    console.warn(`[${role}] WARNING: Structured output was reconstructed by Haiku (tier 3). Data provenance degraded.`);
+  }
+  return { output: markdown, structured, truncated, extractionTier };
 }
 async function spawnSynthesiser(context, projectRoot, opts) {
   const root = projectRoot ?? findProjectRoot() ?? process.cwd();
@@ -975,7 +1015,7 @@ ${taskPrompt}`;
     role: "synthesiser"
   });
   console.log(`[synthesiser] Complete (cost: $${costUsd.toFixed(4)})`);
-  return { output: markdown, structured: { guidance: markdown }, truncated };
+  return { output: markdown, structured: { guidance: markdown }, truncated, extractionTier: null };
 }
 async function spawnRecovery(role, partialOutput, context, projectRoot) {
   const root = projectRoot ?? findProjectRoot() ?? process.cwd();
@@ -1261,7 +1301,7 @@ var init_config = __esm({
     path3 = __toESM(require("path"));
     DEFAULT_CONFIG = {
       project: { name: "", description: "", objective: "" },
-      metrics: { command: "", fixtures: [], tracked: {} },
+      metrics: { command: "", fixtures: {}, tracked: {} },
       build: { pre_measure: null, post_measure: null },
       cycle: {
         compression_interval: 5,
@@ -1278,7 +1318,8 @@ var init_config = __esm({
       synthesis: 3e4,
       fragility: 15e3,
       experimentDoc: 15e3,
-      deadEnds: 15e3
+      deadEnds: 15e3,
+      experimentLineage: 15e3
     };
   }
 });
@@ -2197,12 +2238,13 @@ var init_upgrade = __esm({
 });
 
 // src/db/queries.ts
-function createExperiment(db, slug, branch, hypothesis, subType, classificationRef) {
+function createExperiment(db, slug, branch, hypothesis, subType, classificationRef, dependsOn = null, contextFiles = null) {
   const stmt = db.prepare(`
-    INSERT INTO experiments (slug, branch, hypothesis, sub_type, classification_ref, status)
-    VALUES (?, ?, ?, ?, ?, 'classified')
+    INSERT INTO experiments (slug, branch, hypothesis, sub_type, classification_ref, status, depends_on, context_files)
+    VALUES (?, ?, ?, ?, ?, 'classified', ?, ?)
   `);
-  const result = stmt.run(slug, branch, hypothesis, subType, classificationRef);
+  const contextJson = contextFiles && contextFiles.length > 0 ? JSON.stringify(contextFiles) : null;
+  const result = stmt.run(slug, branch, hypothesis, subType, classificationRef, dependsOn, contextJson);
   return getExperimentById(db, result.lastInsertRowid);
 }
 function getExperimentById(db, id) {
@@ -2487,7 +2529,7 @@ function updateSwarmMember(db, swarmRunId, slug, finalStatus, overallGrade, cost
     WHERE swarm_run_id = ? AND experiment_slug = ?
   `).run(finalStatus, overallGrade, costUsd, error, swarmRunId, slug);
 }
-function exportForCompressor(db, maxLength = 3e4) {
+function exportForCompressor(db, maxLength = 5e4) {
   const experiments = listAllExperiments(db);
   const sections = ["# Structured Data Export (from SQLite)\n"];
   sections.push("## Experiments");
@@ -2553,6 +2595,70 @@ function exportForCompressor(db, maxLength = 3e4) {
   }
   return full;
 }
+function exportExperimentLineage(db, subType, maxLength = 15e3) {
+  const experiments = subType ? db.prepare(`SELECT * FROM experiments WHERE sub_type = ? ORDER BY created_at`).all(subType) : listAllExperiments(db);
+  if (experiments.length === 0) return "";
+  const sections = ["## Experiment Lineage (from DB \u2014 canonical, not from synthesis)\n"];
+  for (const exp of experiments) {
+    sections.push(`### ${exp.slug} [${exp.status}]`);
+    if (exp.hypothesis) sections.push(`Hypothesis: ${exp.hypothesis}`);
+    const decisions = listDecisionsByExperiment(db, exp.id);
+    if (decisions.length > 0) {
+      sections.push("Decisions:");
+      for (const d of decisions) {
+        sections.push(`  - [${d.evidence_level}/${d.status}] ${d.description}`);
+      }
+    }
+    const beforeMetrics = getMetricsByExperimentAndPhase(db, exp.id, "before");
+    const afterMetrics = getMetricsByExperimentAndPhase(db, exp.id, "after");
+    if (beforeMetrics.length > 0 && afterMetrics.length > 0) {
+      sections.push("Metrics:");
+      for (const bm of beforeMetrics) {
+        const am = afterMetrics.find((a) => a.fixture === bm.fixture && a.metric_name === bm.metric_name);
+        if (am) {
+          const delta = am.metric_value - bm.metric_value;
+          const sign = delta >= 0 ? "+" : "";
+          sections.push(`  - ${bm.fixture}/${bm.metric_name}: ${bm.metric_value} \u2192 ${am.metric_value} (${sign}${delta.toFixed(4)})`);
+        }
+      }
+    }
+    const doubts = getDoubtsByExperiment(db, exp.id);
+    const resolved = doubts.filter((d) => d.resolution);
+    if (resolved.length > 0) {
+      sections.push("Doubt resolutions:");
+      for (const d of resolved) {
+        sections.push(`  - [${d.resolution}] ${d.claim_doubted}`);
+      }
+    }
+    const verifications = getVerificationsByExperiment(db, exp.id);
+    if (verifications.length > 0) {
+      sections.push("Grades:");
+      for (const v of verifications) {
+        sections.push(`  - ${v.component}: ${v.grade}${v.notes ? ` \u2014 ${v.notes}` : ""}`);
+      }
+    }
+    sections.push("");
+    const current = sections.join("\n");
+    if (current.length > maxLength - 500) {
+      sections.push(`[LINEAGE TRUNCATED \u2014 ${experiments.length - experiments.indexOf(exp) - 1} experiments omitted]`);
+      break;
+    }
+  }
+  const deadEnds = subType ? listDeadEndsBySubType(db, subType) : listAllDeadEnds(db);
+  if (deadEnds.length > 0) {
+    sections.push("### Dead Ends (structural constraints)");
+    for (const de of deadEnds) {
+      sections.push(`- [${de.category ?? "structural"}] ${de.approach}: ${de.structural_constraint}`);
+    }
+  }
+  const full = sections.join("\n");
+  if (full.length > maxLength) {
+    return full.slice(0, maxLength) + `
+
+[LINEAGE TRUNCATED at ${maxLength} chars]`;
+  }
+  return full;
+}
 function exportForDiagnostician(db, maxLength = 6e4) {
   const base = exportForCompressor(db, maxLength);
   const sections = [base];
@@ -2711,6 +2817,34 @@ async function status(isJson) {
     console.log(`
   ${yellow(`${judgmentDecisions.length} judgment-level decisions`)} (provisional targets for doubt)`);
   }
+  console.log();
+  header("Project Readiness");
+  const validation = (0, import_shared2.validateProject)({
+    hasGitRepo: fs9.existsSync(path9.join(root, ".git")),
+    hasClaudeMd: fs9.existsSync(path9.join(root, "CLAUDE.md")),
+    metricsCommand: config.metrics.command,
+    metricsCommandRunnable: checkCommandRunnable(config.metrics.command, root),
+    fixtures: config.metrics.fixtures,
+    tracked: config.metrics.tracked,
+    preMeasure: config.build.pre_measure,
+    hasObjective: !!(config.project.objective && config.project.objective.length > 0),
+    hasSynthesis: (() => {
+      const sp = path9.join(root, "docs", "synthesis", "current.md");
+      if (!fs9.existsSync(sp)) return false;
+      const content = fs9.readFileSync(sp, "utf-8");
+      return content.length > 100 && !content.includes("No experiments yet");
+    })()
+  });
+  console.log((0, import_shared2.formatValidation)(validation));
+}
+function checkCommandRunnable(command, cwd) {
+  if (!command || command.includes(`echo '{"fixtures":{}}'`)) return false;
+  try {
+    (0, import_node_child_process3.execSync)(command, { cwd, encoding: "utf-8", timeout: 15e3, stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
 }
 function buildSummary(expCount, activeSession, sessionsSinceCompression, config) {
   const parts = [];
@@ -2721,12 +2855,17 @@ function buildSummary(expCount, activeSession, sessionsSinceCompression, config)
   }
   return parts.join(". ");
 }
+var fs9, path9, import_node_child_process3, import_shared2;
 var init_status = __esm({
   "src/commands/status.ts"() {
     "use strict";
+    fs9 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    import_node_child_process3 = require("child_process");
     init_connection();
     init_queries();
     init_config();
+    import_shared2 = require("@majlis/shared");
     init_format();
   }
 });
@@ -2848,6 +2987,10 @@ var init_machine = __esm({
 });
 
 // src/metrics.ts
+function isGateFixture(fixtures, fixtureName) {
+  if (Array.isArray(fixtures)) return false;
+  return fixtures[fixtureName]?.gate === true;
+}
 function compareMetrics(db, experimentId, config) {
   const before = getMetricsByExperimentAndPhase(db, experimentId, "before");
   const after = getMetricsByExperimentAndPhase(db, experimentId, "after");
@@ -2869,13 +3012,17 @@ function compareMetrics(db, experimentId, config) {
           before: b.metric_value,
           after: a.metric_value,
           delta: a.metric_value - b.metric_value,
-          regression
+          regression,
+          gate: isGateFixture(config.metrics.fixtures, fixture)
         });
       }
     }
   }
   return comparisons;
 }
+function checkGateViolations(comparisons) {
+  return comparisons.filter((c) => c.gate && c.regression);
+}
 function isRegression(before, after, direction, target) {
   switch (direction) {
     case "lower_is_better":
@@ -2939,7 +3086,7 @@ async function captureMetrics(phase, args) {
   if (config.build.pre_measure) {
     info(`Running pre-measure: ${config.build.pre_measure}`);
     try {
-      (0, import_node_child_process3.execSync)(config.build.pre_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
+      (0, import_node_child_process4.execSync)(config.build.pre_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
     } catch {
       warn("Pre-measure command failed \u2014 continuing anyway.");
     }
@@ -2950,7 +3097,7 @@ async function captureMetrics(phase, args) {
   info(`Running metrics: ${config.metrics.command}`);
   let metricsOutput;
   try {
-    metricsOutput = (0, import_node_child_process3.execSync)(config.metrics.command, {
+    metricsOutput = (0, import_node_child_process4.execSync)(config.metrics.command, {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -2969,7 +3116,7 @@ async function captureMetrics(phase, args) {
   success(`Captured ${parsed.length} metric(s) for ${exp.slug} (phase: ${phase})`);
   if (config.build.post_measure) {
     try {
-      (0, import_node_child_process3.execSync)(config.build.post_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
+      (0, import_node_child_process4.execSync)(config.build.post_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
     } catch {
       warn("Post-measure command failed.");
     }
@@ -3020,11 +3167,11 @@ function formatDelta(delta) {
   const prefix = delta > 0 ? "+" : "";
   return `${prefix}${delta.toFixed(4)}`;
 }
-var import_node_child_process3;
+var import_node_child_process4;
 var init_measure = __esm({
   "src/commands/measure.ts"() {
     "use strict";
-    import_node_child_process3 = require("child_process");
+    import_node_child_process4 = require("child_process");
     init_connection();
     init_queries();
     init_metrics();
@@ -3057,7 +3204,7 @@ async function newExperiment(args) {
   const paddedNum = String(num).padStart(3, "0");
   const branch = `exp/${paddedNum}-${slug}`;
   try {
-    (0, import_node_child_process4.execFileSync)("git", ["checkout", "-b", branch], {
+    (0, import_node_child_process5.execFileSync)("git", ["checkout", "-b", branch], {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3067,15 +3214,28 @@ async function newExperiment(args) {
     warn(`Could not create branch ${branch} \u2014 continuing without git branch.`);
   }
   const subType = getFlagValue(args, "--sub-type") ?? null;
-  const exp = createExperiment(db, slug, branch, hypothesis, subType, null);
+  const dependsOn = getFlagValue(args, "--depends-on") ?? null;
+  const contextArg = getFlagValue(args, "--context") ?? null;
+  const contextFiles = contextArg ? contextArg.split(",").map((f) => f.trim()) : null;
+  if (dependsOn) {
+    const depExp = getExperimentBySlug(db, dependsOn);
+    if (!depExp) {
+      throw new Error(`Dependency experiment not found: ${dependsOn}`);
+    }
+    info(`Depends on: ${dependsOn} (status: ${depExp.status})`);
+  }
+  const exp = createExperiment(db, slug, branch, hypothesis, subType, null, dependsOn, contextFiles);
+  if (contextFiles) {
+    info(`Context files: ${contextFiles.join(", ")}`);
+  }
   success(`Created experiment #${exp.id}: ${exp.slug}`);
-  const docsDir = path9.join(root, "docs", "experiments");
-  const templatePath = path9.join(docsDir, "_TEMPLATE.md");
-  if (fs9.existsSync(templatePath)) {
-    const template = fs9.readFileSync(templatePath, "utf-8");
+  const docsDir = path10.join(root, "docs", "experiments");
+  const templatePath = path10.join(docsDir, "_TEMPLATE.md");
+  if (fs10.existsSync(templatePath)) {
+    const template = fs10.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 = path9.join(docsDir, `${paddedNum}-${slug}.md`);
-    fs9.writeFileSync(logPath, logContent);
+    const logPath = path10.join(docsDir, `${paddedNum}-${slug}.md`);
+    fs10.writeFileSync(logPath, logContent);
     info(`Created experiment log: docs/experiments/${paddedNum}-${slug}.md`);
   }
   autoCommit(root, `new: ${slug}`);
@@ -3115,19 +3275,19 @@ async function revert(args) {
   );
   adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "revert");
   try {
-    const currentBranch = (0, import_node_child_process4.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    const currentBranch = (0, import_node_child_process5.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd: root,
       encoding: "utf-8"
     }).trim();
     if (currentBranch === exp.branch) {
       try {
-        (0, import_node_child_process4.execFileSync)("git", ["checkout", "main"], {
+        (0, import_node_child_process5.execFileSync)("git", ["checkout", "main"], {
           cwd: root,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         });
       } catch {
-        (0, import_node_child_process4.execFileSync)("git", ["checkout", "master"], {
+        (0, import_node_child_process5.execFileSync)("git", ["checkout", "master"], {
           cwd: root,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -3139,13 +3299,13 @@ async function revert(args) {
   }
   info(`Experiment ${exp.slug} reverted to dead-end. Reason: ${reason}`);
 }
-var fs9, path9, import_node_child_process4;
+var fs10, path10, import_node_child_process5;
 var init_experiment = __esm({
   "src/commands/experiment.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs"));
-    path9 = __toESM(require("path"));
-    import_node_child_process4 = require("child_process");
+    fs10 = __toESM(require("fs"));
+    path10 = __toESM(require("path"));
+    import_node_child_process5 = require("child_process");
     init_connection();
     init_queries();
     init_machine();
@@ -3288,12 +3448,12 @@ function queryDeadEnds(db, args, isJson) {
   console.log(table(["ID", "Sub-Type", "Approach", "Constraint"], rows));
 }
 function queryFragility(root, isJson) {
-  const fragPath = path10.join(root, "docs", "synthesis", "fragility.md");
-  if (!fs10.existsSync(fragPath)) {
+  const fragPath = path11.join(root, "docs", "synthesis", "fragility.md");
+  if (!fs11.existsSync(fragPath)) {
     info("No fragility map found.");
     return;
   }
-  const content = fs10.readFileSync(fragPath, "utf-8");
+  const content = fs11.readFileSync(fragPath, "utf-8");
   if (isJson) {
     console.log(JSON.stringify({ content }, null, 2));
     return;
@@ -3349,7 +3509,7 @@ function queryCircuitBreakers(db, root, isJson) {
 function checkCommit(db) {
   let stdinData = "";
   try {
-    stdinData = fs10.readFileSync(0, "utf-8");
+    stdinData = fs11.readFileSync(0, "utf-8");
   } catch {
   }
   if (stdinData) {
@@ -3374,12 +3534,12 @@ function checkCommit(db) {
     process.exit(1);
   }
 }
-var fs10, path10;
+var fs11, path11;
 var init_query = __esm({
   "src/commands/query.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path11 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_config();
@@ -3413,6 +3573,28 @@ async function resolve2(db, exp, projectRoot) {
     grades = getVerificationsByExperiment(db, exp.id);
   }
   const overallGrade = worstGrade(grades);
+  const config = loadConfig(projectRoot);
+  const metricComparisons = compareMetrics(db, exp.id, config);
+  const gateViolations = checkGateViolations(metricComparisons);
+  if (gateViolations.length > 0 && (overallGrade === "sound" || overallGrade === "good")) {
+    warn("Gate fixture regression detected \u2014 blocking merge:");
+    for (const v of gateViolations) {
+      warn(`  ${v.fixture} / ${v.metric}: ${v.before} \u2192 ${v.after} (${v.delta > 0 ? "+" : ""}${v.delta})`);
+    }
+    updateExperimentStatus(db, exp.id, "resolved");
+    const guidanceText = `Gate fixture regression blocks merge. Fix these regressions before re-attempting:
+` + gateViolations.map((v) => `- ${v.fixture} / ${v.metric}: was ${v.before}, now ${v.after}`).join("\n");
+    transition("resolved" /* RESOLVED */, "building" /* BUILDING */);
+    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 \u2014 gate fixture(s) regressed.`);
+    return;
+  }
   updateExperimentStatus(db, exp.id, "resolved");
   switch (overallGrade) {
     case "sound": {
@@ -3500,6 +3682,28 @@ async function resolveDbOnly(db, exp, projectRoot) {
     grades = getVerificationsByExperiment(db, exp.id);
   }
   const overallGrade = worstGrade(grades);
+  const config = loadConfig(projectRoot);
+  const metricComparisons = compareMetrics(db, exp.id, config);
+  const gateViolations = checkGateViolations(metricComparisons);
+  if (gateViolations.length > 0 && (overallGrade === "sound" || overallGrade === "good")) {
+    warn("Gate fixture regression detected \u2014 blocking merge:");
+    for (const v of gateViolations) {
+      warn(`  ${v.fixture} / ${v.metric}: ${v.before} \u2192 ${v.after} (${v.delta > 0 ? "+" : ""}${v.delta})`);
+    }
+    updateExperimentStatus(db, exp.id, "resolved");
+    const guidanceText = `Gate fixture regression blocks merge. Fix these regressions before re-attempting:
+` + gateViolations.map((v) => `- ${v.fixture} / ${v.metric}: was ${v.before}, now ${v.after}`).join("\n");
+    transition("resolved" /* RESOLVED */, "building" /* BUILDING */);
+    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 \u2014 gate fixture(s) regressed.`);
+    return "weak";
+  }
   updateExperimentStatus(db, exp.id, "resolved");
   switch (overallGrade) {
     case "sound":
@@ -3570,19 +3774,19 @@ async function resolveDbOnly(db, exp, projectRoot) {
 function gitMerge(branch, cwd) {
   try {
     try {
-      (0, import_node_child_process5.execFileSync)("git", ["checkout", "main"], {
+      (0, import_node_child_process6.execFileSync)("git", ["checkout", "main"], {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
     } catch {
-      (0, import_node_child_process5.execFileSync)("git", ["checkout", "master"], {
+      (0, import_node_child_process6.execFileSync)("git", ["checkout", "master"], {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
       });
     }
-    (0, import_node_child_process5.execFileSync)("git", ["merge", branch, "--no-ff", "-m", `Merge experiment branch ${branch}`], {
+    (0, import_node_child_process6.execFileSync)("git", ["merge", branch, "--no-ff", "-m", `Merge experiment branch ${branch}`], {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3593,23 +3797,23 @@ function gitMerge(branch, cwd) {
 }
 function gitRevert(branch, cwd) {
   try {
-    const currentBranch = (0, import_node_child_process5.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    const currentBranch = (0, import_node_child_process6.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd,
       encoding: "utf-8"
     }).trim();
     if (currentBranch === branch) {
       try {
-        (0, import_node_child_process5.execFileSync)("git", ["checkout", "--", "."], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        (0, import_node_child_process6.execFileSync)("git", ["checkout", "--", "."], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
       } catch {
       }
       try {
-        (0, import_node_child_process5.execFileSync)("git", ["checkout", "main"], {
+        (0, import_node_child_process6.execFileSync)("git", ["checkout", "main"], {
           cwd,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         });
       } catch {
-        (0, import_node_child_process5.execFileSync)("git", ["checkout", "master"], {
+        (0, import_node_child_process6.execFileSync)("git", ["checkout", "master"], {
           cwd,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
@@ -3621,28 +3825,30 @@ function gitRevert(branch, cwd) {
   }
 }
 function appendToFragilityMap(projectRoot, expSlug, gaps) {
-  const fragPath = path11.join(projectRoot, "docs", "synthesis", "fragility.md");
+  const fragPath = path12.join(projectRoot, "docs", "synthesis", "fragility.md");
   let content = "";
-  if (fs11.existsSync(fragPath)) {
-    content = fs11.readFileSync(fragPath, "utf-8");
+  if (fs12.existsSync(fragPath)) {
+    content = fs12.readFileSync(fragPath, "utf-8");
   }
   const entry = `
 ## From experiment: ${expSlug}
 ${gaps}
 `;
-  fs11.writeFileSync(fragPath, content + entry);
+  fs12.writeFileSync(fragPath, content + entry);
 }
-var fs11, path11, import_node_child_process5;
+var fs12, path12, import_node_child_process6;
 var init_resolve = __esm({
   "src/resolve.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
+    fs12 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
     init_types2();
     init_machine();
     init_queries();
+    init_metrics();
+    init_config();
     init_spawn();
-    import_node_child_process5 = require("child_process");
+    import_node_child_process6 = require("child_process");
     init_git();
     init_format();
   }
@@ -3710,8 +3916,8 @@ async function runResolve(db, exp, root) {
 }
 async function doGate(db, exp, root) {
   transition(exp.status, "gated" /* GATED */);
-  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
-  const fragility = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path13.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: {
@@ -3742,9 +3948,18 @@ Output your gate_decision as "approve", "reject", or "flag" with reasoning.`
   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.`);
+    insertDeadEnd(
+      db,
+      exp.id,
+      exp.hypothesis ?? exp.slug,
+      reason,
+      `Gate rejected: ${reason}`,
+      exp.sub_type,
+      "procedural"
+    );
+    adminTransitionAndPersist(db, exp.id, "gated", "dead_end" /* DEAD_END */, "revert");
+    warn(`Gate REJECTED for ${exp.slug}: ${reason}. Dead-ended.`);
+    return;
   } else {
     if (decision === "flag") {
       warn(`Gate flagged concerns for ${exp.slug}: ${reason}`);
@@ -3754,17 +3969,25 @@ Output your gate_decision as "approve", "reject", or "flag" with reasoning.`
   }
 }
 async function doBuild(db, exp, root) {
+  if (exp.depends_on) {
+    const dep = getExperimentBySlug(db, exp.depends_on);
+    if (!dep || dep.status !== "merged") {
+      throw new Error(
+        `Experiment "${exp.slug}" depends on "${exp.depends_on}" which is ${dep ? dep.status : "not found"}. Dependency must be merged before building.`
+      );
+    }
+  }
   transition(exp.status, "building" /* BUILDING */);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
   const builderGuidance = getBuilderGuidance(db, exp.id);
-  const fragility = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
-  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path13.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_process6.execSync)(config.metrics.command, {
+      const output = (0, import_node_child_process7.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -3792,6 +4015,11 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
     }
   }
   taskPrompt += "\n\nNote: The framework captures metrics automatically. Do NOT claim specific numbers unless quoting framework output.";
+  const supplementaryContext = loadExperimentContext(exp, root);
+  const lineage = exportExperimentLineage(db, exp.sub_type);
+  if (lineage) {
+    taskPrompt += "\n\n" + lineage;
+  }
   const result = await spawnAgent("builder", {
     experiment: {
       id: exp.id,
@@ -3809,9 +4037,25 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
     fragility,
     synthesis,
     confirmedDoubts,
+    supplementaryContext: supplementaryContext || void 0,
+    experimentLineage: lineage || void 0,
     taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
+  if (result.structured?.abandon) {
+    insertDeadEnd(
+      db,
+      exp.id,
+      exp.hypothesis ?? exp.slug,
+      result.structured.abandon.reason,
+      result.structured.abandon.structural_constraint,
+      exp.sub_type,
+      "structural"
+    );
+    adminTransitionAndPersist(db, exp.id, "building", "dead_end" /* DEAD_END */, "revert");
+    info(`Builder abandoned ${exp.slug}: ${result.structured.abandon.reason}`);
+    return;
+  }
   if (result.truncated && !result.structured) {
     warn(`Builder was truncated (hit max turns) without producing structured output.`);
     await spawnRecovery("builder", result.output, {
@@ -3819,9 +4063,28 @@ 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.build?.pre_measure) {
+      try {
+        const [cmd, ...cmdArgs] = config.build.pre_measure.split(/\s+/);
+        (0, import_node_child_process7.execFileSync)(cmd, cmdArgs, {
+          cwd: root,
+          encoding: "utf-8",
+          timeout: 3e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        const guidance = `Build verification failed after builder completion. Code may be syntactically broken or incomplete.
+Error: ${errMsg.slice(0, 500)}`;
+        storeBuilderGuidance(db, exp.id, guidance);
+        warn(`Build verification failed for ${exp.slug}. Staying at 'building'.`);
+        warn(`Guidance stored for retry. Run \`majlis build\` to retry.`);
+        return;
+      }
+    }
     if (config.metrics?.command) {
       try {
-        const output = (0, import_node_child_process6.execSync)(config.metrics.command, {
+        const output = (0, import_node_child_process7.execSync)(config.metrics.command, {
           cwd: root,
           encoding: "utf-8",
           timeout: 6e4,
@@ -3837,6 +4100,15 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
       }
     }
     gitCommitBuild(exp, root);
+    if (result.extractionTier === 3) {
+      warn(`Builder output extracted via Haiku (tier 3). Data provenance degraded.`);
+      const existing = getBuilderGuidance(db, exp.id) ?? "";
+      storeBuilderGuidance(
+        db,
+        exp.id,
+        existing + "\n[PROVENANCE WARNING] Builder structured output was reconstructed by a secondary model (tier 3). Treat reported decisions with additional scrutiny."
+      );
+    }
     updateExperimentStatus(db, exp.id, "built");
     success(`Build complete for ${exp.slug}. Run \`majlis doubt\` or \`majlis challenge\` next.`);
   }
@@ -3845,7 +4117,7 @@ async function doChallenge(db, exp, root) {
   transition(exp.status, "challenged" /* CHALLENGED */);
   let gitDiff = "";
   try {
-    gitDiff = (0, import_node_child_process6.execSync)('git diff main -- . ":!.majlis/"', {
+    gitDiff = (0, import_node_child_process7.execSync)('git diff main -- . ":!.majlis/"', {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3853,7 +4125,7 @@ async function doChallenge(db, exp, root) {
   } catch {
   }
   if (gitDiff.length > 8e3) gitDiff = gitDiff.slice(0, 8e3) + "\n[DIFF TRUNCATED]";
-  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const synthesis = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
   let taskPrompt = `Construct adversarial test cases for experiment ${exp.slug}: ${exp.hypothesis}`;
   if (gitDiff) {
     taskPrompt += `
@@ -3886,9 +4158,9 @@ ${gitDiff}
 async function doDoubt(db, exp, root) {
   transition(exp.status, "doubted" /* DOUBTED */);
   const paddedNum = String(exp.id).padStart(3, "0");
-  const expDocPath = path12.join(root, "docs", "experiments", `${paddedNum}-${exp.slug}.md`);
+  const expDocPath = path13.join(root, "docs", "experiments", `${paddedNum}-${exp.slug}.md`);
   const experimentDoc = truncateContext(readFileOrEmpty(expDocPath), CONTEXT_LIMITS.experimentDoc);
-  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const synthesis = truncateContext(readFileOrEmpty(path13.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) {
@@ -3927,8 +4199,8 @@ ${experimentDoc}
 }
 async function doScout(db, exp, root) {
   transition(exp.status, "scouted" /* SCOUTED */);
-  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
-  const fragility = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path13.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}`
@@ -3975,31 +4247,49 @@ ${fragility}`;
 async function doVerify(db, exp, root) {
   transition(exp.status, "verifying" /* VERIFYING */);
   const doubts = getDoubtsByExperiment(db, exp.id);
-  const challengeDir = path12.join(root, "docs", "challenges");
+  const challengeDir = path13.join(root, "docs", "challenges");
   let challenges = "";
-  if (fs12.existsSync(challengeDir)) {
-    const files = fs12.readdirSync(challengeDir).filter((f) => f.includes(exp.slug) && f.endsWith(".md"));
+  if (fs13.existsSync(challengeDir)) {
+    const files = fs13.readdirSync(challengeDir).filter((f) => f.includes(exp.slug) && f.endsWith(".md"));
     for (const f of files) {
-      challenges += fs12.readFileSync(path12.join(challengeDir, f), "utf-8") + "\n\n";
+      challenges += fs13.readFileSync(path13.join(challengeDir, f), "utf-8") + "\n\n";
     }
   }
-  const beforeMetrics = getMetricsByExperimentAndPhase(db, exp.id, "before");
-  const afterMetrics = getMetricsByExperimentAndPhase(db, exp.id, "after");
+  const config = loadConfig(root);
+  const metricComparisons = compareMetrics(db, exp.id, config);
   let metricsSection = "";
-  if (beforeMetrics.length > 0 || afterMetrics.length > 0) {
+  if (metricComparisons.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}
+    metricsSection += "| Fixture | Metric | Before | After | Delta | Regression | Gate |\n";
+    metricsSection += "|---------|--------|--------|-------|-------|------------|------|\n";
+    for (const c of metricComparisons) {
+      metricsSection += `| ${c.fixture} | ${c.metric} | ${c.before} | ${c.after} | ${c.delta > 0 ? "+" : ""}${c.delta} | ${c.regression ? "YES" : "no"} | ${c.gate ? "GATE" : "-"} |
+`;
+    }
+    const gateViolations = metricComparisons.filter((c) => c.gate && c.regression);
+    if (gateViolations.length > 0) {
+      metricsSection += `
+**GATE VIOLATION**: ${gateViolations.length} gate fixture(s) regressed. This MUST be addressed \u2014 gate regressions block merge.
 `;
-      }
     }
-    if (afterMetrics.length > 0) {
-      metricsSection += "### After Build\n";
-      for (const m of afterMetrics) {
-        metricsSection += `- ${m.fixture} / ${m.metric_name}: ${m.metric_value}
+  } else {
+    const beforeMetrics = getMetricsByExperimentAndPhase(db, exp.id, "before");
+    const afterMetrics = getMetricsByExperimentAndPhase(db, exp.id, "after");
+    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}
 `;
+        }
       }
     }
   }
@@ -4013,6 +4303,16 @@ async function doVerify(db, exp, root) {
     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 verifierSupplementaryContext = loadExperimentContext(exp, root);
+  const verifierLineage = exportExperimentLineage(db, exp.sub_type);
+  let verifierTaskPrompt = `Verify experiment ${exp.slug}: ${exp.hypothesis}. Check provenance and content. Test the ${doubts.length} doubt(s) and any adversarial challenges.` + metricsSection + doubtReference;
+  if (verifierLineage) {
+    verifierTaskPrompt += "\n\n" + verifierLineage;
+  }
+  const builderGuidanceForVerifier = getBuilderGuidance(db, exp.id);
+  if (builderGuidanceForVerifier?.includes("[PROVENANCE WARNING]")) {
+    verifierTaskPrompt += "\n\nNote: The builder's structured output was reconstructed by a secondary model (tier 3). Treat reported decisions with additional scrutiny.";
+  }
   const result = await spawnAgent("verifier", {
     experiment: {
       id: exp.id,
@@ -4024,7 +4324,10 @@ 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.` + metricsSection + doubtReference
+    metricComparisons: metricComparisons.length > 0 ? metricComparisons : void 0,
+    supplementaryContext: verifierSupplementaryContext || void 0,
+    experimentLineage: verifierLineage || void 0,
+    taskPrompt: verifierTaskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
   if (result.truncated && !result.structured) {
@@ -4048,22 +4351,22 @@ async function doVerify(db, exp, root) {
   success(`Verification complete for ${exp.slug}. Run \`majlis resolve\` next.`);
 }
 async function doCompress(db, root) {
-  const synthesisPath = path12.join(root, "docs", "synthesis", "current.md");
-  const sizeBefore = fs12.existsSync(synthesisPath) ? fs12.statSync(synthesisPath).size : 0;
+  const synthesisPath = path13.join(root, "docs", "synthesis", "current.md");
+  const sizeBefore = fs13.existsSync(synthesisPath) ? fs13.statSync(synthesisPath).size : 0;
   const sessionCount = getSessionsSinceCompression(db);
   const dbExport = exportForCompressor(db);
   const result = await spawnAgent("compressor", {
     taskPrompt: "## Structured Data (CANONICAL \u2014 from SQLite database)\nThe database export below is the source of truth. docs/ files are agent artifacts that may contain stale or incorrect information. Cross-reference everything against this data.\n\n" + dbExport + "\n\n## Your Task\nRead ALL experiments, decisions, doubts, challenges, verification reports, reframes, and recent diffs. Cross-reference for contradictions, redundancies, and patterns. REWRITE docs/synthesis/current.md \u2014 shorter and denser. Update docs/synthesis/fragility.md with current weak areas. Update docs/synthesis/dead-ends.md with structural constraints from rejected experiments."
   }, root);
-  const sizeAfter = fs12.existsSync(synthesisPath) ? fs12.statSync(synthesisPath).size : 0;
+  const sizeAfter = fs13.existsSync(synthesisPath) ? fs13.statSync(synthesisPath).size : 0;
   recordCompression(db, sessionCount, sizeBefore, sizeAfter);
   autoCommit(root, "compress: update synthesis");
   success(`Compression complete. Synthesis: ${sizeBefore}B \u2192 ${sizeAfter}B`);
 }
 function gitCommitBuild(exp, cwd) {
   try {
-    (0, import_node_child_process6.execSync)('git add -A -- ":!.majlis/"', { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-    const diff = (0, import_node_child_process6.execSync)("git diff --cached --stat", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    (0, import_node_child_process7.execSync)('git add -A -- ":!.majlis/"', { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const diff = (0, import_node_child_process7.execSync)("git diff --cached --stat", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     if (!diff) {
       info("No code changes to commit.");
       return;
@@ -4071,12 +4374,37 @@ function gitCommitBuild(exp, cwd) {
     const msg = `EXP-${String(exp.id).padStart(3, "0")}: ${exp.slug}
 
 ${exp.hypothesis ?? ""}`;
-    (0, import_node_child_process6.execFileSync)("git", ["commit", "-m", msg], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    (0, import_node_child_process7.execFileSync)("git", ["commit", "-m", 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 loadExperimentContext(exp, root) {
+  if (!exp.context_files) return "";
+  let files;
+  try {
+    files = JSON.parse(exp.context_files);
+  } catch {
+    return "";
+  }
+  if (!Array.isArray(files) || files.length === 0) return "";
+  const sections = ["## Experiment-Scoped Reference Material"];
+  for (const relPath of files) {
+    const absPath = path13.join(root, relPath);
+    try {
+      const content = fs13.readFileSync(absPath, "utf-8");
+      sections.push(`### ${relPath}
+\`\`\`
+${content.slice(0, 8e3)}
+\`\`\``);
+    } catch {
+      sections.push(`### ${relPath}
+*(file not found)*`);
+    }
+  }
+  return sections.join("\n\n");
+}
 function resolveExperimentArg(db, args) {
   const slugArg = args.filter((a) => !a.startsWith("--"))[0];
   let exp;
@@ -4149,13 +4477,13 @@ function ingestStructuredOutput(db, experimentId, structured) {
     }
   })();
 }
-var fs12, path12, import_node_child_process6;
+var fs13, path13, import_node_child_process7;
 var init_cycle = __esm({
   "src/commands/cycle.ts"() {
     "use strict";
-    fs12 = __toESM(require("fs"));
-    path12 = __toESM(require("path"));
-    import_node_child_process6 = require("child_process");
+    fs13 = __toESM(require("fs"));
+    path13 = __toESM(require("path"));
+    import_node_child_process7 = require("child_process");
     init_connection();
     init_queries();
     init_machine();
@@ -4182,10 +4510,10 @@ async function classify(args) {
   if (!domain) {
     throw new Error('Usage: majlis classify "domain description"');
   }
-  const synthesisPath = path13.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs13.existsSync(synthesisPath) ? fs13.readFileSync(synthesisPath, "utf-8") : "";
-  const deadEndsPath = path13.join(root, "docs", "synthesis", "dead-ends.md");
-  const deadEnds = fs13.existsSync(deadEndsPath) ? fs13.readFileSync(deadEndsPath, "utf-8") : "";
+  const synthesisPath = path14.join(root, "docs", "synthesis", "current.md");
+  const synthesis = fs14.existsSync(synthesisPath) ? fs14.readFileSync(synthesisPath, "utf-8") : "";
+  const deadEndsPath = path14.join(root, "docs", "synthesis", "dead-ends.md");
+  const deadEnds = fs14.existsSync(deadEndsPath) ? fs14.readFileSync(deadEndsPath, "utf-8") : "";
   info(`Classifying problem domain: ${domain}`);
   const result = await spawnAgent("builder", {
     synthesis,
@@ -4204,22 +4532,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 = path13.join(root, "docs", "classification");
+  const classificationDir = path14.join(root, "docs", "classification");
   let classificationContent = "";
-  if (fs13.existsSync(classificationDir)) {
-    const files = fs13.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+  if (fs14.existsSync(classificationDir)) {
+    const files = fs14.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
     for (const f of files) {
-      classificationContent += fs13.readFileSync(path13.join(classificationDir, f), "utf-8") + "\n\n";
+      classificationContent += fs14.readFileSync(path14.join(classificationDir, f), "utf-8") + "\n\n";
     }
   }
-  const synthesisPath = path13.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs13.existsSync(synthesisPath) ? fs13.readFileSync(synthesisPath, "utf-8") : "";
-  const deadEndsPath = path13.join(root, "docs", "synthesis", "dead-ends.md");
-  const deadEnds = fs13.existsSync(deadEndsPath) ? fs13.readFileSync(deadEndsPath, "utf-8") : "";
-  const configPath = path13.join(root, ".majlis", "config.json");
+  const synthesisPath = path14.join(root, "docs", "synthesis", "current.md");
+  const synthesis = fs14.existsSync(synthesisPath) ? fs14.readFileSync(synthesisPath, "utf-8") : "";
+  const deadEndsPath = path14.join(root, "docs", "synthesis", "dead-ends.md");
+  const deadEnds = fs14.existsSync(deadEndsPath) ? fs14.readFileSync(deadEndsPath, "utf-8") : "";
+  const configPath = path14.join(root, ".majlis", "config.json");
   let problemStatement = "";
-  if (fs13.existsSync(configPath)) {
-    const config = JSON.parse(fs13.readFileSync(configPath, "utf-8"));
+  if (fs14.existsSync(configPath)) {
+    const config = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
     problemStatement = `${config.project?.description ?? ""}
 Objective: ${config.project?.objective ?? ""}`;
   }
@@ -4244,12 +4572,12 @@ Write to docs/reframes/.`
   autoCommit(root, `reframe: ${target.slice(0, 60)}`);
   success("Reframe complete. Check docs/reframes/ for the output.");
 }
-var fs13, path13;
+var fs14, path14;
 var init_classify = __esm({
   "src/commands/classify.ts"() {
     "use strict";
-    fs13 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
+    fs14 = __toESM(require("fs"));
+    path14 = __toESM(require("path"));
     init_connection();
     init_spawn();
     init_git();
@@ -4271,15 +4599,15 @@ async function audit(args) {
   const experiments = listAllExperiments(db);
   const deadEnds = listAllDeadEnds(db);
   const circuitBreakers = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
-  const classificationDir = path14.join(root, "docs", "classification");
+  const classificationDir = path15.join(root, "docs", "classification");
   let classification = "";
-  if (fs14.existsSync(classificationDir)) {
-    const files = fs14.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+  if (fs15.existsSync(classificationDir)) {
+    const files = fs15.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
     for (const f of files) {
-      classification += fs14.readFileSync(path14.join(classificationDir, f), "utf-8") + "\n\n";
+      classification += fs15.readFileSync(path15.join(classificationDir, f), "utf-8") + "\n\n";
     }
   }
-  const synthesis = readFileOrEmpty(path14.join(root, "docs", "synthesis", "current.md"));
+  const synthesis = readFileOrEmpty(path15.join(root, "docs", "synthesis", "current.md"));
   header("Maqasid Check \u2014 Purpose Audit");
   const trippedBreakers = circuitBreakers.filter((cb) => cb.tripped);
   if (trippedBreakers.length > 0) {
@@ -4323,12 +4651,12 @@ Output: either "classification confirmed \u2014 continue" or "re-classify from X
   }, root);
   success("Purpose audit complete. Review the output above.");
 }
-var fs14, path14;
+var fs15, path15;
 var init_audit = __esm({
   "src/commands/audit.ts"() {
     "use strict";
-    fs14 = __toESM(require("fs"));
-    path14 = __toESM(require("path"));
+    fs15 = __toESM(require("fs"));
+    path15 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_spawn();
@@ -4619,16 +4947,16 @@ async function run(args) {
   info("Run `majlis status` to see final state.");
 }
 async function deriveNextHypothesis(goal, root, db) {
-  const synthesis = truncateContext(readFileOrEmpty(path15.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
-  const fragility = truncateContext(readFileOrEmpty(path15.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
-  const deadEndsDoc = truncateContext(readFileOrEmpty(path15.join(root, "docs", "synthesis", "dead-ends.md")), CONTEXT_LIMITS.deadEnds);
+  const synthesis = truncateContext(readFileOrEmpty(path16.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path16.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const deadEndsDoc = truncateContext(readFileOrEmpty(path16.join(root, "docs", "synthesis", "dead-ends.md")), CONTEXT_LIMITS.deadEnds);
   const diagnosis = truncateContext(readLatestDiagnosis(root), CONTEXT_LIMITS.synthesis);
   const deadEnds = listAllDeadEnds(db);
   const config = loadConfig(root);
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
-      metricsOutput = (0, import_node_child_process7.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process8.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -4727,7 +5055,7 @@ async function createNewExperiment(db, root, hypothesis) {
   const paddedNum = String(num).padStart(3, "0");
   const branch = `exp/${paddedNum}-${finalSlug}`;
   try {
-    (0, import_node_child_process7.execFileSync)("git", ["checkout", "-b", branch], {
+    (0, import_node_child_process8.execFileSync)("git", ["checkout", "-b", branch], {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4739,24 +5067,24 @@ async function createNewExperiment(db, root, hypothesis) {
   const exp = createExperiment(db, finalSlug, branch, hypothesis, null, null);
   adminTransitionAndPersist(db, exp.id, exp.status, "reframed" /* REFRAMED */, "bootstrap");
   exp.status = "reframed";
-  const docsDir = path15.join(root, "docs", "experiments");
-  const templatePath = path15.join(docsDir, "_TEMPLATE.md");
-  if (fs15.existsSync(templatePath)) {
-    const template = fs15.readFileSync(templatePath, "utf-8");
+  const docsDir = path16.join(root, "docs", "experiments");
+  const templatePath = path16.join(docsDir, "_TEMPLATE.md");
+  if (fs16.existsSync(templatePath)) {
+    const template = fs16.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 = path15.join(docsDir, `${paddedNum}-${finalSlug}.md`);
-    fs15.writeFileSync(logPath, logContent);
+    const logPath = path16.join(docsDir, `${paddedNum}-${finalSlug}.md`);
+    fs16.writeFileSync(logPath, logContent);
     info(`Created experiment log: docs/experiments/${paddedNum}-${finalSlug}.md`);
   }
   return exp;
 }
-var fs15, path15, import_node_child_process7;
+var fs16, path16, import_node_child_process8;
 var init_run = __esm({
   "src/commands/run.ts"() {
     "use strict";
-    fs15 = __toESM(require("fs"));
-    path15 = __toESM(require("path"));
-    import_node_child_process7 = require("child_process");
+    fs16 = __toESM(require("fs"));
+    path16 = __toESM(require("path"));
+    import_node_child_process8 = require("child_process");
     init_connection();
     init_queries();
     init_machine();
@@ -4773,11 +5101,11 @@ var init_run = __esm({
 
 // src/swarm/worktree.ts
 function createWorktree(mainRoot, slug, paddedNum) {
-  const projectName = path16.basename(mainRoot);
+  const projectName = path17.basename(mainRoot);
   const worktreeName = `${projectName}-swarm-${paddedNum}-${slug}`;
-  const worktreePath = path16.join(path16.dirname(mainRoot), worktreeName);
+  const worktreePath = path17.join(path17.dirname(mainRoot), worktreeName);
   const branch = `swarm/${paddedNum}-${slug}`;
-  (0, import_node_child_process8.execFileSync)("git", ["worktree", "add", worktreePath, "-b", branch], {
+  (0, import_node_child_process9.execFileSync)("git", ["worktree", "add", worktreePath, "-b", branch], {
     cwd: mainRoot,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4792,43 +5120,43 @@ function createWorktree(mainRoot, slug, paddedNum) {
   };
 }
 function initializeWorktree(mainRoot, worktreePath) {
-  const majlisDir = path16.join(worktreePath, ".majlis");
-  fs16.mkdirSync(majlisDir, { recursive: true });
-  const configSrc = path16.join(mainRoot, ".majlis", "config.json");
-  if (fs16.existsSync(configSrc)) {
-    fs16.copyFileSync(configSrc, path16.join(majlisDir, "config.json"));
-  }
-  const agentsSrc = path16.join(mainRoot, ".majlis", "agents");
-  if (fs16.existsSync(agentsSrc)) {
-    const agentsDst = path16.join(majlisDir, "agents");
-    fs16.mkdirSync(agentsDst, { recursive: true });
-    for (const file of fs16.readdirSync(agentsSrc)) {
-      fs16.copyFileSync(path16.join(agentsSrc, file), path16.join(agentsDst, file));
-    }
-  }
-  const synthSrc = path16.join(mainRoot, "docs", "synthesis");
-  if (fs16.existsSync(synthSrc)) {
-    const synthDst = path16.join(worktreePath, "docs", "synthesis");
-    fs16.mkdirSync(synthDst, { recursive: true });
-    for (const file of fs16.readdirSync(synthSrc)) {
-      const srcFile = path16.join(synthSrc, file);
-      if (fs16.statSync(srcFile).isFile()) {
-        fs16.copyFileSync(srcFile, path16.join(synthDst, file));
+  const majlisDir = path17.join(worktreePath, ".majlis");
+  fs17.mkdirSync(majlisDir, { recursive: true });
+  const configSrc = path17.join(mainRoot, ".majlis", "config.json");
+  if (fs17.existsSync(configSrc)) {
+    fs17.copyFileSync(configSrc, path17.join(majlisDir, "config.json"));
+  }
+  const agentsSrc = path17.join(mainRoot, ".majlis", "agents");
+  if (fs17.existsSync(agentsSrc)) {
+    const agentsDst = path17.join(majlisDir, "agents");
+    fs17.mkdirSync(agentsDst, { recursive: true });
+    for (const file of fs17.readdirSync(agentsSrc)) {
+      fs17.copyFileSync(path17.join(agentsSrc, file), path17.join(agentsDst, file));
+    }
+  }
+  const synthSrc = path17.join(mainRoot, "docs", "synthesis");
+  if (fs17.existsSync(synthSrc)) {
+    const synthDst = path17.join(worktreePath, "docs", "synthesis");
+    fs17.mkdirSync(synthDst, { recursive: true });
+    for (const file of fs17.readdirSync(synthSrc)) {
+      const srcFile = path17.join(synthSrc, file);
+      if (fs17.statSync(srcFile).isFile()) {
+        fs17.copyFileSync(srcFile, path17.join(synthDst, file));
       }
     }
   }
-  const templateSrc = path16.join(mainRoot, "docs", "experiments", "_TEMPLATE.md");
-  if (fs16.existsSync(templateSrc)) {
-    const expDir = path16.join(worktreePath, "docs", "experiments");
-    fs16.mkdirSync(expDir, { recursive: true });
-    fs16.copyFileSync(templateSrc, path16.join(expDir, "_TEMPLATE.md"));
+  const templateSrc = path17.join(mainRoot, "docs", "experiments", "_TEMPLATE.md");
+  if (fs17.existsSync(templateSrc)) {
+    const expDir = path17.join(worktreePath, "docs", "experiments");
+    fs17.mkdirSync(expDir, { recursive: true });
+    fs17.copyFileSync(templateSrc, path17.join(expDir, "_TEMPLATE.md"));
   }
   const db = openDbAt(worktreePath);
   db.close();
 }
 function cleanupWorktree(mainRoot, wt) {
   try {
-    (0, import_node_child_process8.execFileSync)("git", ["worktree", "remove", wt.path, "--force"], {
+    (0, import_node_child_process9.execFileSync)("git", ["worktree", "remove", wt.path, "--force"], {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4837,7 +5165,7 @@ function cleanupWorktree(mainRoot, wt) {
     warn(`Could not remove worktree ${wt.path} \u2014 remove manually.`);
   }
   try {
-    (0, import_node_child_process8.execFileSync)("git", ["branch", "-D", wt.branch], {
+    (0, import_node_child_process9.execFileSync)("git", ["branch", "-D", wt.branch], {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4845,7 +5173,7 @@ function cleanupWorktree(mainRoot, wt) {
   } catch {
   }
   try {
-    (0, import_node_child_process8.execSync)("git worktree prune", {
+    (0, import_node_child_process9.execSync)("git worktree prune", {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4853,13 +5181,13 @@ function cleanupWorktree(mainRoot, wt) {
   } catch {
   }
 }
-var fs16, path16, import_node_child_process8;
+var fs17, path17, import_node_child_process9;
 var init_worktree = __esm({
   "src/swarm/worktree.ts"() {
     "use strict";
-    fs16 = __toESM(require("fs"));
-    path16 = __toESM(require("path"));
-    import_node_child_process8 = require("child_process");
+    fs17 = __toESM(require("fs"));
+    path17 = __toESM(require("path"));
+    import_node_child_process9 = require("child_process");
     init_connection();
     init_format();
   }
@@ -4877,12 +5205,12 @@ async function runExperimentInWorktree(wt) {
     exp = createExperiment(db, wt.slug, wt.branch, wt.hypothesis, null, null);
     adminTransitionAndPersist(db, exp.id, exp.status, "reframed" /* REFRAMED */, "bootstrap");
     exp.status = "reframed";
-    const templatePath = path17.join(wt.path, "docs", "experiments", "_TEMPLATE.md");
-    if (fs17.existsSync(templatePath)) {
-      const template = fs17.readFileSync(templatePath, "utf-8");
+    const templatePath = path18.join(wt.path, "docs", "experiments", "_TEMPLATE.md");
+    if (fs18.existsSync(templatePath)) {
+      const template = fs18.readFileSync(templatePath, "utf-8");
       const logContent = template.replace(/\{\{title\}\}/g, wt.hypothesis).replace(/\{\{hypothesis\}\}/g, wt.hypothesis).replace(/\{\{branch\}\}/g, wt.branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-      const logPath = path17.join(wt.path, "docs", "experiments", `${wt.paddedNum}-${wt.slug}.md`);
-      fs17.writeFileSync(logPath, logContent);
+      const logPath = path18.join(wt.path, "docs", "experiments", `${wt.paddedNum}-${wt.slug}.md`);
+      fs18.writeFileSync(logPath, logContent);
     }
     info(`${label} Starting: ${wt.hypothesis}`);
     while (stepCount < MAX_STEPS) {
@@ -5005,12 +5333,12 @@ function statusToStepName(status2) {
       return null;
   }
 }
-var fs17, path17, MAX_STEPS;
+var fs18, path18, MAX_STEPS;
 var init_runner = __esm({
   "src/swarm/runner.ts"() {
     "use strict";
-    fs17 = __toESM(require("fs"));
-    path17 = __toESM(require("path"));
+    fs18 = __toESM(require("fs"));
+    path18 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_machine();
@@ -5164,7 +5492,7 @@ async function swarm(args) {
     MAX_PARALLEL
   );
   try {
-    const status2 = (0, import_node_child_process9.execSync)("git status --porcelain", {
+    const status2 = (0, import_node_child_process10.execSync)("git status --porcelain", {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -5192,20 +5520,20 @@ async function swarm(args) {
     info(`  ${i + 1}. ${hypotheses[i]}`);
   }
   try {
-    const worktreeList = (0, import_node_child_process9.execFileSync)("git", ["worktree", "list", "--porcelain"], {
+    const worktreeList = (0, import_node_child_process10.execFileSync)("git", ["worktree", "list", "--porcelain"], {
       cwd: root,
       encoding: "utf-8"
     });
     const orphaned = worktreeList.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.replace("worktree ", "")).filter((p) => p.includes("-swarm-"));
     for (const orphanPath of orphaned) {
       try {
-        (0, import_node_child_process9.execFileSync)("git", ["worktree", "remove", orphanPath, "--force"], { cwd: root, encoding: "utf-8" });
-        info(`Cleaned up orphaned worktree: ${path18.basename(orphanPath)}`);
+        (0, import_node_child_process10.execFileSync)("git", ["worktree", "remove", orphanPath, "--force"], { cwd: root, encoding: "utf-8" });
+        info(`Cleaned up orphaned worktree: ${path19.basename(orphanPath)}`);
       } catch {
       }
     }
     if (orphaned.length > 0) {
-      (0, import_node_child_process9.execFileSync)("git", ["worktree", "prune"], { cwd: root, encoding: "utf-8" });
+      (0, import_node_child_process10.execFileSync)("git", ["worktree", "prune"], { cwd: root, encoding: "utf-8" });
     }
   } catch {
   }
@@ -5268,16 +5596,80 @@ async function swarm(args) {
     if (summary.bestExperiment && isMergeable(summary.bestExperiment.overallGrade)) {
       const best = summary.bestExperiment;
       info(`Best experiment: ${best.worktree.slug} (${best.overallGrade})`);
+      let merged = false;
       try {
-        (0, import_node_child_process9.execFileSync)(
+        (0, import_node_child_process10.execFileSync)(
           "git",
           ["merge", best.worktree.branch, "--no-ff", "-m", `Merge swarm winner: ${best.worktree.slug}`],
           { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
         );
         success(`Merged ${best.worktree.slug} into main.`);
+        merged = true;
       } catch {
-        warn(`Git merge of ${best.worktree.slug} failed. Merge manually with:`);
-        info(`  git merge ${best.worktree.branch} --no-ff`);
+        warn(`Git merge of ${best.worktree.slug} failed (conflict). Attempting rebase...`);
+        try {
+          (0, import_node_child_process10.execFileSync)("git", ["merge", "--abort"], { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        } catch {
+        }
+        try {
+          (0, import_node_child_process10.execFileSync)(
+            "git",
+            ["rebase", "main", best.worktree.branch],
+            { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+          );
+          info(`Rebase of ${best.worktree.slug} onto main succeeded. Re-verifying gates...`);
+          const config = loadConfig(root);
+          let gatesHold = true;
+          if (config.metrics?.command && best.experiment) {
+            try {
+              const output = (0, import_node_child_process10.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, best.experiment.id, "after", m.fixture, m.metric_name, m.metric_value);
+              }
+              const comparisons = compareMetrics(db, best.experiment.id, config);
+              const gateViolations = checkGateViolations(comparisons);
+              if (gateViolations.length > 0) {
+                gatesHold = false;
+                warn(`Gate violations after rebase:`);
+                for (const v of gateViolations) {
+                  warn(`  - ${v.fixture}/${v.metric}: ${v.before} \u2192 ${v.after} (delta: ${v.delta})`);
+                }
+              }
+            } catch {
+              warn("Could not re-capture metrics after rebase. Proceeding cautiously.");
+            }
+          }
+          if (gatesHold) {
+            (0, import_node_child_process10.execFileSync)("git", ["checkout", "main"], { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+            (0, import_node_child_process10.execFileSync)(
+              "git",
+              ["merge", "--ff-only", best.worktree.branch],
+              { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+            );
+            success(`Merged ${best.worktree.slug} into main (via rebase + ff).`);
+            merged = true;
+          } else {
+            warn(`Gate violations after rebase. NOT merging ${best.worktree.slug}.`);
+            info(`Manual resolution needed:`);
+            info(`  git checkout main && git merge ${best.worktree.branch} --no-ff`);
+          }
+        } catch {
+          try {
+            (0, import_node_child_process10.execFileSync)("git", ["rebase", "--abort"], { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+          } catch {
+          }
+          warn(`Rebase of ${best.worktree.slug} also failed. Manual merge required:`);
+          info(`  git merge ${best.worktree.branch} --no-ff`);
+        }
+      }
+      if (!merged) {
+        info(`${best.worktree.slug} was NOT merged automatically.`);
       }
     } else {
       info("No experiment achieved sound/good grade. Nothing merged.");
@@ -5320,15 +5712,15 @@ function isMergeable(grade) {
 }
 async function deriveMultipleHypotheses(goal, root, count) {
   const synthesis = truncateContext(
-    readFileOrEmpty(path18.join(root, "docs", "synthesis", "current.md")),
+    readFileOrEmpty(path19.join(root, "docs", "synthesis", "current.md")),
     CONTEXT_LIMITS.synthesis
   );
   const fragility = truncateContext(
-    readFileOrEmpty(path18.join(root, "docs", "synthesis", "fragility.md")),
+    readFileOrEmpty(path19.join(root, "docs", "synthesis", "fragility.md")),
     CONTEXT_LIMITS.fragility
   );
   const deadEndsDoc = truncateContext(
-    readFileOrEmpty(path18.join(root, "docs", "synthesis", "dead-ends.md")),
+    readFileOrEmpty(path19.join(root, "docs", "synthesis", "dead-ends.md")),
     CONTEXT_LIMITS.deadEnds
   );
   const diagnosis = truncateContext(readLatestDiagnosis(root), CONTEXT_LIMITS.synthesis);
@@ -5338,7 +5730,7 @@ async function deriveMultipleHypotheses(goal, root, count) {
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
-      metricsOutput = (0, import_node_child_process9.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process10.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -5418,18 +5810,19 @@ If the goal is met:
   warn("Planner did not return structured hypotheses. Using goal as single hypothesis.");
   return [goal];
 }
-var path18, import_node_child_process9, MAX_PARALLEL, DEFAULT_PARALLEL;
+var path19, import_node_child_process10, MAX_PARALLEL, DEFAULT_PARALLEL;
 var init_swarm = __esm({
   "src/commands/swarm.ts"() {
     "use strict";
-    path18 = __toESM(require("path"));
-    import_node_child_process9 = require("child_process");
+    path19 = __toESM(require("path"));
+    import_node_child_process10 = require("child_process");
     init_connection();
     init_queries();
     init_machine();
     init_types2();
     init_spawn();
     init_config();
+    init_metrics();
     init_worktree();
     init_runner();
     init_aggregate();
@@ -5450,21 +5843,21 @@ async function diagnose(args) {
   const db = getDb(root);
   const focus = args.filter((a) => !a.startsWith("--")).join(" ");
   const keepScripts = args.includes("--keep-scripts");
-  const scriptsDir = path19.join(root, ".majlis", "scripts");
-  if (!fs18.existsSync(scriptsDir)) {
-    fs18.mkdirSync(scriptsDir, { recursive: true });
+  const scriptsDir = path20.join(root, ".majlis", "scripts");
+  if (!fs19.existsSync(scriptsDir)) {
+    fs19.mkdirSync(scriptsDir, { recursive: true });
   }
   header("Deep Diagnosis");
   if (focus) info(`Focus: ${focus}`);
   const dbExport = exportForDiagnostician(db);
-  const synthesis = readFileOrEmpty(path19.join(root, "docs", "synthesis", "current.md"));
-  const fragility = readFileOrEmpty(path19.join(root, "docs", "synthesis", "fragility.md"));
-  const deadEndsDoc = readFileOrEmpty(path19.join(root, "docs", "synthesis", "dead-ends.md"));
+  const synthesis = readFileOrEmpty(path20.join(root, "docs", "synthesis", "current.md"));
+  const fragility = readFileOrEmpty(path20.join(root, "docs", "synthesis", "fragility.md"));
+  const deadEndsDoc = readFileOrEmpty(path20.join(root, "docs", "synthesis", "dead-ends.md"));
   const config = loadConfig(root);
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
-      metricsOutput = (0, import_node_child_process10.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process11.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -5510,13 +5903,13 @@ Perform a deep diagnostic analysis of this project. Identify root causes, recurr
 Remember: you may write files ONLY to .majlis/scripts/. You cannot modify project code.`;
   info("Spawning diagnostician (60 turns, full DB access)...");
   const result = await spawnAgent("diagnostician", { taskPrompt }, root);
-  const diagnosisDir = path19.join(root, "docs", "diagnosis");
-  if (!fs18.existsSync(diagnosisDir)) {
-    fs18.mkdirSync(diagnosisDir, { recursive: true });
+  const diagnosisDir = path20.join(root, "docs", "diagnosis");
+  if (!fs19.existsSync(diagnosisDir)) {
+    fs19.mkdirSync(diagnosisDir, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const artifactPath = path19.join(diagnosisDir, `diagnosis-${timestamp}.md`);
-  fs18.writeFileSync(artifactPath, result.output);
+  const artifactPath = path20.join(diagnosisDir, `diagnosis-${timestamp}.md`);
+  fs19.writeFileSync(artifactPath, result.output);
   info(`Diagnostic report: docs/diagnosis/diagnosis-${timestamp}.md`);
   if (result.structured?.diagnosis) {
     const d = result.structured.diagnosis;
@@ -5529,11 +5922,11 @@ Remember: you may write files ONLY to .majlis/scripts/. You cannot modify projec
   }
   if (!keepScripts) {
     try {
-      const files = fs18.readdirSync(scriptsDir);
+      const files = fs19.readdirSync(scriptsDir);
       for (const f of files) {
-        fs18.unlinkSync(path19.join(scriptsDir, f));
+        fs19.unlinkSync(path20.join(scriptsDir, f));
       }
-      fs18.rmdirSync(scriptsDir);
+      fs19.rmdirSync(scriptsDir);
       info("Cleaned up .majlis/scripts/");
     } catch {
     }
@@ -5546,13 +5939,13 @@ Remember: you may write files ONLY to .majlis/scripts/. You cannot modify projec
   autoCommit(root, `diagnosis: ${focus || "general"}`);
   success("Diagnosis complete.");
 }
-var fs18, path19, import_node_child_process10;
+var fs19, path20, import_node_child_process11;
 var init_diagnose = __esm({
   "src/commands/diagnose.ts"() {
     "use strict";
-    fs18 = __toESM(require("fs"));
-    path19 = __toESM(require("path"));
-    import_node_child_process10 = require("child_process");
+    fs19 = __toESM(require("fs"));
+    path20 = __toESM(require("path"));
+    import_node_child_process11 = require("child_process");
     init_connection();
     init_queries();
     init_spawn();
@@ -5591,7 +5984,7 @@ function getLastActivityTimestamp(db) {
 }
 function getCommitsSince(root, timestamp) {
   try {
-    const output = (0, import_node_child_process11.execFileSync)(
+    const output = (0, import_node_child_process12.execFileSync)(
       "git",
       ["log", `--since=${timestamp}`, "--oneline", "--", ".", ":!.majlis/", ":!docs/"],
       { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
@@ -5604,13 +5997,13 @@ function getCommitsSince(root, timestamp) {
 }
 function getGitDiffStat(root, timestamp) {
   try {
-    const baseRef = (0, import_node_child_process11.execFileSync)(
+    const baseRef = (0, import_node_child_process12.execFileSync)(
       "git",
       ["rev-list", "-1", `--before=${timestamp}`, "HEAD"],
       { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     if (!baseRef) return { stat: "", filesChanged: 0 };
-    const stat = (0, import_node_child_process11.execFileSync)(
+    const stat = (0, import_node_child_process12.execFileSync)(
       "git",
       ["diff", "--stat", baseRef, "--", ".", ":!.majlis/", ":!docs/"],
       { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
@@ -5647,11 +6040,11 @@ function checkMetrics(root, config) {
   const command = config.metrics?.command;
   if (!command) return { working: false, error: "No metrics command configured" };
   try {
-    const scriptPath = path20.join(root, command);
-    if (command.includes("/") && !fs19.existsSync(scriptPath)) {
+    const scriptPath = path21.join(root, command);
+    if (command.includes("/") && !fs20.existsSync(scriptPath)) {
       return { working: false, error: `Script not found: ${command}` };
     }
-    const output = (0, import_node_child_process11.execSync)(command, {
+    const output = (0, import_node_child_process12.execSync)(command, {
       cwd: root,
       encoding: "utf-8",
       timeout: 6e4,
@@ -5679,10 +6072,10 @@ function assessStaleness(db, root, profile, config) {
     filesChanged = diffResult.filesChanged;
   }
   const configDrift = detectConfigDrift(config, profile);
-  const synthesisPath = path20.join(root, "docs", "synthesis", "current.md");
+  const synthesisPath = path21.join(root, "docs", "synthesis", "current.md");
   let synthesisSize = 0;
   try {
-    synthesisSize = fs19.statSync(synthesisPath).size;
+    synthesisSize = fs20.statSync(synthesisPath).size;
   } catch {
   }
   const unresolvedDoubts = db.prepare(`
@@ -5740,13 +6133,13 @@ function printStalenessReport(report) {
     success("  Already up to date.");
   }
 }
-var fs19, path20, import_node_child_process11;
+var fs20, path21, import_node_child_process12;
 var init_staleness = __esm({
   "src/scan/staleness.ts"() {
     "use strict";
-    fs19 = __toESM(require("fs"));
-    path20 = __toESM(require("path"));
-    import_node_child_process11 = require("child_process");
+    fs20 = __toESM(require("fs"));
+    path21 = __toESM(require("path"));
+    import_node_child_process12 = require("child_process");
     init_queries();
     init_format();
   }
@@ -5796,13 +6189,13 @@ async function resync(args) {
     return;
   }
   info("Phase 1: Deep re-scan...");
-  const synthesisDir = path21.join(root, "docs", "synthesis");
-  const scriptsDir = path21.join(root, ".majlis", "scripts");
-  if (!fs20.existsSync(synthesisDir)) fs20.mkdirSync(synthesisDir, { recursive: true });
-  if (!fs20.existsSync(scriptsDir)) fs20.mkdirSync(scriptsDir, { recursive: true });
+  const synthesisDir = path22.join(root, "docs", "synthesis");
+  const scriptsDir = path22.join(root, ".majlis", "scripts");
+  if (!fs21.existsSync(synthesisDir)) fs21.mkdirSync(synthesisDir, { recursive: true });
+  if (!fs21.existsSync(scriptsDir)) fs21.mkdirSync(scriptsDir, { recursive: true });
   const profileJson = JSON.stringify(profile, null, 2);
-  const oldSynthesis = readFileOrEmpty(path21.join(root, "docs", "synthesis", "current.md"));
-  const oldFragility = readFileOrEmpty(path21.join(root, "docs", "synthesis", "fragility.md"));
+  const oldSynthesis = readFileOrEmpty(path22.join(root, "docs", "synthesis", "current.md"));
+  const oldFragility = readFileOrEmpty(path22.join(root, "docs", "synthesis", "fragility.md"));
   const dbExport = exportForCompressor(db);
   const stalenessSummary = `Last Majlis activity: ${report.daysSinceActivity} days ago (${report.lastActivitySource}).
 Commits since: ${report.commitsSinceActivity}. Files changed: ${report.filesChanged}.
@@ -5928,10 +6321,10 @@ You may ONLY write to .majlis/scripts/. Output your structured JSON when done.`;
       info("Updated .majlis/config.json with resync results.");
       if (toolsmithOutput.metrics_command) {
         try {
-          const metricsPath = path21.join(root, toolsmithOutput.metrics_command);
-          if (fs20.existsSync(metricsPath)) {
+          const metricsPath = path22.join(root, toolsmithOutput.metrics_command);
+          if (fs21.existsSync(metricsPath)) {
             try {
-              fs20.chmodSync(metricsPath, 493);
+              fs21.chmodSync(metricsPath, 493);
             } catch {
             }
           }
@@ -5968,8 +6361,8 @@ You may ONLY write to .majlis/scripts/. Output your structured JSON when done.`;
   }
   if (cartographerOk) {
     const sessionCount = getSessionsSinceCompression(db);
-    const newSynthesisPath = path21.join(root, "docs", "synthesis", "current.md");
-    const newSynthesisSize = fs20.existsSync(newSynthesisPath) ? fs20.statSync(newSynthesisPath).size : 0;
+    const newSynthesisPath = path22.join(root, "docs", "synthesis", "current.md");
+    const newSynthesisSize = fs21.existsSync(newSynthesisPath) ? fs21.statSync(newSynthesisPath).size : 0;
     recordCompression(db, sessionCount, report.synthesisSize, newSynthesisSize);
     info("Recorded compression in DB.");
   }
@@ -5979,12 +6372,12 @@ You may ONLY write to .majlis/scripts/. Output your structured JSON when done.`;
   if (toolsmithOk) info("  \u2192 .majlis/scripts/metrics.sh + .majlis/config.json");
   info("Run `majlis status` to see project state.");
 }
-var fs20, path21;
+var fs21, path22;
 var init_resync = __esm({
   "src/commands/resync.ts"() {
     "use strict";
-    fs20 = __toESM(require("fs"));
-    path21 = __toESM(require("path"));
+    fs21 = __toESM(require("fs"));
+    path22 = __toESM(require("path"));
     init_connection();
     init_connection();
     init_queries();
@@ -5999,10 +6392,10 @@ var init_resync = __esm({
 });
 
 // src/cli.ts
-var fs21 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 var VERSION2 = JSON.parse(
-  fs21.readFileSync(path22.join(__dirname, "..", "package.json"), "utf-8")
+  fs22.readFileSync(path23.join(__dirname, "..", "package.json"), "utf-8")
 ).version;
 async function main() {
   let sigintCount = 0;
@@ -6169,6 +6562,9 @@ Lifecycle:
 
 Experiments:
   new "hypothesis"           Create experiment, branch, log, DB entry
+    --sub-type TYPE          Classify by problem sub-type
+    --depends-on SLUG        Block building until dependency is merged
+    --context FILE,FILE      Inject domain-specific docs into agent context
   baseline                   Capture metrics snapshot (before)
   measure                    Capture metrics snapshot (after)
   compare [--json]           Compare before/after, detect regressions