majlis 0.6.1 → 0.6.2

package/dist/cli.js

@@ -435,6 +435,10 @@ var init_format = __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,
   init: () => init
 });
 async function init(_args) {
@@ -1435,6 +1439,193 @@ Run \`majlis status\` for live experiment state and cycle position.
   }
 });
 
+// src/git.ts
+function autoCommit(root, message) {
+  try {
+    (0, import_node_child_process.execSync)("git add docs/ .majlis/scripts/ 2>/dev/null; true", {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const diff = (0, import_node_child_process.execSync)("git diff --cached --stat", {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    if (!diff) return;
+    (0, import_node_child_process.execSync)(`git commit -m ${JSON.stringify(`[majlis] ${message}`)}`, {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    info(`Auto-committed: ${message}`);
+  } catch {
+  }
+}
+var import_node_child_process;
+var init_git = __esm({
+  "src/git.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+    init_format();
+  }
+});
+
+// src/commands/upgrade.ts
+var upgrade_exports = {};
+__export(upgrade_exports, {
+  upgrade: () => upgrade
+});
+async function upgrade(_args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  header(`Upgrading to Majlis v${VERSION}`);
+  let updated = 0;
+  let added = 0;
+  const majlisAgentsDir = path3.join(root, ".majlis", "agents");
+  const claudeAgentsDir = path3.join(root, ".claude", "agents");
+  mkdirSafe2(majlisAgentsDir);
+  mkdirSafe2(claudeAgentsDir);
+  for (const [name, content] of Object.entries(AGENT_DEFINITIONS)) {
+    const majlisPath = path3.join(majlisAgentsDir, `${name}.md`);
+    const claudePath = path3.join(claudeAgentsDir, `${name}.md`);
+    const existed = fs3.existsSync(majlisPath);
+    const current = existed ? fs3.readFileSync(majlisPath, "utf-8") : "";
+    if (current !== content) {
+      fs3.writeFileSync(majlisPath, content);
+      fs3.writeFileSync(claudePath, content);
+      if (existed) {
+        info(`  Updated agent: ${name}`);
+        updated++;
+      } else {
+        info(`  Added agent: ${name}`);
+        added++;
+      }
+    }
+  }
+  try {
+    for (const file of fs3.readdirSync(majlisAgentsDir)) {
+      const name = file.replace(".md", "");
+      if (!AGENT_DEFINITIONS[name]) {
+        fs3.unlinkSync(path3.join(majlisAgentsDir, file));
+        try {
+          fs3.unlinkSync(path3.join(claudeAgentsDir, file));
+        } catch {
+        }
+        info(`  Removed deprecated agent: ${name}`);
+        updated++;
+      }
+    }
+  } catch {
+  }
+  const commandsDir = path3.join(root, ".claude", "commands");
+  mkdirSafe2(commandsDir);
+  for (const [name, cmd] of Object.entries(SLASH_COMMANDS)) {
+    const cmdPath = path3.join(commandsDir, `${name}.md`);
+    const content = `---
+description: ${cmd.description}
+---
+${cmd.body}
+`;
+    const existed = fs3.existsSync(cmdPath);
+    const current = existed ? fs3.readFileSync(cmdPath, "utf-8") : "";
+    if (current !== content) {
+      fs3.writeFileSync(cmdPath, content);
+      if (existed) {
+        updated++;
+      } else {
+        added++;
+      }
+      info(`  ${existed ? "Updated" : "Added"} command: /${name}`);
+    }
+  }
+  const settingsPath = path3.join(root, ".claude", "settings.json");
+  try {
+    if (fs3.existsSync(settingsPath)) {
+      const existing = JSON.parse(fs3.readFileSync(settingsPath, "utf-8"));
+      const before = JSON.stringify(existing.hooks);
+      existing.hooks = { ...existing.hooks, ...HOOKS_CONFIG.hooks };
+      if (JSON.stringify(existing.hooks) !== before) {
+        fs3.writeFileSync(settingsPath, JSON.stringify(existing, null, 2));
+        info("  Updated hooks in .claude/settings.json");
+        updated++;
+      }
+    } else {
+      fs3.writeFileSync(settingsPath, JSON.stringify(HOOKS_CONFIG, null, 2));
+      info("  Created .claude/settings.json");
+      added++;
+    }
+  } catch {
+    warn("  Could not update .claude/settings.json");
+  }
+  const docDirs = [
+    "inbox",
+    "experiments",
+    "decisions",
+    "classification",
+    "doubts",
+    "challenges",
+    "verification",
+    "reframes",
+    "rihla",
+    "synthesis",
+    "diagnosis"
+  ];
+  for (const dir of docDirs) {
+    const dirPath = path3.join(root, "docs", dir);
+    if (!fs3.existsSync(dirPath)) {
+      fs3.mkdirSync(dirPath, { recursive: true });
+      info(`  Added docs/${dir}/`);
+      added++;
+    }
+  }
+  const claudeMdPath = path3.join(root, "CLAUDE.md");
+  if (fs3.existsSync(claudeMdPath)) {
+    const existing = fs3.readFileSync(claudeMdPath, "utf-8");
+    if (existing.includes("## Majlis Protocol")) {
+      const replaced = existing.replace(
+        /## Majlis Protocol[\s\S]*?(?=\n## [^M]|\n## $|$)/,
+        CLAUDE_MD_SECTION.trim()
+      );
+      if (replaced !== existing) {
+        fs3.writeFileSync(claudeMdPath, replaced);
+        info("  Updated Majlis Protocol in CLAUDE.md");
+        updated++;
+      }
+    } else {
+      fs3.writeFileSync(claudeMdPath, existing + "\n" + CLAUDE_MD_SECTION);
+      info("  Appended Majlis Protocol to CLAUDE.md");
+      added++;
+    }
+  }
+  if (updated === 0 && added === 0) {
+    success(`Already up to date (v${VERSION}).`);
+  } else {
+    autoCommit(root, `upgrade to v${VERSION}`);
+    success(`Upgraded to v${VERSION}: ${updated} updated, ${added} added.`);
+  }
+}
+function mkdirSafe2(dir) {
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+}
+var fs3, path3, VERSION;
+var init_upgrade = __esm({
+  "src/commands/upgrade.ts"() {
+    "use strict";
+    fs3 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
+    init_connection();
+    init_init();
+    init_git();
+    init_format();
+    VERSION = JSON.parse(
+      fs3.readFileSync(path3.join(__dirname, "..", "package.json"), "utf-8")
+    ).version;
+  }
+});
+
 // src/db/queries.ts
 function createExperiment(db, slug, branch, hypothesis, subType, classificationRef) {
   const stmt = db.prepare(`
@@ -1869,13 +2060,13 @@ var init_queries = __esm({
 // src/config.ts
 function loadConfig(projectRoot) {
   if (_cachedConfig && _cachedRoot === projectRoot) return _cachedConfig;
-  const configPath = path3.join(projectRoot, ".majlis", "config.json");
-  if (!fs3.existsSync(configPath)) {
+  const configPath = path4.join(projectRoot, ".majlis", "config.json");
+  if (!fs4.existsSync(configPath)) {
     _cachedConfig = { ...DEFAULT_CONFIG2 };
     _cachedRoot = projectRoot;
     return _cachedConfig;
   }
-  const loaded = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+  const loaded = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
   _cachedConfig = {
     ...DEFAULT_CONFIG2,
     ...loaded,
@@ -1889,7 +2080,7 @@ function loadConfig(projectRoot) {
 }
 function readFileOrEmpty(filePath) {
   try {
-    return fs3.readFileSync(filePath, "utf-8");
+    return fs4.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -1904,21 +2095,21 @@ function truncateContext(content, limit) {
   return content.slice(0, limit) + "\n[TRUNCATED]";
 }
 function readLatestDiagnosis(projectRoot) {
-  const dir = path3.join(projectRoot, "docs", "diagnosis");
+  const dir = path4.join(projectRoot, "docs", "diagnosis");
   try {
-    const files = fs3.readdirSync(dir).filter((f) => f.startsWith("diagnosis-") && f.endsWith(".md")).sort().reverse();
+    const files = fs4.readdirSync(dir).filter((f) => f.startsWith("diagnosis-") && f.endsWith(".md")).sort().reverse();
     if (files.length === 0) return "";
-    return fs3.readFileSync(path3.join(dir, files[0]), "utf-8");
+    return fs4.readFileSync(path4.join(dir, files[0]), "utf-8");
   } catch {
     return "";
   }
 }
-var fs3, path3, DEFAULT_CONFIG2, _cachedConfig, _cachedRoot, CONTEXT_LIMITS;
+var fs4, path4, DEFAULT_CONFIG2, _cachedConfig, _cachedRoot, CONTEXT_LIMITS;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
-    fs3 = __toESM(require("fs"));
-    path3 = __toESM(require("path"));
+    fs4 = __toESM(require("fs"));
+    path4 = __toESM(require("path"));
     DEFAULT_CONFIG2 = {
       project: { name: "", description: "", objective: "" },
       metrics: { command: "", fixtures: [], tracked: {} },
@@ -2247,11 +2438,11 @@ var init_parse = __esm({
 // src/agents/spawn.ts
 function loadAgentDefinition(role, projectRoot) {
   const root = projectRoot ?? findProjectRoot() ?? process.cwd();
-  const filePath = path4.join(root, ".majlis", "agents", `${role}.md`);
-  if (!fs4.existsSync(filePath)) {
+  const filePath = path5.join(root, ".majlis", "agents", `${role}.md`);
+  if (!fs5.existsSync(filePath)) {
     throw new Error(`Agent definition not found: ${filePath}`);
   }
-  const content = fs4.readFileSync(filePath, "utf-8");
+  const content = fs5.readFileSync(filePath, "utf-8");
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!frontmatterMatch) {
     throw new Error(`Invalid agent definition (missing YAML frontmatter): ${filePath}`);
@@ -2459,15 +2650,15 @@ async function spawnRecovery(role, partialOutput, context, projectRoot) {
   const root = projectRoot ?? findProjectRoot() ?? process.cwd();
   const expSlug = context.experiment?.slug ?? "unknown";
   console.log(`[recovery] Cleaning up after truncated ${role} for ${expSlug}...`);
-  const expDocPath = path4.join(
+  const expDocPath = path5.join(
     root,
     "docs",
     "experiments",
     `${String(context.experiment?.id ?? 0).padStart(3, "0")}-${expSlug}.md`
   );
-  const templatePath = path4.join(root, "docs", "experiments", "_TEMPLATE.md");
-  const template = fs4.existsSync(templatePath) ? fs4.readFileSync(templatePath, "utf-8") : "";
-  const currentDoc = fs4.existsSync(expDocPath) ? fs4.readFileSync(expDocPath, "utf-8") : "";
+  const templatePath = path5.join(root, "docs", "experiments", "_TEMPLATE.md");
+  const template = fs5.existsSync(templatePath) ? fs5.readFileSync(templatePath, "utf-8") : "";
+  const currentDoc = fs5.existsSync(expDocPath) ? fs5.readFileSync(expDocPath, "utf-8") : "";
   const prompt = `The ${role} agent was truncated (hit max turns) while working on experiment "${expSlug}".
 
 Here is the partial agent output (reasoning + tool calls):
@@ -2630,23 +2821,23 @@ function writeArtifact(role, context, markdown, projectRoot) {
   const dir = dirMap[role];
   if (!dir) return null;
   if (role === "builder" || role === "compressor" || role === "diagnostician") return null;
-  const fullDir = path4.join(projectRoot, dir);
-  if (!fs4.existsSync(fullDir)) {
-    fs4.mkdirSync(fullDir, { recursive: true });
+  const fullDir = path5.join(projectRoot, dir);
+  if (!fs5.existsSync(fullDir)) {
+    fs5.mkdirSync(fullDir, { recursive: true });
   }
   const expSlug = context.experiment?.slug ?? "general";
   const nextNum = String(context.experiment?.id ?? 1).padStart(3, "0");
   const filename = `${nextNum}-${role}-${expSlug}.md`;
-  const target = path4.join(fullDir, filename);
-  fs4.writeFileSync(target, markdown);
+  const target = path5.join(fullDir, filename);
+  fs5.writeFileSync(target, markdown);
   return target;
 }
-var fs4, path4, import_claude_agent_sdk2, ROLE_MAX_TURNS, CHECKPOINT_INTERVAL, DIM2, RESET2, CYAN2;
+var fs5, path5, import_claude_agent_sdk2, ROLE_MAX_TURNS, CHECKPOINT_INTERVAL, DIM2, RESET2, CYAN2;
 var init_spawn = __esm({
   "src/agents/spawn.ts"() {
     "use strict";
-    fs4 = __toESM(require("fs"));
-    path4 = __toESM(require("path"));
+    fs5 = __toESM(require("fs"));
+    path5 = __toESM(require("path"));
     import_claude_agent_sdk2 = require("@anthropic-ai/claude-agent-sdk");
     init_parse();
     init_connection();
@@ -2675,38 +2866,6 @@ var init_spawn = __esm({
   }
 });
 
-// src/git.ts
-function autoCommit(root, message) {
-  try {
-    (0, import_node_child_process.execSync)("git add docs/ .majlis/scripts/ 2>/dev/null; true", {
-      cwd: root,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const diff = (0, import_node_child_process.execSync)("git diff --cached --stat", {
-      cwd: root,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    if (!diff) return;
-    (0, import_node_child_process.execSync)(`git commit -m ${JSON.stringify(`[majlis] ${message}`)}`, {
-      cwd: root,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    info(`Auto-committed: ${message}`);
-  } catch {
-  }
-}
-var import_node_child_process;
-var init_git = __esm({
-  "src/git.ts"() {
-    "use strict";
-    import_node_child_process = require("child_process");
-    init_format();
-  }
-});
-
 // src/metrics.ts
 function compareMetrics(db, experimentId, config) {
   const before = getMetricsByExperimentAndPhase(db, experimentId, "before");
@@ -2926,13 +3085,13 @@ async function newExperiment(args) {
   const subType = getFlagValue(args, "--sub-type") ?? null;
   const exp = createExperiment(db, slug, branch, hypothesis, subType, null);
   success(`Created experiment #${exp.id}: ${exp.slug}`);
-  const docsDir = path5.join(root, "docs", "experiments");
-  const templatePath = path5.join(docsDir, "_TEMPLATE.md");
-  if (fs5.existsSync(templatePath)) {
-    const template = fs5.readFileSync(templatePath, "utf-8");
+  const docsDir = path6.join(root, "docs", "experiments");
+  const templatePath = path6.join(docsDir, "_TEMPLATE.md");
+  if (fs6.existsSync(templatePath)) {
+    const template = fs6.readFileSync(templatePath, "utf-8");
     const logContent = template.replace(/\{\{title\}\}/g, hypothesis).replace(/\{\{hypothesis\}\}/g, hypothesis).replace(/\{\{branch\}\}/g, branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, subType ?? "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    const logPath = path5.join(docsDir, `${paddedNum}-${slug}.md`);
-    fs5.writeFileSync(logPath, logContent);
+    const logPath = path6.join(docsDir, `${paddedNum}-${slug}.md`);
+    fs6.writeFileSync(logPath, logContent);
     info(`Created experiment log: docs/experiments/${paddedNum}-${slug}.md`);
   }
   autoCommit(root, `new: ${slug}`);
@@ -2988,12 +3147,12 @@ async function revert(args) {
   }
   info(`Experiment ${exp.slug} reverted to dead-end. Reason: ${reason}`);
 }
-var fs5, path5, import_node_child_process3;
+var fs6, path6, import_node_child_process3;
 var init_experiment = __esm({
   "src/commands/experiment.ts"() {
     "use strict";
-    fs5 = __toESM(require("fs"));
-    path5 = __toESM(require("path"));
+    fs6 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
     import_node_child_process3 = require("child_process");
     init_connection();
     init_queries();
@@ -3135,12 +3294,12 @@ function queryDeadEnds(db, args, isJson) {
   console.log(table(["ID", "Sub-Type", "Approach", "Constraint"], rows));
 }
 function queryFragility(root, isJson) {
-  const fragPath = path6.join(root, "docs", "synthesis", "fragility.md");
-  if (!fs6.existsSync(fragPath)) {
+  const fragPath = path7.join(root, "docs", "synthesis", "fragility.md");
+  if (!fs7.existsSync(fragPath)) {
     info("No fragility map found.");
     return;
   }
-  const content = fs6.readFileSync(fragPath, "utf-8");
+  const content = fs7.readFileSync(fragPath, "utf-8");
   if (isJson) {
     console.log(JSON.stringify({ content }, null, 2));
     return;
@@ -3196,7 +3355,7 @@ function queryCircuitBreakers(db, root, isJson) {
 function checkCommit(db) {
   let stdinData = "";
   try {
-    stdinData = fs6.readFileSync(0, "utf-8");
+    stdinData = fs7.readFileSync(0, "utf-8");
   } catch {
   }
   if (stdinData) {
@@ -3221,12 +3380,12 @@ function checkCommit(db) {
     process.exit(1);
   }
 }
-var fs6, path6;
+var fs7, path7;
 var init_query = __esm({
   "src/commands/query.ts"() {
     "use strict";
-    fs6 = __toESM(require("fs"));
-    path6 = __toESM(require("path"));
+    fs7 = __toESM(require("fs"));
+    path7 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_config();
@@ -3518,23 +3677,23 @@ function gitRevert(branch, cwd) {
   }
 }
 function appendToFragilityMap(projectRoot, expSlug, gaps) {
-  const fragPath = path7.join(projectRoot, "docs", "synthesis", "fragility.md");
+  const fragPath = path8.join(projectRoot, "docs", "synthesis", "fragility.md");
   let content = "";
-  if (fs7.existsSync(fragPath)) {
-    content = fs7.readFileSync(fragPath, "utf-8");
+  if (fs8.existsSync(fragPath)) {
+    content = fs8.readFileSync(fragPath, "utf-8");
   }
   const entry = `
 ## From experiment: ${expSlug}
 ${gaps}
 `;
-  fs7.writeFileSync(fragPath, content + entry);
+  fs8.writeFileSync(fragPath, content + entry);
 }
-var fs7, path7, import_node_child_process4;
+var fs8, path8, import_node_child_process4;
 var init_resolve = __esm({
   "src/resolve.ts"() {
     "use strict";
-    fs7 = __toESM(require("fs"));
-    path7 = __toESM(require("path"));
+    fs8 = __toESM(require("fs"));
+    path8 = __toESM(require("path"));
     init_types2();
     init_queries();
     init_spawn();
@@ -3606,8 +3765,8 @@ async function runResolve(db, exp, root) {
 }
 async function doGate(db, exp, root) {
   transition(exp.status, "gated" /* GATED */);
-  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
-  const fragility = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path9.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
   const structuralDeadEnds = exp.sub_type ? listStructuralDeadEndsBySubType(db, exp.sub_type) : listStructuralDeadEnds(db);
   const result = await spawnAgent("gatekeeper", {
     experiment: {
@@ -3651,8 +3810,8 @@ async function doBuild(db, exp, root) {
   transition(exp.status, "building" /* BUILDING */);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
   const builderGuidance = getBuilderGuidance(db, exp.id);
-  const fragility = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
-  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path9.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
   const confirmedDoubts = getConfirmedDoubts(db, exp.id);
   const config = loadConfig(root);
   const existingBaseline = getMetricsByExperimentAndPhase(db, exp.id, "before");
@@ -3747,7 +3906,7 @@ async function doChallenge(db, exp, root) {
   } catch {
   }
   if (gitDiff.length > 8e3) gitDiff = gitDiff.slice(0, 8e3) + "\n[DIFF TRUNCATED]";
-  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const synthesis = truncateContext(readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
   let taskPrompt = `Construct adversarial test cases for experiment ${exp.slug}: ${exp.hypothesis}`;
   if (gitDiff) {
     taskPrompt += `
@@ -3780,9 +3939,9 @@ ${gitDiff}
 async function doDoubt(db, exp, root) {
   transition(exp.status, "doubted" /* DOUBTED */);
   const paddedNum = String(exp.id).padStart(3, "0");
-  const expDocPath = path8.join(root, "docs", "experiments", `${paddedNum}-${exp.slug}.md`);
+  const expDocPath = path9.join(root, "docs", "experiments", `${paddedNum}-${exp.slug}.md`);
   const experimentDoc = truncateContext(readFileOrEmpty(expDocPath), CONTEXT_LIMITS.experimentDoc);
-  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const synthesis = truncateContext(readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
   let taskPrompt = `Doubt the work in experiment ${exp.slug}: ${exp.hypothesis}. Produce a doubt document with evidence for each doubt.`;
   if (experimentDoc) {
@@ -3821,8 +3980,8 @@ ${experimentDoc}
 }
 async function doScout(db, exp, root) {
   transition(exp.status, "scouted" /* SCOUTED */);
-  const synthesis = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
-  const fragility = truncateContext(readFileOrEmpty(path8.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const synthesis = truncateContext(readFileOrEmpty(path9.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path9.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
   const deadEnds = exp.sub_type ? listDeadEndsBySubType(db, exp.sub_type) : listAllDeadEnds(db);
   const deadEndsSummary = deadEnds.map(
     (d) => `- [${d.category ?? "structural"}] ${d.approach}: ${d.why_failed}`
@@ -3869,12 +4028,12 @@ ${fragility}`;
 async function doVerify(db, exp, root) {
   transition(exp.status, "verifying" /* VERIFYING */);
   const doubts = getDoubtsByExperiment(db, exp.id);
-  const challengeDir = path8.join(root, "docs", "challenges");
+  const challengeDir = path9.join(root, "docs", "challenges");
   let challenges = "";
-  if (fs8.existsSync(challengeDir)) {
-    const files = fs8.readdirSync(challengeDir).filter((f) => f.includes(exp.slug) && f.endsWith(".md"));
+  if (fs9.existsSync(challengeDir)) {
+    const files = fs9.readdirSync(challengeDir).filter((f) => f.includes(exp.slug) && f.endsWith(".md"));
     for (const f of files) {
-      challenges += fs8.readFileSync(path8.join(challengeDir, f), "utf-8") + "\n\n";
+      challenges += fs9.readFileSync(path9.join(challengeDir, f), "utf-8") + "\n\n";
     }
   }
   const beforeMetrics = getMetricsByExperimentAndPhase(db, exp.id, "before");
@@ -3942,14 +4101,14 @@ async function doVerify(db, exp, root) {
   success(`Verification complete for ${exp.slug}. Run \`majlis resolve\` next.`);
 }
 async function doCompress(db, root) {
-  const synthesisPath = path8.join(root, "docs", "synthesis", "current.md");
-  const sizeBefore = fs8.existsSync(synthesisPath) ? fs8.statSync(synthesisPath).size : 0;
+  const synthesisPath = path9.join(root, "docs", "synthesis", "current.md");
+  const sizeBefore = fs9.existsSync(synthesisPath) ? fs9.statSync(synthesisPath).size : 0;
   const sessionCount = getSessionsSinceCompression(db);
   const dbExport = exportForCompressor(db);
   const result = await spawnAgent("compressor", {
     taskPrompt: "## Structured Data (CANONICAL \u2014 from SQLite database)\nThe database export below is the source of truth. docs/ files are agent artifacts that may contain stale or incorrect information. Cross-reference everything against this data.\n\n" + dbExport + "\n\n## Your Task\nRead ALL experiments, decisions, doubts, challenges, verification reports, reframes, and recent diffs. Cross-reference for contradictions, redundancies, and patterns. REWRITE docs/synthesis/current.md \u2014 shorter and denser. Update docs/synthesis/fragility.md with current weak areas. Update docs/synthesis/dead-ends.md with structural constraints from rejected experiments."
   }, root);
-  const sizeAfter = fs8.existsSync(synthesisPath) ? fs8.statSync(synthesisPath).size : 0;
+  const sizeAfter = fs9.existsSync(synthesisPath) ? fs9.statSync(synthesisPath).size : 0;
   recordCompression(db, sessionCount, sizeBefore, sizeAfter);
   autoCommit(root, "compress: update synthesis");
   success(`Compression complete. Synthesis: ${sizeBefore}B \u2192 ${sizeAfter}B`);
@@ -4041,12 +4200,12 @@ function ingestStructuredOutput(db, experimentId, structured) {
     info(`Ingested ${structured.findings.length} finding(s)`);
   }
 }
-var fs8, path8, import_node_child_process5;
+var fs9, path9, import_node_child_process5;
 var init_cycle = __esm({
   "src/commands/cycle.ts"() {
     "use strict";
-    fs8 = __toESM(require("fs"));
-    path8 = __toESM(require("path"));
+    fs9 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
     import_node_child_process5 = require("child_process");
     init_connection();
     init_queries();
@@ -4074,10 +4233,10 @@ async function classify(args) {
   if (!domain) {
     throw new Error('Usage: majlis classify "domain description"');
   }
-  const synthesisPath = path9.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs9.existsSync(synthesisPath) ? fs9.readFileSync(synthesisPath, "utf-8") : "";
-  const deadEndsPath = path9.join(root, "docs", "synthesis", "dead-ends.md");
-  const deadEnds = fs9.existsSync(deadEndsPath) ? fs9.readFileSync(deadEndsPath, "utf-8") : "";
+  const synthesisPath = path10.join(root, "docs", "synthesis", "current.md");
+  const synthesis = fs10.existsSync(synthesisPath) ? fs10.readFileSync(synthesisPath, "utf-8") : "";
+  const deadEndsPath = path10.join(root, "docs", "synthesis", "dead-ends.md");
+  const deadEnds = fs10.existsSync(deadEndsPath) ? fs10.readFileSync(deadEndsPath, "utf-8") : "";
   info(`Classifying problem domain: ${domain}`);
   const result = await spawnAgent("builder", {
     synthesis,
@@ -4096,22 +4255,22 @@ Write the classification to docs/classification/ following the template.`
 async function reframe(args) {
   const root = findProjectRoot();
   if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
-  const classificationDir = path9.join(root, "docs", "classification");
+  const classificationDir = path10.join(root, "docs", "classification");
   let classificationContent = "";
-  if (fs9.existsSync(classificationDir)) {
-    const files = fs9.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+  if (fs10.existsSync(classificationDir)) {
+    const files = fs10.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
     for (const f of files) {
-      classificationContent += fs9.readFileSync(path9.join(classificationDir, f), "utf-8") + "\n\n";
+      classificationContent += fs10.readFileSync(path10.join(classificationDir, f), "utf-8") + "\n\n";
     }
   }
-  const synthesisPath = path9.join(root, "docs", "synthesis", "current.md");
-  const synthesis = fs9.existsSync(synthesisPath) ? fs9.readFileSync(synthesisPath, "utf-8") : "";
-  const deadEndsPath = path9.join(root, "docs", "synthesis", "dead-ends.md");
-  const deadEnds = fs9.existsSync(deadEndsPath) ? fs9.readFileSync(deadEndsPath, "utf-8") : "";
-  const configPath = path9.join(root, ".majlis", "config.json");
+  const synthesisPath = path10.join(root, "docs", "synthesis", "current.md");
+  const synthesis = fs10.existsSync(synthesisPath) ? fs10.readFileSync(synthesisPath, "utf-8") : "";
+  const deadEndsPath = path10.join(root, "docs", "synthesis", "dead-ends.md");
+  const deadEnds = fs10.existsSync(deadEndsPath) ? fs10.readFileSync(deadEndsPath, "utf-8") : "";
+  const configPath = path10.join(root, ".majlis", "config.json");
   let problemStatement = "";
-  if (fs9.existsSync(configPath)) {
-    const config = JSON.parse(fs9.readFileSync(configPath, "utf-8"));
+  if (fs10.existsSync(configPath)) {
+    const config = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
     problemStatement = `${config.project?.description ?? ""}
 Objective: ${config.project?.objective ?? ""}`;
   }
@@ -4136,12 +4295,12 @@ Write to docs/reframes/.`
   autoCommit(root, `reframe: ${target.slice(0, 60)}`);
   success("Reframe complete. Check docs/reframes/ for the output.");
 }
-var fs9, path9;
+var fs10, path10;
 var init_classify = __esm({
   "src/commands/classify.ts"() {
     "use strict";
-    fs9 = __toESM(require("fs"));
-    path9 = __toESM(require("path"));
+    fs10 = __toESM(require("fs"));
+    path10 = __toESM(require("path"));
     init_connection();
     init_spawn();
     init_git();
@@ -4163,15 +4322,15 @@ async function audit(args) {
   const experiments = listAllExperiments(db);
   const deadEnds = listAllDeadEnds(db);
   const circuitBreakers = getAllCircuitBreakerStates(db, config.cycle.circuit_breaker_threshold);
-  const classificationDir = path10.join(root, "docs", "classification");
+  const classificationDir = path11.join(root, "docs", "classification");
   let classification = "";
-  if (fs10.existsSync(classificationDir)) {
-    const files = fs10.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
+  if (fs11.existsSync(classificationDir)) {
+    const files = fs11.readdirSync(classificationDir).filter((f) => f.endsWith(".md") && !f.startsWith("_"));
     for (const f of files) {
-      classification += fs10.readFileSync(path10.join(classificationDir, f), "utf-8") + "\n\n";
+      classification += fs11.readFileSync(path11.join(classificationDir, f), "utf-8") + "\n\n";
     }
   }
-  const synthesis = readFileOrEmpty(path10.join(root, "docs", "synthesis", "current.md"));
+  const synthesis = readFileOrEmpty(path11.join(root, "docs", "synthesis", "current.md"));
   header("Maqasid Check \u2014 Purpose Audit");
   const trippedBreakers = circuitBreakers.filter((cb) => cb.tripped);
   if (trippedBreakers.length > 0) {
@@ -4215,12 +4374,12 @@ Output: either "classification confirmed \u2014 continue" or "re-classify from X
   }, root);
   success("Purpose audit complete. Review the output above.");
 }
-var fs10, path10;
+var fs11, path11;
 var init_audit = __esm({
   "src/commands/audit.ts"() {
     "use strict";
-    fs10 = __toESM(require("fs"));
-    path10 = __toESM(require("path"));
+    fs11 = __toESM(require("fs"));
+    path11 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_spawn();
@@ -4505,9 +4664,9 @@ async function run(args) {
   info("Run `majlis status` to see final state.");
 }
 async function deriveNextHypothesis(goal, root, db) {
-  const synthesis = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
-  const fragility = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
-  const deadEndsDoc = truncateContext(readFileOrEmpty(path11.join(root, "docs", "synthesis", "dead-ends.md")), CONTEXT_LIMITS.deadEnds);
+  const synthesis = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "current.md")), CONTEXT_LIMITS.synthesis);
+  const fragility = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "fragility.md")), CONTEXT_LIMITS.fragility);
+  const deadEndsDoc = truncateContext(readFileOrEmpty(path12.join(root, "docs", "synthesis", "dead-ends.md")), CONTEXT_LIMITS.deadEnds);
   const diagnosis = truncateContext(readLatestDiagnosis(root), CONTEXT_LIMITS.synthesis);
   const deadEnds = listAllDeadEnds(db);
   const config = loadConfig(root);
@@ -4625,23 +4784,23 @@ async function createNewExperiment(db, root, hypothesis) {
   const exp = createExperiment(db, finalSlug, branch, hypothesis, null, null);
   updateExperimentStatus(db, exp.id, "reframed");
   exp.status = "reframed";
-  const docsDir = path11.join(root, "docs", "experiments");
-  const templatePath = path11.join(docsDir, "_TEMPLATE.md");
-  if (fs11.existsSync(templatePath)) {
-    const template = fs11.readFileSync(templatePath, "utf-8");
+  const docsDir = path12.join(root, "docs", "experiments");
+  const templatePath = path12.join(docsDir, "_TEMPLATE.md");
+  if (fs12.existsSync(templatePath)) {
+    const template = fs12.readFileSync(templatePath, "utf-8");
     const logContent = template.replace(/\{\{title\}\}/g, hypothesis).replace(/\{\{hypothesis\}\}/g, hypothesis).replace(/\{\{branch\}\}/g, branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    const logPath = path11.join(docsDir, `${paddedNum}-${finalSlug}.md`);
-    fs11.writeFileSync(logPath, logContent);
+    const logPath = path12.join(docsDir, `${paddedNum}-${finalSlug}.md`);
+    fs12.writeFileSync(logPath, logContent);
     info(`Created experiment log: docs/experiments/${paddedNum}-${finalSlug}.md`);
   }
   return exp;
 }
-var fs11, path11, import_node_child_process6;
+var fs12, path12, import_node_child_process6;
 var init_run = __esm({
   "src/commands/run.ts"() {
     "use strict";
-    fs11 = __toESM(require("fs"));
-    path11 = __toESM(require("path"));
+    fs12 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
     import_node_child_process6 = require("child_process");
     init_connection();
     init_queries();
@@ -4658,9 +4817,9 @@ var init_run = __esm({
 
 // src/swarm/worktree.ts
 function createWorktree(mainRoot, slug, paddedNum) {
-  const projectName = path12.basename(mainRoot);
+  const projectName = path13.basename(mainRoot);
   const worktreeName = `${projectName}-swarm-${paddedNum}-${slug}`;
-  const worktreePath = path12.join(path12.dirname(mainRoot), worktreeName);
+  const worktreePath = path13.join(path13.dirname(mainRoot), worktreeName);
   const branch = `swarm/${paddedNum}-${slug}`;
   (0, import_node_child_process7.execSync)(`git worktree add ${JSON.stringify(worktreePath)} -b ${branch}`, {
     cwd: mainRoot,
@@ -4677,36 +4836,36 @@ function createWorktree(mainRoot, slug, paddedNum) {
   };
 }
 function initializeWorktree(mainRoot, worktreePath) {
-  const majlisDir = path12.join(worktreePath, ".majlis");
-  fs12.mkdirSync(majlisDir, { recursive: true });
-  const configSrc = path12.join(mainRoot, ".majlis", "config.json");
-  if (fs12.existsSync(configSrc)) {
-    fs12.copyFileSync(configSrc, path12.join(majlisDir, "config.json"));
-  }
-  const agentsSrc = path12.join(mainRoot, ".majlis", "agents");
-  if (fs12.existsSync(agentsSrc)) {
-    const agentsDst = path12.join(majlisDir, "agents");
-    fs12.mkdirSync(agentsDst, { recursive: true });
-    for (const file of fs12.readdirSync(agentsSrc)) {
-      fs12.copyFileSync(path12.join(agentsSrc, file), path12.join(agentsDst, file));
+  const majlisDir = path13.join(worktreePath, ".majlis");
+  fs13.mkdirSync(majlisDir, { recursive: true });
+  const configSrc = path13.join(mainRoot, ".majlis", "config.json");
+  if (fs13.existsSync(configSrc)) {
+    fs13.copyFileSync(configSrc, path13.join(majlisDir, "config.json"));
+  }
+  const agentsSrc = path13.join(mainRoot, ".majlis", "agents");
+  if (fs13.existsSync(agentsSrc)) {
+    const agentsDst = path13.join(majlisDir, "agents");
+    fs13.mkdirSync(agentsDst, { recursive: true });
+    for (const file of fs13.readdirSync(agentsSrc)) {
+      fs13.copyFileSync(path13.join(agentsSrc, file), path13.join(agentsDst, file));
     }
   }
-  const synthSrc = path12.join(mainRoot, "docs", "synthesis");
-  if (fs12.existsSync(synthSrc)) {
-    const synthDst = path12.join(worktreePath, "docs", "synthesis");
-    fs12.mkdirSync(synthDst, { recursive: true });
-    for (const file of fs12.readdirSync(synthSrc)) {
-      const srcFile = path12.join(synthSrc, file);
-      if (fs12.statSync(srcFile).isFile()) {
-        fs12.copyFileSync(srcFile, path12.join(synthDst, file));
+  const synthSrc = path13.join(mainRoot, "docs", "synthesis");
+  if (fs13.existsSync(synthSrc)) {
+    const synthDst = path13.join(worktreePath, "docs", "synthesis");
+    fs13.mkdirSync(synthDst, { recursive: true });
+    for (const file of fs13.readdirSync(synthSrc)) {
+      const srcFile = path13.join(synthSrc, file);
+      if (fs13.statSync(srcFile).isFile()) {
+        fs13.copyFileSync(srcFile, path13.join(synthDst, file));
       }
     }
   }
-  const templateSrc = path12.join(mainRoot, "docs", "experiments", "_TEMPLATE.md");
-  if (fs12.existsSync(templateSrc)) {
-    const expDir = path12.join(worktreePath, "docs", "experiments");
-    fs12.mkdirSync(expDir, { recursive: true });
-    fs12.copyFileSync(templateSrc, path12.join(expDir, "_TEMPLATE.md"));
+  const templateSrc = path13.join(mainRoot, "docs", "experiments", "_TEMPLATE.md");
+  if (fs13.existsSync(templateSrc)) {
+    const expDir = path13.join(worktreePath, "docs", "experiments");
+    fs13.mkdirSync(expDir, { recursive: true });
+    fs13.copyFileSync(templateSrc, path13.join(expDir, "_TEMPLATE.md"));
   }
   const db = openDbAt(worktreePath);
   db.close();
@@ -4738,12 +4897,12 @@ function cleanupWorktree(mainRoot, wt) {
   } catch {
   }
 }
-var fs12, path12, import_node_child_process7;
+var fs13, path13, import_node_child_process7;
 var init_worktree = __esm({
   "src/swarm/worktree.ts"() {
     "use strict";
-    fs12 = __toESM(require("fs"));
-    path12 = __toESM(require("path"));
+    fs13 = __toESM(require("fs"));
+    path13 = __toESM(require("path"));
     import_node_child_process7 = require("child_process");
     init_connection();
     init_format();
@@ -4762,12 +4921,12 @@ async function runExperimentInWorktree(wt) {
     exp = createExperiment(db, wt.slug, wt.branch, wt.hypothesis, null, null);
     updateExperimentStatus(db, exp.id, "reframed");
     exp.status = "reframed";
-    const templatePath = path13.join(wt.path, "docs", "experiments", "_TEMPLATE.md");
-    if (fs13.existsSync(templatePath)) {
-      const template = fs13.readFileSync(templatePath, "utf-8");
+    const templatePath = path14.join(wt.path, "docs", "experiments", "_TEMPLATE.md");
+    if (fs14.existsSync(templatePath)) {
+      const template = fs14.readFileSync(templatePath, "utf-8");
       const logContent = template.replace(/\{\{title\}\}/g, wt.hypothesis).replace(/\{\{hypothesis\}\}/g, wt.hypothesis).replace(/\{\{branch\}\}/g, wt.branch).replace(/\{\{status\}\}/g, "classified").replace(/\{\{sub_type\}\}/g, "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-      const logPath = path13.join(wt.path, "docs", "experiments", `${wt.paddedNum}-${wt.slug}.md`);
-      fs13.writeFileSync(logPath, logContent);
+      const logPath = path14.join(wt.path, "docs", "experiments", `${wt.paddedNum}-${wt.slug}.md`);
+      fs14.writeFileSync(logPath, logContent);
     }
     info(`${label} Starting: ${wt.hypothesis}`);
     while (stepCount < MAX_STEPS) {
@@ -4890,12 +5049,12 @@ function statusToStepName(status2) {
       return null;
   }
 }
-var fs13, path13, MAX_STEPS;
+var fs14, path14, MAX_STEPS;
 var init_runner = __esm({
   "src/swarm/runner.ts"() {
     "use strict";
-    fs13 = __toESM(require("fs"));
-    path13 = __toESM(require("path"));
+    fs14 = __toESM(require("fs"));
+    path14 = __toESM(require("path"));
     init_connection();
     init_queries();
     init_machine();
@@ -5181,15 +5340,15 @@ function isMergeable(grade) {
 }
 async function deriveMultipleHypotheses(goal, root, count) {
   const synthesis = truncateContext(
-    readFileOrEmpty(path14.join(root, "docs", "synthesis", "current.md")),
+    readFileOrEmpty(path15.join(root, "docs", "synthesis", "current.md")),
     CONTEXT_LIMITS.synthesis
   );
   const fragility = truncateContext(
-    readFileOrEmpty(path14.join(root, "docs", "synthesis", "fragility.md")),
+    readFileOrEmpty(path15.join(root, "docs", "synthesis", "fragility.md")),
     CONTEXT_LIMITS.fragility
   );
   const deadEndsDoc = truncateContext(
-    readFileOrEmpty(path14.join(root, "docs", "synthesis", "dead-ends.md")),
+    readFileOrEmpty(path15.join(root, "docs", "synthesis", "dead-ends.md")),
     CONTEXT_LIMITS.deadEnds
   );
   const diagnosis = truncateContext(readLatestDiagnosis(root), CONTEXT_LIMITS.synthesis);
@@ -5279,11 +5438,11 @@ If the goal is met:
   warn("Planner did not return structured hypotheses. Using goal as single hypothesis.");
   return [goal];
 }
-var path14, import_node_child_process8, MAX_PARALLEL, DEFAULT_PARALLEL;
+var path15, import_node_child_process8, MAX_PARALLEL, DEFAULT_PARALLEL;
 var init_swarm = __esm({
   "src/commands/swarm.ts"() {
     "use strict";
-    path14 = __toESM(require("path"));
+    path15 = __toESM(require("path"));
     import_node_child_process8 = require("child_process");
     init_connection();
     init_queries();
@@ -5309,16 +5468,16 @@ async function diagnose(args) {
   const db = getDb(root);
   const focus = args.filter((a) => !a.startsWith("--")).join(" ");
   const keepScripts = args.includes("--keep-scripts");
-  const scriptsDir = path15.join(root, ".majlis", "scripts");
-  if (!fs14.existsSync(scriptsDir)) {
-    fs14.mkdirSync(scriptsDir, { recursive: true });
+  const scriptsDir = path16.join(root, ".majlis", "scripts");
+  if (!fs15.existsSync(scriptsDir)) {
+    fs15.mkdirSync(scriptsDir, { recursive: true });
   }
   header("Deep Diagnosis");
   if (focus) info(`Focus: ${focus}`);
   const dbExport = exportForDiagnostician(db);
-  const synthesis = readFileOrEmpty(path15.join(root, "docs", "synthesis", "current.md"));
-  const fragility = readFileOrEmpty(path15.join(root, "docs", "synthesis", "fragility.md"));
-  const deadEndsDoc = readFileOrEmpty(path15.join(root, "docs", "synthesis", "dead-ends.md"));
+  const synthesis = readFileOrEmpty(path16.join(root, "docs", "synthesis", "current.md"));
+  const fragility = readFileOrEmpty(path16.join(root, "docs", "synthesis", "fragility.md"));
+  const deadEndsDoc = readFileOrEmpty(path16.join(root, "docs", "synthesis", "dead-ends.md"));
   const config = loadConfig(root);
   let metricsOutput = "";
   if (config.metrics?.command) {
@@ -5369,13 +5528,13 @@ Perform a deep diagnostic analysis of this project. Identify root causes, recurr
 Remember: you may write files ONLY to .majlis/scripts/. You cannot modify project code.`;
   info("Spawning diagnostician (60 turns, full DB access)...");
   const result = await spawnAgent("diagnostician", { taskPrompt }, root);
-  const diagnosisDir = path15.join(root, "docs", "diagnosis");
-  if (!fs14.existsSync(diagnosisDir)) {
-    fs14.mkdirSync(diagnosisDir, { recursive: true });
+  const diagnosisDir = path16.join(root, "docs", "diagnosis");
+  if (!fs15.existsSync(diagnosisDir)) {
+    fs15.mkdirSync(diagnosisDir, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const artifactPath = path15.join(diagnosisDir, `diagnosis-${timestamp}.md`);
-  fs14.writeFileSync(artifactPath, result.output);
+  const artifactPath = path16.join(diagnosisDir, `diagnosis-${timestamp}.md`);
+  fs15.writeFileSync(artifactPath, result.output);
   info(`Diagnostic report: docs/diagnosis/diagnosis-${timestamp}.md`);
   if (result.structured?.diagnosis) {
     const d = result.structured.diagnosis;
@@ -5388,11 +5547,11 @@ Remember: you may write files ONLY to .majlis/scripts/. You cannot modify projec
   }
   if (!keepScripts) {
     try {
-      const files = fs14.readdirSync(scriptsDir);
+      const files = fs15.readdirSync(scriptsDir);
       for (const f of files) {
-        fs14.unlinkSync(path15.join(scriptsDir, f));
+        fs15.unlinkSync(path16.join(scriptsDir, f));
       }
-      fs14.rmdirSync(scriptsDir);
+      fs15.rmdirSync(scriptsDir);
       info("Cleaned up .majlis/scripts/");
     } catch {
     }
@@ -5405,12 +5564,12 @@ Remember: you may write files ONLY to .majlis/scripts/. You cannot modify projec
   autoCommit(root, `diagnosis: ${focus || "general"}`);
   success("Diagnosis complete.");
 }
-var fs14, path15, import_node_child_process9;
+var fs15, path16, import_node_child_process9;
 var init_diagnose = __esm({
   "src/commands/diagnose.ts"() {
     "use strict";
-    fs14 = __toESM(require("fs"));
-    path15 = __toESM(require("path"));
+    fs15 = __toESM(require("fs"));
+    path16 = __toESM(require("path"));
     import_node_child_process9 = require("child_process");
     init_connection();
     init_queries();
@@ -5422,10 +5581,10 @@ var init_diagnose = __esm({
 });
 
 // src/cli.ts
-var fs15 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
-var VERSION = JSON.parse(
-  fs15.readFileSync(path16.join(__dirname, "..", "package.json"), "utf-8")
+var fs16 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
+var VERSION2 = JSON.parse(
+  fs16.readFileSync(path17.join(__dirname, "..", "package.json"), "utf-8")
 ).version;
 async function main() {
   let sigintCount = 0;
@@ -5438,7 +5597,7 @@ async function main() {
   });
   const args = process.argv.slice(2);
   if (args.includes("--version") || args.includes("-v")) {
-    console.log(VERSION);
+    console.log(VERSION2);
     return;
   }
   if (args.includes("--help") || args.includes("-h") || args.length === 0) {
@@ -5455,6 +5614,11 @@ async function main() {
         await init2(rest);
         break;
       }
+      case "upgrade": {
+        const { upgrade: upgrade2 } = await Promise.resolve().then(() => (init_upgrade(), upgrade_exports));
+        await upgrade2(rest);
+        break;
+      }
       case "status": {
         const { status: status2 } = await Promise.resolve().then(() => (init_status(), status_exports));
         await status2(isJson);
@@ -5563,12 +5727,13 @@ async function main() {
 }
 function printHelp() {
   console.log(`
-majlis v${VERSION} \u2014 Structured multi-agent problem solving
+majlis v${VERSION2} \u2014 Structured multi-agent problem solving
 
 Usage: majlis <command> [options]
 
 Lifecycle:
   init                       Initialize Majlis in current project
+  upgrade                    Sync agents, commands, hooks from CLI version
   status [--json]            Show experiment states and cycle position
 
 Experiments:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "majlis",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Multi-agent workflow CLI for structured doubt, independent verification, and compressed knowledge",
   "bin": {
     "majlis": "./dist/cli.js"