majlis 0.7.3 → 0.8.1

package/dist/cli.js

@@ -369,6 +369,12 @@ var init_migrations = __esm({
         db.exec(`
       ALTER TABLE experiments ADD COLUMN depends_on TEXT;
       ALTER TABLE experiments ADD COLUMN context_files TEXT;
+    `);
+      },
+      // Migration 007: v6 → v7 — Gate rejection reason (pause instead of auto-kill)
+      (db) => {
+        db.exec(`
+      ALTER TABLE experiments ADD COLUMN gate_rejection_reason TEXT;
     `);
       }
     ];
@@ -512,7 +518,9 @@ You are the Builder. You write code, run experiments, and make technical decisio
 Before building:
 1. Read docs/synthesis/current.md for project state \u2014 this IS ground truth. Trust it.
 2. Read the dead-ends provided in your context \u2014 these are structural constraints.
-3. Read the experiment doc for this experiment \u2014 it has your hypothesis.
+3. Read your experiment doc \u2014 its path is in your taskPrompt. It already exists
+   (the framework created it from a template). Read it, then fill in the Approach
+   section before you start coding. Do NOT search for it with glob or ls.
 
 The synthesis already contains the diagnosis. Do NOT re-diagnose. Do NOT run
 exploratory scripts to "understand the problem." The classify/doubt/challenge
@@ -527,6 +535,17 @@ Do NOT read raw data files (fixtures/, ground truth JSON/STL). The synthesis
 has the relevant facts. Reading raw data wastes turns re-deriving what the
 doubt/challenge/verify cycle already established.
 
+## Anti-patterns (DO NOT \u2014 these waste turns and produce zero value)
+- Do NOT query SQLite or explore \`.majlis/\`. The framework manages its own state.
+- Do NOT use \`ls\`, \`find\`, or broad globs (\`**/*\`) to discover project structure.
+  The synthesis has the architecture. Read the specific files named in your hypothesis.
+- Do NOT pipe commands through \`head\`, \`tail\`, or \`| grep\`. The tools handle
+  output truncation automatically. Run the command directly.
+- Do NOT create or run exploratory/diagnostic scripts (Python, shell, etc.).
+  Diagnosis is the diagnostician's job, not yours.
+- Do NOT spend your reading turns on framework internals, CI config, or build
+  system files unless your hypothesis specifically targets them.
+
 ## The Rule: ONE Change, Then Document
 
 You make ONE code change per cycle. Not two, not "one more quick fix." ONE.
@@ -584,8 +603,8 @@ If you are running low on turns, STOP coding and immediately:
 The framework CANNOT recover your work if you get truncated without structured output.
 An incomplete experiment doc with honest "did not finish" notes is infinitely better
 than a truncated run with no output. Budget your turns: ~8 turns for reading,
-~10 turns for coding + benchmark, ~5 turns for documentation. If you've used 35+
-turns, wrap up NOW regardless of where you are.
+~20 turns for coding + build verification, ~10 turns for benchmark + documentation.
+If you've used 40+ turns, wrap up NOW regardless of where you are.
 
 You may NOT verify your own work or mark your own decisions as proven.
 Output your decisions in structured format so they can be recorded in the database.
@@ -816,15 +835,20 @@ the database export.
 2. Read docs/ files for narrative context, but trust the database when they conflict.
 3. Cross-reference: same question in different language? contradicting decisions?
    workaround masking root cause?
-4. Update fragility map: thin coverage, weak components, untested judgment
+4. **VERIFY before claiming code is live.** Dead-ended experiments are REVERTED \u2014
+   their code changes do NOT exist on the current branch. Before writing that code
+   is "live", "shipping", or "regressing", use Grep/Glob to confirm it actually
+   exists in the current codebase. If the code only existed on experiment branches,
+   say so explicitly and mark the issue as RESOLVED, not CRITICAL.
+5. Update fragility map: thin coverage, weak components, untested judgment
    decisions, broken provenance.
-5. Update dead-end registry: compress rejected experiments into structural constraints.
+6. Update dead-end registry: compress rejected experiments into structural constraints.
    Mark each dead-end as [structural] or [procedural].
-6. REWRITE synthesis using the Write tool \u2014 shorter and denser. If it's growing,
+7. REWRITE synthesis using the Write tool \u2014 shorter and denser. If it's growing,
    you're accumulating, not compressing. You MUST use the Write tool to update
    docs/synthesis/current.md, docs/synthesis/fragility.md, and docs/synthesis/dead-ends.md.
    The framework does NOT auto-save your output for these files.
-7. Review classification: new sub-types? resolved sub-types?
+8. Review classification: new sub-types? resolved sub-types?
 
 You may ONLY write to these three files:
 - docs/synthesis/current.md
@@ -1096,7 +1120,80 @@ Produce a diagnostic report as markdown. At the end, include:
 ## Safety Reminders
 - You are READ-ONLY for project code. Write ONLY to .majlis/scripts/.
 - Focus on diagnosis, not fixing. Your value is insight, not implementation.
-- Trust the database export over docs/ files when they conflict.`
+- Trust the database export over docs/ files when they conflict.`,
+      postmortem: `---
+name: postmortem
+model: opus
+tools: [Read, Glob, Grep]
+---
+You are the Post-Mortem Analyst. You analyze reverted or failed experiments and extract
+structural learnings that prevent future experiments from repeating the same mistakes.
+
+You run automatically when an experiment is reverted. Your job is to produce a specific,
+falsifiable structural constraint that blocks future experiments from repeating the approach.
+
+## What You Receive
+
+- The experiment's hypothesis and metadata
+- Git diff of the experiment branch vs main (what was changed or attempted)
+- The user's reason for reverting (if provided) \u2014 use as a starting point, not the final answer
+- Related dead-ends from the registry
+- Synthesis and fragility docs
+- Optionally: artifact files (sweep results, build logs, etc.) pointed to by --context
+
+## Your Process
+
+1. **Read the context** \u2014 understand what was attempted and why it's being reverted.
+2. **Examine artifacts** \u2014 if --context files are provided, read them. If sweep results,
+   build logs, or metric outputs exist in the working directory, find and read them.
+3. **Analyze the failure** \u2014 determine whether this is structural (approach provably wrong)
+   or procedural (approach might work but was executed poorly or abandoned for other reasons).
+4. **Produce the constraint** \u2014 write a specific, falsifiable structural constraint.
+
+## Constraint Quality
+
+Good constraints are specific and block future repetition:
+- "L6 config space is null \u2014 13-eval Bayesian sweep found all 12 params insensitive (ls=1.27), score ceiling 0.67"
+- "Relaxing curvature split threshold in recursive_curvature_split causes false splits on pure-surface thin strips (seg_pct 95->72.5)"
+- "Torus topology prevents genus-0 assumption for manifold extraction"
+
+Bad constraints are vague and useless:
+- "Didn't work"
+- "Manually reverted"
+- "Needs more investigation"
+
+## Scope
+
+The constraint should clearly state what class of approaches it applies to and what it
+does NOT apply to. For example:
+- "SCOPE: Applies to split threshold changes in Pass 2. Does NOT apply to post-Pass-1 merge operations."
+
+## Output Format
+
+Write a brief analysis (2-5 paragraphs), then output:
+
+<!-- majlis-json
+{
+  "postmortem": {
+    "why_failed": "What was tried and why it failed \u2014 specific, evidence-based",
+    "structural_constraint": "What this proves about the solution space \u2014 blocks future repeats. Include scope.",
+    "category": "structural or procedural"
+  }
+}
+-->
+
+Categories:
+- **structural** \u2014 the approach is provably wrong or the solution space is null. Future experiments
+  that repeat this approach should be rejected by the gatekeeper.
+- **procedural** \u2014 the approach was abandoned for process reasons (e.g., time, priority change,
+  execution error). The approach might still be valid if executed differently.
+
+## Safety Reminders
+- You are READ-ONLY. Do not modify any files.
+- Focus on extracting the constraint, not on suggesting fixes.
+- Trust the evidence in the context over speculation.
+- If you cannot determine the structural constraint from the available context, say so explicitly
+  and categorize as procedural.`
     };
     var SLASH_COMMANDS2 = {
       classify: {
@@ -1771,6 +1868,8 @@ function getExtractionSchema(role) {
       return '{"architecture": {"modules": ["string"], "entry_points": ["string"], "key_abstractions": ["string"], "dependency_graph": "string"}}';
     case "toolsmith":
       return '{"toolsmith": {"metrics_command": "string|null", "build_command": "string|null", "test_command": "string|null", "test_framework": "string|null", "pre_measure": "string|null", "post_measure": "string|null", "fixtures": {}, "tracked": {}, "verification_output": "string", "issues": ["string"]}}';
+    case "postmortem":
+      return '{"postmortem": {"why_failed": "string", "structural_constraint": "string", "category": "structural|procedural"}}';
     default:
       return EXTRACTION_SCHEMA;
   }
@@ -1797,7 +1896,8 @@ var init_types = __esm({
       compressor: ["compression_report"],
       diagnostician: ["diagnosis"],
       cartographer: ["architecture"],
-      toolsmith: ["toolsmith"]
+      toolsmith: ["toolsmith"],
+      postmortem: ["postmortem"]
     };
   }
 });
@@ -1896,6 +1996,18 @@ function extractViaPatterns(role, markdown) {
     });
   }
   if (doubts.length > 0) result.doubts = doubts;
+  if (role === "postmortem") {
+    const pmPattern = /(?:WHY\s*FAILED|Why\s*Failed|Failure)\s*[:=]\s*(.+?)(?:\n|$)[\s\S]*?(?:STRUCTURAL\s*CONSTRAINT|Structural\s*Constraint|Constraint)\s*[:=]\s*(.+?)(?:\n|$)/im;
+    const pmMatch = markdown.match(pmPattern);
+    if (pmMatch) {
+      const categoryMatch = markdown.match(/(?:CATEGORY|Category)\s*[:=]\s*(structural|procedural)/im);
+      result.postmortem = {
+        why_failed: pmMatch[1].trim(),
+        structural_constraint: pmMatch[2].trim(),
+        category: categoryMatch?.[1]?.toLowerCase() ?? "procedural"
+      };
+    }
+  }
   if (role === "builder") {
     const abandonPattern = /\[ABANDON\]\s*(.+?)(?:\n|$)[\s\S]*?(?:structural.?constraint|Constraint|CONSTRAINT)\s*[:=]\s*(.+?)(?:\n|$)/im;
     const abandonMatch = markdown.match(abandonPattern);
@@ -1952,7 +2064,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 || output.abandon);
+  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 || output.postmortem);
 }
 function validateForRole(role, output) {
   const required = ROLE_REQUIRED_FIELDS[role];
@@ -1998,12 +2110,27 @@ function buildCheckpointMessage(role, toolUseCount, maxTurns) {
   const approxTurn = Math.round(toolUseCount / 2);
   const header2 = `[MAJLIS CHECKPOINT \u2014 ~${approxTurn} of ${maxTurns} turns used]`;
   switch (role) {
-    case "builder":
-      return `${header2}
-Reminder: ONE code change per cycle.
-- Have you run the benchmark? YES \u2192 document results + output JSON + STOP.
-- If NO \u2192 run it now, then wrap up.
+    case "builder": {
+      if (toolUseCount <= 15) {
+        return `${header2}
+You should be done reading by now.
+- Your experiment doc path is in the taskPrompt. Do NOT search for it.
+- Do NOT query SQLite, explore .majlis/, or glob broadly.
+- If you haven't started coding, START NOW.`;
+      } else if (toolUseCount <= 40) {
+        return `${header2}
+ONE code change per cycle.
+- Have you run the build/benchmark? YES \u2192 document results + output JSON + STOP.
+- If NO \u2192 finish your change and run it now.
 Do NOT start a second change or investigate unrelated failures.`;
+      } else {
+        return `${header2}
+URGENT: You are running out of turns.
+1. Update the experiment doc with whatever results you have.
+2. Output the <!-- majlis-json --> block NOW.
+The framework CANNOT recover your work without structured output.`;
+      }
+    }
     case "verifier":
       return `${header2}
 AT MOST 3 diagnostic scripts total.
@@ -2046,6 +2173,11 @@ If you are past turn 30, begin writing current.md and fragility.md NOW.`;
 You write ONLY to .majlis/scripts/. Verify toolchain, create metrics wrapper.
 Phase 1 (1-10): verify toolchain. Phase 2 (11-25): create metrics.sh. Phase 3 (26-30): output config JSON.
 If you are past turn 25, output your structured JSON NOW.`;
+    case "postmortem":
+      return `${header2}
+You are READ-ONLY. Focus on the structural constraint.
+What does this experiment prove about the solution space?
+If you have enough context, output your postmortem JSON NOW.`;
     default:
       return `${header2}
 Check: is your core task done? If yes, wrap up and output JSON.`;
@@ -2154,6 +2286,18 @@ function buildPreToolUseGuards(role, cwd) {
       { matcher: "Bash", hooks: [bashGuard] }
     ];
   }
+  if (role === "postmortem") {
+    const blockWrite = async () => {
+      return {
+        decision: "block",
+        reason: "Post-mortem agent is read-only. No file modifications allowed."
+      };
+    };
+    return [
+      { matcher: "Write", hooks: [blockWrite] },
+      { matcher: "Edit", hooks: [blockWrite] }
+    ];
+  }
   if (role === "builder") {
     const bashGuard = async (input) => {
       const toolInput = input.tool_input ?? {};
@@ -2476,10 +2620,11 @@ var init_spawn = __esm({
       gatekeeper: 10,
       diagnostician: 60,
       cartographer: 40,
-      toolsmith: 30
+      toolsmith: 30,
+      postmortem: 20
     };
     CHECKPOINT_INTERVAL = {
-      builder: 15,
+      builder: 12,
       verifier: 12,
       critic: 15,
       adversary: 15,
@@ -2487,7 +2632,8 @@ var init_spawn = __esm({
       gatekeeper: 2,
       diagnostician: 20,
       cartographer: 12,
-      toolsmith: 10
+      toolsmith: 10,
+      postmortem: 8
     };
   }
 });
@@ -3323,6 +3469,56 @@ function autoCommit(root, message) {
   } catch {
   }
 }
+function handleDeadEndGit(exp, root) {
+  try {
+    const currentBranch = (0, import_node_child_process2.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: root,
+      encoding: "utf-8"
+    }).trim();
+    if (currentBranch !== exp.branch) return;
+  } catch {
+    return;
+  }
+  try {
+    (0, import_node_child_process2.execSync)('git add -A -- ":!.majlis/"', {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const diff = (0, import_node_child_process2.execSync)("git diff --cached --stat", {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (diff) {
+      const msg = `EXP-${String(exp.id).padStart(3, "0")}: ${exp.slug} [dead-end]`;
+      (0, import_node_child_process2.execFileSync)("git", ["commit", "-m", msg], {
+        cwd: root,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      info(`Committed builder changes on ${exp.branch} before dead-end.`);
+    }
+  } catch {
+  }
+  try {
+    (0, import_node_child_process2.execFileSync)("git", ["checkout", "main"], {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    try {
+      (0, import_node_child_process2.execFileSync)("git", ["checkout", "master"], {
+        cwd: root,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      warn(`Could not switch away from ${exp.branch} \u2014 do this manually.`);
+    }
+  }
+}
 var import_node_child_process2;
 var init_git = __esm({
   "src/git.ts"() {
@@ -3532,6 +3728,16 @@ function getBuilderGuidance(db, experimentId) {
   const row = db.prepare("SELECT builder_guidance FROM experiments WHERE id = ?").get(experimentId);
   return row?.builder_guidance ?? null;
 }
+function storeGateRejection(db, experimentId, reason) {
+  db.prepare(`
+    UPDATE experiments SET gate_rejection_reason = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
+  `).run(reason, experimentId);
+}
+function clearGateRejection(db, experimentId) {
+  db.prepare(`
+    UPDATE experiments SET gate_rejection_reason = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?
+  `).run(experimentId);
+}
 function insertDecision(db, experimentId, description, evidenceLevel, justification) {
   const stmt = db.prepare(`
     INSERT INTO decisions (experiment_id, description, evidence_level, justification)
@@ -4215,7 +4421,7 @@ function determineNextStep(exp, valid, hasDoubts2, hasChallenges2) {
     }
   }
   if (status2 === "building" /* BUILDING */) {
-    return valid.includes("built" /* BUILT */) ? "built" /* BUILT */ : valid[0];
+    return "building" /* BUILDING */;
   }
   if (status2 === "scouted" /* SCOUTED */) {
     return valid.includes("verifying" /* VERIFYING */) ? "verifying" /* VERIFYING */ : valid[0];
@@ -4223,6 +4429,9 @@ function determineNextStep(exp, valid, hasDoubts2, hasChallenges2) {
   if (status2 === "verified" /* VERIFIED */) {
     return valid.includes("resolved" /* RESOLVED */) ? "resolved" /* RESOLVED */ : valid[0];
   }
+  if (status2 === "resolved" /* RESOLVED */) {
+    return valid.includes("compressed" /* COMPRESSED */) ? "compressed" /* COMPRESSED */ : valid[0];
+  }
   if (status2 === "compressed" /* COMPRESSED */) {
     return valid.includes("merged" /* MERGED */) ? "merged" /* MERGED */ : valid[0];
   }
@@ -4307,869 +4516,701 @@ var init_metrics = __esm({
   }
 });
 
-// src/commands/measure.ts
-var measure_exports = {};
-__export(measure_exports, {
-  baseline: () => baseline,
-  compare: () => compare,
-  measure: () => measure
-});
-async function baseline(args) {
-  await captureMetrics("before", args);
-}
-async function measure(args) {
-  await captureMetrics("after", args);
-}
-async function captureMetrics(phase, args) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const db = getDb(root);
-  const config = loadConfig(root);
-  const expIdStr = getFlagValue(args, "--experiment");
-  let exp;
-  if (expIdStr !== void 0) {
-    exp = getExperimentById(db, Number(expIdStr));
-  } else {
-    exp = getLatestExperiment(db);
-  }
-  if (!exp) throw new Error('No active experiment. Run `majlis new "hypothesis"` first.');
-  if (config.build.pre_measure) {
-    info(`Running pre-measure: ${config.build.pre_measure}`);
-    try {
-      (0, import_node_child_process4.execSync)(config.build.pre_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
-    } catch {
-      warn("Pre-measure command failed \u2014 continuing anyway.");
-    }
+// src/resolve.ts
+function worstGrade(grades) {
+  if (grades.length === 0) {
+    throw new Error("Cannot determine grade from empty verification set \u2014 this indicates a data integrity issue");
   }
-  if (!config.metrics.command) {
-    throw new Error("No metrics.command configured in .majlis/config.json");
+  for (const grade of GRADE_ORDER) {
+    if (grades.some((g) => g.grade === grade)) return grade;
   }
-  info(`Running metrics: ${config.metrics.command}`);
-  let metricsOutput;
-  try {
-    metricsOutput = (0, import_node_child_process4.execSync)(config.metrics.command, {
-      cwd: root,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch (err) {
-    throw new Error(`Metrics command failed: ${err instanceof Error ? err.message : String(err)}`);
+  return "sound";
+}
+async function resolve2(db, exp, projectRoot) {
+  let grades = getVerificationsByExperiment(db, exp.id);
+  if (grades.length === 0) {
+    warn(`No verification records for ${exp.slug}. Defaulting to weak.`);
+    insertVerification(
+      db,
+      exp.id,
+      "auto-default",
+      "weak",
+      null,
+      null,
+      "No structured verification output. Auto-defaulted to weak."
+    );
+    grades = getVerificationsByExperiment(db, exp.id);
   }
-  const parsed = parseMetricsOutput(metricsOutput);
-  if (parsed.length === 0) {
-    warn("Metrics command returned no data.");
+  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;
   }
-  for (const m of parsed) {
-    insertMetric(db, exp.id, phase, m.fixture, m.metric_name, m.metric_value);
-  }
-  success(`Captured ${parsed.length} metric(s) for ${exp.slug} (phase: ${phase})`);
-  if (config.build.post_measure) {
-    try {
-      (0, import_node_child_process4.execSync)(config.build.post_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
-    } catch {
-      warn("Post-measure command failed.");
+  updateExperimentStatus(db, exp.id, "resolved");
+  switch (overallGrade) {
+    case "sound": {
+      gitMerge(exp.branch, projectRoot);
+      transition("resolved" /* RESOLVED */, "merged" /* MERGED */);
+      updateExperimentStatus(db, exp.id, "merged");
+      success(`Experiment ${exp.slug} MERGED (all sound).`);
+      break;
+    }
+    case "good": {
+      gitMerge(exp.branch, projectRoot);
+      const gaps = grades.filter((g) => g.grade === "good").map((g) => `- **${g.component}**: ${g.notes ?? "minor gaps"}`).join("\n");
+      appendToFragilityMap(projectRoot, exp.slug, gaps);
+      autoCommit(projectRoot, `resolve: fragility gaps from ${exp.slug}`);
+      transition("resolved" /* RESOLVED */, "merged" /* MERGED */);
+      updateExperimentStatus(db, exp.id, "merged");
+      success(`Experiment ${exp.slug} MERGED (good, ${grades.filter((g) => g.grade === "good").length} gaps added to fragility map).`);
+      break;
+    }
+    case "weak": {
+      const confirmedDoubts = getConfirmedDoubts(db, exp.id);
+      const guidance = await spawnSynthesiser({
+        experiment: {
+          id: exp.id,
+          slug: exp.slug,
+          hypothesis: exp.hypothesis,
+          status: exp.status,
+          sub_type: exp.sub_type,
+          builder_guidance: exp.builder_guidance
+        },
+        verificationReport: grades,
+        confirmedDoubts,
+        taskPrompt: "Synthesise the verification report, confirmed doubts, and adversarial case results into specific, actionable guidance for the builder's next attempt. Be concrete: which specific decisions need revisiting, which assumptions broke, and what constraints must the next approach satisfy."
+      }, projectRoot);
+      const guidanceText = guidance.structured?.guidance ?? guidance.output;
+      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 (weak). Guidance generated for builder.`);
+      break;
+    }
+    case "rejected": {
+      gitRevert(exp.branch, projectRoot);
+      const rejectedComponents = grades.filter((g) => g.grade === "rejected");
+      const whyFailed = rejectedComponents.map((r) => r.notes ?? "rejected").join("; ");
+      transition("resolved" /* RESOLVED */, "dead_end" /* DEAD_END */);
+      db.transaction(() => {
+        insertDeadEnd(
+          db,
+          exp.id,
+          exp.hypothesis ?? exp.slug,
+          whyFailed,
+          `Approach rejected: ${whyFailed}`,
+          exp.sub_type,
+          "structural"
+        );
+        updateExperimentStatus(db, exp.id, "dead_end");
+        if (exp.sub_type) {
+          incrementSubTypeFailure(db, exp.sub_type, exp.id, "rejected");
+        }
+      })();
+      info(`Experiment ${exp.slug} DEAD-ENDED (rejected). Constraint recorded.`);
+      break;
     }
   }
 }
-async function compare(args, isJson) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const db = getDb(root);
-  const config = loadConfig(root);
-  const expIdStr = getFlagValue(args, "--experiment");
-  let exp;
-  if (expIdStr !== void 0) {
-    exp = getExperimentById(db, Number(expIdStr));
-  } else {
-    exp = getLatestExperiment(db);
-  }
-  if (!exp) throw new Error("No active experiment.");
-  const comparisons = compareMetrics(db, exp.id, config);
-  if (comparisons.length === 0) {
-    warn(`No before/after metrics to compare for ${exp.slug}. Run baseline and measure first.`);
-    return;
+async function resolveDbOnly(db, exp, projectRoot) {
+  let grades = getVerificationsByExperiment(db, exp.id);
+  if (grades.length === 0) {
+    warn(`No verification records for ${exp.slug}. Defaulting to weak.`);
+    insertVerification(
+      db,
+      exp.id,
+      "auto-default",
+      "weak",
+      null,
+      null,
+      "No structured verification output. Auto-defaulted to weak."
+    );
+    grades = getVerificationsByExperiment(db, exp.id);
   }
-  if (isJson) {
-    console.log(JSON.stringify({ experiment: exp.slug, comparisons }, null, 2));
-    return;
+  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";
   }
-  header(`Metric Comparison \u2014 ${exp.slug}`);
-  const regressions = comparisons.filter((c) => c.regression);
-  const rows = comparisons.map((c) => [
-    c.fixture,
-    c.metric,
-    String(c.before),
-    String(c.after),
-    formatDelta(c.delta),
-    c.regression ? red("REGRESSION") : green("OK")
-  ]);
-  console.log(table(["Fixture", "Metric", "Before", "After", "Delta", "Status"], rows));
-  if (regressions.length > 0) {
-    console.log();
-    warn(`${regressions.length} regression(s) detected!`);
-  } else {
-    console.log();
-    success("No regressions detected.");
+  updateExperimentStatus(db, exp.id, "resolved");
+  switch (overallGrade) {
+    case "sound":
+      transition("resolved" /* RESOLVED */, "merged" /* MERGED */);
+      updateExperimentStatus(db, exp.id, "merged");
+      success(`Experiment ${exp.slug} RESOLVED (sound) \u2014 git merge deferred.`);
+      break;
+    case "good": {
+      const gaps = grades.filter((g) => g.grade === "good").map((g) => `- **${g.component}**: ${g.notes ?? "minor gaps"}`).join("\n");
+      appendToFragilityMap(projectRoot, exp.slug, gaps);
+      transition("resolved" /* RESOLVED */, "merged" /* MERGED */);
+      updateExperimentStatus(db, exp.id, "merged");
+      success(`Experiment ${exp.slug} RESOLVED (good) \u2014 git merge deferred.`);
+      break;
+    }
+    case "weak": {
+      const confirmedDoubts = getConfirmedDoubts(db, exp.id);
+      const guidance = await spawnSynthesiser({
+        experiment: {
+          id: exp.id,
+          slug: exp.slug,
+          hypothesis: exp.hypothesis,
+          status: exp.status,
+          sub_type: exp.sub_type,
+          builder_guidance: exp.builder_guidance
+        },
+        verificationReport: grades,
+        confirmedDoubts,
+        taskPrompt: "Synthesise the verification report, confirmed doubts, and adversarial case results into specific, actionable guidance for the builder's next attempt. Be concrete: which specific decisions need revisiting, which assumptions broke, and what constraints must the next approach satisfy."
+      }, projectRoot);
+      const guidanceText = guidance.structured?.guidance ?? guidance.output;
+      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 (weak). Guidance generated.`);
+      break;
+    }
+    case "rejected": {
+      const rejectedComponents = grades.filter((g) => g.grade === "rejected");
+      const whyFailed = rejectedComponents.map((r) => r.notes ?? "rejected").join("; ");
+      transition("resolved" /* RESOLVED */, "dead_end" /* DEAD_END */);
+      db.transaction(() => {
+        insertDeadEnd(
+          db,
+          exp.id,
+          exp.hypothesis ?? exp.slug,
+          whyFailed,
+          `Approach rejected: ${whyFailed}`,
+          exp.sub_type,
+          "structural"
+        );
+        updateExperimentStatus(db, exp.id, "dead_end");
+        if (exp.sub_type) {
+          incrementSubTypeFailure(db, exp.sub_type, exp.id, "rejected");
+        }
+      })();
+      info(`Experiment ${exp.slug} DEAD-ENDED (rejected). Constraint recorded.`);
+      break;
+    }
   }
+  return overallGrade;
 }
-function formatDelta(delta) {
-  const prefix = delta > 0 ? "+" : "";
-  return `${prefix}${delta.toFixed(4)}`;
-}
-var import_node_child_process4;
-var init_measure = __esm({
-  "src/commands/measure.ts"() {
-    "use strict";
-    import_node_child_process4 = require("child_process");
-    init_connection();
-    init_queries();
-    init_metrics();
-    init_config();
-    init_format();
-  }
-});
-
-// src/commands/experiment.ts
-var experiment_exports = {};
-__export(experiment_exports, {
-  newExperiment: () => newExperiment,
-  revert: () => revert
-});
-async function newExperiment(args) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const hypothesis = args.filter((a) => !a.startsWith("--")).join(" ");
-  if (!hypothesis) {
-    throw new Error('Usage: majlis new "hypothesis"');
-  }
-  const db = getDb(root);
-  const config = loadConfig(root);
-  const slug = getFlagValue(args, "--slug") ?? await generateSlug(hypothesis, root);
-  if (getExperimentBySlug(db, slug)) {
-    throw new Error(`Experiment with slug "${slug}" already exists.`);
-  }
-  const allExps = db.prepare("SELECT COUNT(*) as count FROM experiments").get();
-  const num = allExps.count + 1;
-  const paddedNum = String(num).padStart(3, "0");
-  const branch = `exp/${paddedNum}-${slug}`;
+function gitMerge(branch, cwd) {
   try {
-    (0, import_node_child_process5.execFileSync)("git", ["checkout", "-b", branch], {
-      cwd: root,
+    try {
+      (0, import_node_child_process4.execFileSync)("git", ["checkout", "main"], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      (0, import_node_child_process4.execFileSync)("git", ["checkout", "master"], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    (0, import_node_child_process4.execFileSync)("git", ["merge", branch, "--no-ff", "-m", `Merge experiment branch ${branch}`], {
+      cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
-    info(`Created branch: ${branch}`);
   } catch (err) {
-    warn(`Could not create branch ${branch} \u2014 continuing without git branch.`);
-  }
-  const subType = getFlagValue(args, "--sub-type") ?? 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 = 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 = path10.join(docsDir, `${paddedNum}-${slug}.md`);
-    fs10.writeFileSync(logPath, logContent);
-    info(`Created experiment log: docs/experiments/${paddedNum}-${slug}.md`);
-  }
-  autoCommit(root, `new: ${slug}`);
-  if (config.cycle.auto_baseline_on_new_experiment && config.metrics.command) {
-    info("Auto-baselining... (run `majlis baseline` to do this manually)");
-    try {
-      const { baseline: baseline2 } = await Promise.resolve().then(() => (init_measure(), measure_exports));
-      await baseline2(["--experiment", String(exp.id)]);
-    } catch (err) {
-      warn("Auto-baseline failed \u2014 run `majlis baseline` manually.");
-    }
+    warn(`Git merge of ${branch} failed \u2014 you may need to merge manually.`);
   }
 }
-async function revert(args) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const db = getDb(root);
-  let exp;
-  const slugArg = args.filter((a) => !a.startsWith("--"))[0];
-  if (slugArg) {
-    exp = getExperimentBySlug(db, slugArg);
-    if (!exp) throw new Error(`Experiment not found: ${slugArg}`);
-  } else {
-    exp = getLatestExperiment(db);
-    if (!exp) throw new Error("No active experiments to revert.");
-  }
-  const reason = getFlagValue(args, "--reason") ?? "Manually reverted";
-  const category = args.includes("--structural") ? "structural" : "procedural";
-  insertDeadEnd(
-    db,
-    exp.id,
-    exp.hypothesis ?? exp.slug,
-    reason,
-    `Reverted: ${reason}`,
-    exp.sub_type,
-    category
-  );
-  adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "revert");
+function gitRevert(branch, cwd) {
   try {
-    const currentBranch = (0, import_node_child_process5.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd: root,
+    const currentBranch = (0, import_node_child_process4.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd,
       encoding: "utf-8"
     }).trim();
-    if (currentBranch === exp.branch) {
+    if (currentBranch === branch) {
       try {
-        (0, import_node_child_process5.execFileSync)("git", ["checkout", "main"], {
-          cwd: root,
+        (0, import_node_child_process4.execFileSync)("git", ["checkout", "--", "."], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+      } catch {
+      }
+      try {
+        (0, import_node_child_process4.execFileSync)("git", ["checkout", "main"], {
+          cwd,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         });
       } catch {
-        (0, import_node_child_process5.execFileSync)("git", ["checkout", "master"], {
-          cwd: root,
+        (0, import_node_child_process4.execFileSync)("git", ["checkout", "master"], {
+          cwd,
           encoding: "utf-8",
           stdio: ["pipe", "pipe", "pipe"]
         });
       }
     }
   } catch {
-    warn("Could not switch git branches \u2014 do this manually.");
+    warn(`Could not switch away from ${branch} \u2014 you may need to do this manually.`);
   }
-  info(`Experiment ${exp.slug} reverted to dead-end. Reason: ${reason}`);
 }
-var fs10, path10, import_node_child_process5;
-var init_experiment = __esm({
-  "src/commands/experiment.ts"() {
-    "use strict";
-    fs10 = __toESM(require("fs"));
+function appendToFragilityMap(projectRoot, expSlug, gaps) {
+  const fragPath = path10.join(projectRoot, "docs", "synthesis", "fragility.md");
+  let content = "";
+  if (fs10.existsSync(fragPath)) {
+    content = fs10.readFileSync(fragPath, "utf-8");
+  }
+  const entry = `
+## From experiment: ${expSlug}
+${gaps}
+`;
+  fs10.writeFileSync(fragPath, content + entry);
+}
+var fs10, path10, import_node_child_process4;
+var init_resolve = __esm({
+  "src/resolve.ts"() {
+    "use strict";
+    fs10 = __toESM(require("fs"));
     path10 = __toESM(require("path"));
-    import_node_child_process5 = require("child_process");
-    init_connection();
-    init_queries();
-    init_machine();
     init_types2();
+    init_machine();
+    init_queries();
+    init_metrics();
     init_config();
     init_spawn();
+    import_node_child_process4 = require("child_process");
     init_git();
     init_format();
   }
 });
 
-// src/commands/session.ts
-var session_exports = {};
-__export(session_exports, {
-  session: () => session
+// src/commands/cycle.ts
+var cycle_exports = {};
+__export(cycle_exports, {
+  cycle: () => cycle,
+  expDocRelPath: () => expDocRelPath,
+  resolveCmd: () => resolveCmd,
+  runResolve: () => runResolve,
+  runStep: () => runStep
 });
-async function session(args) {
-  const subcommand = args[0];
-  if (!subcommand || subcommand !== "start" && subcommand !== "end") {
-    throw new Error('Usage: majlis session start "intent" | majlis session end');
-  }
+async function cycle(step, args) {
   const root = findProjectRoot();
   if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
   const db = getDb(root);
-  if (subcommand === "start") {
-    const intent = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
-    if (!intent) {
-      throw new Error('Usage: majlis session start "intent"');
-    }
-    const existing = getActiveSession(db);
-    if (existing) {
-      warn(`Session already active: "${existing.intent}" (started ${existing.started_at})`);
-      warn("End it first with `majlis session end`.");
-      return;
-    }
-    const latestExp = getLatestExperiment(db);
-    const sess = startSession(db, intent, latestExp?.id ?? null);
-    success(`Session started: "${intent}" (id: ${sess.id})`);
-    if (latestExp) {
-      info(`Linked to experiment: ${latestExp.slug} (${latestExp.status})`);
-    }
-  } else {
-    const active = getActiveSession(db);
-    if (!active) {
-      throw new Error("No active session to end.");
-    }
-    const accomplished = getFlagValue(args, "--accomplished") ?? null;
-    const unfinished = getFlagValue(args, "--unfinished") ?? null;
-    const fragility = getFlagValue(args, "--fragility") ?? null;
-    endSession(db, active.id, accomplished, unfinished, fragility);
-    success(`Session ended: "${active.intent}"`);
-    if (accomplished) info(`Accomplished: ${accomplished}`);
-    if (unfinished) info(`Unfinished: ${unfinished}`);
-    if (fragility) warn(`New fragility: ${fragility}`);
+  if (step === "compress") return doCompress(db, root);
+  const exp = resolveExperimentArg(db, args);
+  switch (step) {
+    case "build":
+      return doBuild(db, exp, root);
+    case "challenge":
+      return doChallenge(db, exp, root);
+    case "doubt":
+      return doDoubt(db, exp, root);
+    case "scout":
+      return doScout(db, exp, root);
+    case "verify":
+      return doVerify(db, exp, root);
+    case "gate":
+      return doGate(db, exp, root);
   }
 }
-var init_session = __esm({
-  "src/commands/session.ts"() {
-    "use strict";
-    init_connection();
-    init_queries();
-    init_config();
-    init_format();
-  }
-});
-
-// src/commands/query.ts
-var query_exports = {};
-__export(query_exports, {
-  query: () => query3
-});
-async function query3(command, args, isJson) {
+async function resolveCmd(args) {
   const root = findProjectRoot();
   if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
   const db = getDb(root);
-  switch (command) {
-    case "decisions":
-      return queryDecisions(db, args, isJson);
-    case "dead-ends":
-      return queryDeadEnds(db, args, isJson);
-    case "fragility":
-      return queryFragility(root, isJson);
-    case "history":
-      return queryHistory(db, args, isJson);
-    case "circuit-breakers":
-      return queryCircuitBreakers(db, root, isJson);
-    case "check-commit":
-      return checkCommit(db);
-  }
+  const exp = resolveExperimentArg(db, args);
+  transition(exp.status, "resolved" /* RESOLVED */);
+  await resolve2(db, exp, root);
 }
-function queryDecisions(db, args, isJson) {
-  const level = getFlagValue(args, "--level");
-  const expIdStr = getFlagValue(args, "--experiment");
-  const experimentId = expIdStr !== void 0 ? Number(expIdStr) : void 0;
-  const decisions = listAllDecisions(db, level, experimentId);
-  if (isJson) {
-    console.log(JSON.stringify(decisions, null, 2));
-    return;
-  }
-  if (decisions.length === 0) {
-    info("No decisions found.");
-    return;
+async function runStep(step, db, exp, root) {
+  switch (step) {
+    case "build":
+      return doBuild(db, exp, root);
+    case "challenge":
+      return doChallenge(db, exp, root);
+    case "doubt":
+      return doDoubt(db, exp, root);
+    case "scout":
+      return doScout(db, exp, root);
+    case "verify":
+      return doVerify(db, exp, root);
+    case "gate":
+      return doGate(db, exp, root);
+    case "compress":
+      return doCompress(db, root);
   }
-  header("Decisions");
-  const rows = decisions.map((d) => [
-    String(d.id),
-    String(d.experiment_id),
-    evidenceColor(d.evidence_level),
-    d.description.slice(0, 60) + (d.description.length > 60 ? "..." : ""),
-    d.status
-  ]);
-  console.log(table(["ID", "Exp", "Level", "Description", "Status"], rows));
 }
-function queryDeadEnds(db, args, isJson) {
-  const subType = getFlagValue(args, "--sub-type");
-  const searchTerm = getFlagValue(args, "--search");
-  let deadEnds;
-  if (subType) {
-    deadEnds = listDeadEndsBySubType(db, subType);
-  } else if (searchTerm) {
-    deadEnds = searchDeadEnds(db, searchTerm);
-  } else {
-    deadEnds = listAllDeadEnds(db);
-  }
-  if (isJson) {
-    console.log(JSON.stringify(deadEnds, null, 2));
-    return;
-  }
-  if (deadEnds.length === 0) {
-    info("No dead-ends recorded.");
-    return;
-  }
-  header("Dead-End Registry");
-  const rows = deadEnds.map((d) => [
-    String(d.id),
-    d.sub_type ?? "\u2014",
-    d.approach.slice(0, 40) + (d.approach.length > 40 ? "..." : ""),
-    d.structural_constraint.slice(0, 40) + (d.structural_constraint.length > 40 ? "..." : "")
-  ]);
-  console.log(table(["ID", "Sub-Type", "Approach", "Constraint"], rows));
+async function runResolve(db, exp, root) {
+  transition(exp.status, "resolved" /* RESOLVED */);
+  await resolve2(db, exp, root);
 }
-function queryFragility(root, isJson) {
-  const fragPath = path11.join(root, "docs", "synthesis", "fragility.md");
-  if (!fs11.existsSync(fragPath)) {
-    info("No fragility map found.");
-    return;
-  }
-  const content = fs11.readFileSync(fragPath, "utf-8");
-  if (isJson) {
-    console.log(JSON.stringify({ content }, null, 2));
+async function doGate(db, exp, root) {
+  transition(exp.status, "gated" /* GATED */);
+  const synthesis = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const structuralDeadEnds = exp.sub_type ? listStructuralDeadEndsBySubType(db, exp.sub_type) : listStructuralDeadEnds(db);
+  const result = await spawnAgent("gatekeeper", {
+    experiment: {
+      id: exp.id,
+      slug: exp.slug,
+      hypothesis: exp.hypothesis,
+      status: exp.status,
+      sub_type: exp.sub_type,
+      builder_guidance: null
+    },
+    deadEnds: structuralDeadEnds.map((d) => ({
+      approach: d.approach,
+      why_failed: d.why_failed,
+      structural_constraint: d.structural_constraint
+    })),
+    fragility,
+    synthesis,
+    taskPrompt: `Gate-check hypothesis for experiment ${exp.slug}:
+"${exp.hypothesis}"
+
+This is a FAST gate \u2014 decide in 1-2 turns. Do NOT read source code or large files. Use the synthesis, dead-ends, and fragility provided in your context. At most, do one targeted grep to verify a function name exists.
+
+Check: (a) stale references \u2014 does the hypothesis reference specific lines, functions, or structures that may not exist? (b) dead-end overlap \u2014 does this hypothesis repeat an approach already ruled out by structural dead-ends? (c) scope \u2014 is this a single focused change, or does it try to do multiple things?
+
+Output your gate_decision as "approve", "reject", or "flag" with reasoning.`
+  }, root);
+  ingestStructuredOutput(db, exp.id, result.structured);
+  const decision = result.structured?.gate_decision ?? "approve";
+  const reason = result.structured?.reason ?? "";
+  if (decision === "reject") {
+    updateExperimentStatus(db, exp.id, "gated");
+    storeGateRejection(db, exp.id, reason);
+    warn(`Gate REJECTED for ${exp.slug}: ${reason}`);
+    info("Run `majlis next --override-gate` to proceed anyway, or `majlis revert` to abandon.");
     return;
+  } else {
+    if (decision === "flag") {
+      warn(`Gate flagged concerns for ${exp.slug}: ${reason}`);
+    }
+    updateExperimentStatus(db, exp.id, "gated");
+    success(`Gate passed for ${exp.slug}. Run \`majlis build\` next.`);
   }
-  header("Fragility Map");
-  console.log(content);
 }
-function queryHistory(db, args, isJson) {
-  const fixture = args.filter((a) => !a.startsWith("--"))[0];
-  if (!fixture) {
-    throw new Error("Usage: majlis history <fixture>");
-  }
-  const history = getMetricHistoryByFixture(db, fixture);
-  if (isJson) {
-    console.log(JSON.stringify(history, null, 2));
-    return;
-  }
-  if (history.length === 0) {
-    info(`No metric history for fixture: ${fixture}`);
-    return;
+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.`
+      );
+    }
   }
-  header(`Metric History \u2014 ${fixture}`);
-  const rows = history.map((h) => [
-    String(h.experiment_id),
-    h.experiment_slug ?? "\u2014",
-    h.phase,
-    h.metric_name,
-    String(h.metric_value),
-    h.captured_at
-  ]);
-  console.log(table(["Exp", "Slug", "Phase", "Metric", "Value", "Captured"], rows));
-}
-function queryCircuitBreakers(db, root, isJson) {
+  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(path11.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const confirmedDoubts = getConfirmedDoubts(db, exp.id);
   const config = loadConfig(root);
-  const states = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
-  if (isJson) {
-    console.log(JSON.stringify(states, null, 2));
-    return;
-  }
-  if (states.length === 0) {
-    info("No circuit breaker data.");
-    return;
-  }
-  header("Circuit Breakers");
-  const rows = states.map((s) => [
-    s.sub_type,
-    String(s.failure_count),
-    String(config.cycle.circuit_breaker_threshold),
-    s.tripped ? red("TRIPPED") : green("OK")
-  ]);
-  console.log(table(["Sub-Type", "Failures", "Threshold", "Status"], rows));
-}
-function checkCommit(db) {
-  let stdinData = "";
-  try {
-    stdinData = fs11.readFileSync(0, "utf-8");
-  } catch {
-  }
-  if (stdinData) {
+  const existingBaseline = getMetricsByExperimentAndPhase(db, exp.id, "before");
+  if (config.metrics?.command && existingBaseline.length === 0) {
     try {
-      const hookInput = JSON.parse(stdinData);
-      const command = hookInput?.tool_input?.command ?? "";
-      if (!command.includes("git commit")) {
-        return;
+      const output = (0, import_node_child_process5.execSync)(config.metrics.command, {
+        cwd: root,
+        encoding: "utf-8",
+        timeout: 6e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      const parsed = parseMetricsOutput(output);
+      for (const m of parsed) {
+        insertMetric(db, exp.id, "before", m.fixture, m.metric_name, m.metric_value);
       }
+      if (parsed.length > 0) info(`Captured ${parsed.length} baseline metric(s).`);
     } catch {
+      warn("Could not capture baseline metrics.");
     }
   }
-  const active = listActiveExperiments(db);
-  const unverified = active.filter(
-    (e) => !["merged", "dead_end", "verified", "resolved", "compressed"].includes(e.status)
-  );
-  if (unverified.length > 0) {
-    console.error(`[majlis] ${unverified.length} unverified experiment(s):`);
-    for (const e of unverified) {
-      console.error(`  - ${e.slug} (${e.status})`);
+  updateExperimentStatus(db, exp.id, "building");
+  let taskPrompt = builderGuidance ? `Previous attempt was weak. Here is guidance for this attempt:
+${builderGuidance}
+
+Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothesis}`;
+  if (confirmedDoubts.length > 0) {
+    taskPrompt += "\n\n## Confirmed Doubts (MUST address)\nThese weaknesses were confirmed by the verifier. Your build MUST address each one:\n";
+    for (const d of confirmedDoubts) {
+      taskPrompt += `- [${d.severity}] ${d.claim_doubted}: ${d.evidence_for_doubt}
+`;
     }
-    process.exit(1);
-  }
-}
-var fs11, path11;
-var init_query = __esm({
-  "src/commands/query.ts"() {
-    "use strict";
-    fs11 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
-    init_connection();
-    init_queries();
-    init_config();
-    init_format();
   }
-});
+  taskPrompt += `
 
-// src/resolve.ts
-function worstGrade(grades) {
-  if (grades.length === 0) {
-    throw new Error("Cannot determine grade from empty verification set \u2014 this indicates a data integrity issue");
-  }
-  for (const grade of GRADE_ORDER) {
-    if (grades.some((g) => g.grade === grade)) return grade;
+Your experiment doc: ${expDocRelPath(exp)}`;
+  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;
   }
-  return "sound";
-}
-async function resolve2(db, exp, projectRoot) {
-  let grades = getVerificationsByExperiment(db, exp.id);
-  if (grades.length === 0) {
-    warn(`No verification records for ${exp.slug}. Defaulting to weak.`);
-    insertVerification(
+  const result = await spawnAgent("builder", {
+    experiment: {
+      id: exp.id,
+      slug: exp.slug,
+      hypothesis: exp.hypothesis,
+      status: "building",
+      sub_type: exp.sub_type,
+      builder_guidance: builderGuidance
+    },
+    deadEnds: deadEnds.map((d) => ({
+      approach: d.approach,
+      why_failed: d.why_failed,
+      structural_constraint: d.structural_constraint
+    })),
+    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,
-      "auto-default",
-      "weak",
-      null,
-      null,
-      "No structured verification output. Auto-defaulted to weak."
+      exp.hypothesis ?? exp.slug,
+      result.structured.abandon.reason,
+      result.structured.abandon.structural_constraint,
+      exp.sub_type,
+      "structural"
     );
-    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.`);
+    adminTransitionAndPersist(db, exp.id, "building", "dead_end" /* DEAD_END */, "revert");
+    handleDeadEndGit(exp, root);
+    info(`Builder abandoned ${exp.slug}: ${result.structured.abandon.reason}`);
     return;
   }
-  updateExperimentStatus(db, exp.id, "resolved");
-  switch (overallGrade) {
-    case "sound": {
-      gitMerge(exp.branch, projectRoot);
-      transition("resolved" /* RESOLVED */, "merged" /* MERGED */);
-      updateExperimentStatus(db, exp.id, "merged");
-      success(`Experiment ${exp.slug} MERGED (all sound).`);
-      break;
-    }
-    case "good": {
-      gitMerge(exp.branch, projectRoot);
-      const gaps = grades.filter((g) => g.grade === "good").map((g) => `- **${g.component}**: ${g.notes ?? "minor gaps"}`).join("\n");
-      appendToFragilityMap(projectRoot, exp.slug, gaps);
-      autoCommit(projectRoot, `resolve: fragility gaps from ${exp.slug}`);
-      transition("resolved" /* RESOLVED */, "merged" /* MERGED */);
-      updateExperimentStatus(db, exp.id, "merged");
-      success(`Experiment ${exp.slug} MERGED (good, ${grades.filter((g) => g.grade === "good").length} gaps added to fragility map).`);
-      break;
-    }
-    case "weak": {
-      const confirmedDoubts = getConfirmedDoubts(db, exp.id);
-      const guidance = await spawnSynthesiser({
-        experiment: {
-          id: exp.id,
-          slug: exp.slug,
-          hypothesis: exp.hypothesis,
-          status: exp.status,
-          sub_type: exp.sub_type,
-          builder_guidance: exp.builder_guidance
-        },
-        verificationReport: grades,
-        confirmedDoubts,
-        taskPrompt: "Synthesise the verification report, confirmed doubts, and adversarial case results into specific, actionable guidance for the builder's next attempt. Be concrete: which specific decisions need revisiting, which assumptions broke, and what constraints must the next approach satisfy."
-      }, projectRoot);
-      const guidanceText = guidance.structured?.guidance ?? guidance.output;
-      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");
+  if (result.truncated && !result.structured) {
+    warn(`Builder was truncated (hit max turns) without producing structured output.`);
+    const recovery = await extractStructuredData("builder", result.output);
+    if (recovery.data && !recovery.data.abandon) {
+      info(`Recovered structured output from truncated builder (tier ${recovery.tier}).`);
+      ingestStructuredOutput(db, exp.id, recovery.data);
+      if (config.build?.pre_measure) {
+        try {
+          const [cmd, ...cmdArgs] = config.build.pre_measure.split(/\s+/);
+          (0, import_node_child_process5.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);
+          storeBuilderGuidance(
+            db,
+            exp.id,
+            `Build verification failed after truncated recovery.
+Error: ${errMsg.slice(0, 500)}`
+          );
+          warn(`Build verification failed for ${exp.slug}. Staying at 'building'.`);
+          return;
         }
-      })();
-      warn(`Experiment ${exp.slug} CYCLING BACK (weak). Guidance generated for builder.`);
-      break;
-    }
-    case "rejected": {
-      gitRevert(exp.branch, projectRoot);
-      const rejectedComponents = grades.filter((g) => g.grade === "rejected");
-      const whyFailed = rejectedComponents.map((r) => r.notes ?? "rejected").join("; ");
-      transition("resolved" /* RESOLVED */, "dead_end" /* DEAD_END */);
-      db.transaction(() => {
-        insertDeadEnd(
+      }
+      if (config.metrics?.command) {
+        try {
+          const output = (0, import_node_child_process5.execSync)(config.metrics.command, {
+            cwd: root,
+            encoding: "utf-8",
+            timeout: 6e4,
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+          const parsed = parseMetricsOutput(output);
+          for (const m of parsed) {
+            insertMetric(db, exp.id, "after", m.fixture, m.metric_name, m.metric_value);
+          }
+          if (parsed.length > 0) info(`Captured ${parsed.length} post-build metric(s).`);
+        } catch {
+        }
+      }
+      gitCommitBuild(exp, root);
+      if (recovery.tier === 3) {
+        warn(`Builder output extracted via Haiku (tier 3). Data provenance degraded.`);
+        const existing = getBuilderGuidance(db, exp.id) ?? "";
+        storeBuilderGuidance(
           db,
           exp.id,
-          exp.hypothesis ?? exp.slug,
-          whyFailed,
-          `Approach rejected: ${whyFailed}`,
-          exp.sub_type,
-          "structural"
+          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, "dead_end");
-        if (exp.sub_type) {
-          incrementSubTypeFailure(db, exp.sub_type, exp.id, "rejected");
-        }
-      })();
-      info(`Experiment ${exp.slug} DEAD-ENDED (rejected). Constraint recorded.`);
-      break;
-    }
-  }
-}
-async function resolveDbOnly(db, exp, projectRoot) {
-  let grades = getVerificationsByExperiment(db, exp.id);
-  if (grades.length === 0) {
-    warn(`No verification records for ${exp.slug}. Defaulting to weak.`);
-    insertVerification(
-      db,
-      exp.id,
-      "auto-default",
-      "weak",
-      null,
-      null,
-      "No structured verification output. Auto-defaulted to weak."
-    );
-    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":
-      transition("resolved" /* RESOLVED */, "merged" /* MERGED */);
-      updateExperimentStatus(db, exp.id, "merged");
-      success(`Experiment ${exp.slug} RESOLVED (sound) \u2014 git merge deferred.`);
-      break;
-    case "good": {
-      const gaps = grades.filter((g) => g.grade === "good").map((g) => `- **${g.component}**: ${g.notes ?? "minor gaps"}`).join("\n");
-      appendToFragilityMap(projectRoot, exp.slug, gaps);
-      transition("resolved" /* RESOLVED */, "merged" /* MERGED */);
-      updateExperimentStatus(db, exp.id, "merged");
-      success(`Experiment ${exp.slug} RESOLVED (good) \u2014 git merge deferred.`);
-      break;
-    }
-    case "weak": {
-      const confirmedDoubts = getConfirmedDoubts(db, exp.id);
-      const guidance = await spawnSynthesiser({
-        experiment: {
-          id: exp.id,
-          slug: exp.slug,
-          hypothesis: exp.hypothesis,
-          status: exp.status,
-          sub_type: exp.sub_type,
-          builder_guidance: exp.builder_guidance
-        },
-        verificationReport: grades,
-        confirmedDoubts,
-        taskPrompt: "Synthesise the verification report, confirmed doubts, and adversarial case results into specific, actionable guidance for the builder's next attempt. Be concrete: which specific decisions need revisiting, which assumptions broke, and what constraints must the next approach satisfy."
-      }, projectRoot);
-      const guidanceText = guidance.structured?.guidance ?? guidance.output;
-      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 (weak). Guidance generated.`);
-      break;
-    }
-    case "rejected": {
-      const rejectedComponents = grades.filter((g) => g.grade === "rejected");
-      const whyFailed = rejectedComponents.map((r) => r.notes ?? "rejected").join("; ");
-      transition("resolved" /* RESOLVED */, "dead_end" /* DEAD_END */);
-      db.transaction(() => {
-        insertDeadEnd(
+      updateExperimentStatus(db, exp.id, "built");
+      success(`Build complete for ${exp.slug} (recovered from truncation). Run \`majlis doubt\` or \`majlis challenge\` next.`);
+    } else if (recovery.data?.abandon) {
+      insertDeadEnd(
+        db,
+        exp.id,
+        exp.hypothesis ?? exp.slug,
+        recovery.data.abandon.reason,
+        recovery.data.abandon.structural_constraint,
+        exp.sub_type,
+        "structural"
+      );
+      adminTransitionAndPersist(db, exp.id, "building", "dead_end" /* DEAD_END */, "revert");
+      handleDeadEndGit(exp, root);
+      info(`Builder abandoned ${exp.slug} (recovered from truncation): ${recovery.data.abandon.reason}`);
+    } else {
+      const tail = result.output.slice(-2e3).trim();
+      if (tail) {
+        storeBuilderGuidance(
           db,
           exp.id,
-          exp.hypothesis ?? exp.slug,
-          whyFailed,
-          `Approach rejected: ${whyFailed}`,
-          exp.sub_type,
-          "structural"
+          `Builder was truncated. Last ~2000 chars of output:
+${tail}`
         );
-        updateExperimentStatus(db, exp.id, "dead_end");
-        if (exp.sub_type) {
-          incrementSubTypeFailure(db, exp.sub_type, exp.id, "rejected");
-        }
-      })();
-      info(`Experiment ${exp.slug} DEAD-ENDED (rejected). Constraint recorded.`);
-      break;
-    }
-  }
-  return overallGrade;
-}
-function gitMerge(branch, cwd) {
-  try {
-    try {
-      (0, import_node_child_process6.execFileSync)("git", ["checkout", "main"], {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    } catch {
-      (0, import_node_child_process6.execFileSync)("git", ["checkout", "master"], {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    }
-    (0, import_node_child_process6.execFileSync)("git", ["merge", branch, "--no-ff", "-m", `Merge experiment branch ${branch}`], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-  } catch (err) {
-    warn(`Git merge of ${branch} failed \u2014 you may need to merge manually.`);
-  }
-}
-function gitRevert(branch, cwd) {
-  try {
-    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_process6.execFileSync)("git", ["checkout", "--", "."], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-      } catch {
       }
+      warn(`Experiment stays at 'building'. Run \`majlis build\` to retry or \`majlis revert\` to abandon.`);
+    }
+  } else {
+    if (config.build?.pre_measure) {
       try {
-        (0, import_node_child_process6.execFileSync)("git", ["checkout", "main"], {
-          cwd,
+        const [cmd, ...cmdArgs] = config.build.pre_measure.split(/\s+/);
+        (0, import_node_child_process5.execFileSync)(cmd, cmdArgs, {
+          cwd: root,
           encoding: "utf-8",
+          timeout: 3e4,
           stdio: ["pipe", "pipe", "pipe"]
         });
-      } catch {
-        (0, import_node_child_process6.execFileSync)("git", ["checkout", "master"], {
-          cwd,
+      } 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_process5.execSync)(config.metrics.command, {
+          cwd: root,
           encoding: "utf-8",
+          timeout: 6e4,
           stdio: ["pipe", "pipe", "pipe"]
-        });
+        }).trim();
+        const parsed = parseMetricsOutput(output);
+        for (const m of parsed) {
+          insertMetric(db, exp.id, "after", m.fixture, m.metric_name, m.metric_value);
+        }
+        if (parsed.length > 0) info(`Captured ${parsed.length} post-build metric(s).`);
+      } catch {
+        warn("Could not capture post-build metrics.");
       }
     }
-  } catch {
-    warn(`Could not switch away from ${branch} \u2014 you may need to do this manually.`);
-  }
-}
-function appendToFragilityMap(projectRoot, expSlug, gaps) {
-  const fragPath = path12.join(projectRoot, "docs", "synthesis", "fragility.md");
-  let content = "";
-  if (fs12.existsSync(fragPath)) {
-    content = fs12.readFileSync(fragPath, "utf-8");
+    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.`);
   }
-  const entry = `
-## From experiment: ${expSlug}
-${gaps}
-`;
-  fs12.writeFileSync(fragPath, content + entry);
 }
-var fs12, path12, import_node_child_process6;
-var init_resolve = __esm({
-  "src/resolve.ts"() {
-    "use strict";
-    fs12 = __toESM(require("fs"));
-    path12 = __toESM(require("path"));
-    init_types2();
-    init_machine();
-    init_queries();
-    init_metrics();
-    init_config();
-    init_spawn();
-    import_node_child_process6 = require("child_process");
-    init_git();
-    init_format();
+async function doChallenge(db, exp, root) {
+  transition(exp.status, "challenged" /* CHALLENGED */);
+  let gitDiff = "";
+  try {
+    gitDiff = (0, import_node_child_process5.execSync)('git diff main -- . ":!.majlis/"', {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
   }
-});
+  if (gitDiff.length > 8e3) gitDiff = gitDiff.slice(0, 8e3) + "\n[DIFF TRUNCATED]";
+  const synthesis = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  let taskPrompt = `Construct adversarial test cases for experiment ${exp.slug}: ${exp.hypothesis}`;
+  if (gitDiff) {
+    taskPrompt += `
 
-// src/commands/cycle.ts
-var cycle_exports = {};
-__export(cycle_exports, {
-  cycle: () => cycle,
-  resolveCmd: () => resolveCmd,
-  runResolve: () => runResolve,
-  runStep: () => runStep
-});
-async function cycle(step, args) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const db = getDb(root);
-  const exp = resolveExperimentArg(db, args);
-  switch (step) {
-    case "build":
-      return doBuild(db, exp, root);
-    case "challenge":
-      return doChallenge(db, exp, root);
-    case "doubt":
-      return doDoubt(db, exp, root);
-    case "scout":
-      return doScout(db, exp, root);
-    case "verify":
-      return doVerify(db, exp, root);
-    case "gate":
-      return doGate(db, exp, root);
-    case "compress":
-      return doCompress(db, root);
+## Code Changes (git diff main)
+\`\`\`diff
+${gitDiff}
+\`\`\``;
   }
-}
-async function resolveCmd(args) {
-  const root = findProjectRoot();
-  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const db = getDb(root);
-  const exp = resolveExperimentArg(db, args);
-  transition(exp.status, "resolved" /* RESOLVED */);
-  await resolve2(db, exp, root);
-}
-async function runStep(step, db, exp, root) {
-  switch (step) {
-    case "build":
-      return doBuild(db, exp, root);
-    case "challenge":
-      return doChallenge(db, exp, root);
-    case "doubt":
-      return doDoubt(db, exp, root);
-    case "scout":
-      return doScout(db, exp, root);
-    case "verify":
-      return doVerify(db, exp, root);
-    case "gate":
-      return doGate(db, exp, root);
-    case "compress":
-      return doCompress(db, root);
+  const result = await spawnAgent("adversary", {
+    experiment: {
+      id: exp.id,
+      slug: exp.slug,
+      hypothesis: exp.hypothesis,
+      status: exp.status,
+      sub_type: exp.sub_type,
+      builder_guidance: null
+    },
+    synthesis,
+    taskPrompt
+  }, root);
+  ingestStructuredOutput(db, exp.id, result.structured);
+  if (result.truncated && !result.structured) {
+    warn(`Adversary was truncated without structured output. Experiment stays at current status.`);
+  } else {
+    updateExperimentStatus(db, exp.id, "challenged");
+    success(`Challenge complete for ${exp.slug}. Run \`majlis doubt\` or \`majlis verify\` next.`);
   }
 }
-async function runResolve(db, exp, root) {
-  transition(exp.status, "resolved" /* RESOLVED */);
-  await resolve2(db, exp, root);
-}
-async function doGate(db, exp, root) {
-  transition(exp.status, "gated" /* GATED */);
-  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", {
+async function doDoubt(db, exp, root) {
+  transition(exp.status, "doubted" /* DOUBTED */);
+  const expDocPath = path11.join(root, expDocRelPath(exp));
+  const experimentDoc = truncateContext(readFileOrEmpty(expDocPath), CONTEXT_LIMITS.experimentDoc);
+  const synthesis = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
+  let taskPrompt = `Doubt the work in experiment ${exp.slug}: ${exp.hypothesis}. Produce a doubt document with evidence for each doubt.`;
+  if (experimentDoc) {
+    taskPrompt += `
+
+## Experiment Document (builder's artifact)
+<experiment_doc>
+${experimentDoc}
+</experiment_doc>`;
+  }
+  const result = await spawnAgent("critic", {
     experiment: {
       id: exp.id,
       slug: exp.slug,
@@ -5177,391 +5218,66 @@ async function doGate(db, exp, root) {
       status: exp.status,
       sub_type: exp.sub_type,
       builder_guidance: null
+      // Critic does NOT see builder reasoning
     },
-    deadEnds: structuralDeadEnds.map((d) => ({
+    synthesis,
+    deadEnds: deadEnds.map((d) => ({
       approach: d.approach,
       why_failed: d.why_failed,
       structural_constraint: d.structural_constraint
     })),
-    fragility,
-    synthesis,
-    taskPrompt: `Gate-check hypothesis for experiment ${exp.slug}:
-"${exp.hypothesis}"
-
-This is a FAST gate \u2014 decide in 1-2 turns. Do NOT read source code or large files. Use the synthesis, dead-ends, and fragility provided in your context. At most, do one targeted grep to verify a function name exists.
-
-Check: (a) stale references \u2014 does the hypothesis reference specific lines, functions, or structures that may not exist? (b) dead-end overlap \u2014 does this hypothesis repeat an approach already ruled out by structural dead-ends? (c) scope \u2014 is this a single focused change, or does it try to do multiple things?
-
-Output your gate_decision as "approve", "reject", or "flag" with reasoning.`
+    taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
-  const decision = result.structured?.gate_decision ?? "approve";
-  const reason = result.structured?.reason ?? "";
-  if (decision === "reject") {
-    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;
+  if (result.truncated && !result.structured) {
+    warn(`Critic was truncated without structured output. Experiment stays at current status.`);
   } else {
-    if (decision === "flag") {
-      warn(`Gate flagged concerns for ${exp.slug}: ${reason}`);
-    }
-    updateExperimentStatus(db, exp.id, "gated");
-    success(`Gate passed for ${exp.slug}. Run \`majlis build\` next.`);
+    updateExperimentStatus(db, exp.id, "doubted");
+    success(`Doubt pass complete for ${exp.slug}. Run \`majlis challenge\` or \`majlis verify\` next.`);
   }
 }
-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 */);
+async function doScout(db, exp, root) {
+  transition(exp.status, "scouted" /* SCOUTED */);
+  const synthesis = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
-  const builderGuidance = getBuilderGuidance(db, exp.id);
-  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_process7.execSync)(config.metrics.command, {
-        cwd: root,
-        encoding: "utf-8",
-        timeout: 6e4,
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trim();
-      const parsed = parseMetricsOutput(output);
-      for (const m of parsed) {
-        insertMetric(db, exp.id, "before", m.fixture, m.metric_name, m.metric_value);
-      }
-      if (parsed.length > 0) info(`Captured ${parsed.length} baseline metric(s).`);
-    } catch {
-      warn("Could not capture baseline metrics.");
-    }
-  }
-  updateExperimentStatus(db, exp.id, "building");
-  let taskPrompt = builderGuidance ? `Previous attempt was weak. Here is guidance for this attempt:
-${builderGuidance}
+  const deadEndsSummary = deadEnds.map(
+    (d) => `- [${d.category ?? "structural"}] ${d.approach}: ${d.why_failed}`
+  ).join("\n");
+  let taskPrompt = `Search for alternative approaches to the problem in experiment ${exp.slug}: ${exp.hypothesis}. Look for contradictory approaches, solutions from other fields, and known limitations of the current approach.`;
+  if (deadEndsSummary) {
+    taskPrompt += `
 
-Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothesis}`;
-  if (confirmedDoubts.length > 0) {
-    taskPrompt += "\n\n## Confirmed Doubts (MUST address)\nThese weaknesses were confirmed by the verifier. Your build MUST address each one:\n";
-    for (const d of confirmedDoubts) {
-      taskPrompt += `- [${d.severity}] ${d.claim_doubted}: ${d.evidence_for_doubt}
-`;
-    }
+## Known Dead Ends (avoid these approaches)
+${deadEndsSummary}`;
   }
-  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;
+  if (fragility) {
+    taskPrompt += `
+
+## Fragility Map (target these weak areas)
+${fragility}`;
   }
-  const result = await spawnAgent("builder", {
+  const result = await spawnAgent("scout", {
     experiment: {
       id: exp.id,
       slug: exp.slug,
       hypothesis: exp.hypothesis,
-      status: "building",
+      status: exp.status,
       sub_type: exp.sub_type,
-      builder_guidance: builderGuidance
+      builder_guidance: null
     },
+    synthesis,
+    fragility,
     deadEnds: deadEnds.map((d) => ({
       approach: d.approach,
       why_failed: d.why_failed,
       structural_constraint: d.structural_constraint
     })),
-    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.`);
-    const recovery = await extractStructuredData("builder", result.output);
-    if (recovery.data && !recovery.data.abandon) {
-      info(`Recovered structured output from truncated builder (tier ${recovery.tier}).`);
-      ingestStructuredOutput(db, exp.id, recovery.data);
-      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);
-          storeBuilderGuidance(
-            db,
-            exp.id,
-            `Build verification failed after truncated recovery.
-Error: ${errMsg.slice(0, 500)}`
-          );
-          warn(`Build verification failed for ${exp.slug}. Staying at 'building'.`);
-          return;
-        }
-      }
-      if (config.metrics?.command) {
-        try {
-          const output = (0, import_node_child_process7.execSync)(config.metrics.command, {
-            cwd: root,
-            encoding: "utf-8",
-            timeout: 6e4,
-            stdio: ["pipe", "pipe", "pipe"]
-          }).trim();
-          const parsed = parseMetricsOutput(output);
-          for (const m of parsed) {
-            insertMetric(db, exp.id, "after", m.fixture, m.metric_name, m.metric_value);
-          }
-          if (parsed.length > 0) info(`Captured ${parsed.length} post-build metric(s).`);
-        } catch {
-        }
-      }
-      gitCommitBuild(exp, root);
-      if (recovery.tier === 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} (recovered from truncation). Run \`majlis doubt\` or \`majlis challenge\` next.`);
-    } else if (recovery.data?.abandon) {
-      insertDeadEnd(
-        db,
-        exp.id,
-        exp.hypothesis ?? exp.slug,
-        recovery.data.abandon.reason,
-        recovery.data.abandon.structural_constraint,
-        exp.sub_type,
-        "structural"
-      );
-      adminTransitionAndPersist(db, exp.id, "building", "dead_end" /* DEAD_END */, "revert");
-      info(`Builder abandoned ${exp.slug} (recovered from truncation): ${recovery.data.abandon.reason}`);
-    } else {
-      const tail = result.output.slice(-2e3).trim();
-      if (tail) {
-        storeBuilderGuidance(
-          db,
-          exp.id,
-          `Builder was truncated. Last ~2000 chars of output:
-${tail}`
-        );
-      }
-      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_process7.execSync)(config.metrics.command, {
-          cwd: root,
-          encoding: "utf-8",
-          timeout: 6e4,
-          stdio: ["pipe", "pipe", "pipe"]
-        }).trim();
-        const parsed = parseMetricsOutput(output);
-        for (const m of parsed) {
-          insertMetric(db, exp.id, "after", m.fixture, m.metric_name, m.metric_value);
-        }
-        if (parsed.length > 0) info(`Captured ${parsed.length} post-build metric(s).`);
-      } catch {
-        warn("Could not capture post-build metrics.");
-      }
-    }
-    gitCommitBuild(exp, root);
-    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.`);
-  }
-}
-async function doChallenge(db, exp, root) {
-  transition(exp.status, "challenged" /* CHALLENGED */);
-  let gitDiff = "";
-  try {
-    gitDiff = (0, import_node_child_process7.execSync)('git diff main -- . ":!.majlis/"', {
-      cwd: root,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-  }
-  if (gitDiff.length > 8e3) gitDiff = gitDiff.slice(0, 8e3) + "\n[DIFF TRUNCATED]";
-  const synthesis = truncateContext(readFileOrEmpty(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 += `
-
-## Code Changes (git diff main)
-\`\`\`diff
-${gitDiff}
-\`\`\``;
-  }
-  const result = await spawnAgent("adversary", {
-    experiment: {
-      id: exp.id,
-      slug: exp.slug,
-      hypothesis: exp.hypothesis,
-      status: exp.status,
-      sub_type: exp.sub_type,
-      builder_guidance: null
-    },
-    synthesis,
-    taskPrompt
-  }, root);
-  ingestStructuredOutput(db, exp.id, result.structured);
-  if (result.truncated && !result.structured) {
-    warn(`Adversary was truncated without structured output. Experiment stays at current status.`);
-  } else {
-    updateExperimentStatus(db, exp.id, "challenged");
-    success(`Challenge complete for ${exp.slug}. Run \`majlis doubt\` or \`majlis verify\` next.`);
-  }
-}
-async function doDoubt(db, exp, root) {
-  transition(exp.status, "doubted" /* DOUBTED */);
-  const paddedNum = String(exp.id).padStart(3, "0");
-  const expDocPath = path13.join(root, "docs", "experiments", `${paddedNum}-${exp.slug}.md`);
-  const experimentDoc = truncateContext(readFileOrEmpty(expDocPath), CONTEXT_LIMITS.experimentDoc);
-  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) {
-    taskPrompt += `
-
-## Experiment Document (builder's artifact)
-<experiment_doc>
-${experimentDoc}
-</experiment_doc>`;
-  }
-  const result = await spawnAgent("critic", {
-    experiment: {
-      id: exp.id,
-      slug: exp.slug,
-      hypothesis: exp.hypothesis,
-      status: exp.status,
-      sub_type: exp.sub_type,
-      builder_guidance: null
-      // Critic does NOT see builder reasoning
-    },
-    synthesis,
-    deadEnds: deadEnds.map((d) => ({
-      approach: d.approach,
-      why_failed: d.why_failed,
-      structural_constraint: d.structural_constraint
-    })),
-    taskPrompt
-  }, root);
-  ingestStructuredOutput(db, exp.id, result.structured);
-  if (result.truncated && !result.structured) {
-    warn(`Critic was truncated without structured output. Experiment stays at current status.`);
-  } else {
-    updateExperimentStatus(db, exp.id, "doubted");
-    success(`Doubt pass complete for ${exp.slug}. Run \`majlis challenge\` or \`majlis verify\` next.`);
-  }
-}
-async function doScout(db, exp, root) {
-  transition(exp.status, "scouted" /* SCOUTED */);
-  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}`
-  ).join("\n");
-  let taskPrompt = `Search for alternative approaches to the problem in experiment ${exp.slug}: ${exp.hypothesis}. Look for contradictory approaches, solutions from other fields, and known limitations of the current approach.`;
-  if (deadEndsSummary) {
-    taskPrompt += `
-
-## Known Dead Ends (avoid these approaches)
-${deadEndsSummary}`;
-  }
-  if (fragility) {
-    taskPrompt += `
-
-## Fragility Map (target these weak areas)
-${fragility}`;
-  }
-  const result = await spawnAgent("scout", {
-    experiment: {
-      id: exp.id,
-      slug: exp.slug,
-      hypothesis: exp.hypothesis,
-      status: exp.status,
-      sub_type: exp.sub_type,
-      builder_guidance: null
-    },
-    synthesis,
-    fragility,
-    deadEnds: deadEnds.map((d) => ({
-      approach: d.approach,
-      why_failed: d.why_failed,
-      structural_constraint: d.structural_constraint
-    })),
-    taskPrompt
-  }, root);
-  ingestStructuredOutput(db, exp.id, result.structured);
-  if (result.truncated && !result.structured) {
-    warn(`Scout was truncated without structured output. Experiment stays at current status.`);
+  if (result.truncated && !result.structured) {
+    warn(`Scout was truncated without structured output. Experiment stays at current status.`);
     return;
   }
   updateExperimentStatus(db, exp.id, "scouted");
@@ -5570,12 +5286,12 @@ ${fragility}`;
 async function doVerify(db, exp, root) {
   transition(exp.status, "verifying" /* VERIFYING */);
   const doubts = getDoubtsByExperiment(db, exp.id);
-  const challengeDir = path13.join(root, "docs", "challenges");
+  const challengeDir = path11.join(root, "docs", "challenges");
   let challenges = "";
-  if (fs13.existsSync(challengeDir)) {
-    const files = fs13.readdirSync(challengeDir).filter((f) => f.includes(exp.slug) && f.endsWith(".md"));
+  if (fs11.existsSync(challengeDir)) {
+    const files = fs11.readdirSync(challengeDir).filter((f) => f.includes(exp.slug) && f.endsWith(".md"));
     for (const f of files) {
-      challenges += fs13.readFileSync(path13.join(challengeDir, f), "utf-8") + "\n\n";
+      challenges += fs11.readFileSync(path11.join(challengeDir, f), "utf-8") + "\n\n";
     }
   }
   const config = loadConfig(root);
@@ -5632,191 +5348,802 @@ async function doVerify(db, exp, root) {
   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 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,
+      slug: exp.slug,
+      hypothesis: exp.hypothesis,
+      status: "verifying",
+      sub_type: exp.sub_type,
+      builder_guidance: null
+    },
+    doubts,
+    challenges,
+    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) {
+    warn(`Verifier was truncated without structured output. Experiment stays at 'verifying'.`);
+    return;
+  }
+  if (result.structured?.doubt_resolutions) {
+    const knownDoubtIds = new Set(doubts.map((d) => d.id));
+    for (let i = 0; i < result.structured.doubt_resolutions.length; i++) {
+      const dr = result.structured.doubt_resolutions[i];
+      if (!dr.resolution) continue;
+      if (dr.doubt_id && knownDoubtIds.has(dr.doubt_id)) {
+        updateDoubtResolution(db, dr.doubt_id, dr.resolution);
+      } else if (doubts[i]) {
+        warn(`Doubt resolution ID ${dr.doubt_id} not found. Using ordinal fallback \u2192 DOUBT-${doubts[i].id}.`);
+        updateDoubtResolution(db, doubts[i].id, dr.resolution);
+      }
+    }
+  }
+  updateExperimentStatus(db, exp.id, "verified");
+  success(`Verification complete for ${exp.slug}. Run \`majlis resolve\` next.`);
+}
+async function doCompress(db, root) {
+  const synthesisPath = path11.join(root, "docs", "synthesis", "current.md");
+  const sizeBefore = fs11.existsSync(synthesisPath) ? fs11.statSync(synthesisPath).size : 0;
+  const sessionCount = getSessionsSinceCompression(db);
+  const dbExport = exportForCompressor(db);
+  let currentBranch = "main";
+  try {
+    currentBranch = (0, import_node_child_process5.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+      cwd: root,
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+  }
+  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 + `
+
+## Current Branch: ${currentBranch}
+Dead-ended experiments have been REVERTED \u2014 their code changes do NOT exist on this branch. Before claiming any code is "live" or "regressing", verify with Grep/Glob that it exists in the current codebase.
+
+## Your Task
+Read ALL experiments, decisions, doubts, challenges, verification reports, reframes, and recent diffs. Cross-reference for contradictions, redundancies, and patterns. REWRITE docs/synthesis/current.md \u2014 shorter and denser. Update docs/synthesis/fragility.md with current weak areas. Update docs/synthesis/dead-ends.md with structural constraints from rejected experiments.`
+  }, root);
+  const sizeAfter = fs11.existsSync(synthesisPath) ? fs11.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_process5.execSync)('git add -A -- ":!.majlis/"', { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const diff = (0, import_node_child_process5.execSync)("git diff --cached --stat", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (!diff) {
+      info("No code changes to commit.");
+      return;
+    }
+    const msg = `EXP-${String(exp.id).padStart(3, "0")}: ${exp.slug}
+
+${exp.hypothesis ?? ""}`;
+    (0, import_node_child_process5.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 = path11.join(root, relPath);
+    try {
+      const content = fs11.readFileSync(absPath, "utf-8");
+      sections.push(`### ${relPath}
+\`\`\`
+${content.slice(0, 8e3)}
+\`\`\``);
+    } catch {
+      sections.push(`### ${relPath}
+*(file not found)*`);
+    }
+  }
+  return sections.join("\n\n");
+}
+function expDocRelPath(exp) {
+  return `docs/experiments/${String(exp.id).padStart(3, "0")}-${exp.slug}.md`;
+}
+function resolveExperimentArg(db, args) {
+  const slugArg = args.filter((a) => !a.startsWith("--"))[0];
+  let exp;
+  if (slugArg) {
+    exp = getExperimentBySlug(db, slugArg);
+    if (!exp) throw new Error(`Experiment not found: ${slugArg}`);
+  } else {
+    exp = getLatestExperiment(db);
+    if (!exp) throw new Error('No active experiments. Run `majlis new "hypothesis"` first.');
+  }
+  return exp;
+}
+function ingestStructuredOutput(db, experimentId, structured) {
+  if (!structured) return;
+  db.transaction(() => {
+    if (structured.decisions) {
+      for (const d of structured.decisions) {
+        insertDecision(db, experimentId, d.description, d.evidence_level, d.justification);
+      }
+      info(`Ingested ${structured.decisions.length} decision(s)`);
+    }
+    if (structured.grades) {
+      for (const g of structured.grades) {
+        insertVerification(
+          db,
+          experimentId,
+          g.component,
+          g.grade,
+          g.provenance_intact ?? null,
+          g.content_correct ?? null,
+          g.notes ?? null
+        );
+      }
+      info(`Ingested ${structured.grades.length} verification grade(s)`);
+    }
+    if (structured.doubts) {
+      for (const d of structured.doubts) {
+        insertDoubt(
+          db,
+          experimentId,
+          d.claim_doubted,
+          d.evidence_level_of_claim,
+          d.evidence_for_doubt,
+          d.severity
+        );
+      }
+      info(`Ingested ${structured.doubts.length} doubt(s)`);
+    }
+    if (structured.challenges) {
+      for (const c of structured.challenges) {
+        insertChallenge(db, experimentId, c.description, c.reasoning);
+      }
+      info(`Ingested ${structured.challenges.length} challenge(s)`);
+    }
+    if (structured.reframe) {
+      insertReframe(
+        db,
+        experimentId,
+        structured.reframe.decomposition,
+        JSON.stringify(structured.reframe.divergences),
+        structured.reframe.recommendation
+      );
+      info(`Ingested reframe`);
+    }
+    if (structured.findings) {
+      for (const f of structured.findings) {
+        insertFinding(db, experimentId, f.approach, f.source, f.relevance, f.contradicts_current);
+      }
+      info(`Ingested ${structured.findings.length} finding(s)`);
+    }
+  })();
+}
+var fs11, path11, import_node_child_process5;
+var init_cycle = __esm({
+  "src/commands/cycle.ts"() {
+    "use strict";
+    fs11 = __toESM(require("fs"));
+    path11 = __toESM(require("path"));
+    import_node_child_process5 = require("child_process");
+    init_connection();
+    init_queries();
+    init_machine();
+    init_types2();
+    init_spawn();
+    init_parse();
+    init_resolve();
+    init_config();
+    init_metrics();
+    init_git();
+    init_format();
+  }
+});
+
+// src/commands/measure.ts
+var measure_exports = {};
+__export(measure_exports, {
+  baseline: () => baseline,
+  compare: () => compare,
+  measure: () => measure
+});
+async function baseline(args) {
+  await captureMetrics("before", args);
+}
+async function measure(args) {
+  await captureMetrics("after", args);
+}
+async function captureMetrics(phase, args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  const config = loadConfig(root);
+  const expIdStr = getFlagValue(args, "--experiment");
+  let exp;
+  if (expIdStr !== void 0) {
+    exp = getExperimentById(db, Number(expIdStr));
+  } else {
+    exp = getLatestExperiment(db);
+  }
+  if (!exp) throw new Error('No active experiment. Run `majlis new "hypothesis"` first.');
+  if (config.build.pre_measure) {
+    info(`Running pre-measure: ${config.build.pre_measure}`);
+    try {
+      (0, import_node_child_process6.execSync)(config.build.pre_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
+    } catch {
+      warn("Pre-measure command failed \u2014 continuing anyway.");
+    }
+  }
+  if (!config.metrics.command) {
+    throw new Error("No metrics.command configured in .majlis/config.json");
+  }
+  info(`Running metrics: ${config.metrics.command}`);
+  let metricsOutput;
+  try {
+    metricsOutput = (0, import_node_child_process6.execSync)(config.metrics.command, {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (err) {
+    throw new Error(`Metrics command failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const parsed = parseMetricsOutput(metricsOutput);
+  if (parsed.length === 0) {
+    warn("Metrics command returned no data.");
+    return;
+  }
+  for (const m of parsed) {
+    insertMetric(db, exp.id, phase, m.fixture, m.metric_name, m.metric_value);
+  }
+  success(`Captured ${parsed.length} metric(s) for ${exp.slug} (phase: ${phase})`);
+  if (config.build.post_measure) {
+    try {
+      (0, import_node_child_process6.execSync)(config.build.post_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
+    } catch {
+      warn("Post-measure command failed.");
+    }
+  }
+}
+async function compare(args, isJson) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  const config = loadConfig(root);
+  const expIdStr = getFlagValue(args, "--experiment");
+  let exp;
+  if (expIdStr !== void 0) {
+    exp = getExperimentById(db, Number(expIdStr));
+  } else {
+    exp = getLatestExperiment(db);
+  }
+  if (!exp) throw new Error("No active experiment.");
+  const comparisons = compareMetrics(db, exp.id, config);
+  if (comparisons.length === 0) {
+    warn(`No before/after metrics to compare for ${exp.slug}. Run baseline and measure first.`);
+    return;
+  }
+  if (isJson) {
+    console.log(JSON.stringify({ experiment: exp.slug, comparisons }, null, 2));
+    return;
+  }
+  header(`Metric Comparison \u2014 ${exp.slug}`);
+  const regressions = comparisons.filter((c) => c.regression);
+  const rows = comparisons.map((c) => [
+    c.fixture,
+    c.metric,
+    String(c.before),
+    String(c.after),
+    formatDelta(c.delta),
+    c.regression ? red("REGRESSION") : green("OK")
+  ]);
+  console.log(table(["Fixture", "Metric", "Before", "After", "Delta", "Status"], rows));
+  if (regressions.length > 0) {
+    console.log();
+    warn(`${regressions.length} regression(s) detected!`);
+  } else {
+    console.log();
+    success("No regressions detected.");
+  }
+}
+function formatDelta(delta) {
+  const prefix = delta > 0 ? "+" : "";
+  return `${prefix}${delta.toFixed(4)}`;
+}
+var import_node_child_process6;
+var init_measure = __esm({
+  "src/commands/measure.ts"() {
+    "use strict";
+    import_node_child_process6 = require("child_process");
+    init_connection();
+    init_queries();
+    init_metrics();
+    init_config();
+    init_format();
+  }
+});
+
+// src/commands/experiment.ts
+var experiment_exports = {};
+__export(experiment_exports, {
+  newExperiment: () => newExperiment,
+  revert: () => revert
+});
+async function newExperiment(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const hypothesis = args.filter((a) => !a.startsWith("--")).join(" ");
+  if (!hypothesis) {
+    throw new Error('Usage: majlis new "hypothesis"');
+  }
+  const db = getDb(root);
+  const config = loadConfig(root);
+  let slug = getFlagValue(args, "--slug") ?? await generateSlug(hypothesis, root);
+  let attempt = 0;
+  while (getExperimentBySlug(db, slug + (attempt ? `-${attempt}` : ""))) {
+    attempt++;
+  }
+  if (attempt > 0) {
+    const original = slug;
+    slug = `${slug}-${attempt}`;
+    info(`Slug "${original}" already exists, using "${slug}"`);
+  }
+  const allExps = db.prepare("SELECT COUNT(*) as count FROM experiments").get();
+  const num = allExps.count + 1;
+  const paddedNum = String(num).padStart(3, "0");
+  const branch = `exp/${paddedNum}-${slug}`;
+  try {
+    (0, import_node_child_process7.execFileSync)("git", ["checkout", "-b", branch], {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    info(`Created branch: ${branch}`);
+  } catch (err) {
+    warn(`Could not create branch ${branch} \u2014 continuing without git branch.`);
+  }
+  const subType = getFlagValue(args, "--sub-type") ?? 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 docRelPath = expDocRelPath(exp);
+  const docsDir = path12.join(root, "docs", "experiments");
+  const templatePath = path12.join(docsDir, "_TEMPLATE.md");
+  if (fs12.existsSync(templatePath)) {
+    const template = fs12.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 = path12.join(root, docRelPath);
+    fs12.writeFileSync(logPath, logContent);
+    info(`Created experiment log: ${docRelPath}`);
+  }
+  autoCommit(root, `new: ${slug}`);
+  if (config.cycle.auto_baseline_on_new_experiment && config.metrics.command) {
+    info("Auto-baselining... (run `majlis baseline` to do this manually)");
+    try {
+      const { baseline: baseline2 } = await Promise.resolve().then(() => (init_measure(), measure_exports));
+      await baseline2(["--experiment", String(exp.id)]);
+    } catch (err) {
+      warn("Auto-baseline failed \u2014 run `majlis baseline` manually.");
+    }
+  }
+}
+async function revert(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  let exp;
+  const slugArg = args.filter((a) => !a.startsWith("--"))[0];
+  if (slugArg) {
+    exp = getExperimentBySlug(db, slugArg);
+    if (!exp) throw new Error(`Experiment not found: ${slugArg}`);
+  } else {
+    exp = getLatestExperiment(db);
+    if (!exp) throw new Error("No active experiments to revert.");
+  }
+  const reason = getFlagValue(args, "--reason") ?? "Manually reverted";
+  const contextArg = getFlagValue(args, "--context") ?? null;
+  const contextFiles = contextArg ? contextArg.split(",").map((f) => f.trim()) : [];
+  let whyFailed = reason;
+  let structuralConstraint = `Reverted: ${reason}`;
+  let category = args.includes("--structural") ? "structural" : "procedural";
+  try {
+    const gitDiff = getGitDiff(root, exp.branch);
+    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 deadEnds = exp.sub_type ? listStructuralDeadEndsBySubType(db, exp.sub_type) : listStructuralDeadEnds(db);
+    let supplementary = "";
+    if (contextFiles.length > 0) {
+      const sections = ["## Artifact Files (pointed to by --context)"];
+      for (const relPath of contextFiles) {
+        const absPath = path12.join(root, relPath);
+        try {
+          const content = fs12.readFileSync(absPath, "utf-8");
+          sections.push(`### ${relPath}
+\`\`\`
+${content.slice(0, 12e3)}
+\`\`\``);
+        } catch {
+          sections.push(`### ${relPath}
+*(file not found)*`);
+        }
+      }
+      supplementary = sections.join("\n\n");
+    }
+    let taskPrompt = `Analyze this reverted experiment and produce a structured dead-end record.
+
+`;
+    taskPrompt += `## Experiment
+- Slug: ${exp.slug}
+- Hypothesis: ${exp.hypothesis ?? "(none)"}
+`;
+    taskPrompt += `- Status at revert: ${exp.status}
+- Sub-type: ${exp.sub_type ?? "(none)"}
+
+`;
+    taskPrompt += `## User's Reason for Reverting
+${reason}
+
+`;
+    if (gitDiff) {
+      taskPrompt += `## Git Diff (branch vs main)
+\`\`\`diff
+${gitDiff.slice(0, 15e3)}
+\`\`\`
+
+`;
+    }
+    if (supplementary) {
+      taskPrompt += `${supplementary}
+
+`;
+    }
+    taskPrompt += "Produce a specific structural constraint. Include scope (what this applies to and does NOT apply to).";
+    info("Running post-mortem analysis...");
+    const result = await spawnAgent("postmortem", {
+      experiment: {
+        id: exp.id,
+        slug: exp.slug,
+        hypothesis: exp.hypothesis,
+        status: exp.status,
+        sub_type: exp.sub_type,
+        builder_guidance: null
+      },
+      deadEnds: deadEnds.map((d) => ({
+        approach: d.approach,
+        why_failed: d.why_failed,
+        structural_constraint: d.structural_constraint
+      })),
+      fragility,
+      synthesis,
+      supplementaryContext: supplementary || void 0,
+      taskPrompt
+    }, root);
+    if (result.structured?.postmortem) {
+      const pm = result.structured.postmortem;
+      whyFailed = pm.why_failed;
+      structuralConstraint = pm.structural_constraint;
+      category = pm.category;
+      success("Post-mortem analysis complete.");
+    } else {
+      warn("Post-mortem agent did not produce structured output. Using --reason text.");
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warn(`Post-mortem agent failed: ${msg}. Using --reason text.`);
+  }
+  insertDeadEnd(
+    db,
+    exp.id,
+    exp.hypothesis ?? exp.slug,
+    whyFailed,
+    structuralConstraint,
+    exp.sub_type,
+    category
+  );
+  if (exp.gate_rejection_reason) clearGateRejection(db, exp.id);
+  adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "revert");
+  handleDeadEndGit(exp, root);
+  info(`Experiment ${exp.slug} reverted to dead-end.`);
+  info(`Constraint: ${structuralConstraint.slice(0, 120)}${structuralConstraint.length > 120 ? "..." : ""}`);
+}
+function getGitDiff(root, branch) {
+  try {
+    return (0, import_node_child_process7.execFileSync)("git", ["diff", `main...${branch}`, "--stat", "--patch"], {
+      cwd: root,
+      encoding: "utf-8",
+      maxBuffer: 1024 * 1024,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    try {
+      return (0, import_node_child_process7.execFileSync)("git", ["diff", `master...${branch}`, "--stat", "--patch"], {
+        cwd: root,
+        encoding: "utf-8",
+        maxBuffer: 1024 * 1024,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    } catch {
+      return null;
+    }
+  }
+}
+var fs12, path12, import_node_child_process7;
+var init_experiment = __esm({
+  "src/commands/experiment.ts"() {
+    "use strict";
+    fs12 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
+    import_node_child_process7 = require("child_process");
+    init_connection();
+    init_queries();
+    init_machine();
+    init_types2();
+    init_config();
+    init_spawn();
+    init_git();
+    init_cycle();
+    init_format();
+  }
+});
+
+// src/commands/session.ts
+var session_exports = {};
+__export(session_exports, {
+  session: () => session
+});
+async function session(args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand !== "start" && subcommand !== "end") {
+    throw new Error('Usage: majlis session start "intent" | majlis session end');
+  }
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  if (subcommand === "start") {
+    const intent = args.slice(1).filter((a) => !a.startsWith("--")).join(" ");
+    if (!intent) {
+      throw new Error('Usage: majlis session start "intent"');
+    }
+    const existing = getActiveSession(db);
+    if (existing) {
+      warn(`Session already active: "${existing.intent}" (started ${existing.started_at})`);
+      warn("End it first with `majlis session end`.");
+      return;
+    }
+    const latestExp = getLatestExperiment(db);
+    const sess = startSession(db, intent, latestExp?.id ?? null);
+    success(`Session started: "${intent}" (id: ${sess.id})`);
+    if (latestExp) {
+      info(`Linked to experiment: ${latestExp.slug} (${latestExp.status})`);
+    }
+  } else {
+    const active = getActiveSession(db);
+    if (!active) {
+      throw new Error("No active session to end.");
+    }
+    const accomplished = getFlagValue(args, "--accomplished") ?? null;
+    const unfinished = getFlagValue(args, "--unfinished") ?? null;
+    const fragility = getFlagValue(args, "--fragility") ?? null;
+    endSession(db, active.id, accomplished, unfinished, fragility);
+    success(`Session ended: "${active.intent}"`);
+    if (accomplished) info(`Accomplished: ${accomplished}`);
+    if (unfinished) info(`Unfinished: ${unfinished}`);
+    if (fragility) warn(`New fragility: ${fragility}`);
+  }
+}
+var init_session = __esm({
+  "src/commands/session.ts"() {
+    "use strict";
+    init_connection();
+    init_queries();
+    init_config();
+    init_format();
+  }
+});
+
+// src/commands/query.ts
+var query_exports = {};
+__export(query_exports, {
+  query: () => query3
+});
+async function query3(command, args, isJson) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  switch (command) {
+    case "decisions":
+      return queryDecisions(db, args, isJson);
+    case "dead-ends":
+      return queryDeadEnds(db, args, isJson);
+    case "fragility":
+      return queryFragility(root, isJson);
+    case "history":
+      return queryHistory(db, args, isJson);
+    case "circuit-breakers":
+      return queryCircuitBreakers(db, root, isJson);
+    case "check-commit":
+      return checkCommit(db);
+  }
+}
+function queryDecisions(db, args, isJson) {
+  const level = getFlagValue(args, "--level");
+  const expIdStr = getFlagValue(args, "--experiment");
+  const experimentId = expIdStr !== void 0 ? Number(expIdStr) : void 0;
+  const decisions = listAllDecisions(db, level, experimentId);
+  if (isJson) {
+    console.log(JSON.stringify(decisions, null, 2));
+    return;
+  }
+  if (decisions.length === 0) {
+    info("No decisions found.");
+    return;
+  }
+  header("Decisions");
+  const rows = decisions.map((d) => [
+    String(d.id),
+    String(d.experiment_id),
+    evidenceColor(d.evidence_level),
+    d.description.slice(0, 60) + (d.description.length > 60 ? "..." : ""),
+    d.status
+  ]);
+  console.log(table(["ID", "Exp", "Level", "Description", "Status"], rows));
+}
+function queryDeadEnds(db, args, isJson) {
+  const subType = getFlagValue(args, "--sub-type");
+  const searchTerm = getFlagValue(args, "--search");
+  let deadEnds;
+  if (subType) {
+    deadEnds = listDeadEndsBySubType(db, subType);
+  } else if (searchTerm) {
+    deadEnds = searchDeadEnds(db, searchTerm);
+  } else {
+    deadEnds = listAllDeadEnds(db);
+  }
+  if (isJson) {
+    console.log(JSON.stringify(deadEnds, null, 2));
+    return;
   }
-  const result = await spawnAgent("verifier", {
-    experiment: {
-      id: exp.id,
-      slug: exp.slug,
-      hypothesis: exp.hypothesis,
-      status: "verifying",
-      sub_type: exp.sub_type,
-      builder_guidance: null
-    },
-    doubts,
-    challenges,
-    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) {
-    warn(`Verifier was truncated without structured output. Experiment stays at 'verifying'.`);
+  if (deadEnds.length === 0) {
+    info("No dead-ends recorded.");
     return;
   }
-  if (result.structured?.doubt_resolutions) {
-    const knownDoubtIds = new Set(doubts.map((d) => d.id));
-    for (let i = 0; i < result.structured.doubt_resolutions.length; i++) {
-      const dr = result.structured.doubt_resolutions[i];
-      if (!dr.resolution) continue;
-      if (dr.doubt_id && knownDoubtIds.has(dr.doubt_id)) {
-        updateDoubtResolution(db, dr.doubt_id, dr.resolution);
-      } else if (doubts[i]) {
-        warn(`Doubt resolution ID ${dr.doubt_id} not found. Using ordinal fallback \u2192 DOUBT-${doubts[i].id}.`);
-        updateDoubtResolution(db, doubts[i].id, dr.resolution);
-      }
-    }
+  header("Dead-End Registry");
+  const rows = deadEnds.map((d) => [
+    String(d.id),
+    d.sub_type ?? "\u2014",
+    d.approach.slice(0, 40) + (d.approach.length > 40 ? "..." : ""),
+    d.structural_constraint.slice(0, 40) + (d.structural_constraint.length > 40 ? "..." : "")
+  ]);
+  console.log(table(["ID", "Sub-Type", "Approach", "Constraint"], rows));
+}
+function queryFragility(root, isJson) {
+  const fragPath = path13.join(root, "docs", "synthesis", "fragility.md");
+  if (!fs13.existsSync(fragPath)) {
+    info("No fragility map found.");
+    return;
   }
-  updateExperimentStatus(db, exp.id, "verified");
-  success(`Verification complete for ${exp.slug}. Run \`majlis resolve\` next.`);
+  const content = fs13.readFileSync(fragPath, "utf-8");
+  if (isJson) {
+    console.log(JSON.stringify({ content }, null, 2));
+    return;
+  }
+  header("Fragility Map");
+  console.log(content);
 }
-async function doCompress(db, root) {
-  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 = 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 queryHistory(db, args, isJson) {
+  const fixture = args.filter((a) => !a.startsWith("--"))[0];
+  if (!fixture) {
+    throw new Error("Usage: majlis history <fixture>");
+  }
+  const history = getMetricHistoryByFixture(db, fixture);
+  if (isJson) {
+    console.log(JSON.stringify(history, null, 2));
+    return;
+  }
+  if (history.length === 0) {
+    info(`No metric history for fixture: ${fixture}`);
+    return;
+  }
+  header(`Metric History \u2014 ${fixture}`);
+  const rows = history.map((h) => [
+    String(h.experiment_id),
+    h.experiment_slug ?? "\u2014",
+    h.phase,
+    h.metric_name,
+    String(h.metric_value),
+    h.captured_at
+  ]);
+  console.log(table(["Exp", "Slug", "Phase", "Metric", "Value", "Captured"], rows));
 }
-function gitCommitBuild(exp, cwd) {
-  try {
-    (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;
-    }
-    const msg = `EXP-${String(exp.id).padStart(3, "0")}: ${exp.slug}
-
-${exp.hypothesis ?? ""}`;
-    (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 queryCircuitBreakers(db, root, isJson) {
+  const config = loadConfig(root);
+  const states = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
+  if (isJson) {
+    console.log(JSON.stringify(states, null, 2));
+    return;
+  }
+  if (states.length === 0) {
+    info("No circuit breaker data.");
+    return;
   }
+  header("Circuit Breakers");
+  const rows = states.map((s) => [
+    s.sub_type,
+    String(s.failure_count),
+    String(config.cycle.circuit_breaker_threshold),
+    s.tripped ? red("TRIPPED") : green("OK")
+  ]);
+  console.log(table(["Sub-Type", "Failures", "Threshold", "Status"], rows));
 }
-function loadExperimentContext(exp, root) {
-  if (!exp.context_files) return "";
-  let files;
+function checkCommit(db) {
+  let stdinData = "";
   try {
-    files = JSON.parse(exp.context_files);
+    stdinData = fs13.readFileSync(0, "utf-8");
   } 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);
+  if (stdinData) {
     try {
-      const content = fs13.readFileSync(absPath, "utf-8");
-      sections.push(`### ${relPath}
-\`\`\`
-${content.slice(0, 8e3)}
-\`\`\``);
+      const hookInput = JSON.parse(stdinData);
+      const command = hookInput?.tool_input?.command ?? "";
+      if (!command.includes("git commit")) {
+        return;
+      }
     } 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;
-  if (slugArg) {
-    exp = getExperimentBySlug(db, slugArg);
-    if (!exp) throw new Error(`Experiment not found: ${slugArg}`);
-  } else {
-    exp = getLatestExperiment(db);
-    if (!exp) throw new Error('No active experiments. Run `majlis new "hypothesis"` first.');
-  }
-  return exp;
-}
-function ingestStructuredOutput(db, experimentId, structured) {
-  if (!structured) return;
-  db.transaction(() => {
-    if (structured.decisions) {
-      for (const d of structured.decisions) {
-        insertDecision(db, experimentId, d.description, d.evidence_level, d.justification);
-      }
-      info(`Ingested ${structured.decisions.length} decision(s)`);
-    }
-    if (structured.grades) {
-      for (const g of structured.grades) {
-        insertVerification(
-          db,
-          experimentId,
-          g.component,
-          g.grade,
-          g.provenance_intact ?? null,
-          g.content_correct ?? null,
-          g.notes ?? null
-        );
-      }
-      info(`Ingested ${structured.grades.length} verification grade(s)`);
-    }
-    if (structured.doubts) {
-      for (const d of structured.doubts) {
-        insertDoubt(
-          db,
-          experimentId,
-          d.claim_doubted,
-          d.evidence_level_of_claim,
-          d.evidence_for_doubt,
-          d.severity
-        );
-      }
-      info(`Ingested ${structured.doubts.length} doubt(s)`);
-    }
-    if (structured.challenges) {
-      for (const c of structured.challenges) {
-        insertChallenge(db, experimentId, c.description, c.reasoning);
-      }
-      info(`Ingested ${structured.challenges.length} challenge(s)`);
-    }
-    if (structured.reframe) {
-      insertReframe(
-        db,
-        experimentId,
-        structured.reframe.decomposition,
-        JSON.stringify(structured.reframe.divergences),
-        structured.reframe.recommendation
-      );
-      info(`Ingested reframe`);
-    }
-    if (structured.findings) {
-      for (const f of structured.findings) {
-        insertFinding(db, experimentId, f.approach, f.source, f.relevance, f.contradicts_current);
-      }
-      info(`Ingested ${structured.findings.length} finding(s)`);
+  const active = listActiveExperiments(db);
+  const unverified = active.filter(
+    (e) => !["merged", "dead_end", "verified", "resolved", "compressed"].includes(e.status)
+  );
+  if (unverified.length > 0) {
+    console.error(`[majlis] ${unverified.length} unverified experiment(s):`);
+    for (const e of unverified) {
+      console.error(`  - ${e.slug} (${e.status})`);
     }
-  })();
+    process.exit(1);
+  }
 }
-var fs13, path13, import_node_child_process7;
-var init_cycle = __esm({
-  "src/commands/cycle.ts"() {
+var fs13, path13;
+var init_query = __esm({
+  "src/commands/query.ts"() {
     "use strict";
     fs13 = __toESM(require("fs"));
     path13 = __toESM(require("path"));
-    import_node_child_process7 = require("child_process");
     init_connection();
     init_queries();
-    init_machine();
-    init_types2();
-    init_spawn();
-    init_parse();
-    init_resolve();
     init_config();
-    init_metrics();
-    init_git();
     init_format();
   }
 });
@@ -6011,13 +6338,14 @@ async function next(args, isJson) {
     exp = found;
   }
   const auto = args.includes("--auto");
+  const overrideGate = args.includes("--override-gate");
   if (auto) {
     await runAutoLoop(db, exp, config, root, isJson);
   } else {
-    await runNextStep(db, exp, config, root, isJson);
+    await runNextStep(db, exp, config, root, isJson, overrideGate);
   }
 }
-async function runNextStep(db, exp, config, root, isJson) {
+async function runNextStep(db, exp, config, root, isJson, overrideGate = false) {
   const currentStatus = exp.status;
   const valid = validNext(currentStatus);
   if (valid.length === 0) {
@@ -6040,10 +6368,21 @@ async function runNextStep(db, exp, config, root, isJson) {
       "procedural"
     );
     adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "circuit_breaker");
+    handleDeadEndGit(exp, root);
     warn("Experiment dead-ended. Triggering Maqasid Check (purpose audit).");
     await audit([config.project?.objective ?? ""]);
     return;
   }
+  if (exp.status === "gated" && exp.gate_rejection_reason) {
+    if (overrideGate) {
+      clearGateRejection(db, exp.id);
+      info(`Gate override accepted for ${exp.slug}. Proceeding to build.`);
+    } else {
+      warn(`Gate rejected: ${exp.gate_rejection_reason}`);
+      info("Run `majlis next --override-gate` to proceed anyway, or `majlis revert` to abandon.");
+      return;
+    }
+  }
   const sessionsSinceCompression = getSessionsSinceCompression(db);
   if (sessionsSinceCompression >= config.cycle.compression_interval) {
     warn(
@@ -6074,6 +6413,11 @@ async function runAutoLoop(db, exp, config, root, isJson) {
     const freshExp = getExperimentBySlug(db, exp.slug);
     if (!freshExp) break;
     exp = freshExp;
+    if (exp.gate_rejection_reason) {
+      warn(`Gate rejected: ${exp.gate_rejection_reason}`);
+      info("Stopping auto mode. Use `majlis next --override-gate` or `majlis revert`.");
+      break;
+    }
     if (isTerminal(exp.status)) {
       success(`Experiment ${exp.slug} reached terminal state: ${exp.status}`);
       break;
@@ -6090,6 +6434,7 @@ async function runAutoLoop(db, exp, config, root, isJson) {
         "procedural"
       );
       adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "circuit_breaker");
+      handleDeadEndGit(exp, root);
       await audit([config.project?.objective ?? ""]);
       break;
     }
@@ -6166,6 +6511,7 @@ var init_next = __esm({
     init_config();
     init_cycle();
     init_audit();
+    init_git();
     init_format();
   }
 });
@@ -6237,6 +6583,28 @@ async function run(args) {
     try {
       await next([exp.slug], false);
       consecutiveFailures = 0;
+      const afterStep = getExperimentBySlug(db, exp.slug);
+      if (afterStep?.gate_rejection_reason) {
+        warn(`Gate rejected in autonomous mode: ${afterStep.gate_rejection_reason}. Dead-ending.`);
+        insertDeadEnd(
+          db,
+          afterStep.id,
+          afterStep.hypothesis ?? afterStep.slug,
+          afterStep.gate_rejection_reason,
+          `Gate rejected: ${afterStep.gate_rejection_reason}`,
+          afterStep.sub_type,
+          "procedural"
+        );
+        adminTransitionAndPersist(
+          db,
+          afterStep.id,
+          afterStep.status,
+          "dead_end" /* DEAD_END */,
+          "revert"
+        );
+        handleDeadEndGit(afterStep, root);
+        continue;
+      }
     } catch (err) {
       consecutiveFailures++;
       const message = err instanceof Error ? err.message : String(err);
@@ -6252,6 +6620,7 @@ async function run(args) {
           "procedural"
         );
         adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "error_recovery");
+        handleDeadEndGit(exp, root);
       } catch (innerErr) {
         const innerMsg = innerErr instanceof Error ? innerErr.message : String(innerErr);
         warn(`Could not record dead-end: ${innerMsg}`);
@@ -6391,14 +6760,15 @@ 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 docRelPath = expDocRelPath(exp);
   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 = path16.join(docsDir, `${paddedNum}-${finalSlug}.md`);
+    const logPath = path16.join(root, docRelPath);
     fs16.writeFileSync(logPath, logContent);
-    info(`Created experiment log: docs/experiments/${paddedNum}-${finalSlug}.md`);
+    info(`Created experiment log: ${docRelPath}`);
   }
   return exp;
 }
@@ -6686,8 +7056,9 @@ function importExperimentFromWorktree(sourceDb, targetDb, slug) {
   const sourceId = sourceExp.id;
   const insertExp = targetDb.prepare(`
     INSERT INTO experiments (slug, branch, status, classification_ref, sub_type,
-      hypothesis, builder_guidance, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      hypothesis, builder_guidance, depends_on, context_files,
+      gate_rejection_reason, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
   const result = insertExp.run(
     sourceExp.slug,
@@ -6697,6 +7068,9 @@ function importExperimentFromWorktree(sourceDb, targetDb, slug) {
     sourceExp.sub_type,
     sourceExp.hypothesis,
     sourceExp.builder_guidance,
+    sourceExp.depends_on ?? null,
+    sourceExp.context_files ?? null,
+    sourceExp.gate_rejection_reason ?? null,
     sourceExp.created_at,
     sourceExp.updated_at
   );