majlis 0.6.3 → 0.7.0

package/dist/cli.js

@@ -301,6 +301,12 @@ function closeDb() {
   }
 }
 function resetDb() {
+  if (_db) {
+    try {
+      _db.close();
+    } catch {
+    }
+  }
   _db = null;
 }
 function openDbAt(projectRoot) {
@@ -512,7 +518,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 +723,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 +747,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 +762,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 +778,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 +796,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 +811,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 +826,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 +900,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 +1029,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: {
@@ -1811,18 +1875,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 +1900,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 +1914,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 +1940,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 +1994,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 +2002,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 +2056,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 +2076,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 +2090,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 +2114,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 +2155,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 +2163,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++;
     }
@@ -3661,6 +2731,122 @@ var init_status = __esm({
   }
 });
 
+// src/state/types.ts
+function isTerminalStatus(status2) {
+  return TRANSITIONS[status2].length === 0;
+}
+var TRANSITIONS, GRADE_ORDER, ADMIN_TRANSITIONS;
+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 */, "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 compareMetrics(db, experimentId, config) {
   const before = getMetricsByExperimentAndPhase(db, experimentId, "before");
@@ -3673,8 +2859,10 @@ function compareMetrics(db, experimentId, config) {
       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);
+        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,
@@ -3688,14 +2876,15 @@ function compareMetrics(db, experimentId, config) {
   }
   return comparisons;
 }
-function isRegression(before, after, direction) {
+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":
-      return false;
+      if (target === void 0) return false;
+      return Math.abs(after - target) > Math.abs(before - target);
     default:
       return false;
   }
@@ -3868,7 +3057,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_process4.execFileSync)("git", ["checkout", "-b", branch], {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3924,18 +3113,26 @@ 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_process4.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_process4.execFileSync)("git", ["checkout", "main"], {
+          cwd: root,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch {
+        (0, import_node_child_process4.execFileSync)("git", ["checkout", "master"], {
+          cwd: root,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      }
     }
   } catch {
     warn("Could not switch git branches \u2014 do this manually.");
@@ -3951,6 +3148,8 @@ var init_experiment = __esm({
     import_node_child_process4 = require("child_process");
     init_connection();
     init_queries();
+    init_machine();
+    init_types2();
     init_config();
     init_spawn();
     init_git();
@@ -4188,93 +3387,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 +3413,11 @@ async function resolve(db, exp, projectRoot) {
     grades = getVerificationsByExperiment(db, exp.id);
   }
   const overallGrade = worstGrade(grades);
+  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 +3427,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 +3448,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 +3463,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 +3500,17 @@ async function resolveDbOnly(db, exp, projectRoot) {
     grades = getVerificationsByExperiment(db, exp.id);
   }
   const overallGrade = worstGrade(grades);
+  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 +3531,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 +3545,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 +3569,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_process5.execFileSync)("git", ["checkout", "main"], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch {
+      (0, import_node_child_process5.execFileSync)("git", ["checkout", "master"], {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    (0, import_node_child_process5.execFileSync)("git", ["merge", branch, "--no-ff", "-m", `Merge experiment branch ${branch}`], {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4452,20 +3593,28 @@ 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_process5.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_process5.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_process5.execFileSync)("git", ["checkout", "main"], {
+          cwd,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch {
+        (0, import_node_child_process5.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.`);
@@ -4490,6 +3639,7 @@ var init_resolve = __esm({
     fs11 = __toESM(require("fs"));
     path11 = __toESM(require("path"));
     init_types2();
+    init_machine();
     init_queries();
     init_spawn();
     import_node_child_process5 = require("child_process");
@@ -4534,7 +3684,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,7 +3706,7 @@ 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 */);
@@ -4921,7 +4071,7 @@ 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_process6.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.");
@@ -4941,61 +4091,63 @@ 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 init_cycle = __esm({
@@ -5235,7 +4387,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 +4437,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 +4476,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 +4599,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}`);
@@ -5569,7 +4727,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_process7.execFileSync)("git", ["checkout", "-b", branch], {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -5579,7 +4737,7 @@ 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");
@@ -5602,6 +4760,7 @@ var init_run = __esm({
     init_connection();
     init_queries();
     init_machine();
+    init_types2();
     init_next();
     init_cycle();
     init_spawn();
@@ -5618,7 +4777,7 @@ function createWorktree(mainRoot, slug, paddedNum) {
   const worktreeName = `${projectName}-swarm-${paddedNum}-${slug}`;
   const worktreePath = path16.join(path16.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_process8.execFileSync)("git", ["worktree", "add", worktreePath, "-b", branch], {
     cwd: mainRoot,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -5669,7 +4828,7 @@ function initializeWorktree(mainRoot, worktreePath) {
 }
 function cleanupWorktree(mainRoot, wt) {
   try {
-    (0, import_node_child_process8.execSync)(`git worktree remove ${JSON.stringify(wt.path)} --force`, {
+    (0, import_node_child_process8.execFileSync)("git", ["worktree", "remove", wt.path, "--force"], {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -5678,7 +4837,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_process8.execFileSync)("git", ["branch", "-D", wt.branch], {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -5716,7 +4875,7 @@ 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)) {
@@ -5754,16 +4913,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 +4945,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;
@@ -6032,6 +5191,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_process9.execFileSync)("git", ["worktree", "list", "--porcelain"], {
+      cwd: root,
+      encoding: "utf-8"
+    });
+    const orphaned = worktreeList.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.replace("worktree ", "")).filter((p) => p.includes("-swarm-"));
+    for (const orphanPath of orphaned) {
+      try {
+        (0, import_node_child_process9.execFileSync)("git", ["worktree", "remove", orphanPath, "--force"], { cwd: root, encoding: "utf-8" });
+        info(`Cleaned up orphaned worktree: ${path18.basename(orphanPath)}`);
+      } catch {
+      }
+    }
+    if (orphaned.length > 0) {
+      (0, import_node_child_process9.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 +5232,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_process9.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");
@@ -6243,6 +5426,8 @@ var init_swarm = __esm({
     import_node_child_process9 = require("child_process");
     init_connection();
     init_queries();
+    init_machine();
+    init_types2();
     init_spawn();
     init_config();
     init_worktree();
@@ -6406,8 +5591,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_process11.execFileSync)(
+      "git",
+      ["log", `--since=${timestamp}`, "--oneline", "--", ".", ":!.majlis/", ":!docs/"],
       { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     if (!output) return 0;
@@ -6418,13 +5604,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_process11.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_process11.execFileSync)(
+      "git",
+      ["diff", "--stat", baseRef, "--", ".", ":!.majlis/", ":!docs/"],
       { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     ).trim();
     const lines = stat.split("\n");
@@ -6899,6 +6087,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);
@@ -6992,6 +6181,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