majlis 0.6.3 → 0.7.1

package/dist/cli.js

@@ -249,6 +249,13 @@ var init_migrations = __esm({
       );
 
       CREATE INDEX idx_swarm_members_run ON swarm_members(swarm_run_id);
+    `);
+      },
+      // Migration 006: v5 → v6 — Experiment dependencies and scoped context
+      (db) => {
+        db.exec(`
+      ALTER TABLE experiments ADD COLUMN depends_on TEXT;
+      ALTER TABLE experiments ADD COLUMN context_files TEXT;
     `);
       }
     ];
@@ -301,6 +308,12 @@ function closeDb() {
   }
 }
 function resetDb() {
+  if (_db) {
+    try {
+      _db.close();
+    } catch {
+    }
+  }
   _db = null;
 }
 function openDbAt(projectRoot) {
@@ -512,7 +525,7 @@ async function extractStructuredData(role, markdown) {
   return null;
 }
 function extractMajlisJsonBlock(markdown) {
-  const match = markdown.match(/<!--\s*majlis-json\s*\n([\s\S]*?)-->/);
+  const match = markdown.match(/<!--\s*majlis-json\s*\n?([\s\S]*?)-->/);
   if (!match) return null;
   return match[1].trim();
 }
@@ -717,12 +730,17 @@ If you are past turn 25, output your structured JSON NOW.`;
 Check: is your core task done? If yes, wrap up and output JSON.`;
   }
 }
-function buildPreToolUseGuards(role) {
+function isInsideDir(filePath, allowedDir) {
+  const resolved = path2.resolve(filePath);
+  return resolved.startsWith(allowedDir + path2.sep) || resolved === allowedDir;
+}
+function buildPreToolUseGuards(role, cwd) {
   if (role === "compressor") {
+    const allowedDir = path2.resolve(cwd, "docs", "synthesis");
     const guardHook = async (input) => {
       const toolInput = input.tool_input ?? {};
       const filePath = toolInput.file_path ?? "";
-      if (filePath && !filePath.includes("/docs/synthesis/")) {
+      if (filePath && !isInsideDir(filePath, allowedDir)) {
         return {
           decision: "block",
           reason: `Compressor may only write to docs/synthesis/. Blocked: ${filePath}`
@@ -736,10 +754,11 @@ function buildPreToolUseGuards(role) {
     ];
   }
   if (role === "diagnostician") {
+    const allowedDir = path2.resolve(cwd, ".majlis", "scripts");
     const writeGuard = async (input) => {
       const toolInput = input.tool_input ?? {};
       const filePath = toolInput.file_path ?? "";
-      if (filePath && !filePath.includes("/.majlis/scripts/")) {
+      if (filePath && !isInsideDir(filePath, allowedDir)) {
         return {
           decision: "block",
           reason: `Diagnostician may only write to .majlis/scripts/. Blocked: ${filePath}`
@@ -750,7 +769,7 @@ function buildPreToolUseGuards(role) {
     const bashGuard = async (input) => {
       const toolInput = input.tool_input ?? {};
       const command = toolInput.command ?? "";
-      const destructive = /\b(rm\s+-rf|git\s+(checkout|reset|stash|clean|push)|chmod|chown|mkfs|dd\s+if=)\b/i;
+      const destructive = /\b(rm\s+(-\w*[rf]|--recursive|--force)|git\s+(checkout|reset|stash|clean|push\s+--force)|chmod|chown|mkfs|dd\s+if=|sudo\s)/i;
       if (destructive.test(command)) {
         return {
           decision: "block",
@@ -766,10 +785,11 @@ function buildPreToolUseGuards(role) {
     ];
   }
   if (role === "cartographer") {
+    const allowedDir = path2.resolve(cwd, "docs", "synthesis");
     const guardHook = async (input) => {
       const toolInput = input.tool_input ?? {};
       const filePath = toolInput.file_path ?? "";
-      if (filePath && !filePath.includes("/docs/synthesis/")) {
+      if (filePath && !isInsideDir(filePath, allowedDir)) {
         return {
           decision: "block",
           reason: `Cartographer may only write to docs/synthesis/. Blocked: ${filePath}`
@@ -783,10 +803,11 @@ function buildPreToolUseGuards(role) {
     ];
   }
   if (role === "toolsmith") {
+    const allowedDir = path2.resolve(cwd, ".majlis", "scripts");
     const writeGuard = async (input) => {
       const toolInput = input.tool_input ?? {};
       const filePath = toolInput.file_path ?? "";
-      if (filePath && !filePath.includes("/.majlis/scripts/")) {
+      if (filePath && !isInsideDir(filePath, allowedDir)) {
         return {
           decision: "block",
           reason: `Toolsmith may only write to .majlis/scripts/. Blocked: ${filePath}`
@@ -797,7 +818,7 @@ function buildPreToolUseGuards(role) {
     const bashGuard = async (input) => {
       const toolInput = input.tool_input ?? {};
       const command = toolInput.command ?? "";
-      const destructive = /\b(rm\s+-rf|git\s+(checkout|reset|stash|clean|push)|chmod|chown|mkfs|dd\s+if=)\b/i;
+      const destructive = /\b(rm\s+(-\w*[rf]|--recursive|--force)|git\s+(checkout|reset|stash|clean|push\s+--force)|chmod|chown|mkfs|dd\s+if=|sudo\s)/i;
       if (destructive.test(command)) {
         return {
           decision: "block",
@@ -812,9 +833,59 @@ function buildPreToolUseGuards(role) {
       { matcher: "Bash", hooks: [bashGuard] }
     ];
   }
+  if (role === "builder") {
+    const bashGuard = async (input) => {
+      const toolInput = input.tool_input ?? {};
+      const command = toolInput.command ?? "";
+      const destructive = /\b(rm\s+(-\w*[rf]|--recursive|--force)|git\s+(checkout|reset|stash|clean|push\s+--force)|chmod|chown|mkfs|dd\s+if=|sudo\s)/i;
+      if (destructive.test(command)) {
+        return { decision: "block", reason: `Builder blocked destructive command: ${command.slice(0, 100)}` };
+      }
+      return {};
+    };
+    const configFile = path2.resolve(cwd, ".majlis", "config.json");
+    const dbFile = path2.resolve(cwd, ".majlis", "majlis.db");
+    const settingsFile = path2.resolve(cwd, ".claude", "settings.json");
+    const configGuard = async (input) => {
+      const toolInput = input.tool_input ?? {};
+      const filePath = toolInput.file_path ?? "";
+      if (filePath) {
+        const resolved = path2.resolve(filePath);
+        if (resolved === configFile || resolved === dbFile || resolved === settingsFile) {
+          return { decision: "block", reason: `Builder may not modify framework files: ${filePath}` };
+        }
+      }
+      return {};
+    };
+    return [
+      { matcher: "Bash", hooks: [bashGuard] },
+      { matcher: "Write", hooks: [configGuard] },
+      { matcher: "Edit", hooks: [configGuard] }
+    ];
+  }
+  if (role === "verifier") {
+    const configFile = path2.resolve(cwd, ".majlis", "config.json");
+    const dbFile = path2.resolve(cwd, ".majlis", "majlis.db");
+    const settingsFile = path2.resolve(cwd, ".claude", "settings.json");
+    const configGuard = async (input) => {
+      const toolInput = input.tool_input ?? {};
+      const filePath = toolInput.file_path ?? "";
+      if (filePath) {
+        const resolved = path2.resolve(filePath);
+        if (resolved === configFile || resolved === dbFile || resolved === settingsFile) {
+          return { decision: "block", reason: `Verifier may not modify framework files: ${filePath}` };
+        }
+      }
+      return {};
+    };
+    return [
+      { matcher: "Write", hooks: [configGuard] },
+      { matcher: "Edit", hooks: [configGuard] }
+    ];
+  }
   return void 0;
 }
-function buildAgentHooks(role, maxTurns) {
+function buildAgentHooks(role, maxTurns, cwd) {
   const result = {};
   let hasHooks = false;
   const interval = CHECKPOINT_INTERVAL[role];
@@ -836,7 +907,7 @@ function buildAgentHooks(role, maxTurns) {
     result.PostToolUse = [{ hooks: [checkpointHook] }];
     hasHooks = true;
   }
-  const guards = buildPreToolUseGuards(role);
+  const guards = buildPreToolUseGuards(role, cwd);
   if (guards) {
     result.PreToolUse = guards;
     hasHooks = true;
@@ -965,7 +1036,7 @@ Your job: Write a CLEAN experiment doc to ${expDocPath} using the Write tool.
 async function runQuery(opts) {
   let truncated = false;
   const tag = opts.label ?? "majlis";
-  const hooks = opts.role ? buildAgentHooks(opts.role, opts.maxTurns ?? 15) : void 0;
+  const hooks = opts.role ? buildAgentHooks(opts.role, opts.maxTurns ?? 15, opts.cwd) : void 0;
   const conversation = (0, import_claude_agent_sdk2.query)({
     prompt: opts.prompt,
     options: {
@@ -1197,7 +1268,7 @@ var init_config = __esm({
     path3 = __toESM(require("path"));
     DEFAULT_CONFIG = {
       project: { name: "", description: "", objective: "" },
-      metrics: { command: "", fixtures: [], tracked: {} },
+      metrics: { command: "", fixtures: {}, tracked: {} },
       build: { pre_measure: null, post_measure: null },
       cycle: {
         compression_interval: 5,
@@ -1811,18 +1882,23 @@ var init_scan = __esm({
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
-  AGENT_DEFINITIONS: () => AGENT_DEFINITIONS,
-  CLAUDE_MD_SECTION: () => CLAUDE_MD_SECTION,
-  HOOKS_CONFIG: () => HOOKS_CONFIG,
-  SLASH_COMMANDS: () => SLASH_COMMANDS,
+  AGENT_DEFINITIONS: () => import_shared.AGENT_DEFINITIONS,
+  CLAUDE_MD_SECTION: () => import_shared.CLAUDE_MD_SECTION,
+  HOOKS_CONFIG: () => import_shared.HOOKS_CONFIG,
+  SLASH_COMMANDS: () => import_shared.SLASH_COMMANDS,
   init: () => init
 });
+function writeIfMissing(filePath, content) {
+  if (!fs7.existsSync(filePath)) {
+    fs7.writeFileSync(filePath, content);
+  }
+}
 async function init(_args) {
   const runScan = _args.includes("--scan");
   const projectRoot = process.cwd();
   header("Initializing Majlis");
   const majlisDir = path7.join(projectRoot, ".majlis");
-  mkdirSafe(majlisDir);
+  (0, import_shared.mkdirSafe)(majlisDir);
   info("Created .majlis/");
   resetDb();
   const db = getDb(projectRoot);
@@ -1831,7 +1907,7 @@ async function init(_args) {
   resetDb();
   const configPath = path7.join(majlisDir, "config.json");
   if (!fs7.existsSync(configPath)) {
-    const config = { ...DEFAULT_CONFIG2 };
+    const config = { ...import_shared.DEFAULT_CONFIG };
     const pkgPath = path7.join(projectRoot, "package.json");
     if (fs7.existsSync(pkgPath)) {
       try {
@@ -1845,20 +1921,20 @@ async function init(_args) {
     info("Created .majlis/config.json");
   }
   const agentsDir = path7.join(majlisDir, "agents");
-  mkdirSafe(agentsDir);
-  for (const [name, content] of Object.entries(AGENT_DEFINITIONS)) {
-    fs7.writeFileSync(path7.join(agentsDir, `${name}.md`), content);
+  (0, import_shared.mkdirSafe)(agentsDir);
+  for (const [name, content] of Object.entries(import_shared.AGENT_DEFINITIONS)) {
+    writeIfMissing(path7.join(agentsDir, `${name}.md`), content);
   }
   info("Created agent definitions in .majlis/agents/");
   const claudeAgentsDir = path7.join(projectRoot, ".claude", "agents");
-  mkdirSafe(claudeAgentsDir);
-  for (const [name, content] of Object.entries(AGENT_DEFINITIONS)) {
-    fs7.writeFileSync(path7.join(claudeAgentsDir, `${name}.md`), content);
+  (0, import_shared.mkdirSafe)(claudeAgentsDir);
+  for (const [name, content] of Object.entries(import_shared.AGENT_DEFINITIONS)) {
+    writeIfMissing(path7.join(claudeAgentsDir, `${name}.md`), content);
   }
   info("Copied agent definitions to .claude/agents/");
   const commandsDir = path7.join(projectRoot, ".claude", "commands");
-  mkdirSafe(commandsDir);
-  for (const [name, cmd] of Object.entries(SLASH_COMMANDS)) {
+  (0, import_shared.mkdirSafe)(commandsDir);
+  for (const [name, cmd] of Object.entries(import_shared.SLASH_COMMANDS)) {
     const content = `---
 description: ${cmd.description}
 ---
@@ -1871,69 +1947,53 @@ ${cmd.body}
   if (fs7.existsSync(settingsPath)) {
     try {
       const existing = JSON.parse(fs7.readFileSync(settingsPath, "utf-8"));
-      existing.hooks = { ...existing.hooks, ...HOOKS_CONFIG.hooks };
+      existing.hooks = { ...existing.hooks, ...import_shared.HOOKS_CONFIG.hooks };
       fs7.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
     } catch {
-      fs7.writeFileSync(settingsPath, JSON.stringify(HOOKS_CONFIG, null, 2));
+      fs7.writeFileSync(settingsPath, JSON.stringify(import_shared.HOOKS_CONFIG, null, 2));
     }
   } else {
-    fs7.writeFileSync(settingsPath, JSON.stringify(HOOKS_CONFIG, null, 2));
+    fs7.writeFileSync(settingsPath, JSON.stringify(import_shared.HOOKS_CONFIG, null, 2));
   }
   info("Created hooks in .claude/settings.json");
   const docsDir = path7.join(projectRoot, "docs");
-  const docDirs = [
-    "inbox",
-    "experiments",
-    "decisions",
-    "classification",
-    "doubts",
-    "challenges",
-    "verification",
-    "reframes",
-    "rihla",
-    "synthesis",
-    "diagnosis"
-  ];
-  for (const dir of docDirs) {
-    mkdirSafe(path7.join(docsDir, dir));
+  for (const dir of import_shared.DOC_DIRS) {
+    (0, import_shared.mkdirSafe)(path7.join(docsDir, dir));
   }
-  for (const [relativePath, content] of Object.entries(DOC_TEMPLATES)) {
+  for (const [relativePath, content] of Object.entries(import_shared.DOC_TEMPLATES)) {
     const fullPath = path7.join(docsDir, relativePath);
-    if (!fs7.existsSync(fullPath)) {
-      fs7.writeFileSync(fullPath, content);
-    }
+    writeIfMissing(fullPath, content);
   }
   info("Created docs/ tree with templates");
   const synthesisDir = path7.join(docsDir, "synthesis");
-  const currentPath = path7.join(synthesisDir, "current.md");
-  if (!fs7.existsSync(currentPath)) {
-    fs7.writeFileSync(currentPath, '# Project Synthesis\n\n*No experiments yet. Run `majlis new "hypothesis"` to begin.*\n');
-  }
-  const fragPath = path7.join(synthesisDir, "fragility.md");
-  if (!fs7.existsSync(fragPath)) {
-    fs7.writeFileSync(fragPath, "# Fragility Map\n\n*No fragility recorded yet.*\n");
-  }
-  const deadEndsPath = path7.join(synthesisDir, "dead-ends.md");
-  if (!fs7.existsSync(deadEndsPath)) {
-    fs7.writeFileSync(deadEndsPath, "# Dead-End Registry\n\n*No dead-ends recorded yet.*\n");
+  for (const [filename, content] of Object.entries(import_shared.SYNTHESIS_STARTERS)) {
+    writeIfMissing(path7.join(synthesisDir, filename), content);
   }
   const workflowPath = path7.join(docsDir, "workflow.md");
-  if (!fs7.existsSync(workflowPath)) {
-    fs7.writeFileSync(workflowPath, WORKFLOW_MD);
-  }
+  writeIfMissing(workflowPath, import_shared.WORKFLOW_MD);
   info("Created docs/workflow.md");
   const claudeMdPath = path7.join(projectRoot, "CLAUDE.md");
   if (fs7.existsSync(claudeMdPath)) {
     const existing = fs7.readFileSync(claudeMdPath, "utf-8");
     if (!existing.includes("## Majlis Protocol")) {
-      fs7.writeFileSync(claudeMdPath, existing + "\n" + CLAUDE_MD_SECTION);
+      fs7.writeFileSync(claudeMdPath, existing + "\n" + import_shared.CLAUDE_MD_SECTION);
       info("Appended Majlis Protocol to existing CLAUDE.md");
     }
   } else {
     fs7.writeFileSync(claudeMdPath, `# ${path7.basename(projectRoot)}
-${CLAUDE_MD_SECTION}`);
+${import_shared.CLAUDE_MD_SECTION}`);
     info("Created CLAUDE.md with Majlis Protocol");
   }
+  const gitignorePath = path7.join(projectRoot, ".gitignore");
+  const dbEntries = [".majlis/majlis.db", ".majlis/majlis.db-wal", ".majlis/majlis.db-shm"];
+  if (fs7.existsSync(gitignorePath)) {
+    const existing = fs7.readFileSync(gitignorePath, "utf-8");
+    if (!existing.includes(".majlis/majlis.db")) {
+      const suffix = existing.endsWith("\n") ? "" : "\n";
+      fs7.writeFileSync(gitignorePath, existing + suffix + dbEntries.join("\n") + "\n");
+      info("Added .majlis/majlis.db to .gitignore");
+    }
+  }
   success("Majlis initialized. Run `majlis status` to see project state.");
   if (runScan) {
     info("Running project scan...");
@@ -1941,12 +2001,7 @@ ${CLAUDE_MD_SECTION}`);
     await scan2([]);
   }
 }
-function mkdirSafe(dir) {
-  if (!fs7.existsSync(dir)) {
-    fs7.mkdirSync(dir, { recursive: true });
-  }
-}
-var fs7, path7, DEFAULT_CONFIG2, AGENT_DEFINITIONS, SLASH_COMMANDS, HOOKS_CONFIG, CLAUDE_MD_SECTION, WORKFLOW_MD, DOC_TEMPLATES;
+var fs7, path7, import_shared;
 var init_init = __esm({
   "src/commands/init.ts"() {
     "use strict";
@@ -1954,1006 +2009,28 @@ var init_init = __esm({
     path7 = __toESM(require("path"));
     init_connection();
     init_format();
-    DEFAULT_CONFIG2 = {
-      project: {
-        name: "",
-        description: "",
-        objective: ""
-      },
-      metrics: {
-        command: `echo '{"fixtures":{}}'`,
-        fixtures: [],
-        tracked: {}
-      },
-      build: {
-        pre_measure: null,
-        post_measure: null
-      },
-      cycle: {
-        compression_interval: 5,
-        circuit_breaker_threshold: 3,
-        require_doubt_before_verify: true,
-        require_challenge_before_verify: false,
-        auto_baseline_on_new_experiment: true
-      },
-      models: {
-        builder: "opus",
-        critic: "opus",
-        adversary: "opus",
-        verifier: "opus",
-        reframer: "opus",
-        compressor: "opus"
-      }
-    };
-    AGENT_DEFINITIONS = {
-      builder: `---
-name: builder
-model: opus
-tools: [Read, Write, Edit, Bash, Glob, Grep]
----
-You are the Builder. You write code, run experiments, and make technical decisions.
-
-Before building:
-1. Read docs/synthesis/current.md for project state
-2. Read the dead-ends provided in your context \u2014 these are structural constraints
-3. Check docs/classification/ for problem taxonomy
-4. Check docs/experiments/ for prior work
-
-Read as much code as you need to understand the problem. Reading is free \u2014 spend
-as many turns as necessary on Read, Grep, and Glob to build full context before
-you touch anything.
-
-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.
-
-## The Rule: ONE Change, Then Document
-
-You make ONE code change per cycle. Not two, not "one more quick fix." ONE.
-
-The sequence:
-1. **Read and understand** \u2014 read synthesis, dead-ends, source code. Take your time.
-2. **Write the experiment doc FIRST** \u2014 before coding, fill in the Approach section
-   with what you plan to do and why. This ensures there is always a record.
-3. **Implement ONE focused change** \u2014 a single coherent edit to the codebase.
-4. **Run the benchmark ONCE** \u2014 observe the result.
-5. **Update the experiment doc** \u2014 fill in Results and Metrics with what happened.
-6. **Output the majlis-json block** \u2014 your structured decisions.
-7. **STOP.**
-
-If your change doesn't work, document what happened and STOP. Do NOT try to fix it.
-Do NOT iterate. Do NOT "try one more thing." The adversary, critic, and verifier
-exist to diagnose what went wrong. The cycle comes back to you with their insights.
-
-If you find yourself wanting to debug your own fix, that's the signal to stop
-and write up what you learned.
-
-## Off-limits (DO NOT modify)
-- \`fixtures/\` \u2014 test data, ground truth, STL files. Read-only.
-- \`scripts/benchmark.py\` \u2014 the measurement tool. Never change how you're measured.
-- \`.majlis/\` \u2014 framework config. Not your concern.
-
-## Confirmed Doubts
-If your context includes confirmedDoubts, these are weaknesses that the verifier has
-confirmed from a previous cycle. You MUST address each one. Do not ignore them \u2014
-the verifier will check again.
-
-## Metrics
-The framework captures baseline and post-build metrics automatically. Do NOT claim
-specific metric numbers unless quoting framework output. Do NOT run the benchmark
-yourself unless instructed to. If you need to verify your change works, do a minimal
-targeted test, not a full benchmark run.
-
-## During building:
-- Tag EVERY decision: proof / test / strong-consensus / consensus / analogy / judgment
-- When making judgment-level decisions, state: "This is judgment \u2014 reasoning without precedent"
-
-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.
-
-## Structured Output Format
-At the end of your work, include a <!-- majlis-json --> block with your decisions:
-\`\`\`
-<!-- majlis-json
-{
-  "decisions": [
-    { "description": "...", "evidence_level": "judgment|test|proof|analogy|consensus|strong_consensus", "justification": "..." }
-  ]
-}
--->
-\`\`\``,
-      critic: `---
-name: critic
-model: opus
-tools: [Read, Glob, Grep]
----
-You are the Critic. You practise constructive doubt.
-
-You receive:
-- The builder's experiment document (the artifact, not the reasoning chain)
-- The current synthesis (project state)
-- Dead-ends (approaches that have been tried and failed)
-- The hypothesis and experiment metadata
-
-You do NOT see the builder's reasoning chain \u2014 only their documented output.
-Use the experiment doc, synthesis, and dead-ends to find weaknesses.
-
-For each doubt:
-- What specific claim, decision, or assumption you doubt
-- WHY: reference a prior experiment, inconsistency, untested case, or false analogy
-- Evidence level of the doubted decision
-- Severity: minor / moderate / critical
-
-Rules:
-- Every doubt MUST reference evidence. "This feels wrong" is not a doubt.
-- You may NOT suggest fixes. Identify problems only.
-- Focus on judgment and analogy-level decisions first.
-- You may NOT modify any files. Produce your doubt document as output only.
-- Do NOT attempt to write files. The framework saves your output automatically.
-
-## Structured Output Format
-<!-- majlis-json
-{
-  "doubts": [
-    { "claim_doubted": "...", "evidence_level_of_claim": "judgment", "evidence_for_doubt": "...", "severity": "critical|moderate|minor" }
-  ]
-}
--->`,
-      adversary: `---
-name: adversary
-model: opus
-tools: [Read, Glob, Grep]
----
-You are the Adversary. You do NOT review code for bugs.
-You reason about problem structure to CONSTRUCT pathological cases.
-
-You receive:
-- The git diff of the builder's code changes (the actual code, not prose)
-- The current synthesis (project state)
-- The hypothesis and experiment metadata
-
-Study the CODE DIFF carefully \u2014 that is where the builder's assumptions are exposed.
-
-For each approach the builder takes, ask:
-- What input would make this fail?
-- What boundary condition was not tested?
-- What degenerate case collapses a distinction the algorithm relies on?
-- What distribution shift invalidates the assumptions?
-- Under what conditions do two things the builder treats as distinct become identical?
-
-Produce constructed counterexamples with reasoning.
-Do NOT suggest fixes. Do NOT modify files. Do NOT attempt to write files.
-The framework saves your output automatically.
-
-## Structured Output Format
-<!-- majlis-json
-{
-  "challenges": [
-    { "description": "...", "reasoning": "..." }
-  ]
-}
--->`,
-      verifier: `---
-name: verifier
-model: opus
-tools: [Read, Glob, Grep, Bash]
----
-You are the Verifier. Perform dual verification:
-
-You receive:
-- All doubts with explicit DOUBT-{id} identifiers (use these in your doubt_resolutions)
-- Challenge documents from the adversary
-- Framework-captured metrics (baseline vs post-build) \u2014 this is GROUND TRUTH
-- The hypothesis and experiment metadata
-
-## Scope Constraint (CRITICAL)
-
-You must produce your structured output (grades + doubt resolutions) within your turn budget.
-Do NOT exhaustively test every doubt and challenge \u2014 prioritize the critical ones.
-For each doubt/challenge: one targeted check is enough. Confirm, dismiss, or mark inconclusive.
-Reserve your final turns for writing the structured majlis-json output.
-
-The framework saves your output automatically. Do NOT attempt to write files.
-
-## Metrics (GROUND TRUTH)
-If framework-captured metrics are in your context, these are the canonical before/after numbers.
-Do NOT trust numbers claimed by the builder \u2014 compare against the framework metrics.
-If the builder claims improvement but the framework metrics show regression, flag this.
-
-## PROVENANCE CHECK:
-- Can every piece of code trace to an experiment or decision?
-- Is the chain unbroken from requirement -> classification -> experiment -> code?
-- Flag any broken chains.
-
-## CONTENT CHECK:
-- Does the code do what the experiment log says?
-- Run at most 3-5 targeted diagnostic scripts, focused on the critical doubts/challenges.
-- Do NOT run exhaustive diagnostics on every claim.
-
-Framework-captured metrics are ground truth \u2014 if they show regression, that
-alone justifies a "rejected" grade. Do not re-derive from raw fixture data.
-
-Grade each component: sound / good / weak / rejected
-Grade each doubt/challenge: confirmed / dismissed (with evidence) / inconclusive
-
-## Structured Output Format
-IMPORTANT: For doubt_resolutions, use the DOUBT-{id} numbers from your context.
-Example: if your context lists "DOUBT-7: [critical] The algorithm fails on X",
-use doubt_id: 7 in your output.
-
-<!-- majlis-json
-{
-  "grades": [
-    { "component": "...", "grade": "sound|good|weak|rejected", "provenance_intact": true, "content_correct": true, "notes": "..." }
-  ],
-  "doubt_resolutions": [
-    { "doubt_id": 7, "resolution": "confirmed|dismissed|inconclusive" }
-  ]
-}
--->`,
-      reframer: `---
-name: reframer
-model: opus
-tools: [Read, Glob, Grep]
----
-You are the Reframer. You receive ONLY:
-- The original problem statement
-- The current classification document
-- The synthesis and dead-end registry
-
-You do NOT read builder code, experiments, or solutions.
-
-Independently propose:
-- How should this problem be decomposed?
-- What are the natural joints?
-- What analogies from other domains apply?
-- What framework would a different field use?
-
-Compare your decomposition with the existing classification.
-Flag structural divergences \u2014 these are the most valuable signals.
-
-Produce your reframe document as output. Do NOT attempt to write files.
-The framework saves your output automatically.
-
-## Structured Output Format
-<!-- majlis-json
-{
-  "reframe": {
-    "decomposition": "How you decomposed the problem",
-    "divergences": ["List of structural divergences from current classification"],
-    "recommendation": "What should change based on your independent analysis"
-  }
-}
--->`,
-      compressor: `---
-name: compressor
-model: opus
-tools: [Read, Write, Edit, Glob, Grep]
----
-You are the Compressor. Hold the entire project in view and compress it.
-
-Your taskPrompt includes a "Structured Data (CANONICAL)" section exported directly
-from the SQLite database. This is the source of truth. docs/ files are agent artifacts
-that may contain stale or incorrect information. Cross-reference everything against
-the database export.
-
-1. Read the database export in your context FIRST \u2014 it has all experiments, decisions,
-   doubts (with resolutions), verifications (with grades), challenges, and dead-ends.
-2. Read docs/ files for narrative context, but trust the database when they conflict.
-3. Cross-reference: same question in different language? contradicting decisions?
-   workaround masking root cause?
-4. Update fragility map: thin coverage, weak components, untested judgment
-   decisions, broken provenance.
-5. Update dead-end registry: compress rejected experiments into structural constraints.
-   Mark each dead-end as [structural] or [procedural].
-6. REWRITE synthesis using the Write tool \u2014 shorter and denser. If it's growing,
-   you're accumulating, not compressing. You MUST use the Write tool to update
-   docs/synthesis/current.md, docs/synthesis/fragility.md, and docs/synthesis/dead-ends.md.
-   The framework does NOT auto-save your output for these files.
-7. Review classification: new sub-types? resolved sub-types?
-
-You may ONLY write to these three files:
-- docs/synthesis/current.md
-- docs/synthesis/fragility.md
-- docs/synthesis/dead-ends.md
-
-Do NOT modify MEMORY.md, .claude/, classification/, experiments/, or any other paths.
-
-You may NOT write code, make decisions, or run experiments.
-
-## Structured Output Format
-<!-- majlis-json
-{
-  "compression_report": {
-    "synthesis_delta": "What changed in synthesis and why",
-    "new_dead_ends": ["List of newly identified dead-end constraints"],
-    "fragility_changes": ["List of changes to the fragility map"]
-  }
-}
--->`,
-      scout: `---
-name: scout
-model: opus
-tools: [Read, Glob, Grep, WebSearch]
----
-You are the Scout. You practise rihla \u2014 travel in search of knowledge.
-
-Your job is to search externally for alternative approaches, contradictory evidence,
-and perspectives from other fields that could inform the current experiment.
-
-You receive:
-- The current synthesis and fragility map
-- Dead-ends (approaches that have been tried and failed) \u2014 search for alternatives that circumvent these
-- The hypothesis and experiment metadata
-
-For the given experiment:
-1. Describe the problem in domain-neutral terms
-2. Search for alternative approaches in other fields or frameworks
-3. Identify known limitations of the current approach from external sources
-4. Find structurally similar problems in unrelated domains
-5. Report what you find on its own terms \u2014 do not judge or filter
-
-Rules:
-- Present findings neutrally. Report each approach on its own terms.
-- Note where external approaches contradict the current one \u2014 these are the most valuable signals.
-- Focus on approaches that CIRCUMVENT known dead-ends \u2014 these are the most valuable.
-- You may NOT modify code or make decisions. Produce your rihla document as output only.
-- Do NOT attempt to write files. The framework saves your output automatically.
-
-## Structured Output Format
-<!-- majlis-json
-{
-  "findings": [
-    { "approach": "Name of alternative approach", "source": "Where you found it", "relevance": "How it applies", "contradicts_current": true }
-  ]
-}
--->`,
-      gatekeeper: `---
-name: gatekeeper
-model: sonnet
-tools: [Read, Glob, Grep]
----
-You are the Gatekeeper. You check hypotheses before expensive build cycles.
-
-Your job is a fast quality gate \u2014 prevent wasted Opus builds on hypotheses that
-are stale, redundant with dead-ends, or too vague to produce a focused change.
-
-## Checks (in order)
-
-### 1. Stale References
-Does the hypothesis reference specific functions, line numbers, or structures that
-may not exist in the current code? Read the relevant files to verify.
-- If references are stale, list them in stale_references.
-
-### 2. Dead-End Overlap
-Does this hypothesis repeat an approach already ruled out by structural dead-ends?
-Check each structural dead-end in your context \u2014 if the hypothesis matches the
-approach or violates the structural_constraint, flag it.
-- If overlapping, list the dead-end IDs in overlapping_dead_ends.
-
-### 3. Scope Check
-Is this a single focused change? A good hypothesis names ONE function, mechanism,
-or parameter to change. A bad hypothesis says "improve X and also Y and also Z."
-- Flag if the hypothesis tries to do multiple things.
-
-## Output
-
-gate_decision:
-- **approve** \u2014 all checks pass, proceed to build
-- **flag** \u2014 concerns found but not blocking (warnings only)
-- **reject** \u2014 hypothesis must be revised (stale refs, dead-end repeat, or too vague)
-
-## Structured Output Format
-<!-- majlis-json
-{
-  "gate_decision": "approve|reject|flag",
-  "reason": "Brief explanation of decision",
-  "stale_references": ["list of stale references found, if any"],
-  "overlapping_dead_ends": [0]
-}
--->`,
-      cartographer: `---
-name: cartographer
-model: opus
-tools: [Read, Write, Edit, Glob, Grep, Bash]
----
-You are the Cartographer. You map the architecture of an existing codebase.
-
-You receive a ProjectProfile JSON (deterministic surface scan) as context.
-Your job is to deeply explore the codebase and produce two synthesis documents:
-- docs/synthesis/current.md \u2014 project identity, architecture, key abstractions,
-  entry points, test coverage, build pipeline
-- docs/synthesis/fragility.md \u2014 untested areas, single points of failure,
-  dependency risk, tech debt
-
-## Your Approach
-
-Phase 1: Orientation (turns 1-10)
-- Read README, main entry point, 2-3 key imports
-- Understand the project's purpose and structure
-
-Phase 2: Architecture Mapping (turns 11-30)
-- Trace module boundaries and dependency graph
-- Identify data flow patterns, config patterns
-- For huge codebases: focus on entry points and top 5 most-imported modules
-- Map test coverage and build pipeline
-
-Phase 3: Write Synthesis (turns 31-40)
-- Write docs/synthesis/current.md with dense, actionable content
-- Write docs/synthesis/fragility.md with identified weak spots
-
-You may ONLY write to docs/synthesis/. Do NOT modify source code.
-
-## Structured Output Format
-<!-- majlis-json
-{
-  "architecture": {
-    "modules": ["list of key modules"],
-    "entry_points": ["main entry points"],
-    "key_abstractions": ["core abstractions and patterns"],
-    "dependency_graph": "brief description of dependency structure"
-  }
-}
--->`,
-      toolsmith: `---
-name: toolsmith
-model: opus
-tools: [Read, Write, Edit, Bash, Glob, Grep]
----
-You are the Toolsmith. You verify toolchain and create a working metrics pipeline.
-
-You receive a ProjectProfile JSON as context with detected test/build commands.
-Your job is to verify these commands actually work, then create a metrics wrapper
-script that translates test output into Majlis fixtures JSON format.
-
-## Your Approach
-
-Phase 1: Verify Toolchain (turns 1-10)
-- Try running the detected test command
-- Try the build command
-- Read CI config for hints if commands fail
-- Determine what actually works
-
-Phase 2: Create Metrics Wrapper (turns 11-25)
-- Create .majlis/scripts/metrics.sh
-- The wrapper MUST output valid JSON to stdout: {"fixtures":{"test_suite":{"total":N,"passed":N,"failed":N,"duration_ms":N}}}
-- Redirect all non-JSON output to stderr
-- Strategy per framework:
-  - jest/vitest: --json flag \u2192 parse JSON
-  - pytest: --tb=no -q \u2192 parse summary line
-  - go test: -json \u2192 aggregate
-  - cargo test: parse "test result:" line
-  - no tests: stub with {"fixtures":{"project":{"has_tests":0}}}
-
-Phase 3: Output Config (turns 26-30)
-- Output structured JSON with verified commands and config
-
-## Edge Cases
-- Build fails \u2192 set build_command: null, note issue, metrics wrapper still works
-- Tests fail \u2192 wrapper still outputs valid JSON with fail counts
-- No tests \u2192 stub wrapper
-- Huge monorepo \u2192 focus on primary workspace
-
-You may ONLY write to .majlis/scripts/. Do NOT modify source code.
-
-## Structured Output Format
-<!-- majlis-json
-{
-  "toolsmith": {
-    "metrics_command": ".majlis/scripts/metrics.sh",
-    "build_command": "npm run build",
-    "test_command": "npm test",
-    "test_framework": "jest",
-    "pre_measure": null,
-    "post_measure": null,
-    "fixtures": {},
-    "tracked": {},
-    "verification_output": "brief summary of what worked",
-    "issues": ["list of issues encountered"]
-  }
-}
--->`,
-      diagnostician: `---
-name: diagnostician
-model: opus
-tools: [Read, Write, Bash, Glob, Grep, WebSearch]
----
-You are the Diagnostician. You perform deep project-wide analysis.
-
-You have the highest turn budget of any agent. Use it for depth, not breadth.
-Your job is pure insight \u2014 you do NOT fix code, you do NOT build, you do NOT
-make decisions. You diagnose.
-
-## What You Receive
-- Full database export: every experiment, decision, doubt, challenge, verification,
-  dead-end, metric, and compression across the entire project history
-- Current synthesis, fragility map, and dead-end registry
-- Full read access to the entire project codebase
-- Bash access to run tests, profiling, git archaeology, and analysis scripts
-
-## What You Can Do
-1. **Read everything** \u2014 source code, docs, git history, test output
-2. **Run analysis** \u2014 execute tests, profilers, git log/blame/bisect, custom scripts
-3. **Write analysis scripts** \u2014 you may write scripts ONLY to \`.majlis/scripts/\`
-4. **Search externally** \u2014 WebSearch for patterns, known issues, relevant techniques
-
-## What You CANNOT Do
-- Modify any project files outside \`.majlis/scripts/\`
-- Make code changes, fixes, or patches
-- Create experiments or make decisions
-- Write to docs/, src/, or any other project directory
-
-## Your Approach
-
-Phase 1: Orientation (turns 1-10)
-- Read the full database export in your context
-- Read synthesis, fragility, dead-ends
-- Identify patterns: recurring failures, unresolved doubts, evidence gaps
-
-Phase 2: Deep Investigation (turns 11-40)
-- Read source code at critical points identified in Phase 1
-- Run targeted tests, profiling, git archaeology
-- Write and execute analysis scripts in .majlis/scripts/
-- Cross-reference findings across experiments
-
-Phase 3: Synthesis (turns 41-60)
-- Compile findings into a diagnostic report
-- Identify root causes, not symptoms
-- Rank issues by structural impact
-- Suggest investigation directions (not fixes)
-
-## Output Format
-Produce a diagnostic report as markdown. At the end, include:
-
-<!-- majlis-json
-{
-  "diagnosis": {
-    "root_causes": ["List of identified root causes"],
-    "patterns": ["Recurring patterns across experiments"],
-    "evidence_gaps": ["What we don't know but should"],
-    "investigation_directions": ["Suggested directions for next experiments"]
-  }
-}
--->
-
-## 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.`
-    };
-    SLASH_COMMANDS = {
-      classify: {
-        description: "Classify a problem domain into canonical sub-types before building",
-        body: `Run \`majlis classify "$ARGUMENTS"\` and follow its output.
-If the CLI is not installed, act as the Builder in classification mode.
-Read docs/synthesis/current.md and docs/synthesis/dead-ends.md for context.
-Enumerate and classify all canonical sub-types of: $ARGUMENTS
-Produce a classification document following docs/classification/_TEMPLATE.md.`
-      },
-      doubt: {
-        description: "Run a constructive doubt pass on an experiment",
-        body: `Run \`majlis doubt $ARGUMENTS\` to spawn the critic agent.
-If the CLI is not installed, act as the Critic directly.
-Doubt the experiment at $ARGUMENTS. Produce a doubt document
-following docs/doubts/_TEMPLATE.md.`
-      },
-      challenge: {
-        description: "Construct adversarial test cases for an experiment",
-        body: `Run \`majlis challenge $ARGUMENTS\` to spawn the adversary agent.
-If the CLI is not installed, act as the Adversary directly.
-Construct pathological inputs designed to break the approach in $ARGUMENTS.
-Produce a challenge document following docs/challenges/_TEMPLATE.md.`
-      },
-      verify: {
-        description: "Verify correctness and provenance of an experiment",
-        body: `Run \`majlis verify $ARGUMENTS\` to spawn the verifier agent.
-If the CLI is not installed, act as the Verifier directly.
-Perform dual verification (provenance + content) on $ARGUMENTS.
-Produce a verification report following docs/verification/_TEMPLATE.md.`
-      },
-      reframe: {
-        description: "Independently reframe a problem from scratch",
-        body: `Run \`majlis reframe $ARGUMENTS\` to spawn the reframer agent.
-If the CLI is not installed, act as the Reframer directly.
-You receive ONLY the problem statement and classification \u2014 NOT builder code.
-Independently decompose $ARGUMENTS and compare with existing classification.`
-      },
-      compress: {
-        description: "Compress project state into dense synthesis",
-        body: `Run \`majlis compress\` to spawn the compressor agent.
-If the CLI is not installed, act as the Compressor directly.
-Read everything. Rewrite docs/synthesis/current.md shorter and denser.
-Update fragility map and dead-end registry.`
-      },
-      scout: {
-        description: "Search externally for alternative approaches",
-        body: `Run \`majlis scout $ARGUMENTS\` to spawn the scout agent.
-If the CLI is not installed, search for alternative approaches to $ARGUMENTS.
-Look for: limitations of current approach, alternative formulations from other fields,
-structurally similar problems in unrelated domains.
-Produce a rihla document at docs/rihla/.`
-      },
-      audit: {
-        description: "Maqasid check \u2014 is the frame right?",
-        body: `Run \`majlis audit "$ARGUMENTS"\` for a purpose audit.
-If the CLI is not installed, review: original objective, current classification,
-recent failures, dead-ends. Ask: is the classification serving the objective?
-Would we decompose differently with what we now know?`
-      },
-      diagnose: {
-        description: "Deep project-wide diagnostic analysis",
-        body: `Run \`majlis diagnose $ARGUMENTS\` for deep diagnosis.
-If the CLI is not installed, perform a deep diagnostic analysis.
-Read docs/synthesis/current.md, fragility.md, dead-ends.md, and all experiments.
-Identify root causes, recurring patterns, evidence gaps, and investigation directions.
-Do NOT modify project code \u2014 analysis only.`
-      },
-      scan: {
-        description: "Scan existing project to auto-detect config and write synthesis",
-        body: `Run \`majlis scan\` to analyze the existing codebase.
-This spawns two agents in parallel:
-- Cartographer: maps architecture \u2192 docs/synthesis/current.md + fragility.md
-- Toolsmith: verifies toolchain \u2192 .majlis/scripts/metrics.sh + config.json
-Use --force to overwrite existing synthesis files.`
-      },
-      resync: {
-        description: "Update stale synthesis after project evolved without Majlis",
-        body: `Run \`majlis resync\` to bring Majlis back up to speed.
-Unlike scan (which starts from zero), resync starts from existing knowledge.
-It assesses staleness, then re-runs cartographer (always) and toolsmith (if needed)
-with the old synthesis and DB history as context.
-Use --check to see the staleness report without making changes.
-Use --force to skip active experiment checks.`
-      }
-    };
-    HOOKS_CONFIG = {
-      hooks: {
-        SessionStart: [
-          {
-            hooks: [
-              {
-                type: "command",
-                command: "majlis status --json 2>/dev/null || true"
-              }
-            ]
-          }
-        ],
-        PreToolUse: [
-          {
-            matcher: "Bash",
-            hooks: [
-              {
-                type: "command",
-                command: "majlis check-commit 2>/dev/null || true",
-                timeout: 10
-              }
-            ]
-          }
-        ],
-        SubagentStop: [
-          {
-            hooks: [
-              {
-                type: "command",
-                command: "echo 'Subagent completed. Run majlis next to continue the cycle.'",
-                timeout: 5
-              }
-            ]
-          }
-        ]
-      }
-    };
-    CLAUDE_MD_SECTION = `
-## Majlis Protocol
-
-This project uses the Majlis Framework for structured multi-agent problem solving.
-See \`docs/workflow.md\` for the full cycle. See \`.claude/agents/\` for role definitions (source of truth in \`.majlis/agents/\`).
-
-### Evidence Hierarchy (tag every decision)
-1. **Proof** \u2014 mathematical proof. Overturn requires error in proof.
-2. **Test** \u2014 empirical test. Overturn requires showing test insufficiency.
-3a. **Strong Consensus** \u2014 convergence across independent approaches.
-3b. **Consensus** \u2014 agreement from same-model experiments.
-4. **Analogy** \u2014 justified by similarity to prior work.
-5. **Judgment** \u2014 independent reasoning without precedent.
-
-### Session Discipline
-- One intent per session. Declare it with \`majlis session start "intent"\`.
-- Stray thoughts \u2192 Telegram (Scribe) or docs/inbox/.
-- Every session ends with \`majlis session end\`.
-
-### Before Building
-- Read \`docs/synthesis/current.md\` for compressed project state.
-- Run \`majlis dead-ends --sub-type <relevant>\` for structural constraints.
-- Run \`majlis decisions --level judgment\` for provisional decisions to challenge.
-
-### Compression Trigger
-- Run \`majlis status\` \u2014 it will warn when compression is due.
-
-### Current State
-Run \`majlis status\` for live experiment state and cycle position.
-`;
-    WORKFLOW_MD = `# Majlis Workflow \u2014 Quick Reference
-
-## The Cycle
-
-\`\`\`
-1. CLASSIFY   \u2192 Taxonomy before solution (Al-Khwarizmi)
-2. REFRAME    \u2192 Independent decomposition (Al-Biruni)
-3. BUILD      \u2192 Write code with tagged decisions (Ijtihad)
-4. CHALLENGE  \u2192 Construct breaking inputs (Ibn al-Haytham)
-5. DOUBT      \u2192 Systematic challenge with evidence (Shukuk)
-6. SCOUT      \u2192 External search for alternatives (Rihla)
-7. VERIFY     \u2192 Provenance + content checks (Isnad + Matn)
-8. RESOLVE    \u2192 Route based on grades
-9. COMPRESS   \u2192 Shorter and denser (Hifz)
-\`\`\`
-
-## Resolution
-- **Sound** \u2192 Merge
-- **Good** \u2192 Merge + add gaps to fragility map
-- **Weak** \u2192 Cycle back with synthesised guidance
-- **Rejected** \u2192 Dead-end with structural constraint
-
-## Circuit Breaker
-3+ weak/rejected on same sub-type \u2192 Maqasid Check (purpose audit)
-
-## Evidence Hierarchy
-1. Proof \u2192 2. Test \u2192 3a. Strong Consensus \u2192 3b. Consensus \u2192 4. Analogy \u2192 5. Judgment
-
-## Commands
-| Action | Command |
-|--------|---------|
-| Initialize | \`majlis init\` |
-| Status | \`majlis status\` |
-| New experiment | \`majlis new "hypothesis"\` |
-| Baseline metrics | \`majlis baseline\` |
-| Measure metrics | \`majlis measure\` |
-| Compare metrics | \`majlis compare\` |
-| Next step | \`majlis next\` |
-| Auto cycle | \`majlis next --auto\` |
-| Autonomous | \`majlis run "goal"\` |
-| Session start | \`majlis session start "intent"\` |
-| Session end | \`majlis session end\` |
-| Compress | \`majlis compress\` |
-| Audit | \`majlis audit "objective"\` |
-`;
-    DOC_TEMPLATES = {
-      "experiments/_TEMPLATE.md": `# Experiment: {{title}}
-
-**Hypothesis:** {{hypothesis}}
-**Branch:** {{branch}}
-**Status:** {{status}}
-**Sub-type:** {{sub_type}}
-**Created:** {{date}}
-
-## Approach
-
-[Describe the approach]
-
-## Decisions
-
-- [evidence_level] Decision description \u2014 justification
-
-## Results
-
-[Describe the results]
-
-## Metrics
-
-| Fixture | Metric | Before | After | Delta |
-|---------|--------|--------|-------|-------|
-| | | | | |
-
-<!-- majlis-json
-{
-  "decisions": [],
-  "grades": []
-}
--->
-`,
-      "decisions/_TEMPLATE.md": `# Decision: {{title}}
-
-**Evidence Level:** {{evidence_level}}
-**Experiment:** {{experiment}}
-**Date:** {{date}}
-
-## Description
-
-[What was decided]
-
-## Justification
-
-[Why this decision was made, referencing evidence]
-
-## Alternatives Considered
-
-[What else was considered and why it was rejected]
-
-<!-- majlis-json
-{
-  "decisions": [
-    { "description": "", "evidence_level": "", "justification": "" }
-  ]
-}
--->
-`,
-      "classification/_TEMPLATE.md": `# Classification: {{domain}}
-
-**Date:** {{date}}
-
-## Problem Domain
-
-[Describe the problem domain]
-
-## Sub-Types
-
-### 1. {{sub_type_1}}
-- **Description:**
-- **Canonical form:**
-- **Known constraints:**
-
-### 2. {{sub_type_2}}
-- **Description:**
-- **Canonical form:**
-- **Known constraints:**
-
-## Relationships
-
-[How sub-types relate to each other]
-`,
-      "doubts/_TEMPLATE.md": `# Doubt Document \u2014 Against Experiment {{experiment}}
-
-**Critic:** {{agent}}
-**Date:** {{date}}
-
-## Doubt 1: {{title}}
-
-**Claim doubted:** {{claim}}
-**Evidence level of claim:** {{evidence_level}}
-**Severity:** {{severity}}
-
-**Evidence for doubt:**
-[Specific evidence \u2014 a prior experiment, inconsistency, untested case, or false analogy]
-
-<!-- majlis-json
-{
-  "doubts": [
-    { "claim_doubted": "", "evidence_level_of_claim": "", "evidence_for_doubt": "", "severity": "critical" }
-  ]
-}
--->
-`,
-      "challenges/_TEMPLATE.md": `# Challenge Document \u2014 Against Experiment {{experiment}}
-
-**Adversary:** {{agent}}
-**Date:** {{date}}
-
-## Challenge 1: {{title}}
-
-**Constructed case:**
-[Specific input or condition designed to break the approach]
-
-**Reasoning:**
-[Why this case should break the approach \u2014 what assumption does it violate?]
-
-## Challenge 2: {{title}}
-
-**Constructed case:**
-[Specific input or condition]
-
-**Reasoning:**
-[Why this should break]
-
-<!-- majlis-json
-{
-  "challenges": [
-    { "description": "", "reasoning": "" }
-  ]
-}
--->
-`,
-      "verification/_TEMPLATE.md": `# Verification Report \u2014 Experiment {{experiment}}
-
-**Verifier:** {{agent}}
-**Date:** {{date}}
-
-## Provenance Check (Isnad)
-
-| Component | Traceable | Chain intact | Notes |
-|-----------|-----------|--------------|-------|
-| | yes/no | yes/no | |
-
-## Content Check (Matn)
-
-| Component | Tests pass | Consistent | Grade | Notes |
-|-----------|-----------|------------|-------|-------|
-| | yes/no | yes/no | sound/good/weak/rejected | |
-
-## Doubt Resolution
-
-| Doubt | Resolution | Evidence |
-|-------|------------|----------|
-| | confirmed/dismissed/inconclusive | |
-
-<!-- majlis-json
-{
-  "grades": [
-    { "component": "", "grade": "sound", "provenance_intact": true, "content_correct": true, "notes": "" }
-  ],
-  "doubt_resolutions": [
-    { "doubt_id": 0, "resolution": "confirmed" }
-  ]
-}
--->
-`,
-      "reframes/_TEMPLATE.md": `# Reframe: {{domain}}
-
-**Reframer:** {{agent}}
-**Date:** {{date}}
-
-## Independent Decomposition
-
-[How this problem should be decomposed \u2014 without seeing the builder's approach]
-
-## Natural Joints
-
-[Where does this problem naturally divide?]
-
-## Cross-Domain Analogies
-
-[What analogies from other domains apply?]
-
-## Comparison with Existing Classification
-
-[Structural divergences from the current classification]
-
-## Divergences (Most Valuable Signals)
-
-[Where the independent decomposition differs from the builder's classification]
-`,
-      "rihla/_TEMPLATE.md": `# Rihla (Scout Report): {{topic}}
-
-**Date:** {{date}}
-
-## Problem (Domain-Neutral)
-
-[Describe the problem in domain-neutral terms]
-
-## Alternative Approaches Found
-
-### 1. {{approach}}
-- **Source:**
-- **Description:**
-- **Applicability:**
-
-## Known Limitations of Current Approach
-
-[What external sources say about where this approach fails]
-
-## Cross-Domain Analogues
-
-[Structurally similar problems in unrelated domains]
-`
-    };
+    import_shared = require("@majlis/shared");
   }
 });
 
 // src/git.ts
 function autoCommit(root, message) {
   try {
-    (0, import_node_child_process2.execSync)("git add docs/ .majlis/scripts/ 2>/dev/null; true", {
-      cwd: root,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
+    try {
+      (0, import_node_child_process2.execFileSync)("git", ["add", "docs/", ".majlis/scripts/"], {
+        cwd: root,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+    }
     const diff = (0, import_node_child_process2.execSync)("git diff --cached --stat", {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
     if (!diff) return;
-    (0, import_node_child_process2.execSync)(`git commit -m ${JSON.stringify(`[majlis] ${message}`)}`, {
+    (0, import_node_child_process2.execFileSync)("git", ["commit", "-m", `[majlis] ${message}`], {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -2986,7 +2063,7 @@ async function upgrade(_args) {
   const claudeAgentsDir = path8.join(root, ".claude", "agents");
   mkdirSafe2(majlisAgentsDir);
   mkdirSafe2(claudeAgentsDir);
-  for (const [name, content] of Object.entries(AGENT_DEFINITIONS)) {
+  for (const [name, content] of Object.entries(import_shared.AGENT_DEFINITIONS)) {
     const majlisPath = path8.join(majlisAgentsDir, `${name}.md`);
     const claudePath = path8.join(claudeAgentsDir, `${name}.md`);
     const existed = fs8.existsSync(majlisPath);
@@ -3006,7 +2083,7 @@ async function upgrade(_args) {
   try {
     for (const file of fs8.readdirSync(majlisAgentsDir)) {
       const name = file.replace(".md", "");
-      if (!AGENT_DEFINITIONS[name]) {
+      if (!import_shared.AGENT_DEFINITIONS[name]) {
         fs8.unlinkSync(path8.join(majlisAgentsDir, file));
         try {
           fs8.unlinkSync(path8.join(claudeAgentsDir, file));
@@ -3020,7 +2097,7 @@ async function upgrade(_args) {
   }
   const commandsDir = path8.join(root, ".claude", "commands");
   mkdirSafe2(commandsDir);
-  for (const [name, cmd] of Object.entries(SLASH_COMMANDS)) {
+  for (const [name, cmd] of Object.entries(import_shared.SLASH_COMMANDS)) {
     const cmdPath = path8.join(commandsDir, `${name}.md`);
     const content = `---
 description: ${cmd.description}
@@ -3044,14 +2121,14 @@ ${cmd.body}
     if (fs8.existsSync(settingsPath)) {
       const existing = JSON.parse(fs8.readFileSync(settingsPath, "utf-8"));
       const before = JSON.stringify(existing.hooks);
-      existing.hooks = { ...existing.hooks, ...HOOKS_CONFIG.hooks };
+      existing.hooks = { ...existing.hooks, ...import_shared.HOOKS_CONFIG.hooks };
       if (JSON.stringify(existing.hooks) !== before) {
         fs8.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
         info("  Updated hooks in .claude/settings.json");
         updated++;
       }
     } else {
-      fs8.writeFileSync(settingsPath, JSON.stringify(HOOKS_CONFIG, null, 2));
+      fs8.writeFileSync(settingsPath, JSON.stringify(import_shared.HOOKS_CONFIG, null, 2));
       info("  Created .claude/settings.json");
       added++;
     }
@@ -3085,7 +2162,7 @@ ${cmd.body}
     if (existing.includes("## Majlis Protocol")) {
       const replaced = existing.replace(
         /## Majlis Protocol[\s\S]*?(?=\n## [^M]|\n## $|$)/,
-        CLAUDE_MD_SECTION.trim()
+        import_shared.CLAUDE_MD_SECTION.trim()
       );
       if (replaced !== existing) {
         fs8.writeFileSync(claudeMdPath, replaced);
@@ -3093,7 +2170,7 @@ ${cmd.body}
         updated++;
       }
     } else {
-      fs8.writeFileSync(claudeMdPath, existing + "\n" + CLAUDE_MD_SECTION);
+      fs8.writeFileSync(claudeMdPath, existing + "\n" + import_shared.CLAUDE_MD_SECTION);
       info("  Appended Majlis Protocol to CLAUDE.md");
       added++;
     }
@@ -3127,12 +2204,13 @@ var init_upgrade = __esm({
 });
 
 // src/db/queries.ts
-function createExperiment(db, slug, branch, hypothesis, subType, classificationRef) {
+function createExperiment(db, slug, branch, hypothesis, subType, classificationRef, dependsOn = null, contextFiles = null) {
   const stmt = db.prepare(`
-    INSERT INTO experiments (slug, branch, hypothesis, sub_type, classification_ref, status)
-    VALUES (?, ?, ?, ?, ?, 'classified')
+    INSERT INTO experiments (slug, branch, hypothesis, sub_type, classification_ref, status, depends_on, context_files)
+    VALUES (?, ?, ?, ?, ?, 'classified', ?, ?)
   `);
-  const result = stmt.run(slug, branch, hypothesis, subType, classificationRef);
+  const contextJson = contextFiles && contextFiles.length > 0 ? JSON.stringify(contextFiles) : null;
+  const result = stmt.run(slug, branch, hypothesis, subType, classificationRef, dependsOn, contextJson);
   return getExperimentById(db, result.lastInsertRowid);
 }
 function getExperimentById(db, id) {
@@ -3641,6 +2719,34 @@ async function status(isJson) {
     console.log(`
   ${yellow(`${judgmentDecisions.length} judgment-level decisions`)} (provisional targets for doubt)`);
   }
+  console.log();
+  header("Project Readiness");
+  const validation = (0, import_shared2.validateProject)({
+    hasGitRepo: fs9.existsSync(path9.join(root, ".git")),
+    hasClaudeMd: fs9.existsSync(path9.join(root, "CLAUDE.md")),
+    metricsCommand: config.metrics.command,
+    metricsCommandRunnable: checkCommandRunnable(config.metrics.command, root),
+    fixtures: config.metrics.fixtures,
+    tracked: config.metrics.tracked,
+    preMeasure: config.build.pre_measure,
+    hasObjective: !!(config.project.objective && config.project.objective.length > 0),
+    hasSynthesis: (() => {
+      const sp = path9.join(root, "docs", "synthesis", "current.md");
+      if (!fs9.existsSync(sp)) return false;
+      const content = fs9.readFileSync(sp, "utf-8");
+      return content.length > 100 && !content.includes("No experiments yet");
+    })()
+  });
+  console.log((0, import_shared2.formatValidation)(validation));
+}
+function checkCommandRunnable(command, cwd) {
+  if (!command || command.includes(`echo '{"fixtures":{}}'`)) return false;
+  try {
+    (0, import_node_child_process3.execSync)(command, { cwd, encoding: "utf-8", timeout: 15e3, stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
 }
 function buildSummary(expCount, activeSession, sessionsSinceCompression, config) {
   const parts = [];
@@ -3651,73 +2757,205 @@ function buildSummary(expCount, activeSession, sessionsSinceCompression, config)
   }
   return parts.join(". ");
 }
+var fs9, path9, import_node_child_process3, import_shared2;
 var init_status = __esm({
   "src/commands/status.ts"() {
     "use strict";
+    fs9 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    import_node_child_process3 = require("child_process");
     init_connection();
     init_queries();
     init_config();
+    import_shared2 = require("@majlis/shared");
     init_format();
   }
 });
 
-// src/metrics.ts
-function compareMetrics(db, experimentId, config) {
-  const before = getMetricsByExperimentAndPhase(db, experimentId, "before");
-  const after = getMetricsByExperimentAndPhase(db, experimentId, "after");
-  const fixtures = new Set([...before, ...after].map((m) => m.fixture));
-  const trackedMetrics = Object.keys(config.metrics.tracked);
-  const comparisons = [];
-  for (const fixture of fixtures) {
-    for (const metric of trackedMetrics) {
-      const b = before.find((m) => m.fixture === fixture && m.metric_name === metric);
-      const a = after.find((m) => m.fixture === fixture && m.metric_name === metric);
-      if (b && a) {
-        const direction = config.metrics.tracked[metric]?.direction ?? "lower_is_better";
-        const regression = isRegression(b.metric_value, a.metric_value, direction);
-        comparisons.push({
-          fixture,
-          metric,
-          before: b.metric_value,
-          after: a.metric_value,
-          delta: a.metric_value - b.metric_value,
-          regression
-        });
-      }
-    }
-  }
-  return comparisons;
-}
-function isRegression(before, after, direction) {
-  switch (direction) {
-    case "lower_is_better":
-      return after > before;
-    case "higher_is_better":
-      return after < before;
-    case "closer_to_gt":
-      return false;
-    default:
-      return false;
-  }
-}
-function parseMetricsOutput(jsonStr) {
-  const data = JSON.parse(jsonStr);
-  const results = [];
-  if (data.fixtures && typeof data.fixtures === "object") {
-    for (const [fixture, metrics] of Object.entries(data.fixtures)) {
-      for (const [metricName, metricValue] of Object.entries(metrics)) {
-        if (typeof metricValue === "number") {
-          results.push({ fixture, metric_name: metricName, metric_value: metricValue });
-        }
-      }
-    }
-  }
-  return results;
+// src/state/types.ts
+function isTerminalStatus(status2) {
+  return TRANSITIONS[status2].length === 0;
 }
-var init_metrics = __esm({
-  "src/metrics.ts"() {
+var TRANSITIONS, GRADE_ORDER, ADMIN_TRANSITIONS;
+var init_types2 = __esm({
+  "src/state/types.ts"() {
     "use strict";
-    init_queries();
+    TRANSITIONS = {
+      ["classified" /* CLASSIFIED */]: ["reframed" /* REFRAMED */, "gated" /* GATED */],
+      ["reframed" /* REFRAMED */]: ["gated" /* GATED */],
+      ["gated" /* GATED */]: ["building" /* BUILDING */, "gated" /* GATED */],
+      // self-loop for rejected hypotheses
+      ["building" /* BUILDING */]: ["built" /* BUILT */, "building" /* BUILDING */],
+      // self-loop for retry after truncation
+      ["built" /* BUILT */]: ["challenged" /* CHALLENGED */, "doubted" /* DOUBTED */],
+      ["challenged" /* CHALLENGED */]: ["doubted" /* DOUBTED */, "verifying" /* VERIFYING */],
+      ["doubted" /* DOUBTED */]: ["challenged" /* CHALLENGED */, "scouted" /* SCOUTED */, "verifying" /* VERIFYING */],
+      ["scouted" /* SCOUTED */]: ["verifying" /* VERIFYING */],
+      ["verifying" /* VERIFYING */]: ["verified" /* VERIFIED */],
+      ["verified" /* VERIFIED */]: ["resolved" /* RESOLVED */],
+      ["resolved" /* RESOLVED */]: ["compressed" /* COMPRESSED */, "building" /* BUILDING */, "merged" /* MERGED */, "dead_end" /* DEAD_END */],
+      ["compressed" /* COMPRESSED */]: ["merged" /* MERGED */, "building" /* BUILDING */],
+      // cycle-back skips gate
+      ["merged" /* MERGED */]: [],
+      ["dead_end" /* DEAD_END */]: []
+    };
+    GRADE_ORDER = ["rejected", "weak", "good", "sound"];
+    ADMIN_TRANSITIONS = {
+      revert: (current, target) => target === "dead_end" /* DEAD_END */ && !isTerminalStatus(current),
+      circuit_breaker: (current, target) => target === "dead_end" /* DEAD_END */ && !isTerminalStatus(current),
+      error_recovery: (current, target) => target === "dead_end" /* DEAD_END */ && !isTerminalStatus(current),
+      bootstrap: (current, target) => current === "classified" /* CLASSIFIED */ && target === "reframed" /* REFRAMED */
+    };
+  }
+});
+
+// src/state/machine.ts
+function transition(current, target) {
+  const valid = TRANSITIONS[current];
+  if (!valid.includes(target)) {
+    throw new Error(
+      `Invalid transition: ${current} \u2192 ${target}. Valid: [${valid.join(", ")}]`
+    );
+  }
+  return target;
+}
+function validNext(current) {
+  return TRANSITIONS[current];
+}
+function isTerminal(status2) {
+  return TRANSITIONS[status2].length === 0;
+}
+function adminTransition(current, target, reason) {
+  const allowed = ADMIN_TRANSITIONS[reason];
+  if (!allowed(current, target)) {
+    throw new Error(
+      `Invalid admin transition (${reason}): ${current} \u2192 ${target}`
+    );
+  }
+  return target;
+}
+function transitionAndPersist(db, experimentId, current, target) {
+  const result = transition(current, target);
+  updateExperimentStatus(db, experimentId, result);
+  return result;
+}
+function adminTransitionAndPersist(db, experimentId, current, target, reason) {
+  const result = adminTransition(current, target, reason);
+  updateExperimentStatus(db, experimentId, result);
+  return result;
+}
+function determineNextStep(exp, valid, hasDoubts2, hasChallenges2) {
+  if (valid.length === 0) {
+    throw new Error(`Experiment ${exp.slug} is terminal (${exp.status})`);
+  }
+  const status2 = exp.status;
+  if (status2 === "classified" /* CLASSIFIED */ || status2 === "reframed" /* REFRAMED */) {
+    return valid.includes("gated" /* GATED */) ? "gated" /* GATED */ : valid[0];
+  }
+  if (status2 === "gated" /* GATED */) {
+    return valid.includes("building" /* BUILDING */) ? "building" /* BUILDING */ : valid[0];
+  }
+  if (status2 === "built" /* BUILT */ && !hasDoubts2) {
+    return valid.includes("doubted" /* DOUBTED */) ? "doubted" /* DOUBTED */ : valid[0];
+  }
+  if (status2 === "doubted" /* DOUBTED */ && !hasChallenges2) {
+    return valid.includes("challenged" /* CHALLENGED */) ? "challenged" /* CHALLENGED */ : valid[0];
+  }
+  if (status2 === "doubted" /* DOUBTED */ || status2 === "challenged" /* CHALLENGED */) {
+    if (valid.includes("verifying" /* VERIFYING */)) {
+      return "verifying" /* VERIFYING */;
+    }
+  }
+  if (status2 === "building" /* BUILDING */) {
+    return valid.includes("built" /* BUILT */) ? "built" /* BUILT */ : valid[0];
+  }
+  if (status2 === "scouted" /* SCOUTED */) {
+    return valid.includes("verifying" /* VERIFYING */) ? "verifying" /* VERIFYING */ : valid[0];
+  }
+  if (status2 === "verified" /* VERIFIED */) {
+    return valid.includes("resolved" /* RESOLVED */) ? "resolved" /* RESOLVED */ : valid[0];
+  }
+  if (status2 === "compressed" /* COMPRESSED */) {
+    return valid.includes("merged" /* MERGED */) ? "merged" /* MERGED */ : valid[0];
+  }
+  return valid[0];
+}
+var init_machine = __esm({
+  "src/state/machine.ts"() {
+    "use strict";
+    init_types2();
+    init_queries();
+  }
+});
+
+// src/metrics.ts
+function isGateFixture(fixtures, fixtureName) {
+  if (Array.isArray(fixtures)) return false;
+  return fixtures[fixtureName]?.gate === true;
+}
+function compareMetrics(db, experimentId, config) {
+  const before = getMetricsByExperimentAndPhase(db, experimentId, "before");
+  const after = getMetricsByExperimentAndPhase(db, experimentId, "after");
+  const fixtures = new Set([...before, ...after].map((m) => m.fixture));
+  const trackedMetrics = Object.keys(config.metrics.tracked);
+  const comparisons = [];
+  for (const fixture of fixtures) {
+    for (const metric of trackedMetrics) {
+      const b = before.find((m) => m.fixture === fixture && m.metric_name === metric);
+      const a = after.find((m) => m.fixture === fixture && m.metric_name === metric);
+      if (b && a) {
+        const tracked = config.metrics.tracked[metric];
+        const direction = tracked?.direction ?? "lower_is_better";
+        const target = tracked?.target;
+        const regression = isRegression(b.metric_value, a.metric_value, direction, target);
+        comparisons.push({
+          fixture,
+          metric,
+          before: b.metric_value,
+          after: a.metric_value,
+          delta: a.metric_value - b.metric_value,
+          regression,
+          gate: isGateFixture(config.metrics.fixtures, fixture)
+        });
+      }
+    }
+  }
+  return comparisons;
+}
+function checkGateViolations(comparisons) {
+  return comparisons.filter((c) => c.gate && c.regression);
+}
+function isRegression(before, after, direction, target) {
+  switch (direction) {
+    case "lower_is_better":
+      return after > before;
+    case "higher_is_better":
+      return after < before;
+    case "closer_to_gt":
+      if (target === void 0) return false;
+      return Math.abs(after - target) > Math.abs(before - target);
+    default:
+      return false;
+  }
+}
+function parseMetricsOutput(jsonStr) {
+  const data = JSON.parse(jsonStr);
+  const results = [];
+  if (data.fixtures && typeof data.fixtures === "object") {
+    for (const [fixture, metrics] of Object.entries(data.fixtures)) {
+      for (const [metricName, metricValue] of Object.entries(metrics)) {
+        if (typeof metricValue === "number") {
+          results.push({ fixture, metric_name: metricName, metric_value: metricValue });
+        }
+      }
+    }
+  }
+  return results;
+}
+var init_metrics = __esm({
+  "src/metrics.ts"() {
+    "use strict";
+    init_queries();
   }
 });
 
@@ -3750,7 +2988,7 @@ async function captureMetrics(phase, args) {
   if (config.build.pre_measure) {
     info(`Running pre-measure: ${config.build.pre_measure}`);
     try {
-      (0, import_node_child_process3.execSync)(config.build.pre_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
+      (0, import_node_child_process4.execSync)(config.build.pre_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
     } catch {
       warn("Pre-measure command failed \u2014 continuing anyway.");
     }
@@ -3761,7 +2999,7 @@ async function captureMetrics(phase, args) {
   info(`Running metrics: ${config.metrics.command}`);
   let metricsOutput;
   try {
-    metricsOutput = (0, import_node_child_process3.execSync)(config.metrics.command, {
+    metricsOutput = (0, import_node_child_process4.execSync)(config.metrics.command, {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3780,7 +3018,7 @@ async function captureMetrics(phase, args) {
   success(`Captured ${parsed.length} metric(s) for ${exp.slug} (phase: ${phase})`);
   if (config.build.post_measure) {
     try {
-      (0, import_node_child_process3.execSync)(config.build.post_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
+      (0, import_node_child_process4.execSync)(config.build.post_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
     } catch {
       warn("Post-measure command failed.");
     }
@@ -3831,11 +3069,11 @@ function formatDelta(delta) {
   const prefix = delta > 0 ? "+" : "";
   return `${prefix}${delta.toFixed(4)}`;
 }
-var import_node_child_process3;
+var import_node_child_process4;
 var init_measure = __esm({
   "src/commands/measure.ts"() {
     "use strict";
-    import_node_child_process3 = require("child_process");
+    import_node_child_process4 = require("child_process");
     init_connection();
     init_queries();
     init_metrics();
@@ -3868,7 +3106,7 @@ async function newExperiment(args) {
   const paddedNum = String(num).padStart(3, "0");
   const branch = `exp/${paddedNum}-${slug}`;
   try {
-    (0, import_node_child_process4.execSync)(`git checkout -b ${branch}`, {
+    (0, import_node_child_process5.execFileSync)("git", ["checkout", "-b", branch], {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3878,15 +3116,28 @@ async function newExperiment(args) {
     warn(`Could not create branch ${branch} \u2014 continuing without git branch.`);
   }
   const subType = getFlagValue(args, "--sub-type") ?? null;
-  const exp = createExperiment(db, slug, branch, hypothesis, subType, null);
+  const dependsOn = getFlagValue(args, "--depends-on") ?? null;
+  const contextArg = getFlagValue(args, "--context") ?? null;
+  const contextFiles = contextArg ? contextArg.split(",").map((f) => f.trim()) : null;
+  if (dependsOn) {
+    const depExp = getExperimentBySlug(db, dependsOn);
+    if (!depExp) {
+      throw new Error(`Dependency experiment not found: ${dependsOn}`);
+    }
+    info(`Depends on: ${dependsOn} (status: ${depExp.status})`);
+  }
+  const exp = createExperiment(db, slug, branch, hypothesis, subType, null, dependsOn, contextFiles);
+  if (contextFiles) {
+    info(`Context files: ${contextFiles.join(", ")}`);
+  }
   success(`Created experiment #${exp.id}: ${exp.slug}`);
-  const docsDir = path9.join(root, "docs", "experiments");
-  const templatePath = path9.join(docsDir, "_TEMPLATE.md");
-  if (fs9.existsSync(templatePath)) {
-    const template = fs9.readFileSync(templatePath, "utf-8");
+  const docsDir = path10.join(root, "docs", "experiments");
+  const templatePath = path10.join(docsDir, "_TEMPLATE.md");
+  if (fs10.existsSync(templatePath)) {
+    const template = fs10.readFileSync(templatePath, "utf-8");
     const logContent = template.replace(/\{\{title\}\}/g, hypothesis).replace(/\{\{hypothesis\}\}/g, hypothesis).replace(/\{\{branch\}\}/g, branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, subType ?? "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    const logPath = path9.join(docsDir, `${paddedNum}-${slug}.md`);
-    fs9.writeFileSync(logPath, logContent);
+    const logPath = path10.join(docsDir, `${paddedNum}-${slug}.md`);
+    fs10.writeFileSync(logPath, logContent);
     info(`Created experiment log: docs/experiments/${paddedNum}-${slug}.md`);
   }
   autoCommit(root, `new: ${slug}`);
@@ -3924,33 +3175,43 @@ async function revert(args) {
     exp.sub_type,
     category
   );
-  updateExperimentStatus(db, exp.id, "dead_end");
+  adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "revert");
   try {
-    const currentBranch = (0, import_node_child_process4.execSync)("git rev-parse --abbrev-ref HEAD", {
+    const currentBranch = (0, import_node_child_process5.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd: root,
       encoding: "utf-8"
     }).trim();
     if (currentBranch === exp.branch) {
-      (0, import_node_child_process4.execSync)("git checkout main 2>/dev/null || git checkout master", {
-        cwd: root,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
+      try {
+        (0, import_node_child_process5.execFileSync)("git", ["checkout", "main"], {
+          cwd: root,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch {
+        (0, import_node_child_process5.execFileSync)("git", ["checkout", "master"], {
+          cwd: root,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      }
     }
   } catch {
     warn("Could not switch git branches \u2014 do this manually.");
   }
   info(`Experiment ${exp.slug} reverted to dead-end. Reason: ${reason}`);
 }
-var fs9, path9, import_node_child_process4;
+var fs10, path10, import_node_child_process5;
 var init_experiment = __esm({
   "src/commands/experiment.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs"));
-    path9 = __toESM(require("path"));
-    import_node_child_process4 = require("child_process");
+    fs10 = __toESM(require("fs"));
+    path10 = __toESM(require("path"));
+    import_node_child_process5 = require("child_process");
     init_connection();
     init_queries();
+    init_machine();
+    init_types2();
     init_config();
     init_spawn();
     init_git();
@@ -4089,12 +3350,12 @@ function queryDeadEnds(db, args, isJson) {
   console.log(table(["ID", "Sub-Type", "Approach", "Constraint"], rows));
 }
 function queryFragility(root, isJson) {
-  const fragPath = path10.join(root, "docs", "synthesis", "fragility.md");
-  if (!fs10.existsSync(fragPath)) {
+  const fragPath = path11.join(root, "docs", "synthesis", "fragility.md");
+  if (!fs11.existsSync(fragPath)) {
     info("No fragility map found.");
     return;
   }
-  const content = fs10.readFileSync(fragPath, "utf-8");
+  const content = fs11.readFileSync(fragPath, "utf-8");
   if (isJson) {
     console.log(JSON.stringify({ content }, null, 2));
     return;
@@ -4150,7 +3411,7 @@ function queryCircuitBreakers(db, root, isJson) {
 function checkCommit(db) {
   let stdinData = "";
   try {
-    stdinData = fs10.readFileSync(0, "utf-8");
+    stdinData = fs11.readFileSync(0, "utf-8");
   } catch {
   }
   if (stdinData) {
@@ -4175,12 +3436,12 @@ function checkCommit(db) {
     process.exit(1);
   }
 }
-var fs10, path10;
+var fs11, path11;
 var init_query = __esm({
   "src/commands/query.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path11 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_config();
@@ -4188,93 +3449,17 @@ var init_query = __esm({
   }
 });
 
-// src/state/types.ts
-var TRANSITIONS, GRADE_ORDER;
-var init_types2 = __esm({
-  "src/state/types.ts"() {
-    "use strict";
-    TRANSITIONS = {
-      ["classified" /* CLASSIFIED */]: ["reframed" /* REFRAMED */, "gated" /* GATED */],
-      ["reframed" /* REFRAMED */]: ["gated" /* GATED */],
-      ["gated" /* GATED */]: ["building" /* BUILDING */, "gated" /* GATED */],
-      // self-loop for rejected hypotheses
-      ["building" /* BUILDING */]: ["built" /* BUILT */, "building" /* BUILDING */],
-      // self-loop for retry after truncation
-      ["built" /* BUILT */]: ["challenged" /* CHALLENGED */, "doubted" /* DOUBTED */],
-      ["challenged" /* CHALLENGED */]: ["doubted" /* DOUBTED */, "verifying" /* VERIFYING */],
-      ["doubted" /* DOUBTED */]: ["challenged" /* CHALLENGED */, "scouted" /* SCOUTED */, "verifying" /* VERIFYING */],
-      ["scouted" /* SCOUTED */]: ["verifying" /* VERIFYING */],
-      ["verifying" /* VERIFYING */]: ["verified" /* VERIFIED */],
-      ["verified" /* VERIFIED */]: ["resolved" /* RESOLVED */],
-      ["resolved" /* RESOLVED */]: ["compressed" /* COMPRESSED */, "building" /* BUILDING */],
-      // cycle-back skips gate
-      ["compressed" /* COMPRESSED */]: ["merged" /* MERGED */, "building" /* BUILDING */],
-      // cycle-back skips gate
-      ["merged" /* MERGED */]: [],
-      ["dead_end" /* DEAD_END */]: []
-    };
-    GRADE_ORDER = ["rejected", "weak", "good", "sound"];
-  }
-});
-
-// src/state/machine.ts
-function transition(current, target) {
-  const valid = TRANSITIONS[current];
-  if (!valid.includes(target)) {
-    throw new Error(
-      `Invalid transition: ${current} \u2192 ${target}. Valid: [${valid.join(", ")}]`
-    );
-  }
-  return target;
-}
-function validNext(current) {
-  return TRANSITIONS[current];
-}
-function isTerminal(status2) {
-  return TRANSITIONS[status2].length === 0;
-}
-function determineNextStep(exp, valid, hasDoubts2, hasChallenges2) {
-  if (valid.length === 0) {
-    throw new Error(`Experiment ${exp.slug} is terminal (${exp.status})`);
-  }
-  const status2 = exp.status;
-  if (status2 === "classified" /* CLASSIFIED */ || status2 === "reframed" /* REFRAMED */) {
-    return valid.includes("gated" /* GATED */) ? "gated" /* GATED */ : valid[0];
-  }
-  if (status2 === "gated" /* GATED */) {
-    return valid.includes("building" /* BUILDING */) ? "building" /* BUILDING */ : valid[0];
-  }
-  if (status2 === "built" /* BUILT */ && !hasDoubts2) {
-    return valid.includes("doubted" /* DOUBTED */) ? "doubted" /* DOUBTED */ : valid[0];
-  }
-  if (status2 === "doubted" /* DOUBTED */ && !hasChallenges2) {
-    return valid.includes("challenged" /* CHALLENGED */) ? "challenged" /* CHALLENGED */ : valid[0];
-  }
-  if (status2 === "doubted" /* DOUBTED */ || status2 === "challenged" /* CHALLENGED */) {
-    if (valid.includes("verifying" /* VERIFYING */)) {
-      return "verifying" /* VERIFYING */;
-    }
-  }
-  if (status2 === "compressed" /* COMPRESSED */) {
-    return valid.includes("merged" /* MERGED */) ? "merged" /* MERGED */ : valid[0];
-  }
-  return valid[0];
-}
-var init_machine = __esm({
-  "src/state/machine.ts"() {
-    "use strict";
-    init_types2();
-  }
-});
-
 // 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;
   }
   return "sound";
 }
-async function resolve(db, exp, projectRoot) {
+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.`);
@@ -4290,9 +3475,33 @@ async function resolve(db, exp, projectRoot) {
     grades = getVerificationsByExperiment(db, exp.id);
   }
   const overallGrade = worstGrade(grades);
+  const config = loadConfig(projectRoot);
+  const metricComparisons = compareMetrics(db, exp.id, config);
+  const gateViolations = checkGateViolations(metricComparisons);
+  if (gateViolations.length > 0 && (overallGrade === "sound" || overallGrade === "good")) {
+    warn("Gate fixture regression detected \u2014 blocking merge:");
+    for (const v of gateViolations) {
+      warn(`  ${v.fixture} / ${v.metric}: ${v.before} \u2192 ${v.after} (${v.delta > 0 ? "+" : ""}${v.delta})`);
+    }
+    updateExperimentStatus(db, exp.id, "resolved");
+    const guidanceText = `Gate fixture regression blocks merge. Fix these regressions before re-attempting:
+` + gateViolations.map((v) => `- ${v.fixture} / ${v.metric}: was ${v.before}, now ${v.after}`).join("\n");
+    transition("resolved" /* RESOLVED */, "building" /* BUILDING */);
+    db.transaction(() => {
+      storeBuilderGuidance(db, exp.id, guidanceText);
+      updateExperimentStatus(db, exp.id, "building");
+      if (exp.sub_type) {
+        incrementSubTypeFailure(db, exp.sub_type, exp.id, "weak");
+      }
+    })();
+    warn(`Experiment ${exp.slug} CYCLING BACK \u2014 gate fixture(s) regressed.`);
+    return;
+  }
+  updateExperimentStatus(db, exp.id, "resolved");
   switch (overallGrade) {
     case "sound": {
       gitMerge(exp.branch, projectRoot);
+      transition("resolved" /* RESOLVED */, "merged" /* MERGED */);
       updateExperimentStatus(db, exp.id, "merged");
       success(`Experiment ${exp.slug} MERGED (all sound).`);
       break;
@@ -4302,6 +3511,7 @@ async function resolve(db, exp, 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;
@@ -4322,6 +3532,7 @@ async function resolve(db, exp, projectRoot) {
         taskPrompt: "Synthesise the verification report, confirmed doubts, and adversarial case results into specific, actionable guidance for the builder's next attempt. Be concrete: which specific decisions need revisiting, which assumptions broke, and what constraints must the next approach satisfy."
       }, projectRoot);
       const guidanceText = guidance.structured?.guidance ?? guidance.output;
+      transition("resolved" /* RESOLVED */, "building" /* BUILDING */);
       db.transaction(() => {
         storeBuilderGuidance(db, exp.id, guidanceText);
         updateExperimentStatus(db, exp.id, "building");
@@ -4336,6 +3547,7 @@ async function resolve(db, exp, projectRoot) {
       gitRevert(exp.branch, projectRoot);
       const rejectedComponents = grades.filter((g) => g.grade === "rejected");
       const whyFailed = rejectedComponents.map((r) => r.notes ?? "rejected").join("; ");
+      transition("resolved" /* RESOLVED */, "dead_end" /* DEAD_END */);
       db.transaction(() => {
         insertDeadEnd(
           db,
@@ -4372,14 +3584,39 @@ async function resolveDbOnly(db, exp, projectRoot) {
     grades = getVerificationsByExperiment(db, exp.id);
   }
   const overallGrade = worstGrade(grades);
+  const config = loadConfig(projectRoot);
+  const metricComparisons = compareMetrics(db, exp.id, config);
+  const gateViolations = checkGateViolations(metricComparisons);
+  if (gateViolations.length > 0 && (overallGrade === "sound" || overallGrade === "good")) {
+    warn("Gate fixture regression detected \u2014 blocking merge:");
+    for (const v of gateViolations) {
+      warn(`  ${v.fixture} / ${v.metric}: ${v.before} \u2192 ${v.after} (${v.delta > 0 ? "+" : ""}${v.delta})`);
+    }
+    updateExperimentStatus(db, exp.id, "resolved");
+    const guidanceText = `Gate fixture regression blocks merge. Fix these regressions before re-attempting:
+` + gateViolations.map((v) => `- ${v.fixture} / ${v.metric}: was ${v.before}, now ${v.after}`).join("\n");
+    transition("resolved" /* RESOLVED */, "building" /* BUILDING */);
+    db.transaction(() => {
+      storeBuilderGuidance(db, exp.id, guidanceText);
+      updateExperimentStatus(db, exp.id, "building");
+      if (exp.sub_type) {
+        incrementSubTypeFailure(db, exp.sub_type, exp.id, "weak");
+      }
+    })();
+    warn(`Experiment ${exp.slug} CYCLING BACK \u2014 gate fixture(s) regressed.`);
+    return "weak";
+  }
+  updateExperimentStatus(db, exp.id, "resolved");
   switch (overallGrade) {
     case "sound":
+      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;
@@ -4400,6 +3637,7 @@ async function resolveDbOnly(db, exp, projectRoot) {
         taskPrompt: "Synthesise the verification report, confirmed doubts, and adversarial case results into specific, actionable guidance for the builder's next attempt. Be concrete: which specific decisions need revisiting, which assumptions broke, and what constraints must the next approach satisfy."
       }, projectRoot);
       const guidanceText = guidance.structured?.guidance ?? guidance.output;
+      transition("resolved" /* RESOLVED */, "building" /* BUILDING */);
       db.transaction(() => {
         storeBuilderGuidance(db, exp.id, guidanceText);
         updateExperimentStatus(db, exp.id, "building");
@@ -4413,6 +3651,7 @@ async function resolveDbOnly(db, exp, projectRoot) {
     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,
@@ -4436,12 +3675,20 @@ async function resolveDbOnly(db, exp, projectRoot) {
 }
 function gitMerge(branch, cwd) {
   try {
-    (0, import_node_child_process5.execSync)("git checkout main 2>/dev/null || git checkout master", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    (0, import_node_child_process5.execSync)(`git merge ${branch} --no-ff -m "Merge experiment branch ${branch}"`, {
+    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"]
@@ -4452,47 +3699,58 @@ function gitMerge(branch, cwd) {
 }
 function gitRevert(branch, cwd) {
   try {
-    const currentBranch = (0, import_node_child_process5.execSync)("git rev-parse --abbrev-ref HEAD", {
+    const currentBranch = (0, import_node_child_process6.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd,
       encoding: "utf-8"
     }).trim();
     if (currentBranch === branch) {
       try {
-        (0, import_node_child_process5.execSync)("git checkout -- .", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        (0, import_node_child_process6.execFileSync)("git", ["checkout", "--", "."], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
       } catch {
       }
-      (0, import_node_child_process5.execSync)("git checkout main 2>/dev/null || git checkout master", {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      });
+      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"]
+        });
+      }
     }
   } catch {
     console.warn(`[majlis] Could not switch away from ${branch} \u2014 you may need to do this manually.`);
   }
 }
 function appendToFragilityMap(projectRoot, expSlug, gaps) {
-  const fragPath = path11.join(projectRoot, "docs", "synthesis", "fragility.md");
+  const fragPath = path12.join(projectRoot, "docs", "synthesis", "fragility.md");
   let content = "";
-  if (fs11.existsSync(fragPath)) {
-    content = fs11.readFileSync(fragPath, "utf-8");
+  if (fs12.existsSync(fragPath)) {
+    content = fs12.readFileSync(fragPath, "utf-8");
   }
   const entry = `
 ## From experiment: ${expSlug}
 ${gaps}
 `;
-  fs11.writeFileSync(fragPath, content + entry);
+  fs12.writeFileSync(fragPath, content + entry);
 }
-var fs11, path11, import_node_child_process5;
+var fs12, path12, import_node_child_process6;
 var init_resolve = __esm({
   "src/resolve.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
+    fs12 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
     init_types2();
+    init_machine();
     init_queries();
+    init_metrics();
+    init_config();
     init_spawn();
-    import_node_child_process5 = require("child_process");
+    import_node_child_process6 = require("child_process");
     init_git();
     init_format();
   }
@@ -4534,7 +3792,7 @@ async function resolveCmd(args) {
   const db = getDb(root);
   const exp = resolveExperimentArg(db, args);
   transition(exp.status, "resolved" /* RESOLVED */);
-  await resolve(db, exp, root);
+  await resolve2(db, exp, root);
 }
 async function runStep(step, db, exp, root) {
   switch (step) {
@@ -4556,12 +3814,12 @@ async function runStep(step, db, exp, root) {
 }
 async function runResolve(db, exp, root) {
   transition(exp.status, "resolved" /* RESOLVED */);
-  await resolve(db, exp, root);
+  await resolve2(db, exp, root);
 }
 async function doGate(db, exp, root) {
   transition(exp.status, "gated" /* GATED */);
-  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
-  const fragility = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
   const structuralDeadEnds = exp.sub_type ? listStructuralDeadEndsBySubType(db, exp.sub_type) : listStructuralDeadEnds(db);
   const result = await spawnAgent("gatekeeper", {
     experiment: {
@@ -4604,17 +3862,25 @@ Output your gate_decision as "approve", "reject", or "flag" with reasoning.`
   }
 }
 async function doBuild(db, exp, root) {
+  if (exp.depends_on) {
+    const dep = getExperimentBySlug(db, exp.depends_on);
+    if (!dep || dep.status !== "merged") {
+      throw new Error(
+        `Experiment "${exp.slug}" depends on "${exp.depends_on}" which is ${dep ? dep.status : "not found"}. Dependency must be merged before building.`
+      );
+    }
+  }
   transition(exp.status, "building" /* BUILDING */);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
   const builderGuidance = getBuilderGuidance(db, exp.id);
-  const fragility = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
-  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
   const confirmedDoubts = getConfirmedDoubts(db, exp.id);
   const config = loadConfig(root);
   const existingBaseline = getMetricsByExperimentAndPhase(db, exp.id, "before");
   if (config.metrics?.command && existingBaseline.length === 0) {
     try {
-      const output = (0, import_node_child_process6.execSync)(config.metrics.command, {
+      const output = (0, import_node_child_process7.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -4642,6 +3908,7 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
     }
   }
   taskPrompt += "\n\nNote: The framework captures metrics automatically. Do NOT claim specific numbers unless quoting framework output.";
+  const supplementaryContext = loadExperimentContext(exp, root);
   const result = await spawnAgent("builder", {
     experiment: {
       id: exp.id,
@@ -4659,6 +3926,7 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
     fragility,
     synthesis,
     confirmedDoubts,
+    supplementaryContext: supplementaryContext || void 0,
     taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
@@ -4671,7 +3939,7 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
   } else {
     if (config.metrics?.command) {
       try {
-        const output = (0, import_node_child_process6.execSync)(config.metrics.command, {
+        const output = (0, import_node_child_process7.execSync)(config.metrics.command, {
           cwd: root,
           encoding: "utf-8",
           timeout: 6e4,
@@ -4695,7 +3963,7 @@ async function doChallenge(db, exp, root) {
   transition(exp.status, "challenged" /* CHALLENGED */);
   let gitDiff = "";
   try {
-    gitDiff = (0, import_node_child_process6.execSync)('git diff main -- . ":!.majlis/"', {
+    gitDiff = (0, import_node_child_process7.execSync)('git diff main -- . ":!.majlis/"', {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4703,7 +3971,7 @@ async function doChallenge(db, exp, root) {
   } catch {
   }
   if (gitDiff.length > 8e3) gitDiff = gitDiff.slice(0, 8e3) + "\n[DIFF TRUNCATED]";
-  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const synthesis = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
   let taskPrompt = `Construct adversarial test cases for experiment ${exp.slug}: ${exp.hypothesis}`;
   if (gitDiff) {
     taskPrompt += `
@@ -4736,9 +4004,9 @@ ${gitDiff}
 async function doDoubt(db, exp, root) {
   transition(exp.status, "doubted" /* DOUBTED */);
   const paddedNum = String(exp.id).padStart(3, "0");
-  const expDocPath = path12.join(root, "docs", "experiments", `${paddedNum}-${exp.slug}.md`);
+  const expDocPath = path13.join(root, "docs", "experiments", `${paddedNum}-${exp.slug}.md`);
   const experimentDoc = truncateContext(readFileOrEmpty(expDocPath), CONTEXT_LIMITS.experimentDoc);
-  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const synthesis = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
   let taskPrompt = `Doubt the work in experiment ${exp.slug}: ${exp.hypothesis}. Produce a doubt document with evidence for each doubt.`;
   if (experimentDoc) {
@@ -4777,8 +4045,8 @@ ${experimentDoc}
 }
 async function doScout(db, exp, root) {
   transition(exp.status, "scouted" /* SCOUTED */);
-  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
-  const fragility = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path13.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
   const deadEndsSummary = deadEnds.map(
     (d) => `- [${d.category ?? "structural"}] ${d.approach}: ${d.why_failed}`
@@ -4825,31 +4093,49 @@ ${fragility}`;
 async function doVerify(db, exp, root) {
   transition(exp.status, "verifying" /* VERIFYING */);
   const doubts = getDoubtsByExperiment(db, exp.id);
-  const challengeDir = path12.join(root, "docs", "challenges");
+  const challengeDir = path13.join(root, "docs", "challenges");
   let challenges = "";
-  if (fs12.existsSync(challengeDir)) {
-    const files = fs12.readdirSync(challengeDir).filter((f) => f.includes(exp.slug) && f.endsWith(".md"));
+  if (fs13.existsSync(challengeDir)) {
+    const files = fs13.readdirSync(challengeDir).filter((f) => f.includes(exp.slug) && f.endsWith(".md"));
     for (const f of files) {
-      challenges += fs12.readFileSync(path12.join(challengeDir, f), "utf-8") + "\n\n";
+      challenges += fs13.readFileSync(path13.join(challengeDir, f), "utf-8") + "\n\n";
     }
   }
-  const beforeMetrics = getMetricsByExperimentAndPhase(db, exp.id, "before");
-  const afterMetrics = getMetricsByExperimentAndPhase(db, exp.id, "after");
+  const config = loadConfig(root);
+  const metricComparisons = compareMetrics(db, exp.id, config);
   let metricsSection = "";
-  if (beforeMetrics.length > 0 || afterMetrics.length > 0) {
+  if (metricComparisons.length > 0) {
     metricsSection = "\n\n## Framework-Captured Metrics (GROUND TRUTH \u2014 not self-reported by builder)\n";
-    if (beforeMetrics.length > 0) {
-      metricsSection += "### Before Build\n";
-      for (const m of beforeMetrics) {
-        metricsSection += `- ${m.fixture} / ${m.metric_name}: ${m.metric_value}
+    metricsSection += "| Fixture | Metric | Before | After | Delta | Regression | Gate |\n";
+    metricsSection += "|---------|--------|--------|-------|-------|------------|------|\n";
+    for (const c of metricComparisons) {
+      metricsSection += `| ${c.fixture} | ${c.metric} | ${c.before} | ${c.after} | ${c.delta > 0 ? "+" : ""}${c.delta} | ${c.regression ? "YES" : "no"} | ${c.gate ? "GATE" : "-"} |
 `;
-      }
     }
-    if (afterMetrics.length > 0) {
-      metricsSection += "### After Build\n";
-      for (const m of afterMetrics) {
-        metricsSection += `- ${m.fixture} / ${m.metric_name}: ${m.metric_value}
+    const gateViolations = metricComparisons.filter((c) => c.gate && c.regression);
+    if (gateViolations.length > 0) {
+      metricsSection += `
+**GATE VIOLATION**: ${gateViolations.length} gate fixture(s) regressed. This MUST be addressed \u2014 gate regressions block merge.
 `;
+    }
+  } else {
+    const beforeMetrics = getMetricsByExperimentAndPhase(db, exp.id, "before");
+    const afterMetrics = getMetricsByExperimentAndPhase(db, exp.id, "after");
+    if (beforeMetrics.length > 0 || afterMetrics.length > 0) {
+      metricsSection = "\n\n## Framework-Captured Metrics (GROUND TRUTH \u2014 not self-reported by builder)\n";
+      if (beforeMetrics.length > 0) {
+        metricsSection += "### Before Build\n";
+        for (const m of beforeMetrics) {
+          metricsSection += `- ${m.fixture} / ${m.metric_name}: ${m.metric_value}
+`;
+        }
+      }
+      if (afterMetrics.length > 0) {
+        metricsSection += "### After Build\n";
+        for (const m of afterMetrics) {
+          metricsSection += `- ${m.fixture} / ${m.metric_name}: ${m.metric_value}
+`;
+        }
       }
     }
   }
@@ -4863,6 +4149,7 @@ async function doVerify(db, exp, root) {
     doubtReference += "\nWhen resolving doubts, use the DOUBT-{id} number as the doubt_id value in your doubt_resolutions output.";
   }
   updateExperimentStatus(db, exp.id, "verifying");
+  const verifierSupplementaryContext = loadExperimentContext(exp, root);
   const result = await spawnAgent("verifier", {
     experiment: {
       id: exp.id,
@@ -4874,6 +4161,8 @@ async function doVerify(db, exp, root) {
     },
     doubts,
     challenges,
+    metricComparisons: metricComparisons.length > 0 ? metricComparisons : void 0,
+    supplementaryContext: verifierSupplementaryContext || void 0,
     taskPrompt: `Verify experiment ${exp.slug}: ${exp.hypothesis}. Check provenance and content. Test the ${doubts.length} doubt(s) and any adversarial challenges.` + metricsSection + doubtReference
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
@@ -4898,22 +4187,22 @@ async function doVerify(db, exp, root) {
   success(`Verification complete for ${exp.slug}. Run \`majlis resolve\` next.`);
 }
 async function doCompress(db, root) {
-  const synthesisPath = path12.join(root, "docs", "synthesis", "current.md");
-  const sizeBefore = fs12.existsSync(synthesisPath) ? fs12.statSync(synthesisPath).size : 0;
+  const synthesisPath = path13.join(root, "docs", "synthesis", "current.md");
+  const sizeBefore = fs13.existsSync(synthesisPath) ? fs13.statSync(synthesisPath).size : 0;
   const sessionCount = getSessionsSinceCompression(db);
   const dbExport = exportForCompressor(db);
   const result = await spawnAgent("compressor", {
     taskPrompt: "## Structured Data (CANONICAL \u2014 from SQLite database)\nThe database export below is the source of truth. docs/ files are agent artifacts that may contain stale or incorrect information. Cross-reference everything against this data.\n\n" + dbExport + "\n\n## Your Task\nRead ALL experiments, decisions, doubts, challenges, verification reports, reframes, and recent diffs. Cross-reference for contradictions, redundancies, and patterns. REWRITE docs/synthesis/current.md \u2014 shorter and denser. Update docs/synthesis/fragility.md with current weak areas. Update docs/synthesis/dead-ends.md with structural constraints from rejected experiments."
   }, root);
-  const sizeAfter = fs12.existsSync(synthesisPath) ? fs12.statSync(synthesisPath).size : 0;
+  const sizeAfter = fs13.existsSync(synthesisPath) ? fs13.statSync(synthesisPath).size : 0;
   recordCompression(db, sessionCount, sizeBefore, sizeAfter);
   autoCommit(root, "compress: update synthesis");
   success(`Compression complete. Synthesis: ${sizeBefore}B \u2192 ${sizeAfter}B`);
 }
 function gitCommitBuild(exp, cwd) {
   try {
-    (0, import_node_child_process6.execSync)('git add -A -- ":!.majlis/"', { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-    const diff = (0, import_node_child_process6.execSync)("git diff --cached --stat", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    (0, import_node_child_process7.execSync)('git add -A -- ":!.majlis/"', { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const diff = (0, import_node_child_process7.execSync)("git diff --cached --stat", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     if (!diff) {
       info("No code changes to commit.");
       return;
@@ -4921,12 +4210,37 @@ function gitCommitBuild(exp, cwd) {
     const msg = `EXP-${String(exp.id).padStart(3, "0")}: ${exp.slug}
 
 ${exp.hypothesis ?? ""}`;
-    (0, import_node_child_process6.execSync)(`git commit -m ${JSON.stringify(msg)}`, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    (0, import_node_child_process7.execFileSync)("git", ["commit", "-m", msg], { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
     info(`Committed builder changes on ${exp.branch}.`);
   } catch {
     warn("Could not auto-commit builder changes \u2014 commit manually before resolving.");
   }
 }
+function loadExperimentContext(exp, root) {
+  if (!exp.context_files) return "";
+  let files;
+  try {
+    files = JSON.parse(exp.context_files);
+  } catch {
+    return "";
+  }
+  if (!Array.isArray(files) || files.length === 0) return "";
+  const sections = ["## Experiment-Scoped Reference Material"];
+  for (const relPath of files) {
+    const absPath = path13.join(root, relPath);
+    try {
+      const content = fs13.readFileSync(absPath, "utf-8");
+      sections.push(`### ${relPath}
+\`\`\`
+${content.slice(0, 8e3)}
+\`\`\``);
+    } catch {
+      sections.push(`### ${relPath}
+*(file not found)*`);
+    }
+  }
+  return sections.join("\n\n");
+}
 function resolveExperimentArg(db, args) {
   const slugArg = args.filter((a) => !a.startsWith("--"))[0];
   let exp;
@@ -4941,69 +4255,71 @@ function resolveExperimentArg(db, args) {
 }
 function ingestStructuredOutput(db, experimentId, structured) {
   if (!structured) return;
-  if (structured.decisions) {
-    for (const d of structured.decisions) {
-      insertDecision(db, experimentId, d.description, d.evidence_level, d.justification);
+  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)`);
     }
-    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
-      );
+    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)`);
     }
-    info(`Ingested ${structured.grades.length} verification grade(s)`);
-  }
-  if (structured.doubts) {
-    for (const d of structured.doubts) {
-      insertDoubt(
+    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,
-        d.claim_doubted,
-        d.evidence_level_of_claim,
-        d.evidence_for_doubt,
-        d.severity
+        structured.reframe.decomposition,
+        JSON.stringify(structured.reframe.divergences),
+        structured.reframe.recommendation
       );
+      info(`Ingested reframe`);
     }
-    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);
+    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)`);
     }
-    info(`Ingested ${structured.findings.length} finding(s)`);
-  }
+  })();
 }
-var fs12, path12, import_node_child_process6;
+var fs13, path13, import_node_child_process7;
 var init_cycle = __esm({
   "src/commands/cycle.ts"() {
     "use strict";
-    fs12 = __toESM(require("fs"));
-    path12 = __toESM(require("path"));
-    import_node_child_process6 = require("child_process");
+    fs13 = __toESM(require("fs"));
+    path13 = __toESM(require("path"));
+    import_node_child_process7 = require("child_process");
     init_connection();
     init_queries();
     init_machine();
@@ -5030,10 +4346,10 @@ async function classify(args) {
   if (!domain) {
     throw new Error('Usage: majlis classify "domain description"');
   }
-  const synthesisPath = path13.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs13.existsSync(synthesisPath) ? fs13.readFileSync(synthesisPath, "utf-8") : "";
-  const deadEndsPath = path13.join(root, "docs", "synthesis", "dead-ends.md");
-  const deadEnds = fs13.existsSync(deadEndsPath) ? fs13.readFileSync(deadEndsPath, "utf-8") : "";
+  const synthesisPath = path14.join(root, "docs", "synthesis", "current.md");
+  const synthesis = fs14.existsSync(synthesisPath) ? fs14.readFileSync(synthesisPath, "utf-8") : "";
+  const deadEndsPath = path14.join(root, "docs", "synthesis", "dead-ends.md");
+  const deadEnds = fs14.existsSync(deadEndsPath) ? fs14.readFileSync(deadEndsPath, "utf-8") : "";
   info(`Classifying problem domain: ${domain}`);
   const result = await spawnAgent("builder", {
     synthesis,
@@ -5052,22 +4368,22 @@ Write the classification to docs/classification/ following the template.`
 async function reframe(args) {
   const root = findProjectRoot();
   if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const classificationDir = path13.join(root, "docs", "classification");
+  const classificationDir = path14.join(root, "docs", "classification");
   let classificationContent = "";
-  if (fs13.existsSync(classificationDir)) {
-    const files = fs13.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+  if (fs14.existsSync(classificationDir)) {
+    const files = fs14.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
     for (const f of files) {
-      classificationContent += fs13.readFileSync(path13.join(classificationDir, f), "utf-8") + "\n\n";
+      classificationContent += fs14.readFileSync(path14.join(classificationDir, f), "utf-8") + "\n\n";
     }
   }
-  const synthesisPath = path13.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs13.existsSync(synthesisPath) ? fs13.readFileSync(synthesisPath, "utf-8") : "";
-  const deadEndsPath = path13.join(root, "docs", "synthesis", "dead-ends.md");
-  const deadEnds = fs13.existsSync(deadEndsPath) ? fs13.readFileSync(deadEndsPath, "utf-8") : "";
-  const configPath = path13.join(root, ".majlis", "config.json");
+  const synthesisPath = path14.join(root, "docs", "synthesis", "current.md");
+  const synthesis = fs14.existsSync(synthesisPath) ? fs14.readFileSync(synthesisPath, "utf-8") : "";
+  const deadEndsPath = path14.join(root, "docs", "synthesis", "dead-ends.md");
+  const deadEnds = fs14.existsSync(deadEndsPath) ? fs14.readFileSync(deadEndsPath, "utf-8") : "";
+  const configPath = path14.join(root, ".majlis", "config.json");
   let problemStatement = "";
-  if (fs13.existsSync(configPath)) {
-    const config = JSON.parse(fs13.readFileSync(configPath, "utf-8"));
+  if (fs14.existsSync(configPath)) {
+    const config = JSON.parse(fs14.readFileSync(configPath, "utf-8"));
     problemStatement = `${config.project?.description ?? ""}
 Objective: ${config.project?.objective ?? ""}`;
   }
@@ -5092,12 +4408,12 @@ Write to docs/reframes/.`
   autoCommit(root, `reframe: ${target.slice(0, 60)}`);
   success("Reframe complete. Check docs/reframes/ for the output.");
 }
-var fs13, path13;
+var fs14, path14;
 var init_classify = __esm({
   "src/commands/classify.ts"() {
     "use strict";
-    fs13 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
+    fs14 = __toESM(require("fs"));
+    path14 = __toESM(require("path"));
     init_connection();
     init_spawn();
     init_git();
@@ -5119,15 +4435,15 @@ async function audit(args) {
   const experiments = listAllExperiments(db);
   const deadEnds = listAllDeadEnds(db);
   const circuitBreakers = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
-  const classificationDir = path14.join(root, "docs", "classification");
+  const classificationDir = path15.join(root, "docs", "classification");
   let classification = "";
-  if (fs14.existsSync(classificationDir)) {
-    const files = fs14.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+  if (fs15.existsSync(classificationDir)) {
+    const files = fs15.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
     for (const f of files) {
-      classification += fs14.readFileSync(path14.join(classificationDir, f), "utf-8") + "\n\n";
+      classification += fs15.readFileSync(path15.join(classificationDir, f), "utf-8") + "\n\n";
     }
   }
-  const synthesis = readFileOrEmpty(path14.join(root, "docs", "synthesis", "current.md"));
+  const synthesis = readFileOrEmpty(path15.join(root, "docs", "synthesis", "current.md"));
   header("Maqasid Check \u2014 Purpose Audit");
   const trippedBreakers = circuitBreakers.filter((cb) => cb.tripped);
   if (trippedBreakers.length > 0) {
@@ -5171,12 +4487,12 @@ Output: either "classification confirmed \u2014 continue" or "re-classify from X
   }, root);
   success("Purpose audit complete. Review the output above.");
 }
-var fs14, path14;
+var fs15, path15;
 var init_audit = __esm({
   "src/commands/audit.ts"() {
     "use strict";
-    fs14 = __toESM(require("fs"));
-    path14 = __toESM(require("path"));
+    fs15 = __toESM(require("fs"));
+    path15 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_spawn();
@@ -5235,7 +4551,7 @@ async function runNextStep(db, exp, config, root, isJson) {
       exp.sub_type,
       "procedural"
     );
-    updateExperimentStatus(db, exp.id, "dead_end");
+    adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "circuit_breaker");
     warn("Experiment dead-ended. Triggering Maqasid Check (purpose audit).");
     await audit([config.project?.objective ?? ""]);
     return;
@@ -5285,7 +4601,7 @@ async function runAutoLoop(db, exp, config, root, isJson) {
         exp.sub_type,
         "procedural"
       );
-      updateExperimentStatus(db, exp.id, "dead_end");
+      adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "circuit_breaker");
       await audit([config.project?.objective ?? ""]);
       break;
     }
@@ -5324,18 +4640,24 @@ async function executeStep(step, exp, root) {
       break;
     case "compressed" /* COMPRESSED */:
       await cycle("compress", []);
-      updateExperimentStatus(getDb(root), exp.id, "compressed");
+      transitionAndPersist(getDb(root), exp.id, exp.status, "compressed" /* COMPRESSED */);
       info(`Experiment ${exp.slug} compressed.`);
       break;
     case "gated" /* GATED */:
       await cycle("gate", expArgs);
       break;
-    case "reframed" /* REFRAMED */:
-      updateExperimentStatus(getDb(root), exp.id, "reframed");
+    case "reframed" /* REFRAMED */: {
+      const currentStatus = exp.status;
+      if (currentStatus === "classified" /* CLASSIFIED */) {
+        adminTransitionAndPersist(getDb(root), exp.id, currentStatus, "reframed" /* REFRAMED */, "bootstrap");
+      } else {
+        transitionAndPersist(getDb(root), exp.id, currentStatus, "reframed" /* REFRAMED */);
+      }
       info(`Reframe acknowledged for ${exp.slug}. Proceeding to gate.`);
       break;
+    }
     case "merged" /* MERGED */:
-      updateExperimentStatus(getDb(root), exp.id, "merged");
+      transitionAndPersist(getDb(root), exp.id, exp.status, "merged" /* MERGED */);
       success(`Experiment ${exp.slug} merged.`);
       break;
     case "dead_end" /* DEAD_END */:
@@ -5441,7 +4763,7 @@ async function run(args) {
           exp.sub_type,
           "procedural"
         );
-        updateExperimentStatus(db, exp.id, "dead_end");
+        adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "error_recovery");
       } catch (innerErr) {
         const innerMsg = innerErr instanceof Error ? innerErr.message : String(innerErr);
         warn(`Could not record dead-end: ${innerMsg}`);
@@ -5461,16 +4783,16 @@ async function run(args) {
   info("Run `majlis status` to see final state.");
 }
 async function deriveNextHypothesis(goal, root, db) {
-  const synthesis = truncateContext(readFileOrEmpty(path15.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
-  const fragility = truncateContext(readFileOrEmpty(path15.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
-  const deadEndsDoc = truncateContext(readFileOrEmpty(path15.join(root, "docs", "synthesis", "dead-ends.md")), CONTEXT_LIMITS.deadEnds);
+  const synthesis = truncateContext(readFileOrEmpty(path16.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path16.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const deadEndsDoc = truncateContext(readFileOrEmpty(path16.join(root, "docs", "synthesis", "dead-ends.md")), CONTEXT_LIMITS.deadEnds);
   const diagnosis = truncateContext(readLatestDiagnosis(root), CONTEXT_LIMITS.synthesis);
   const deadEnds = listAllDeadEnds(db);
   const config = loadConfig(root);
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
-      metricsOutput = (0, import_node_child_process7.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process8.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -5569,7 +4891,7 @@ async function createNewExperiment(db, root, hypothesis) {
   const paddedNum = String(num).padStart(3, "0");
   const branch = `exp/${paddedNum}-${finalSlug}`;
   try {
-    (0, import_node_child_process7.execSync)(`git checkout -b ${branch}`, {
+    (0, import_node_child_process8.execFileSync)("git", ["checkout", "-b", branch], {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -5579,29 +4901,30 @@ async function createNewExperiment(db, root, hypothesis) {
     warn(`Could not create branch ${branch} \u2014 continuing without git branch.`);
   }
   const exp = createExperiment(db, finalSlug, branch, hypothesis, null, null);
-  updateExperimentStatus(db, exp.id, "reframed");
+  adminTransitionAndPersist(db, exp.id, exp.status, "reframed" /* REFRAMED */, "bootstrap");
   exp.status = "reframed";
-  const docsDir = path15.join(root, "docs", "experiments");
-  const templatePath = path15.join(docsDir, "_TEMPLATE.md");
-  if (fs15.existsSync(templatePath)) {
-    const template = fs15.readFileSync(templatePath, "utf-8");
+  const docsDir = path16.join(root, "docs", "experiments");
+  const templatePath = path16.join(docsDir, "_TEMPLATE.md");
+  if (fs16.existsSync(templatePath)) {
+    const template = fs16.readFileSync(templatePath, "utf-8");
     const logContent = template.replace(/\{\{title\}\}/g, hypothesis).replace(/\{\{hypothesis\}\}/g, hypothesis).replace(/\{\{branch\}\}/g, branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    const logPath = path15.join(docsDir, `${paddedNum}-${finalSlug}.md`);
-    fs15.writeFileSync(logPath, logContent);
+    const logPath = path16.join(docsDir, `${paddedNum}-${finalSlug}.md`);
+    fs16.writeFileSync(logPath, logContent);
     info(`Created experiment log: docs/experiments/${paddedNum}-${finalSlug}.md`);
   }
   return exp;
 }
-var fs15, path15, import_node_child_process7;
+var fs16, path16, import_node_child_process8;
 var init_run = __esm({
   "src/commands/run.ts"() {
     "use strict";
-    fs15 = __toESM(require("fs"));
-    path15 = __toESM(require("path"));
-    import_node_child_process7 = require("child_process");
+    fs16 = __toESM(require("fs"));
+    path16 = __toESM(require("path"));
+    import_node_child_process8 = require("child_process");
     init_connection();
     init_queries();
     init_machine();
+    init_types2();
     init_next();
     init_cycle();
     init_spawn();
@@ -5614,11 +4937,11 @@ var init_run = __esm({
 
 // src/swarm/worktree.ts
 function createWorktree(mainRoot, slug, paddedNum) {
-  const projectName = path16.basename(mainRoot);
+  const projectName = path17.basename(mainRoot);
   const worktreeName = `${projectName}-swarm-${paddedNum}-${slug}`;
-  const worktreePath = path16.join(path16.dirname(mainRoot), worktreeName);
+  const worktreePath = path17.join(path17.dirname(mainRoot), worktreeName);
   const branch = `swarm/${paddedNum}-${slug}`;
-  (0, import_node_child_process8.execSync)(`git worktree add ${JSON.stringify(worktreePath)} -b ${branch}`, {
+  (0, import_node_child_process9.execFileSync)("git", ["worktree", "add", worktreePath, "-b", branch], {
     cwd: mainRoot,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -5633,43 +4956,43 @@ function createWorktree(mainRoot, slug, paddedNum) {
   };
 }
 function initializeWorktree(mainRoot, worktreePath) {
-  const majlisDir = path16.join(worktreePath, ".majlis");
-  fs16.mkdirSync(majlisDir, { recursive: true });
-  const configSrc = path16.join(mainRoot, ".majlis", "config.json");
-  if (fs16.existsSync(configSrc)) {
-    fs16.copyFileSync(configSrc, path16.join(majlisDir, "config.json"));
-  }
-  const agentsSrc = path16.join(mainRoot, ".majlis", "agents");
-  if (fs16.existsSync(agentsSrc)) {
-    const agentsDst = path16.join(majlisDir, "agents");
-    fs16.mkdirSync(agentsDst, { recursive: true });
-    for (const file of fs16.readdirSync(agentsSrc)) {
-      fs16.copyFileSync(path16.join(agentsSrc, file), path16.join(agentsDst, file));
-    }
-  }
-  const synthSrc = path16.join(mainRoot, "docs", "synthesis");
-  if (fs16.existsSync(synthSrc)) {
-    const synthDst = path16.join(worktreePath, "docs", "synthesis");
-    fs16.mkdirSync(synthDst, { recursive: true });
-    for (const file of fs16.readdirSync(synthSrc)) {
-      const srcFile = path16.join(synthSrc, file);
-      if (fs16.statSync(srcFile).isFile()) {
-        fs16.copyFileSync(srcFile, path16.join(synthDst, file));
+  const majlisDir = path17.join(worktreePath, ".majlis");
+  fs17.mkdirSync(majlisDir, { recursive: true });
+  const configSrc = path17.join(mainRoot, ".majlis", "config.json");
+  if (fs17.existsSync(configSrc)) {
+    fs17.copyFileSync(configSrc, path17.join(majlisDir, "config.json"));
+  }
+  const agentsSrc = path17.join(mainRoot, ".majlis", "agents");
+  if (fs17.existsSync(agentsSrc)) {
+    const agentsDst = path17.join(majlisDir, "agents");
+    fs17.mkdirSync(agentsDst, { recursive: true });
+    for (const file of fs17.readdirSync(agentsSrc)) {
+      fs17.copyFileSync(path17.join(agentsSrc, file), path17.join(agentsDst, file));
+    }
+  }
+  const synthSrc = path17.join(mainRoot, "docs", "synthesis");
+  if (fs17.existsSync(synthSrc)) {
+    const synthDst = path17.join(worktreePath, "docs", "synthesis");
+    fs17.mkdirSync(synthDst, { recursive: true });
+    for (const file of fs17.readdirSync(synthSrc)) {
+      const srcFile = path17.join(synthSrc, file);
+      if (fs17.statSync(srcFile).isFile()) {
+        fs17.copyFileSync(srcFile, path17.join(synthDst, file));
       }
     }
   }
-  const templateSrc = path16.join(mainRoot, "docs", "experiments", "_TEMPLATE.md");
-  if (fs16.existsSync(templateSrc)) {
-    const expDir = path16.join(worktreePath, "docs", "experiments");
-    fs16.mkdirSync(expDir, { recursive: true });
-    fs16.copyFileSync(templateSrc, path16.join(expDir, "_TEMPLATE.md"));
+  const templateSrc = path17.join(mainRoot, "docs", "experiments", "_TEMPLATE.md");
+  if (fs17.existsSync(templateSrc)) {
+    const expDir = path17.join(worktreePath, "docs", "experiments");
+    fs17.mkdirSync(expDir, { recursive: true });
+    fs17.copyFileSync(templateSrc, path17.join(expDir, "_TEMPLATE.md"));
   }
   const db = openDbAt(worktreePath);
   db.close();
 }
 function cleanupWorktree(mainRoot, wt) {
   try {
-    (0, import_node_child_process8.execSync)(`git worktree remove ${JSON.stringify(wt.path)} --force`, {
+    (0, import_node_child_process9.execFileSync)("git", ["worktree", "remove", wt.path, "--force"], {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -5678,7 +5001,7 @@ function cleanupWorktree(mainRoot, wt) {
     warn(`Could not remove worktree ${wt.path} \u2014 remove manually.`);
   }
   try {
-    (0, import_node_child_process8.execSync)(`git branch -D ${wt.branch}`, {
+    (0, import_node_child_process9.execFileSync)("git", ["branch", "-D", wt.branch], {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -5686,7 +5009,7 @@ function cleanupWorktree(mainRoot, wt) {
   } catch {
   }
   try {
-    (0, import_node_child_process8.execSync)("git worktree prune", {
+    (0, import_node_child_process9.execSync)("git worktree prune", {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -5694,13 +5017,13 @@ function cleanupWorktree(mainRoot, wt) {
   } catch {
   }
 }
-var fs16, path16, import_node_child_process8;
+var fs17, path17, import_node_child_process9;
 var init_worktree = __esm({
   "src/swarm/worktree.ts"() {
     "use strict";
-    fs16 = __toESM(require("fs"));
-    path16 = __toESM(require("path"));
-    import_node_child_process8 = require("child_process");
+    fs17 = __toESM(require("fs"));
+    path17 = __toESM(require("path"));
+    import_node_child_process9 = require("child_process");
     init_connection();
     init_format();
   }
@@ -5716,14 +5039,14 @@ async function runExperimentInWorktree(wt) {
   try {
     db = openDbAt(wt.path);
     exp = createExperiment(db, wt.slug, wt.branch, wt.hypothesis, null, null);
-    updateExperimentStatus(db, exp.id, "reframed");
+    adminTransitionAndPersist(db, exp.id, exp.status, "reframed" /* REFRAMED */, "bootstrap");
     exp.status = "reframed";
-    const templatePath = path17.join(wt.path, "docs", "experiments", "_TEMPLATE.md");
-    if (fs17.existsSync(templatePath)) {
-      const template = fs17.readFileSync(templatePath, "utf-8");
+    const templatePath = path18.join(wt.path, "docs", "experiments", "_TEMPLATE.md");
+    if (fs18.existsSync(templatePath)) {
+      const template = fs18.readFileSync(templatePath, "utf-8");
       const logContent = template.replace(/\{\{title\}\}/g, wt.hypothesis).replace(/\{\{hypothesis\}\}/g, wt.hypothesis).replace(/\{\{branch\}\}/g, wt.branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-      const logPath = path17.join(wt.path, "docs", "experiments", `${wt.paddedNum}-${wt.slug}.md`);
-      fs17.writeFileSync(logPath, logContent);
+      const logPath = path18.join(wt.path, "docs", "experiments", `${wt.paddedNum}-${wt.slug}.md`);
+      fs18.writeFileSync(logPath, logContent);
     }
     info(`${label} Starting: ${wt.hypothesis}`);
     while (stepCount < MAX_STEPS) {
@@ -5754,16 +5077,16 @@ async function runExperimentInWorktree(wt) {
       }
       if (nextStep === "compressed" /* COMPRESSED */) {
         await runStep("compress", db, exp, wt.path);
-        updateExperimentStatus(db, exp.id, "compressed");
+        transitionAndPersist(db, exp.id, exp.status, "compressed" /* COMPRESSED */);
         continue;
       }
       if (nextStep === "merged" /* MERGED */) {
-        updateExperimentStatus(db, exp.id, "merged");
+        transitionAndPersist(db, exp.id, exp.status, "merged" /* MERGED */);
         success(`${label} Merged.`);
         break;
       }
       if (nextStep === "reframed" /* REFRAMED */) {
-        updateExperimentStatus(db, exp.id, "reframed");
+        adminTransitionAndPersist(db, exp.id, exp.status, "reframed" /* REFRAMED */, "bootstrap");
         continue;
       }
       const stepName = statusToStepName(nextStep);
@@ -5786,7 +5109,7 @@ async function runExperimentInWorktree(wt) {
             exp.sub_type,
             "procedural"
           );
-          updateExperimentStatus(db, exp.id, "dead_end");
+          adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "error_recovery");
         } catch {
         }
         break;
@@ -5846,12 +5169,12 @@ function statusToStepName(status2) {
       return null;
   }
 }
-var fs17, path17, MAX_STEPS;
+var fs18, path18, MAX_STEPS;
 var init_runner = __esm({
   "src/swarm/runner.ts"() {
     "use strict";
-    fs17 = __toESM(require("fs"));
-    path17 = __toESM(require("path"));
+    fs18 = __toESM(require("fs"));
+    path18 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_machine();
@@ -6005,7 +5328,7 @@ async function swarm(args) {
     MAX_PARALLEL
   );
   try {
-    const status2 = (0, import_node_child_process9.execSync)("git status --porcelain", {
+    const status2 = (0, import_node_child_process10.execSync)("git status --porcelain", {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -6032,6 +5355,24 @@ async function swarm(args) {
   for (let i = 0; i < hypotheses.length; i++) {
     info(`  ${i + 1}. ${hypotheses[i]}`);
   }
+  try {
+    const worktreeList = (0, import_node_child_process10.execFileSync)("git", ["worktree", "list", "--porcelain"], {
+      cwd: root,
+      encoding: "utf-8"
+    });
+    const orphaned = worktreeList.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.replace("worktree ", "")).filter((p) => p.includes("-swarm-"));
+    for (const orphanPath of orphaned) {
+      try {
+        (0, import_node_child_process10.execFileSync)("git", ["worktree", "remove", orphanPath, "--force"], { cwd: root, encoding: "utf-8" });
+        info(`Cleaned up orphaned worktree: ${path19.basename(orphanPath)}`);
+      } catch {
+      }
+    }
+    if (orphaned.length > 0) {
+      (0, import_node_child_process10.execFileSync)("git", ["worktree", "prune"], { cwd: root, encoding: "utf-8" });
+    }
+  } catch {
+  }
   const worktrees = [];
   for (let i = 0; i < hypotheses.length; i++) {
     const paddedNum = String(i + 1).padStart(3, "0");
@@ -6055,69 +5396,75 @@ async function swarm(args) {
   }
   info(`Running ${worktrees.length} experiments in parallel...`);
   info("");
-  const settled = await Promise.allSettled(
-    worktrees.map((wt) => runExperimentInWorktree(wt))
-  );
-  const results = settled.map((s, i) => {
-    if (s.status === "fulfilled") return s.value;
-    return {
-      worktree: worktrees[i],
-      experiment: null,
-      finalStatus: "error",
-      overallGrade: null,
-      costUsd: 0,
-      stepCount: 0,
-      error: s.reason instanceof Error ? s.reason.message : String(s.reason)
-    };
-  });
-  for (const r of results) {
-    updateSwarmMember(
-      db,
-      swarmRun.id,
-      r.worktree.slug,
-      r.finalStatus,
-      r.overallGrade,
-      r.costUsd,
-      r.error ?? null
+  let results;
+  let summary;
+  try {
+    const settled = await Promise.allSettled(
+      worktrees.map((wt) => runExperimentInWorktree(wt))
     );
-  }
-  info("");
-  header("Aggregation");
-  const summary = aggregateSwarmResults(root, db, results);
-  summary.goal = goal;
-  if (summary.bestExperiment && isMergeable(summary.bestExperiment.overallGrade)) {
-    const best = summary.bestExperiment;
-    info(`Best experiment: ${best.worktree.slug} (${best.overallGrade})`);
-    try {
-      (0, import_node_child_process9.execSync)(
-        `git merge ${best.worktree.branch} --no-ff -m "Merge swarm winner: ${best.worktree.slug}"`,
-        { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    results = settled.map((s, i) => {
+      if (s.status === "fulfilled") return s.value;
+      return {
+        worktree: worktrees[i],
+        experiment: null,
+        finalStatus: "error",
+        overallGrade: null,
+        costUsd: 0,
+        stepCount: 0,
+        error: s.reason instanceof Error ? s.reason.message : String(s.reason)
+      };
+    });
+    for (const r of results) {
+      updateSwarmMember(
+        db,
+        swarmRun.id,
+        r.worktree.slug,
+        r.finalStatus,
+        r.overallGrade,
+        r.costUsd,
+        r.error ?? null
       );
-      success(`Merged ${best.worktree.slug} into main.`);
-    } catch {
-      warn(`Git merge of ${best.worktree.slug} failed. Merge manually with:`);
-      info(`  git merge ${best.worktree.branch} --no-ff`);
     }
-  } else {
-    info("No experiment achieved sound/good grade. Nothing merged.");
-  }
-  for (const r of results) {
-    if (r === summary.bestExperiment || r.error || !r.experiment) continue;
-    const mainExp = getExperimentBySlug(db, r.worktree.slug);
-    if (mainExp && mainExp.status !== "dead_end") {
-      updateExperimentStatus(db, mainExp.id, "dead_end");
+    info("");
+    header("Aggregation");
+    summary = aggregateSwarmResults(root, db, results);
+    summary.goal = goal;
+    if (summary.bestExperiment && isMergeable(summary.bestExperiment.overallGrade)) {
+      const best = summary.bestExperiment;
+      info(`Best experiment: ${best.worktree.slug} (${best.overallGrade})`);
+      try {
+        (0, import_node_child_process10.execFileSync)(
+          "git",
+          ["merge", best.worktree.branch, "--no-ff", "-m", `Merge swarm winner: ${best.worktree.slug}`],
+          { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+        );
+        success(`Merged ${best.worktree.slug} into main.`);
+      } catch {
+        warn(`Git merge of ${best.worktree.slug} failed. Merge manually with:`);
+        info(`  git merge ${best.worktree.branch} --no-ff`);
+      }
+    } else {
+      info("No experiment achieved sound/good grade. Nothing merged.");
+    }
+    for (const r of results) {
+      if (r === summary.bestExperiment || r.error || !r.experiment) continue;
+      const mainExp = getExperimentBySlug(db, r.worktree.slug);
+      if (mainExp && mainExp.status !== "dead_end") {
+        adminTransitionAndPersist(db, mainExp.id, mainExp.status, "dead_end" /* DEAD_END */, "error_recovery");
+      }
+    }
+    updateSwarmRun(
+      db,
+      swarmRun.id,
+      summary.errorCount === results.length ? "failed" : "completed",
+      summary.totalCostUsd,
+      summary.bestExperiment?.worktree.slug ?? null
+    );
+  } finally {
+    info("Cleaning up worktrees...");
+    for (const wt of worktrees) {
+      cleanupWorktree(root, wt);
     }
-  }
-  updateSwarmRun(
-    db,
-    swarmRun.id,
-    summary.errorCount === results.length ? "failed" : "completed",
-    summary.totalCostUsd,
-    summary.bestExperiment?.worktree.slug ?? null
-  );
-  info("Cleaning up worktrees...");
-  for (const wt of worktrees) {
-    cleanupWorktree(root, wt);
   }
   info("");
   header("Swarm Summary");
@@ -6137,15 +5484,15 @@ function isMergeable(grade) {
 }
 async function deriveMultipleHypotheses(goal, root, count) {
   const synthesis = truncateContext(
-    readFileOrEmpty(path18.join(root, "docs", "synthesis", "current.md")),
+    readFileOrEmpty(path19.join(root, "docs", "synthesis", "current.md")),
     CONTEXT_LIMITS.synthesis
   );
   const fragility = truncateContext(
-    readFileOrEmpty(path18.join(root, "docs", "synthesis", "fragility.md")),
+    readFileOrEmpty(path19.join(root, "docs", "synthesis", "fragility.md")),
     CONTEXT_LIMITS.fragility
   );
   const deadEndsDoc = truncateContext(
-    readFileOrEmpty(path18.join(root, "docs", "synthesis", "dead-ends.md")),
+    readFileOrEmpty(path19.join(root, "docs", "synthesis", "dead-ends.md")),
     CONTEXT_LIMITS.deadEnds
   );
   const diagnosis = truncateContext(readLatestDiagnosis(root), CONTEXT_LIMITS.synthesis);
@@ -6155,7 +5502,7 @@ async function deriveMultipleHypotheses(goal, root, count) {
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
-      metricsOutput = (0, import_node_child_process9.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process10.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -6235,14 +5582,16 @@ If the goal is met:
   warn("Planner did not return structured hypotheses. Using goal as single hypothesis.");
   return [goal];
 }
-var path18, import_node_child_process9, MAX_PARALLEL, DEFAULT_PARALLEL;
+var path19, import_node_child_process10, MAX_PARALLEL, DEFAULT_PARALLEL;
 var init_swarm = __esm({
   "src/commands/swarm.ts"() {
     "use strict";
-    path18 = __toESM(require("path"));
-    import_node_child_process9 = require("child_process");
+    path19 = __toESM(require("path"));
+    import_node_child_process10 = require("child_process");
     init_connection();
     init_queries();
+    init_machine();
+    init_types2();
     init_spawn();
     init_config();
     init_worktree();
@@ -6265,21 +5614,21 @@ async function diagnose(args) {
   const db = getDb(root);
   const focus = args.filter((a) => !a.startsWith("--")).join(" ");
   const keepScripts = args.includes("--keep-scripts");
-  const scriptsDir = path19.join(root, ".majlis", "scripts");
-  if (!fs18.existsSync(scriptsDir)) {
-    fs18.mkdirSync(scriptsDir, { recursive: true });
+  const scriptsDir = path20.join(root, ".majlis", "scripts");
+  if (!fs19.existsSync(scriptsDir)) {
+    fs19.mkdirSync(scriptsDir, { recursive: true });
   }
   header("Deep Diagnosis");
   if (focus) info(`Focus: ${focus}`);
   const dbExport = exportForDiagnostician(db);
-  const synthesis = readFileOrEmpty(path19.join(root, "docs", "synthesis", "current.md"));
-  const fragility = readFileOrEmpty(path19.join(root, "docs", "synthesis", "fragility.md"));
-  const deadEndsDoc = readFileOrEmpty(path19.join(root, "docs", "synthesis", "dead-ends.md"));
+  const synthesis = readFileOrEmpty(path20.join(root, "docs", "synthesis", "current.md"));
+  const fragility = readFileOrEmpty(path20.join(root, "docs", "synthesis", "fragility.md"));
+  const deadEndsDoc = readFileOrEmpty(path20.join(root, "docs", "synthesis", "dead-ends.md"));
   const config = loadConfig(root);
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
-      metricsOutput = (0, import_node_child_process10.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process11.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -6325,13 +5674,13 @@ Perform a deep diagnostic analysis of this project. Identify root causes, recurr
 Remember: you may write files ONLY to .majlis/scripts/. You cannot modify project code.`;
   info("Spawning diagnostician (60 turns, full DB access)...");
   const result = await spawnAgent("diagnostician", { taskPrompt }, root);
-  const diagnosisDir = path19.join(root, "docs", "diagnosis");
-  if (!fs18.existsSync(diagnosisDir)) {
-    fs18.mkdirSync(diagnosisDir, { recursive: true });
+  const diagnosisDir = path20.join(root, "docs", "diagnosis");
+  if (!fs19.existsSync(diagnosisDir)) {
+    fs19.mkdirSync(diagnosisDir, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const artifactPath = path19.join(diagnosisDir, `diagnosis-${timestamp}.md`);
-  fs18.writeFileSync(artifactPath, result.output);
+  const artifactPath = path20.join(diagnosisDir, `diagnosis-${timestamp}.md`);
+  fs19.writeFileSync(artifactPath, result.output);
   info(`Diagnostic report: docs/diagnosis/diagnosis-${timestamp}.md`);
   if (result.structured?.diagnosis) {
     const d = result.structured.diagnosis;
@@ -6344,11 +5693,11 @@ Remember: you may write files ONLY to .majlis/scripts/. You cannot modify projec
   }
   if (!keepScripts) {
     try {
-      const files = fs18.readdirSync(scriptsDir);
+      const files = fs19.readdirSync(scriptsDir);
       for (const f of files) {
-        fs18.unlinkSync(path19.join(scriptsDir, f));
+        fs19.unlinkSync(path20.join(scriptsDir, f));
       }
-      fs18.rmdirSync(scriptsDir);
+      fs19.rmdirSync(scriptsDir);
       info("Cleaned up .majlis/scripts/");
     } catch {
     }
@@ -6361,13 +5710,13 @@ Remember: you may write files ONLY to .majlis/scripts/. You cannot modify projec
   autoCommit(root, `diagnosis: ${focus || "general"}`);
   success("Diagnosis complete.");
 }
-var fs18, path19, import_node_child_process10;
+var fs19, path20, import_node_child_process11;
 var init_diagnose = __esm({
   "src/commands/diagnose.ts"() {
     "use strict";
-    fs18 = __toESM(require("fs"));
-    path19 = __toESM(require("path"));
-    import_node_child_process10 = require("child_process");
+    fs19 = __toESM(require("fs"));
+    path20 = __toESM(require("path"));
+    import_node_child_process11 = require("child_process");
     init_connection();
     init_queries();
     init_spawn();
@@ -6406,8 +5755,9 @@ function getLastActivityTimestamp(db) {
 }
 function getCommitsSince(root, timestamp) {
   try {
-    const output = (0, import_node_child_process11.execSync)(
-      `git log --since="${timestamp}" --oneline -- . ":!.majlis/" ":!docs/"`,
+    const output = (0, import_node_child_process12.execFileSync)(
+      "git",
+      ["log", `--since=${timestamp}`, "--oneline", "--", ".", ":!.majlis/", ":!docs/"],
       { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     if (!output) return 0;
@@ -6418,13 +5768,15 @@ function getCommitsSince(root, timestamp) {
 }
 function getGitDiffStat(root, timestamp) {
   try {
-    const baseRef = (0, import_node_child_process11.execSync)(
-      `git rev-list -1 --before="${timestamp}" HEAD`,
+    const baseRef = (0, import_node_child_process12.execFileSync)(
+      "git",
+      ["rev-list", "-1", `--before=${timestamp}`, "HEAD"],
       { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     if (!baseRef) return { stat: "", filesChanged: 0 };
-    const stat = (0, import_node_child_process11.execSync)(
-      `git diff --stat ${baseRef} -- . ":!.majlis/" ":!docs/"`,
+    const stat = (0, import_node_child_process12.execFileSync)(
+      "git",
+      ["diff", "--stat", baseRef, "--", ".", ":!.majlis/", ":!docs/"],
       { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     const lines = stat.split("\n");
@@ -6459,11 +5811,11 @@ function checkMetrics(root, config) {
   const command = config.metrics?.command;
   if (!command) return { working: false, error: "No metrics command configured" };
   try {
-    const scriptPath = path20.join(root, command);
-    if (command.includes("/") && !fs19.existsSync(scriptPath)) {
+    const scriptPath = path21.join(root, command);
+    if (command.includes("/") && !fs20.existsSync(scriptPath)) {
       return { working: false, error: `Script not found: ${command}` };
     }
-    const output = (0, import_node_child_process11.execSync)(command, {
+    const output = (0, import_node_child_process12.execSync)(command, {
       cwd: root,
       encoding: "utf-8",
       timeout: 6e4,
@@ -6491,10 +5843,10 @@ function assessStaleness(db, root, profile, config) {
     filesChanged = diffResult.filesChanged;
   }
   const configDrift = detectConfigDrift(config, profile);
-  const synthesisPath = path20.join(root, "docs", "synthesis", "current.md");
+  const synthesisPath = path21.join(root, "docs", "synthesis", "current.md");
   let synthesisSize = 0;
   try {
-    synthesisSize = fs19.statSync(synthesisPath).size;
+    synthesisSize = fs20.statSync(synthesisPath).size;
   } catch {
   }
   const unresolvedDoubts = db.prepare(`
@@ -6552,13 +5904,13 @@ function printStalenessReport(report) {
     success("  Already up to date.");
   }
 }
-var fs19, path20, import_node_child_process11;
+var fs20, path21, import_node_child_process12;
 var init_staleness = __esm({
   "src/scan/staleness.ts"() {
     "use strict";
-    fs19 = __toESM(require("fs"));
-    path20 = __toESM(require("path"));
-    import_node_child_process11 = require("child_process");
+    fs20 = __toESM(require("fs"));
+    path21 = __toESM(require("path"));
+    import_node_child_process12 = require("child_process");
     init_queries();
     init_format();
   }
@@ -6608,13 +5960,13 @@ async function resync(args) {
     return;
   }
   info("Phase 1: Deep re-scan...");
-  const synthesisDir = path21.join(root, "docs", "synthesis");
-  const scriptsDir = path21.join(root, ".majlis", "scripts");
-  if (!fs20.existsSync(synthesisDir)) fs20.mkdirSync(synthesisDir, { recursive: true });
-  if (!fs20.existsSync(scriptsDir)) fs20.mkdirSync(scriptsDir, { recursive: true });
+  const synthesisDir = path22.join(root, "docs", "synthesis");
+  const scriptsDir = path22.join(root, ".majlis", "scripts");
+  if (!fs21.existsSync(synthesisDir)) fs21.mkdirSync(synthesisDir, { recursive: true });
+  if (!fs21.existsSync(scriptsDir)) fs21.mkdirSync(scriptsDir, { recursive: true });
   const profileJson = JSON.stringify(profile, null, 2);
-  const oldSynthesis = readFileOrEmpty(path21.join(root, "docs", "synthesis", "current.md"));
-  const oldFragility = readFileOrEmpty(path21.join(root, "docs", "synthesis", "fragility.md"));
+  const oldSynthesis = readFileOrEmpty(path22.join(root, "docs", "synthesis", "current.md"));
+  const oldFragility = readFileOrEmpty(path22.join(root, "docs", "synthesis", "fragility.md"));
   const dbExport = exportForCompressor(db);
   const stalenessSummary = `Last Majlis activity: ${report.daysSinceActivity} days ago (${report.lastActivitySource}).
 Commits since: ${report.commitsSinceActivity}. Files changed: ${report.filesChanged}.
@@ -6740,10 +6092,10 @@ You may ONLY write to .majlis/scripts/. Output your structured JSON when done.`;
       info("Updated .majlis/config.json with resync results.");
       if (toolsmithOutput.metrics_command) {
         try {
-          const metricsPath = path21.join(root, toolsmithOutput.metrics_command);
-          if (fs20.existsSync(metricsPath)) {
+          const metricsPath = path22.join(root, toolsmithOutput.metrics_command);
+          if (fs21.existsSync(metricsPath)) {
             try {
-              fs20.chmodSync(metricsPath, 493);
+              fs21.chmodSync(metricsPath, 493);
             } catch {
             }
           }
@@ -6780,8 +6132,8 @@ You may ONLY write to .majlis/scripts/. Output your structured JSON when done.`;
   }
   if (cartographerOk) {
     const sessionCount = getSessionsSinceCompression(db);
-    const newSynthesisPath = path21.join(root, "docs", "synthesis", "current.md");
-    const newSynthesisSize = fs20.existsSync(newSynthesisPath) ? fs20.statSync(newSynthesisPath).size : 0;
+    const newSynthesisPath = path22.join(root, "docs", "synthesis", "current.md");
+    const newSynthesisSize = fs21.existsSync(newSynthesisPath) ? fs21.statSync(newSynthesisPath).size : 0;
     recordCompression(db, sessionCount, report.synthesisSize, newSynthesisSize);
     info("Recorded compression in DB.");
   }
@@ -6791,12 +6143,12 @@ You may ONLY write to .majlis/scripts/. Output your structured JSON when done.`;
   if (toolsmithOk) info("  \u2192 .majlis/scripts/metrics.sh + .majlis/config.json");
   info("Run `majlis status` to see project state.");
 }
-var fs20, path21;
+var fs21, path22;
 var init_resync = __esm({
   "src/commands/resync.ts"() {
     "use strict";
-    fs20 = __toESM(require("fs"));
-    path21 = __toESM(require("path"));
+    fs21 = __toESM(require("fs"));
+    path22 = __toESM(require("path"));
     init_connection();
     init_connection();
     init_queries();
@@ -6811,10 +6163,10 @@ var init_resync = __esm({
 });
 
 // src/cli.ts
-var fs21 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 var VERSION2 = JSON.parse(
-  fs21.readFileSync(path22.join(__dirname, "..", "package.json"), "utf-8")
+  fs22.readFileSync(path23.join(__dirname, "..", "package.json"), "utf-8")
 ).version;
 async function main() {
   let sigintCount = 0;
@@ -6899,6 +6251,7 @@ async function main() {
       case "doubt":
       case "scout":
       case "verify":
+      case "gate":
       case "compress": {
         const { cycle: cycle2 } = await Promise.resolve().then(() => (init_cycle(), cycle_exports));
         await cycle2(command, rest);
@@ -6980,6 +6333,9 @@ Lifecycle:
 
 Experiments:
   new "hypothesis"           Create experiment, branch, log, DB entry
+    --sub-type TYPE          Classify by problem sub-type
+    --depends-on SLUG        Block building until dependency is merged
+    --context FILE,FILE      Inject domain-specific docs into agent context
   baseline                   Capture metrics snapshot (before)
   measure                    Capture metrics snapshot (after)
   compare [--json]           Compare before/after, detect regressions
@@ -6992,6 +6348,7 @@ Cycle:
   doubt [experiment]         Spawn critic agent
   scout [experiment]         Spawn scout agent
   verify [experiment]        Spawn verifier agent
+  gate [experiment]          Spawn gatekeeper agent
   resolve [experiment]       Route based on verification grades
   compress                   Spawn compressor agent