majlis 0.7.0 → 0.7.1

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;
     `);
       }
     ];
@@ -1261,7 +1268,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,
@@ -2197,12 +2204,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) {
@@ -2711,6 +2719,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 +2757,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 +2889,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 +2914,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 +2988,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 +2999,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 +3018,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 +3069,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 +3106,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 +3116,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 +3177,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 +3201,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 +3350,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 +3411,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 +3436,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 +3475,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 +3584,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 +3676,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 +3699,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 +3727,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 +3818,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: {
@@ -3754,17 +3862,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 +3908,7 @@ 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 result = await spawnAgent("builder", {
     experiment: {
       id: exp.id,
@@ -3809,6 +3926,7 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
     fragility,
     synthesis,
     confirmedDoubts,
+    supplementaryContext: supplementaryContext || void 0,
     taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
@@ -3821,7 +3939,7 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
   } else {
     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,
@@ -3845,7 +3963,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 +3971,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 +4004,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 +4045,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 +4093,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 +4149,7 @@ 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 result = await spawnAgent("verifier", {
     experiment: {
       id: exp.id,
@@ -4024,6 +4161,8 @@ async function doVerify(db, exp, root) {
     },
     doubts,
     challenges,
+    metricComparisons: metricComparisons.length > 0 ? metricComparisons : void 0,
+    supplementaryContext: verifierSupplementaryContext || void 0,
     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);
@@ -4048,22 +4187,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 +4210,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 +4313,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 +4346,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 +4368,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 +4408,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 +4435,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 +4487,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 +4783,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 +4891,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 +4903,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 +4937,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 +4956,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 +5001,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 +5009,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 +5017,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 +5041,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 +5169,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 +5328,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 +5356,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 {
   }
@@ -5269,7 +5433,7 @@ async function swarm(args) {
       const best = summary.bestExperiment;
       info(`Best experiment: ${best.worktree.slug} (${best.overallGrade})`);
       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"] }
@@ -5320,15 +5484,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 +5502,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,12 +5582,12 @@ 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();
@@ -5450,21 +5614,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 +5674,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 +5693,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 +5710,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 +5755,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 +5768,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 +5811,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 +5843,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 +5904,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 +5960,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 +6092,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 +6132,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 +6143,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 +6163,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 +6333,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