majlis 0.6.0 → 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 "";
   }
@@ -1903,12 +2094,22 @@ function truncateContext(content, limit) {
   if (content.length <= limit) return content;
   return content.slice(0, limit) + "\n[TRUNCATED]";
 }
-var fs3, path3, DEFAULT_CONFIG2, _cachedConfig, _cachedRoot, CONTEXT_LIMITS;
+function readLatestDiagnosis(projectRoot) {
+  const dir = path4.join(projectRoot, "docs", "diagnosis");
+  try {
+    const files = fs4.readdirSync(dir).filter((f) => f.startsWith("diagnosis-") && f.endsWith(".md")).sort().reverse();
+    if (files.length === 0) return "";
+    return fs4.readFileSync(path4.join(dir, files[0]), "utf-8");
+  } catch {
+    return "";
+  }
+}
+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: {} },
@@ -2237,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}`);
@@ -2417,8 +2618,10 @@ ${taskPrompt}`;
   }
   return { output: markdown, structured, truncated };
 }
-async function spawnSynthesiser(context, projectRoot) {
+async function spawnSynthesiser(context, projectRoot, opts) {
   const root = projectRoot ?? findProjectRoot() ?? process.cwd();
+  const maxTurns = opts?.maxTurns ?? 5;
+  const tools = opts?.tools ?? ["Read", "Glob", "Grep"];
   const contextJson = JSON.stringify(context);
   const taskPrompt = context.taskPrompt ?? "Synthesise the findings into actionable builder guidance.";
   const prompt = `Here is your context:
@@ -2429,14 +2632,14 @@ ${contextJson}
 
 ${taskPrompt}`;
   const systemPrompt = 'You are a Synthesis Agent. Be concrete: which decisions failed, which assumptions broke, what constraints must the next approach satisfy. CRITICAL: Your LAST line of output MUST be a <!-- majlis-json --> block. The framework parses this programmatically \u2014 if you omit it, the pipeline breaks. Format: <!-- majlis-json {"guidance": "your guidance here"} -->';
-  console.log(`[synthesiser] Spawning (maxTurns: 5)...`);
+  console.log(`[synthesiser] Spawning (maxTurns: ${maxTurns})...`);
   const { text: markdown, costUsd, truncated } = await runQuery({
     prompt,
     model: "sonnet",
-    tools: ["Read", "Glob", "Grep"],
+    tools,
     systemPrompt,
     cwd: root,
-    maxTurns: 5,
+    maxTurns,
     label: "synthesiser",
     role: "synthesiser"
   });
@@ -2447,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):
@@ -2618,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();
@@ -2752,7 +2955,7 @@ async function captureMetrics(phase, args) {
   if (config.build.pre_measure) {
     info(`Running pre-measure: ${config.build.pre_measure}`);
     try {
-      (0, import_node_child_process.execSync)(config.build.pre_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
+      (0, import_node_child_process2.execSync)(config.build.pre_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
     } catch {
       warn("Pre-measure command failed \u2014 continuing anyway.");
     }
@@ -2763,7 +2966,7 @@ async function captureMetrics(phase, args) {
   info(`Running metrics: ${config.metrics.command}`);
   let metricsOutput;
   try {
-    metricsOutput = (0, import_node_child_process.execSync)(config.metrics.command, {
+    metricsOutput = (0, import_node_child_process2.execSync)(config.metrics.command, {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -2782,7 +2985,7 @@ async function captureMetrics(phase, args) {
   success(`Captured ${parsed.length} metric(s) for ${exp.slug} (phase: ${phase})`);
   if (config.build.post_measure) {
     try {
-      (0, import_node_child_process.execSync)(config.build.post_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
+      (0, import_node_child_process2.execSync)(config.build.post_measure, { cwd: root, encoding: "utf-8", stdio: "inherit" });
     } catch {
       warn("Post-measure command failed.");
     }
@@ -2833,11 +3036,11 @@ function formatDelta(delta) {
   const prefix = delta > 0 ? "+" : "";
   return `${prefix}${delta.toFixed(4)}`;
 }
-var import_node_child_process;
+var import_node_child_process2;
 var init_measure = __esm({
   "src/commands/measure.ts"() {
     "use strict";
-    import_node_child_process = require("child_process");
+    import_node_child_process2 = require("child_process");
     init_connection();
     init_queries();
     init_metrics();
@@ -2870,7 +3073,7 @@ async function newExperiment(args) {
   const paddedNum = String(num).padStart(3, "0");
   const branch = `exp/${paddedNum}-${slug}`;
   try {
-    (0, import_node_child_process2.execSync)(`git checkout -b ${branch}`, {
+    (0, import_node_child_process3.execSync)(`git checkout -b ${branch}`, {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -2882,15 +3085,16 @@ 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}`);
   if (config.cycle.auto_baseline_on_new_experiment && config.metrics.command) {
     info("Auto-baselining... (run `majlis baseline` to do this manually)");
     try {
@@ -2927,12 +3131,12 @@ async function revert(args) {
   );
   updateExperimentStatus(db, exp.id, "dead_end");
   try {
-    const currentBranch = (0, import_node_child_process2.execSync)("git rev-parse --abbrev-ref HEAD", {
+    const currentBranch = (0, import_node_child_process3.execSync)("git rev-parse --abbrev-ref HEAD", {
       cwd: root,
       encoding: "utf-8"
     }).trim();
     if (currentBranch === exp.branch) {
-      (0, import_node_child_process2.execSync)("git checkout main 2>/dev/null || git checkout master", {
+      (0, import_node_child_process3.execSync)("git checkout main 2>/dev/null || git checkout master", {
         cwd: root,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -2943,17 +3147,18 @@ async function revert(args) {
   }
   info(`Experiment ${exp.slug} reverted to dead-end. Reason: ${reason}`);
 }
-var fs5, path5, import_node_child_process2;
+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"));
-    import_node_child_process2 = require("child_process");
+    fs6 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
+    import_node_child_process3 = require("child_process");
     init_connection();
     init_queries();
     init_config();
     init_spawn();
+    init_git();
     init_format();
   }
 });
@@ -3089,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;
@@ -3150,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) {
@@ -3175,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();
@@ -3301,6 +3506,7 @@ async function resolve(db, exp, projectRoot) {
       gitMerge(exp.branch, projectRoot);
       const gaps = grades.filter((g) => g.grade === "good").map((g) => `- **${g.component}**: ${g.notes ?? "minor gaps"}`).join("\n");
       appendToFragilityMap(projectRoot, exp.slug, gaps);
+      autoCommit(projectRoot, `resolve: fragility gaps from ${exp.slug}`);
       updateExperimentStatus(db, exp.id, "merged");
       success(`Experiment ${exp.slug} MERGED (good, ${grades.filter((g) => g.grade === "good").length} gaps added to fragility map).`);
       break;
@@ -3435,7 +3641,12 @@ async function resolveDbOnly(db, exp, projectRoot) {
 }
 function gitMerge(branch, cwd) {
   try {
-    (0, import_node_child_process3.execSync)(`git merge ${branch} --no-ff -m "Merge experiment branch ${branch}"`, {
+    (0, import_node_child_process4.execSync)("git checkout main 2>/dev/null || git checkout master", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    (0, import_node_child_process4.execSync)(`git merge ${branch} --no-ff -m "Merge experiment branch ${branch}"`, {
       cwd,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3446,16 +3657,16 @@ function gitMerge(branch, cwd) {
 }
 function gitRevert(branch, cwd) {
   try {
-    const currentBranch = (0, import_node_child_process3.execSync)("git rev-parse --abbrev-ref HEAD", {
+    const currentBranch = (0, import_node_child_process4.execSync)("git rev-parse --abbrev-ref HEAD", {
       cwd,
       encoding: "utf-8"
     }).trim();
     if (currentBranch === branch) {
       try {
-        (0, import_node_child_process3.execSync)("git checkout -- .", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        (0, import_node_child_process4.execSync)("git checkout -- .", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
       } catch {
       }
-      (0, import_node_child_process3.execSync)("git checkout main 2>/dev/null || git checkout master", {
+      (0, import_node_child_process4.execSync)("git checkout main 2>/dev/null || git checkout master", {
         cwd,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "pipe"]
@@ -3466,27 +3677,28 @@ 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_process3;
+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();
-    import_node_child_process3 = require("child_process");
+    import_node_child_process4 = require("child_process");
+    init_git();
     init_format();
   }
 });
@@ -3553,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: {
@@ -3598,14 +3810,14 @@ 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");
   if (config.metrics?.command && existingBaseline.length === 0) {
     try {
-      const output = (0, import_node_child_process4.execSync)(config.metrics.command, {
+      const output = (0, import_node_child_process5.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -3662,7 +3874,7 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
   } else {
     if (config.metrics?.command) {
       try {
-        const output = (0, import_node_child_process4.execSync)(config.metrics.command, {
+        const output = (0, import_node_child_process5.execSync)(config.metrics.command, {
           cwd: root,
           encoding: "utf-8",
           timeout: 6e4,
@@ -3686,7 +3898,7 @@ async function doChallenge(db, exp, root) {
   transition(exp.status, "challenged" /* CHALLENGED */);
   let gitDiff = "";
   try {
-    gitDiff = (0, import_node_child_process4.execSync)('git diff main -- . ":!.majlis/"', {
+    gitDiff = (0, import_node_child_process5.execSync)('git diff main -- . ":!.majlis/"', {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -3694,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 += `
@@ -3727,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) {
@@ -3768,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}`
@@ -3816,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");
@@ -3889,21 +4101,22 @@ 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`);
 }
 function gitCommitBuild(exp, cwd) {
   try {
-    (0, import_node_child_process4.execSync)('git add -A -- ":!.majlis/"', { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
-    const diff = (0, import_node_child_process4.execSync)("git diff --cached --stat", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    (0, import_node_child_process5.execSync)('git add -A -- ":!.majlis/"', { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const diff = (0, import_node_child_process5.execSync)("git diff --cached --stat", { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
     if (!diff) {
       info("No code changes to commit.");
       return;
@@ -3911,7 +4124,7 @@ function gitCommitBuild(exp, cwd) {
     const msg = `EXP-${String(exp.id).padStart(3, "0")}: ${exp.slug}
 
 ${exp.hypothesis ?? ""}`;
-    (0, import_node_child_process4.execSync)(`git commit -m ${JSON.stringify(msg)}`, { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    (0, import_node_child_process5.execSync)(`git commit -m ${JSON.stringify(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.");
@@ -3987,13 +4200,13 @@ function ingestStructuredOutput(db, experimentId, structured) {
     info(`Ingested ${structured.findings.length} finding(s)`);
   }
 }
-var fs8, path8, import_node_child_process4;
+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"));
-    import_node_child_process4 = require("child_process");
+    fs9 = __toESM(require("fs"));
+    path9 = __toESM(require("path"));
+    import_node_child_process5 = require("child_process");
     init_connection();
     init_queries();
     init_machine();
@@ -4002,6 +4215,7 @@ var init_cycle = __esm({
     init_resolve();
     init_config();
     init_metrics();
+    init_git();
     init_format();
   }
 });
@@ -4019,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,
@@ -4035,27 +4249,28 @@ ${deadEnds}
 
 Write the classification to docs/classification/ following the template.`
   }, root);
+  autoCommit(root, `classify: ${domain.slice(0, 60)}`);
   success("Classification complete. Check docs/classification/ for the output.");
 }
 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 ?? ""}`;
   }
@@ -4077,16 +4292,18 @@ ${deadEnds}
 Independently propose a decomposition. Compare with the existing classification. Flag structural divergences \u2014 these are the most valuable signals.
 Write to docs/reframes/.`
   }, root);
+  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();
     init_format();
   }
 });
@@ -4105,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) {
@@ -4157,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();
@@ -4398,6 +4615,7 @@ async function run(args) {
       usedHypotheses.add(hypothesis);
       info(`Next hypothesis: ${hypothesis}`);
       exp = await createNewExperiment(db, root, hypothesis);
+      autoCommit(root, `new: ${exp.slug}`);
       success(`Created experiment #${exp.id}: ${exp.slug}`);
     }
     if (isTerminal(exp.status)) {
@@ -4446,15 +4664,16 @@ 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);
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
-      metricsOutput = (0, import_node_child_process5.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process6.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -4469,7 +4688,10 @@ async function deriveNextHypothesis(goal, root, db) {
 
 ## Goal
 ${goal}
-
+${diagnosis ? `
+## Latest Diagnosis Report (PRIORITISE \u2014 deep analysis from diagnostician agent)
+${diagnosis}
+` : ""}
 ## Current Metrics
 ${metricsOutput || "(no metrics configured)"}
 
@@ -4489,6 +4711,8 @@ Note: [structural] dead ends are HARD CONSTRAINTS \u2014 your hypothesis MUST NO
 [procedural] dead ends are process failures \u2014 the approach may still be valid if executed differently.
 
 ## Your Task
+DO NOT read source code or use tools. All context you need is above. Plan from the synthesis and dead-end registry.
+
 1. Assess: based on the metrics and synthesis, has the goal been met? Be specific.
 2. If YES \u2014 output the JSON block below with goal_met: true.
 3. If NO \u2014 propose the SINGLE most promising next experiment hypothesis.
@@ -4504,7 +4728,7 @@ CRITICAL: Your LAST line of output MUST be EXACTLY this format (on its own line,
 
 If the goal is met:
 <!-- majlis-json {"goal_met": true, "hypothesis": null} -->`
-  }, root);
+  }, root, { maxTurns: 2, tools: [] });
   const structured = result.structured;
   if (structured?.goal_met === true) {
     return null;
@@ -4530,7 +4754,7 @@ If the goal is met:
 ${result.output.slice(-2e3)}
 
 <!-- majlis-json {"goal_met": false, "hypothesis": "your hypothesis"} -->`
-  }, root);
+  }, root, { maxTurns: 1, tools: [] });
   if (retry.structured?.hypothesis) return retry.structured.hypothesis;
   warn("Could not extract hypothesis. Using goal as fallback.");
   return goal;
@@ -4548,7 +4772,7 @@ async function createNewExperiment(db, root, hypothesis) {
   const paddedNum = String(num).padStart(3, "0");
   const branch = `exp/${paddedNum}-${finalSlug}`;
   try {
-    (0, import_node_child_process5.execSync)(`git checkout -b ${branch}`, {
+    (0, import_node_child_process6.execSync)(`git checkout -b ${branch}`, {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4560,24 +4784,24 @@ 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_process5;
+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"));
-    import_node_child_process5 = require("child_process");
+    fs12 = __toESM(require("fs"));
+    path12 = __toESM(require("path"));
+    import_node_child_process6 = require("child_process");
     init_connection();
     init_queries();
     init_machine();
@@ -4586,17 +4810,18 @@ var init_run = __esm({
     init_spawn();
     init_config();
     init_shutdown();
+    init_git();
     init_format();
   }
 });
 
 // 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_process6.execSync)(`git worktree add ${JSON.stringify(worktreePath)} -b ${branch}`, {
+  (0, import_node_child_process7.execSync)(`git worktree add ${JSON.stringify(worktreePath)} -b ${branch}`, {
     cwd: mainRoot,
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
@@ -4611,43 +4836,43 @@ 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();
 }
 function cleanupWorktree(mainRoot, wt) {
   try {
-    (0, import_node_child_process6.execSync)(`git worktree remove ${JSON.stringify(wt.path)} --force`, {
+    (0, import_node_child_process7.execSync)(`git worktree remove ${JSON.stringify(wt.path)} --force`, {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4656,7 +4881,7 @@ function cleanupWorktree(mainRoot, wt) {
     warn(`Could not remove worktree ${wt.path} \u2014 remove manually.`);
   }
   try {
-    (0, import_node_child_process6.execSync)(`git branch -D ${wt.branch}`, {
+    (0, import_node_child_process7.execSync)(`git branch -D ${wt.branch}`, {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4664,7 +4889,7 @@ function cleanupWorktree(mainRoot, wt) {
   } catch {
   }
   try {
-    (0, import_node_child_process6.execSync)("git worktree prune", {
+    (0, import_node_child_process7.execSync)("git worktree prune", {
       cwd: mainRoot,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -4672,13 +4897,13 @@ function cleanupWorktree(mainRoot, wt) {
   } catch {
   }
 }
-var fs12, path12, import_node_child_process6;
+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"));
-    import_node_child_process6 = require("child_process");
+    fs13 = __toESM(require("fs"));
+    path13 = __toESM(require("path"));
+    import_node_child_process7 = require("child_process");
     init_connection();
     init_format();
   }
@@ -4696,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) {
@@ -4824,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();
@@ -4983,7 +5208,7 @@ async function swarm(args) {
     MAX_PARALLEL
   );
   try {
-    const status2 = (0, import_node_child_process7.execSync)("git status --porcelain", {
+    const status2 = (0, import_node_child_process8.execSync)("git status --porcelain", {
       cwd: root,
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
@@ -5067,7 +5292,7 @@ async function swarm(args) {
     const best = summary.bestExperiment;
     info(`Best experiment: ${best.worktree.slug} (${best.overallGrade})`);
     try {
-      (0, import_node_child_process7.execSync)(
+      (0, import_node_child_process8.execSync)(
         `git merge ${best.worktree.branch} --no-ff -m "Merge swarm winner: ${best.worktree.slug}"`,
         { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       );
@@ -5115,24 +5340,25 @@ 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);
   const db = getDb(root);
   const deadEnds = listAllDeadEnds(db);
   const config = loadConfig(root);
   let metricsOutput = "";
   if (config.metrics?.command) {
     try {
-      metricsOutput = (0, import_node_child_process7.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process8.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -5147,7 +5373,10 @@ async function deriveMultipleHypotheses(goal, root, count) {
 
 ## Goal
 ${goal}
-
+${diagnosis ? `
+## Latest Diagnosis Report (PRIORITISE \u2014 deep analysis from diagnostician agent)
+${diagnosis}
+` : ""}
 ## Current Metrics
 ${metricsOutput || "(no metrics configured)"}
 
@@ -5167,6 +5396,8 @@ Note: [structural] dead ends are HARD CONSTRAINTS \u2014 hypotheses MUST NOT rep
 [procedural] dead ends are process failures \u2014 the approach may still be valid if executed differently.
 
 ## Your Task
+DO NOT read source code or use tools. All context you need is above. Plan from the synthesis and dead-end registry.
+
 1. Assess: based on the metrics and synthesis, has the goal been met? Be specific.
 2. If YES \u2014 output the JSON block below with goal_met: true.
 3. If NO \u2014 generate exactly ${count} DIVERSE hypotheses for parallel testing.
@@ -5184,7 +5415,7 @@ CRITICAL: Your LAST line of output MUST be EXACTLY this format (on its own line,
 
 If the goal is met:
 <!-- majlis-json {"goal_met": true, "hypotheses": []} -->`
-  }, root);
+  }, root, { maxTurns: 2, tools: [] });
   if (result.structured?.goal_met === true) return [];
   if (result.structured?.hypotheses && Array.isArray(result.structured.hypotheses)) {
     return result.structured.hypotheses.filter(
@@ -5207,12 +5438,12 @@ If the goal is met:
   warn("Planner did not return structured hypotheses. Using goal as single hypothesis.");
   return [goal];
 }
-var path14, import_node_child_process7, 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"));
-    import_node_child_process7 = require("child_process");
+    path15 = __toESM(require("path"));
+    import_node_child_process8 = require("child_process");
     init_connection();
     init_queries();
     init_spawn();
@@ -5237,21 +5468,21 @@ async function diagnose(args) {
   const db = getDb(root);
   const focus = args.filter((a) => !a.startsWith("--")).join(" ");
   const keepScripts = args.includes("--keep-scripts");
-  const scriptsDir = 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) {
     try {
-      metricsOutput = (0, import_node_child_process8.execSync)(config.metrics.command, {
+      metricsOutput = (0, import_node_child_process9.execSync)(config.metrics.command, {
         cwd: root,
         encoding: "utf-8",
         timeout: 6e4,
@@ -5297,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;
@@ -5316,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 {
     }
@@ -5330,28 +5561,30 @@ Remember: you may write files ONLY to .majlis/scripts/. You cannot modify projec
   if (result.truncated) {
     warn("Diagnostician was truncated (hit 60 turn limit).");
   }
+  autoCommit(root, `diagnosis: ${focus || "general"}`);
   success("Diagnosis complete.");
 }
-var fs14, path15, import_node_child_process8;
+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"));
-    import_node_child_process8 = require("child_process");
+    fs15 = __toESM(require("fs"));
+    path16 = __toESM(require("path"));
+    import_node_child_process9 = require("child_process");
     init_connection();
     init_queries();
     init_spawn();
     init_config();
+    init_git();
     init_format();
   }
 });
 
 // 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;
@@ -5364,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) {
@@ -5381,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);
@@ -5489,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: