majlis 0.7.1 → 0.7.3

package/dist/cli.js

@@ -9,6 +9,9 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -31,6 +34,116 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/output/format.ts
+function bold(s) {
+  return `${BOLD}${s}${RESET}`;
+}
+function dim(s) {
+  return `${DIM}${s}${RESET}`;
+}
+function red(s) {
+  return `${RED}${s}${RESET}`;
+}
+function green(s) {
+  return `${GREEN}${s}${RESET}`;
+}
+function yellow(s) {
+  return `${YELLOW}${s}${RESET}`;
+}
+function blue(s) {
+  return `${BLUE}${s}${RESET}`;
+}
+function cyan(s) {
+  return `${CYAN}${s}${RESET}`;
+}
+function statusColor(status2) {
+  switch (status2) {
+    case "merged":
+      return green(status2);
+    case "dead_end":
+      return red(status2);
+    case "building":
+    case "built":
+      return blue(status2);
+    case "verifying":
+    case "verified":
+      return cyan(status2);
+    case "classified":
+    case "reframed":
+      return dim(status2);
+    default:
+      return yellow(status2);
+  }
+}
+function evidenceColor(level) {
+  switch (level) {
+    case "proof":
+      return green(level);
+    case "test":
+      return cyan(level);
+    case "strong_consensus":
+      return blue(level);
+    case "consensus":
+      return blue(level);
+    case "analogy":
+      return yellow(level);
+    case "judgment":
+      return red(level);
+    default:
+      return level;
+  }
+}
+function table(headers, rows) {
+  const widths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => stripAnsi(r[i] ?? "").length))
+  );
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500");
+  const bodyLines = rows.map(
+    (row) => row.map((cell, i) => {
+      const stripped = stripAnsi(cell);
+      const padding = widths[i] - stripped.length;
+      return cell + " ".repeat(Math.max(0, padding));
+    }).join("  ")
+  );
+  return [bold(headerLine), separator, ...bodyLines].join("\n");
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function header(title) {
+  console.log(`
+${bold(`[majlis] ${title}`)}
+`);
+}
+function warn(msg) {
+  console.log(`${yellow("[majlis]")} ${msg}`);
+}
+function info(msg) {
+  console.log(`${cyan("[majlis]")} ${msg}`);
+}
+function error(msg) {
+  console.error(`${red("[majlis]")} ${msg}`);
+}
+function success(msg) {
+  console.log(`${green("[majlis]")} ${msg}`);
+}
+var useColor, RESET, BOLD, DIM, RED, GREEN, YELLOW, BLUE, CYAN;
+var init_format = __esm({
+  "src/output/format.ts"() {
+    "use strict";
+    useColor = !process.env.NO_COLOR && process.stderr.isTTY !== false;
+    RESET = useColor ? "\x1B[0m" : "";
+    BOLD = useColor ? "\x1B[1m" : "";
+    DIM = useColor ? "\x1B[2m" : "";
+    RED = useColor ? "\x1B[31m" : "";
+    GREEN = useColor ? "\x1B[32m" : "";
+    YELLOW = useColor ? "\x1B[33m" : "";
+    BLUE = useColor ? "\x1B[34m" : "";
+    CYAN = useColor ? "\x1B[36m" : "";
+  }
+});
+
 // src/shutdown.ts
 var shutdown_exports = {};
 __export(shutdown_exports, {
@@ -339,109 +452,1297 @@ var init_connection = __esm({
   }
 });
 
-// src/output/format.ts
-function bold(s) {
-  return `${BOLD}${s}${RESET}`;
-}
-function dim(s) {
-  return `${DIM}${s}${RESET}`;
-}
-function red(s) {
-  return `${RED}${s}${RESET}`;
-}
-function green(s) {
-  return `${GREEN}${s}${RESET}`;
-}
-function yellow(s) {
-  return `${YELLOW}${s}${RESET}`;
-}
-function blue(s) {
-  return `${BLUE}${s}${RESET}`;
-}
-function cyan(s) {
-  return `${CYAN}${s}${RESET}`;
-}
-function statusColor(status2) {
-  switch (status2) {
-    case "merged":
-      return green(status2);
-    case "dead_end":
-      return red(status2);
-    case "building":
-    case "built":
-      return blue(status2);
-    case "verifying":
-    case "verified":
-      return cyan(status2);
-    case "classified":
-    case "reframed":
-      return dim(status2);
-    default:
-      return yellow(status2);
-  }
+// ../shared/dist/index.js
+var require_dist = __commonJS({
+  "../shared/dist/index.js"(exports2, module2) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      AGENT_DEFINITIONS: () => AGENT_DEFINITIONS2,
+      CLAUDE_MD_SECTION: () => CLAUDE_MD_SECTION2,
+      DEFAULT_CONFIG: () => DEFAULT_CONFIG3,
+      DOC_DIRS: () => DOC_DIRS2,
+      DOC_TEMPLATES: () => DOC_TEMPLATES2,
+      HOOKS_CONFIG: () => HOOKS_CONFIG2,
+      SLASH_COMMANDS: () => SLASH_COMMANDS2,
+      SYNTHESIS_STARTERS: () => SYNTHESIS_STARTERS2,
+      WORKFLOW_MD: () => WORKFLOW_MD2,
+      claudeMdContent: () => claudeMdContent,
+      configTemplate: () => configTemplate,
+      formatValidation: () => formatValidation2,
+      mkdirSafe: () => mkdirSafe3,
+      validateProject: () => validateProject2
+    });
+    module2.exports = __toCommonJS2(index_exports);
+    var AGENT_DEFINITIONS2 = {
+      builder: `---
+name: builder
+model: opus
+tools: [Read, Write, Edit, Bash, Glob, Grep]
+---
+You are the Builder. You write code, run experiments, and make technical decisions.
+
+Before building:
+1. Read docs/synthesis/current.md for project state \u2014 this IS ground truth. Trust it.
+2. Read the dead-ends provided in your context \u2014 these are structural constraints.
+3. Read the experiment doc for this experiment \u2014 it has your hypothesis.
+
+The synthesis already contains the diagnosis. Do NOT re-diagnose. Do NOT run
+exploratory scripts to "understand the problem." The classify/doubt/challenge
+cycle already did that work. Your job is to read the synthesis, read the code
+at the specific sites mentioned, and implement the fix.
+
+Read source code at the specific locations relevant to your change. Do NOT
+read the entire codebase or run diagnostic Python scripts. If the synthesis
+says "lines 1921-22" then read those lines and their context. That's it.
+
+Do NOT read raw data files (fixtures/, ground truth JSON/STL). The synthesis
+has the relevant facts. Reading raw data wastes turns re-deriving what the
+doubt/challenge/verify cycle already established.
+
+## The Rule: ONE Change, Then Document
+
+You make ONE code change per cycle. Not two, not "one more quick fix." ONE.
+
+The sequence:
+1. **Read synthesis + experiment doc** \u2014 3-4 turns max.
+2. **Read code at specific sites** \u2014 2-3 turns max.
+3. **Write the experiment doc FIRST** \u2014 before coding, fill in the Approach section
+   with what you plan to do and why. This ensures there is always a record.
+4. **Implement ONE focused change** \u2014 a single coherent edit to the codebase.
+5. **Run the benchmark ONCE** \u2014 observe the result.
+6. **Update the experiment doc** \u2014 fill in Results and Metrics with what happened.
+7. **Output the majlis-json block** \u2014 your structured decisions.
+8. **STOP.**
+
+After the benchmark: ONLY steps 6-7-8. No investigating why it failed. No reading
+stderr. No "just checking one thing." Record the numbers, write your interpretation,
+output the JSON, DONE. Diagnosing failures is the critic's and adversary's job.
+
+If your change doesn't work, document what happened and STOP. Do NOT try to fix it.
+Do NOT iterate. Do NOT "try one more thing." The adversary, critic, and verifier
+exist to diagnose what went wrong. The cycle comes back to you with their insights.
+
+## Off-limits (DO NOT modify)
+- \`fixtures/\` \u2014 test data, ground truth, STL files. Read-only.
+- \`scripts/benchmark.py\` \u2014 the measurement tool. Never change how you're measured.
+- \`.majlis/\` \u2014 framework config. Not your concern.
+
+## Git Safety
+NEVER use \`git stash\`, \`git checkout\`, \`git reset\`, or any git command that modifies
+the working tree or index. The \`.majlis/majlis.db\` database is in the working tree \u2014
+these commands will corrupt framework state. Use \`git diff\` and \`git show\` for read-only comparison.
+
+## Confirmed Doubts
+If your context includes confirmedDoubts, these are weaknesses that the verifier has
+confirmed from a previous cycle. You MUST address each one. Do not ignore them \u2014
+the verifier will check again.
+
+## Metrics
+The framework captures baseline and post-build metrics automatically. Do NOT claim
+specific metric numbers unless quoting framework output. Do NOT run the benchmark
+yourself unless instructed to. If you need to verify your change works, do a minimal
+targeted test, not a full benchmark run.
+
+## During building:
+- Tag EVERY decision: proof / test / strong-consensus / consensus / analogy / judgment
+- When making judgment-level decisions, state: "This is judgment \u2014 reasoning without precedent"
+
+## CRITICAL: You MUST finish cleanly.
+
+If you are running low on turns, STOP coding and immediately:
+1. Update the experiment doc with whatever results you have
+2. Output the <!-- majlis-json --> block
+
+The framework CANNOT recover your work if you get truncated without structured output.
+An incomplete experiment doc with honest "did not finish" notes is infinitely better
+than a truncated run with no output. Budget your turns: ~8 turns for reading,
+~10 turns for coding + benchmark, ~5 turns for documentation. If you've used 35+
+turns, wrap up NOW regardless of where you are.
+
+You may NOT verify your own work or mark your own decisions as proven.
+Output your decisions in structured format so they can be recorded in the database.
+
+## Build Verification
+The framework runs a build verification command (if configured) after you finish.
+If the build fails, you'll stay at 'building' with guidance explaining the error.
+Make sure your changes compile/lint before you finish.
+
+## Abandoning a Hypothesis
+If you determine through investigation that the hypothesis is mathematically
+impossible, structurally incompatible with the codebase, or has already been
+tried and failed as a dead-end, you may abandon the experiment instead of
+writing code. This saves a full cycle and records the constraint for future
+experiments. Output the abandon block instead of decisions:
+\`\`\`
+<!-- majlis-json
+{
+  "abandon": { "reason": "why the hypothesis cannot work", "structural_constraint": "the specific constraint that prevents it" }
 }
-function evidenceColor(level) {
-  switch (level) {
-    case "proof":
-      return green(level);
-    case "test":
-      return cyan(level);
-    case "strong_consensus":
-      return blue(level);
-    case "consensus":
-      return blue(level);
-    case "analogy":
-      return yellow(level);
-    case "judgment":
-      return red(level);
-    default:
-      return level;
-  }
+-->
+\`\`\`
+Only abandon when you have clear evidence. If you're uncertain, implement the
+hypothesis and let the doubt/verify cycle evaluate it.
+
+## Structured Output Format
+At the end of your work, include a <!-- majlis-json --> block with your decisions:
+\`\`\`
+<!-- majlis-json
+{
+  "decisions": [
+    { "description": "...", "evidence_level": "judgment|test|proof|analogy|consensus|strong_consensus", "justification": "..." }
+  ]
+}
+-->
+\`\`\``,
+      critic: `---
+name: critic
+model: opus
+tools: [Read, Glob, Grep]
+---
+You are the Critic. You practise constructive doubt.
+
+You receive:
+- The builder's experiment document (the artifact, not the reasoning chain)
+- The current synthesis (project state)
+- Dead-ends (approaches that have been tried and failed)
+- The hypothesis and experiment metadata
+
+You do NOT see the builder's reasoning chain \u2014 only their documented output.
+Use the experiment doc, synthesis, and dead-ends to find weaknesses.
+
+For each doubt:
+- What specific claim, decision, or assumption you doubt
+- WHY: reference a prior experiment, inconsistency, untested case, or false analogy
+- Evidence level of the doubted decision
+- Severity: minor / moderate / critical
+
+Rules:
+- Every doubt MUST reference evidence. "This feels wrong" is not a doubt.
+- You may NOT suggest fixes. Identify problems only.
+- Focus on judgment and analogy-level decisions first.
+- You may NOT modify any files. Produce your doubt document as output only.
+- Do NOT attempt to write files. The framework saves your output automatically.
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "doubts": [
+    { "claim_doubted": "...", "evidence_level_of_claim": "judgment", "evidence_for_doubt": "...", "severity": "critical|moderate|minor" }
+  ]
+}
+-->`,
+      adversary: `---
+name: adversary
+model: opus
+tools: [Read, Glob, Grep]
+---
+You are the Adversary. You do NOT review code for bugs.
+You reason about problem structure to CONSTRUCT pathological cases.
+
+You receive:
+- The git diff of the builder's code changes (the actual code, not prose)
+- The current synthesis (project state)
+- The hypothesis and experiment metadata
+
+Study the CODE DIFF carefully \u2014 that is where the builder's assumptions are exposed.
+
+For each approach the builder takes, ask:
+- What input would make this fail?
+- What boundary condition was not tested?
+- What degenerate case collapses a distinction the algorithm relies on?
+- What distribution shift invalidates the assumptions?
+- Under what conditions do two things the builder treats as distinct become identical?
+
+Produce constructed counterexamples with reasoning.
+Do NOT suggest fixes. Do NOT modify files. Do NOT attempt to write files.
+The framework saves your output automatically.
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "challenges": [
+    { "description": "...", "reasoning": "..." }
+  ]
+}
+-->`,
+      verifier: `---
+name: verifier
+model: opus
+tools: [Read, Glob, Grep, Bash]
+---
+You are the Verifier. Perform dual verification:
+
+You receive:
+- All doubts with explicit DOUBT-{id} identifiers (use these in your doubt_resolutions)
+- Challenge documents from the adversary
+- Framework-captured metrics (baseline vs post-build) \u2014 this is GROUND TRUTH
+- The hypothesis and experiment metadata
+
+## Scope Constraint (CRITICAL)
+
+You must produce your structured output (grades + doubt resolutions) within your turn budget.
+Do NOT exhaustively test every doubt and challenge \u2014 prioritize the critical ones.
+For each doubt/challenge: one targeted check is enough. Confirm, dismiss, or mark inconclusive.
+Reserve your final turns for writing the structured majlis-json output.
+
+The framework saves your output automatically. Do NOT attempt to write files.
+
+## Metrics (GROUND TRUTH)
+If framework-captured metrics are in your context, these are the canonical before/after numbers.
+Do NOT trust numbers claimed by the builder \u2014 compare against the framework metrics.
+If the builder claims improvement but the framework metrics show regression, flag this.
+
+## Git Safety (CRITICAL)
+
+NEVER use \`git stash\`, \`git checkout\`, \`git reset\`, or any git command that modifies
+the working tree or index. The \`.majlis/majlis.db\` SQLite database is in the working tree \u2014
+stashing or checking out files will corrupt it and silently break the framework's state.
+
+To compare against baseline code, use read-only git commands:
+- \`git show main:path/to/file\` \u2014 read a file as it was on main
+- \`git diff main -- path/to/file\` \u2014 see what changed
+- \`git log --oneline main..HEAD\` \u2014 see commits on the branch
+
+To verify baseline metrics, run the benchmark on the CURRENT code and compare with the
+documented baseline in docs/synthesis/current.md. Do NOT stash changes to re-run baseline.
+
+## PROVENANCE CHECK:
+- Can every piece of code trace to an experiment or decision?
+- Is the chain unbroken from requirement -> classification -> experiment -> code?
+- Flag any broken chains.
+
+## CONTENT CHECK:
+- Does the code do what the experiment log says?
+- Run at most 3-5 targeted diagnostic scripts, focused on the critical doubts/challenges.
+- Do NOT run exhaustive diagnostics on every claim.
+
+Framework-captured metrics are ground truth \u2014 if they show regression, that
+alone justifies a "rejected" grade. Do not re-derive from raw fixture data.
+
+Grade each component: sound / good / weak / rejected
+Grade each doubt/challenge: confirmed / dismissed (with evidence) / inconclusive
+
+## Structured Output Format
+IMPORTANT: For doubt_resolutions, use the DOUBT-{id} numbers from your context.
+Example: if your context lists "DOUBT-7: [critical] The algorithm fails on X",
+use doubt_id: 7 in your output.
+
+<!-- majlis-json
+{
+  "grades": [
+    { "component": "...", "grade": "sound|good|weak|rejected", "provenance_intact": true, "content_correct": true, "notes": "..." }
+  ],
+  "doubt_resolutions": [
+    { "doubt_id": 7, "resolution": "confirmed|dismissed|inconclusive" }
+  ]
+}
+-->`,
+      reframer: `---
+name: reframer
+model: opus
+tools: [Read, Glob, Grep]
+---
+You are the Reframer. You receive ONLY:
+- The original problem statement
+- The current classification document
+- The synthesis and dead-end registry
+
+You do NOT read builder code, experiments, or solutions.
+
+Independently propose:
+- How should this problem be decomposed?
+- What are the natural joints?
+- What analogies from other domains apply?
+- What framework would a different field use?
+
+Compare your decomposition with the existing classification.
+Flag structural divergences \u2014 these are the most valuable signals.
+
+Produce your reframe document as output. Do NOT attempt to write files.
+The framework saves your output automatically.
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "reframe": {
+    "decomposition": "How you decomposed the problem",
+    "divergences": ["List of structural divergences from current classification"],
+    "recommendation": "What should change based on your independent analysis"
+  }
+}
+-->`,
+      compressor: `---
+name: compressor
+model: opus
+tools: [Read, Write, Edit, Glob, Grep]
+---
+You are the Compressor. Hold the entire project in view and compress it.
+
+Your taskPrompt includes a "Structured Data (CANONICAL)" section exported directly
+from the SQLite database. This is the source of truth. docs/ files are agent artifacts
+that may contain stale or incorrect information. Cross-reference everything against
+the database export.
+
+1. Read the database export in your context FIRST \u2014 it has all experiments, decisions,
+   doubts (with resolutions), verifications (with grades), challenges, and dead-ends.
+2. Read docs/ files for narrative context, but trust the database when they conflict.
+3. Cross-reference: same question in different language? contradicting decisions?
+   workaround masking root cause?
+4. Update fragility map: thin coverage, weak components, untested judgment
+   decisions, broken provenance.
+5. Update dead-end registry: compress rejected experiments into structural constraints.
+   Mark each dead-end as [structural] or [procedural].
+6. REWRITE synthesis using the Write tool \u2014 shorter and denser. If it's growing,
+   you're accumulating, not compressing. You MUST use the Write tool to update
+   docs/synthesis/current.md, docs/synthesis/fragility.md, and docs/synthesis/dead-ends.md.
+   The framework does NOT auto-save your output for these files.
+7. Review classification: new sub-types? resolved sub-types?
+
+You may ONLY write to these three files:
+- docs/synthesis/current.md
+- docs/synthesis/fragility.md
+- docs/synthesis/dead-ends.md
+
+Do NOT modify MEMORY.md, .claude/, classification/, experiments/, or any other paths.
+
+You may NOT write code, make decisions, or run experiments.
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "compression_report": {
+    "synthesis_delta": "What changed in synthesis and why",
+    "new_dead_ends": ["List of newly identified dead-end constraints"],
+    "fragility_changes": ["List of changes to the fragility map"]
+  }
+}
+-->`,
+      gatekeeper: `---
+name: gatekeeper
+model: sonnet
+tools: [Read, Glob, Grep]
+---
+You are the Gatekeeper. You check hypotheses before expensive build cycles.
+
+Your job is a fast quality gate \u2014 prevent wasted Opus builds on hypotheses that
+are stale, redundant with dead-ends, or too vague to produce a focused change.
+
+## Checks (in order)
+
+### 1. Stale References
+Does the hypothesis reference specific functions, line numbers, or structures that
+may not exist in the current code? Read the relevant files to verify.
+- If references are stale, list them in stale_references.
+
+### 2. Dead-End Overlap
+Does this hypothesis repeat an approach already ruled out by structural dead-ends?
+Check each structural dead-end in your context \u2014 if the hypothesis matches the
+approach or violates the structural_constraint, flag it.
+- If overlapping, list the dead-end IDs in overlapping_dead_ends.
+
+### 3. Scope Check
+Is this a single focused change? A good hypothesis names ONE function, mechanism,
+or parameter to change. A bad hypothesis says "improve X and also Y and also Z."
+- Flag if the hypothesis tries to do multiple things.
+
+## Output
+
+gate_decision:
+- **approve** \u2014 all checks pass, proceed to build
+- **flag** \u2014 concerns found but not blocking (warnings only)
+- **reject** \u2014 hypothesis is dead on arrival (stale refs, dead-end repeat, or too vague).
+  Rejected hypotheses are automatically routed to dead-end with a 'procedural' category.
+  This does NOT block future approaches on the same sub-type \u2014 the user can create
+  a new experiment with a revised hypothesis.
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "gate_decision": "approve|reject|flag",
+  "reason": "Brief explanation of decision",
+  "stale_references": ["list of stale references found, if any"],
+  "overlapping_dead_ends": [0]
+}
+-->`,
+      scout: `---
+name: scout
+model: opus
+tools: [Read, Glob, Grep, WebSearch]
+---
+You are the Scout. You practise rihla \u2014 travel in search of knowledge.
+
+Your job is to search externally for alternative approaches, contradictory evidence,
+and perspectives from other fields that could inform the current experiment.
+
+You receive:
+- The current synthesis and fragility map
+- Dead-ends (approaches that have been tried and failed) \u2014 search for alternatives that circumvent these
+- The hypothesis and experiment metadata
+
+For the given experiment:
+1. Describe the problem in domain-neutral terms
+2. Search for alternative approaches in other fields or frameworks
+3. Identify known limitations of the current approach from external sources
+4. Find structurally similar problems in unrelated domains
+5. Report what you find on its own terms \u2014 do not judge or filter
+
+Rules:
+- Present findings neutrally. Report each approach on its own terms.
+- Note where external approaches contradict the current one \u2014 these are the most valuable signals.
+- Focus on approaches that CIRCUMVENT known dead-ends \u2014 these are the most valuable.
+- You may NOT modify code or make decisions. Produce your rihla document as output only.
+- Do NOT attempt to write files. The framework saves your output automatically.
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "findings": [
+    { "approach": "Name of alternative approach", "source": "Where you found it", "relevance": "How it applies", "contradicts_current": true }
+  ]
+}
+-->`,
+      cartographer: `---
+name: cartographer
+model: opus
+tools: [Read, Write, Edit, Glob, Grep, Bash]
+---
+You are the Cartographer. You map the architecture of an existing codebase.
+
+You receive a ProjectProfile JSON (deterministic surface scan) as context.
+Your job is to deeply explore the codebase and produce two synthesis documents:
+- docs/synthesis/current.md \u2014 project identity, architecture, key abstractions,
+  entry points, test coverage, build pipeline
+- docs/synthesis/fragility.md \u2014 untested areas, single points of failure,
+  dependency risk, tech debt
+
+## Your Approach
+
+Phase 1: Orientation (turns 1-10)
+- Read README, main entry point, 2-3 key imports
+- Understand the project's purpose and structure
+
+Phase 2: Architecture Mapping (turns 11-30)
+- Trace module boundaries and dependency graph
+- Identify data flow patterns, config patterns
+- For huge codebases: focus on entry points and top 5 most-imported modules
+- Map test coverage and build pipeline
+
+Phase 3: Write Synthesis (turns 31-40)
+- Write docs/synthesis/current.md with dense, actionable content
+- Write docs/synthesis/fragility.md with identified weak spots
+
+You may ONLY write to docs/synthesis/. Do NOT modify source code.
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "architecture": {
+    "modules": ["list of key modules"],
+    "entry_points": ["main entry points"],
+    "key_abstractions": ["core abstractions and patterns"],
+    "dependency_graph": "brief description of dependency structure"
+  }
+}
+-->`,
+      toolsmith: `---
+name: toolsmith
+model: opus
+tools: [Read, Write, Edit, Bash, Glob, Grep]
+---
+You are the Toolsmith. You verify toolchain and create a working metrics pipeline.
+
+You receive a ProjectProfile JSON as context with detected test/build commands.
+Your job is to verify these commands actually work, then create a metrics wrapper
+script that translates test output into Majlis fixtures JSON format.
+
+## Your Approach
+
+Phase 1: Verify Toolchain (turns 1-10)
+- Try running the detected test command
+- Try the build command
+- Read CI config for hints if commands fail
+- Determine what actually works
+
+Phase 2: Create Metrics Wrapper (turns 11-25)
+- Create .majlis/scripts/metrics.sh that runs tests and outputs valid Majlis JSON to stdout:
+  {"fixtures":{"test_suite":{"total":N,"passed":N,"failed":N,"duration_ms":N}}}
+- Redirect all non-JSON output to stderr
+- Strategy per framework:
+  - jest/vitest: --json flag \u2192 parse JSON
+  - pytest: --tb=no -q \u2192 parse summary line
+  - go test: -json \u2192 aggregate
+  - cargo test: parse "test result:" line
+  - no tests: stub with {"fixtures":{"project":{"has_tests":0}}}
+
+Phase 3: Output Config (turns 26-30)
+- Output structured JSON with verified commands and config
+
+## Edge Cases
+- Build fails \u2192 set build_command: null, note issue, metrics wrapper still works
+- Tests fail \u2192 wrapper still outputs valid JSON with the fail counts
+- No tests \u2192 stub wrapper
+- Huge monorepo \u2192 focus on primary workspace
+
+You may ONLY write to .majlis/scripts/. Do NOT modify source code.
+
+## Structured Output Format
+<!-- majlis-json
+{
+  "toolsmith": {
+    "metrics_command": ".majlis/scripts/metrics.sh",
+    "build_command": "npm run build",
+    "test_command": "npm test",
+    "test_framework": "jest",
+    "pre_measure": null,
+    "post_measure": null,
+    "fixtures": {},
+    "tracked": {},
+    "verification_output": "brief summary of what worked",
+    "issues": ["list of issues encountered"]
+  }
+}
+-->`,
+      diagnostician: `---
+name: diagnostician
+model: opus
+tools: [Read, Write, Bash, Glob, Grep, WebSearch]
+---
+You are the Diagnostician. You perform deep project-wide analysis.
+
+You have the highest turn budget of any agent. Use it for depth, not breadth.
+Your job is pure insight \u2014 you do NOT fix code, you do NOT build, you do NOT
+make decisions. You diagnose.
+
+## What You Receive
+- Full database export: every experiment, decision, doubt, challenge, verification,
+  dead-end, metric, and compression across the entire project history
+- Current synthesis, fragility map, and dead-end registry
+- Full read access to the entire project codebase
+- Bash access to run tests, profiling, git archaeology, and analysis scripts
+
+## What You Can Do
+1. **Read everything** \u2014 source code, docs, git history, test output
+2. **Run analysis** \u2014 execute tests, profilers, git log/blame/bisect, custom scripts
+3. **Write analysis scripts** \u2014 you may write scripts ONLY to \`.majlis/scripts/\`
+4. **Search externally** \u2014 WebSearch for patterns, known issues, relevant techniques
+
+## What You CANNOT Do
+- Modify any project files outside \`.majlis/scripts/\`
+- Make code changes, fixes, or patches
+- Create experiments or make decisions
+- Write to docs/, src/, or any other project directory
+
+## Your Approach
+
+Phase 1: Orientation (turns 1-10)
+- Read the full database export in your context
+- Read synthesis, fragility, dead-ends
+- Identify patterns: recurring failures, unresolved doubts, evidence gaps
+
+Phase 2: Deep Investigation (turns 11-40)
+- Read source code at critical points identified in Phase 1
+- Run targeted tests, profiling, git archaeology
+- Write and execute analysis scripts in .majlis/scripts/
+- Cross-reference findings across experiments
+
+Phase 3: Synthesis (turns 41-60)
+- Compile findings into a diagnostic report
+- Identify root causes, not symptoms
+- Rank issues by structural impact
+- Suggest investigation directions (not fixes)
+
+## Output Format
+Produce a diagnostic report as markdown. At the end, include:
+
+<!-- majlis-json
+{
+  "diagnosis": {
+    "root_causes": ["List of identified root causes"],
+    "patterns": ["Recurring patterns across experiments"],
+    "evidence_gaps": ["What we don't know but should"],
+    "investigation_directions": ["Suggested directions for next experiments"]
+  }
+}
+-->
+
+## Safety Reminders
+- You are READ-ONLY for project code. Write ONLY to .majlis/scripts/.
+- Focus on diagnosis, not fixing. Your value is insight, not implementation.
+- Trust the database export over docs/ files when they conflict.`
+    };
+    var SLASH_COMMANDS2 = {
+      classify: {
+        description: "Classify a problem domain into canonical sub-types before building",
+        body: `Run \`majlis classify "$ARGUMENTS"\` and follow its output.
+If the CLI is not installed, act as the Builder in classification mode.
+Read docs/synthesis/current.md and docs/synthesis/dead-ends.md for context.
+Enumerate and classify all canonical sub-types of: $ARGUMENTS
+Produce a classification document following docs/classification/_TEMPLATE.md.`
+      },
+      doubt: {
+        description: "Run a constructive doubt pass on an experiment",
+        body: `Run \`majlis doubt $ARGUMENTS\` to spawn the critic agent.
+If the CLI is not installed, act as the Critic directly.
+Doubt the experiment at $ARGUMENTS. Produce a doubt document
+following docs/doubts/_TEMPLATE.md.`
+      },
+      challenge: {
+        description: "Construct adversarial test cases for an experiment",
+        body: `Run \`majlis challenge $ARGUMENTS\` to spawn the adversary agent.
+If the CLI is not installed, act as the Adversary directly.
+Construct pathological inputs designed to break the approach in $ARGUMENTS.
+Produce a challenge document following docs/challenges/_TEMPLATE.md.`
+      },
+      verify: {
+        description: "Verify correctness and provenance of an experiment",
+        body: `Run \`majlis verify $ARGUMENTS\` to spawn the verifier agent.
+If the CLI is not installed, act as the Verifier directly.
+Perform dual verification (provenance + content) on $ARGUMENTS.
+Produce a verification report following docs/verification/_TEMPLATE.md.`
+      },
+      reframe: {
+        description: "Independently reframe a problem from scratch",
+        body: `Run \`majlis reframe $ARGUMENTS\` to spawn the reframer agent.
+If the CLI is not installed, act as the Reframer directly.
+You receive ONLY the problem statement and classification \u2014 NOT builder code.
+Independently decompose $ARGUMENTS and compare with existing classification.`
+      },
+      compress: {
+        description: "Compress project state into dense synthesis",
+        body: `Run \`majlis compress\` to spawn the compressor agent.
+If the CLI is not installed, act as the Compressor directly.
+Read everything. Rewrite docs/synthesis/current.md shorter and denser.
+Update fragility map and dead-end registry.`
+      },
+      scout: {
+        description: "Search externally for alternative approaches",
+        body: `Run \`majlis scout $ARGUMENTS\` to spawn the scout agent.
+If the CLI is not installed, search for alternative approaches to $ARGUMENTS.
+Look for: limitations of current approach, alternative formulations from other fields,
+structurally similar problems in unrelated domains.
+Produce a rihla document at docs/rihla/.`
+      },
+      audit: {
+        description: "Maqasid check \u2014 is the frame right?",
+        body: `Run \`majlis audit "$ARGUMENTS"\` for a purpose audit.
+If the CLI is not installed, review: original objective, current classification,
+recent failures, dead-ends. Ask: is the classification serving the objective?
+Would we decompose differently with what we now know?`
+      },
+      diagnose: {
+        description: "Deep project-wide diagnostic analysis",
+        body: `Run \`majlis diagnose $ARGUMENTS\` for deep diagnosis.
+If the CLI is not installed, perform a deep diagnostic analysis.
+Read docs/synthesis/current.md, fragility.md, dead-ends.md, and all experiments.
+Identify root causes, recurring patterns, evidence gaps, and investigation directions.
+Do NOT modify project code \u2014 analysis only.`
+      },
+      scan: {
+        description: "Scan existing project to auto-detect config and write synthesis",
+        body: `Run \`majlis scan\` to analyze the existing codebase.
+This spawns two agents in parallel:
+- Cartographer: maps architecture \u2192 docs/synthesis/current.md + fragility.md
+- Toolsmith: verifies toolchain \u2192 .majlis/scripts/metrics.sh + config.json
+Use --force to overwrite existing synthesis files.`
+      },
+      resync: {
+        description: "Update stale synthesis after project evolved without Majlis",
+        body: `Run \`majlis resync\` to bring Majlis back up to speed.
+Unlike scan (which starts from zero), resync starts from existing knowledge.
+It assesses staleness, then re-runs cartographer (always) and toolsmith (if needed)
+with the old synthesis and DB history as context.
+Use --check to see the staleness report without making changes.
+Use --force to skip active experiment checks.`
+      }
+    };
+    var HOOKS_CONFIG2 = {
+      hooks: {
+        SessionStart: [
+          {
+            hooks: [
+              {
+                type: "command",
+                command: "majlis status --json 2>/dev/null || true"
+              }
+            ]
+          }
+        ],
+        PreToolUse: [
+          {
+            matcher: "Bash",
+            hooks: [
+              {
+                type: "command",
+                command: "majlis check-commit 2>/dev/null || true",
+                timeout: 10
+              }
+            ]
+          }
+        ],
+        SubagentStop: [
+          {
+            hooks: [
+              {
+                type: "command",
+                command: "echo 'Subagent completed. Run majlis next to continue the cycle.'",
+                timeout: 5
+              }
+            ]
+          }
+        ]
+      }
+    };
+    var DOC_TEMPLATES2 = {
+      "experiments/_TEMPLATE.md": `# Experiment: {{title}}
+
+**Hypothesis:** {{hypothesis}}
+**Branch:** {{branch}}
+**Status:** {{status}}
+**Sub-type:** {{sub_type}}
+**Created:** {{date}}
+
+## Approach
+
+[Describe the approach]
+
+## Decisions
+
+- [evidence_level] Decision description \u2014 justification
+
+## Results
+
+[Describe the results]
+
+## Metrics
+
+| Fixture | Metric | Before | After | Delta |
+|---------|--------|--------|-------|-------|
+| | | | | |
+
+<!-- majlis-json
+{
+  "decisions": [],
+  "grades": []
 }
-function table(headers, rows) {
-  const widths = headers.map(
-    (h, i) => Math.max(h.length, ...rows.map((r) => stripAnsi(r[i] ?? "").length))
-  );
-  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
-  const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500");
-  const bodyLines = rows.map(
-    (row) => row.map((cell, i) => {
-      const stripped = stripAnsi(cell);
-      const padding = widths[i] - stripped.length;
-      return cell + " ".repeat(Math.max(0, padding));
-    }).join("  ")
-  );
-  return [bold(headerLine), separator, ...bodyLines].join("\n");
+-->
+`,
+      "decisions/_TEMPLATE.md": `# Decision: {{title}}
+
+**Evidence Level:** {{evidence_level}}
+**Experiment:** {{experiment}}
+**Date:** {{date}}
+
+## Description
+
+[What was decided]
+
+## Justification
+
+[Why this decision was made, referencing evidence]
+
+## Alternatives Considered
+
+[What else was considered and why it was rejected]
+
+<!-- majlis-json
+{
+  "decisions": [
+    { "description": "", "evidence_level": "", "justification": "" }
+  ]
 }
-function stripAnsi(s) {
-  return s.replace(/\x1b\[[0-9;]*m/g, "");
+-->
+`,
+      "classification/_TEMPLATE.md": `# Classification: {{domain}}
+
+**Date:** {{date}}
+
+## Problem Domain
+
+[Describe the problem domain]
+
+## Sub-Types
+
+### 1. {{sub_type_1}}
+- **Description:**
+- **Canonical form:**
+- **Known constraints:**
+
+### 2. {{sub_type_2}}
+- **Description:**
+- **Canonical form:**
+- **Known constraints:**
+
+## Relationships
+
+[How sub-types relate to each other]
+`,
+      "doubts/_TEMPLATE.md": `# Doubt Document \u2014 Against Experiment {{experiment}}
+
+**Critic:** {{agent}}
+**Date:** {{date}}
+
+## Doubt 1: {{title}}
+
+**Claim doubted:** {{claim}}
+**Evidence level of claim:** {{evidence_level}}
+**Severity:** {{severity}}
+
+**Evidence for doubt:**
+[Specific evidence \u2014 a prior experiment, inconsistency, untested case, or false analogy]
+
+<!-- majlis-json
+{
+  "doubts": [
+    { "claim_doubted": "", "evidence_level_of_claim": "", "evidence_for_doubt": "", "severity": "critical" }
+  ]
 }
-function header(title) {
-  console.log(`
-${bold(`[majlis] ${title}`)}
-`);
+-->
+`,
+      "challenges/_TEMPLATE.md": `# Challenge Document \u2014 Against Experiment {{experiment}}
+
+**Adversary:** {{agent}}
+**Date:** {{date}}
+
+## Challenge 1: {{title}}
+
+**Constructed case:**
+[Specific input or condition designed to break the approach]
+
+**Reasoning:**
+[Why this case should break the approach \u2014 what assumption does it violate?]
+
+## Challenge 2: {{title}}
+
+**Constructed case:**
+[Specific input or condition]
+
+**Reasoning:**
+[Why this should break]
+
+<!-- majlis-json
+{
+  "challenges": [
+    { "description": "", "reasoning": "" }
+  ]
 }
-function warn(msg) {
-  console.log(`${yellow("[majlis]")} ${msg}`);
+-->
+`,
+      "verification/_TEMPLATE.md": `# Verification Report \u2014 Experiment {{experiment}}
+
+**Verifier:** {{agent}}
+**Date:** {{date}}
+
+## Provenance Check (Isnad)
+
+| Component | Traceable | Chain intact | Notes |
+|-----------|-----------|--------------|-------|
+| | yes/no | yes/no | |
+
+## Content Check (Matn)
+
+| Component | Tests pass | Consistent | Grade | Notes |
+|-----------|-----------|------------|-------|-------|
+| | yes/no | yes/no | sound/good/weak/rejected | |
+
+## Doubt Resolution
+
+| Doubt | Resolution | Evidence |
+|-------|------------|----------|
+| | confirmed/dismissed/inconclusive | |
+
+<!-- majlis-json
+{
+  "grades": [
+    { "component": "", "grade": "sound", "provenance_intact": true, "content_correct": true, "notes": "" }
+  ],
+  "doubt_resolutions": [
+    { "doubt_id": 0, "resolution": "confirmed" }
+  ]
 }
-function info(msg) {
-  console.log(`${cyan("[majlis]")} ${msg}`);
+-->
+`,
+      "reframes/_TEMPLATE.md": `# Reframe: {{domain}}
+
+**Reframer:** {{agent}}
+**Date:** {{date}}
+
+## Independent Decomposition
+
+[How this problem should be decomposed \u2014 without seeing the builder's approach]
+
+## Natural Joints
+
+[Where does this problem naturally divide?]
+
+## Cross-Domain Analogies
+
+[What analogies from other domains apply?]
+
+## Comparison with Existing Classification
+
+[Structural divergences from the current classification]
+
+## Divergences (Most Valuable Signals)
+
+[Where the independent decomposition differs from the builder's classification]
+`,
+      "rihla/_TEMPLATE.md": `# Rihla (Scout Report): {{topic}}
+
+**Date:** {{date}}
+
+## Problem (Domain-Neutral)
+
+[Describe the problem in domain-neutral terms]
+
+## Alternative Approaches Found
+
+### 1. {{approach}}
+- **Source:**
+- **Description:**
+- **Applicability:**
+
+## Known Limitations of Current Approach
+
+[What external sources say about where this approach fails]
+
+## Cross-Domain Analogues
+
+[Structurally similar problems in unrelated domains]
+`
+    };
+    var DOC_DIRS2 = [
+      "inbox",
+      "experiments",
+      "decisions",
+      "classification",
+      "doubts",
+      "challenges",
+      "verification",
+      "reframes",
+      "rihla",
+      "synthesis",
+      "diagnosis"
+    ];
+    var WORKFLOW_MD2 = `# Majlis Workflow \u2014 Quick Reference
+
+## The Cycle
+
+\`\`\`
+1. CLASSIFY   \u2192 Taxonomy before solution (Al-Khwarizmi)
+2. REFRAME    \u2192 Independent decomposition (Al-Biruni)
+3. GATE       \u2192 Hypothesis quality check ('Ilm al-'Ilal)
+4. BUILD      \u2192 Write code with tagged decisions (Ijtihad)
+5. CHALLENGE  \u2192 Construct breaking inputs (Ibn al-Haytham)
+6. DOUBT      \u2192 Systematic challenge with evidence (Shukuk)
+7. SCOUT      \u2192 External search for alternatives (Rihla)
+8. VERIFY     \u2192 Provenance + content checks (Isnad + Matn)
+9. RESOLVE    \u2192 Route based on grades
+10. COMPRESS  \u2192 Shorter and denser (Hifz)
+\`\`\`
+
+## Resolution
+- **Sound** \u2192 Merge
+- **Good** \u2192 Merge + add gaps to fragility map
+- **Weak** \u2192 Cycle back with synthesised guidance
+- **Rejected** \u2192 Dead-end with structural constraint
+
+## Circuit Breaker
+3+ weak/rejected on same sub-type \u2192 Maqasid Check (purpose audit)
+
+## Evidence Hierarchy
+1. Proof \u2192 2. Test \u2192 3a. Strong Consensus \u2192 3b. Consensus \u2192 4. Analogy \u2192 5. Judgment
+
+## Commands
+| Action | Command |
+|--------|---------|
+| Initialize | \`majlis init\` |
+| Status | \`majlis status\` |
+| New experiment | \`majlis new "hypothesis"\` |
+| Baseline metrics | \`majlis baseline\` |
+| Measure metrics | \`majlis measure\` |
+| Compare metrics | \`majlis compare\` |
+| Next step | \`majlis next\` |
+| Auto cycle | \`majlis next --auto\` |
+| Autonomous | \`majlis run "goal"\` |
+| Session start | \`majlis session start "intent"\` |
+| Session end | \`majlis session end\` |
+| Compress | \`majlis compress\` |
+| Audit | \`majlis audit "objective"\` |
+
+## Experiment Flags
+| Flag | Purpose |
+|------|---------|
+| \`--sub-type TYPE\` | Classify experiment by problem sub-type |
+| \`--depends-on SLUG\` | Block building until dependency is merged |
+| \`--context FILE,FILE\` | Inject domain-specific docs into agent context |
+
+Example: \`majlis new "improve fitting accuracy" --sub-type fitting --depends-on surface-construction --context docs/algorithms/fitting.md,fixtures/anatomy/part1/README.md\`
+
+## Project Readiness
+
+Majlis works with zero config \u2014 agents figure things out from CLAUDE.md. But each
+config field you wire up removes a failure mode and makes cycles more autonomous.
+
+### Metrics Command
+Your \`metrics.command\` must output JSON in this format:
+\`\`\`json
+{ "fixtures": { "fixture_name": { "metric_name": 123.4 } } }
+\`\`\`
+If your test harness outputs human-readable text, write a thin wrapper script that
+parses it into this format. The framework runs this command automatically before and
+after each build to capture regression data.
+
+### Fixtures and Gates
+Define your test cases in \`config.metrics.fixtures\`. Flag your regression baseline
+as a gate \u2014 regressions on gate fixtures block merge regardless of verification grades:
+\`\`\`json
+"fixtures": {
+  "baseline_test": { "gate": true },
+  "target_test": { "gate": false }
 }
-function success(msg) {
-  console.log(`${green("[majlis]")} ${msg}`);
+\`\`\`
+
+### Tracked Metrics
+Name the metrics you care about and set their direction:
+\`\`\`json
+"tracked": {
+  "error_rate": { "direction": "lower_is_better" },
+  "accuracy": { "direction": "higher_is_better" },
+  "value_delta": { "direction": "closer_to_gt", "target": 0 }
 }
-var RESET, BOLD, DIM, RED, GREEN, YELLOW, BLUE, CYAN;
-var init_format = __esm({
-  "src/output/format.ts"() {
-    "use strict";
-    RESET = "\x1B[0m";
-    BOLD = "\x1B[1m";
-    DIM = "\x1B[2m";
-    RED = "\x1B[31m";
-    GREEN = "\x1B[32m";
-    YELLOW = "\x1B[33m";
-    BLUE = "\x1B[34m";
-    CYAN = "\x1B[36m";
+\`\`\`
+
+### Architecture Docs
+Agents read CLAUDE.md for project context. The more specific it is about where things
+live, how to build, and how to test, the better agents perform. Include build commands,
+test commands, file layout, and key patterns.
+
+Run \`majlis status\` to see which readiness checks pass and which need attention.
+`;
+    var SYNTHESIS_STARTERS2 = {
+      "current.md": '# Project Synthesis\n\n*No experiments yet. Run `majlis new "hypothesis"` to begin.*\n',
+      "fragility.md": "# Fragility Map\n\n*No fragility recorded yet.*\n",
+      "dead-ends.md": "# Dead-End Registry\n\n*No dead-ends recorded yet.*\n"
+    };
+    var CLAUDE_MD_SECTION2 = `
+## Majlis Protocol
+
+This project uses the Majlis Framework for structured multi-agent problem solving.
+See \`docs/workflow.md\` for the full cycle. See \`.claude/agents/\` for role definitions (source of truth in \`.majlis/agents/\`).
+
+### Evidence Hierarchy (tag every decision)
+1. **Proof** \u2014 mathematical proof. Overturn requires error in proof.
+2. **Test** \u2014 empirical test. Overturn requires showing test insufficiency.
+3a. **Strong Consensus** \u2014 convergence across independent approaches.
+3b. **Consensus** \u2014 agreement from same-model experiments.
+4. **Analogy** \u2014 justified by similarity to prior work.
+5. **Judgment** \u2014 independent reasoning without precedent.
+
+### Session Discipline
+- One intent per session. Declare it with \`majlis session start "intent"\`.
+- Stray thoughts \u2192 Telegram (Scribe) or docs/inbox/.
+- Every session ends with \`majlis session end\`.
+
+### Before Building
+- Read \`docs/synthesis/current.md\` for compressed project state.
+- Run \`majlis dead-ends --sub-type <relevant>\` for structural constraints.
+- Run \`majlis decisions --level judgment\` for provisional decisions to challenge.
+
+### Compression Trigger
+- Run \`majlis status\` \u2014 it will warn when compression is due.
+
+### Current State
+Run \`majlis status\` for live experiment state and cycle position.
+`;
+    function claudeMdContent(name, objective) {
+      return `# ${name}
+
+${objective ? `**Objective:** ${objective}
+` : ""}## Majlis Protocol
+
+This project uses the Majlis Framework for structured multi-agent problem solving.
+See \`docs/workflow.md\` for the full cycle. See \`.claude/agents/\` for role definitions (source of truth in \`.majlis/agents/\`).
+
+### Evidence Hierarchy (tag every decision)
+1. **Proof** \u2014 mathematical proof. Overturn requires error in proof.
+2. **Test** \u2014 empirical test. Overturn requires showing test insufficiency.
+3a. **Strong Consensus** \u2014 convergence across independent approaches.
+3b. **Consensus** \u2014 agreement from same-model experiments.
+4. **Analogy** \u2014 justified by similarity to prior work.
+5. **Judgment** \u2014 independent reasoning without precedent.
+
+### Session Discipline
+- One intent per session. Declare it with \`majlis session start "intent"\`.
+- Stray thoughts \u2192 Telegram (Scribe) or docs/inbox/.
+- Every session ends with \`majlis session end\`.
+
+### Before Building
+- Read \`docs/synthesis/current.md\` for compressed project state.
+- Run \`majlis dead-ends --sub-type <relevant>\` for structural constraints.
+- Run \`majlis decisions --level judgment\` for provisional decisions to challenge.
+
+### Compression Trigger
+- Run \`majlis status\` \u2014 it will warn when compression is due.
+
+### Current State
+Run \`majlis status\` for live experiment state and cycle position.
+`;
+    }
+    var DEFAULT_CONFIG3 = {
+      project: {
+        name: "",
+        description: "",
+        objective: ""
+      },
+      metrics: {
+        command: `echo '{"fixtures":{}}'`,
+        fixtures: {},
+        tracked: {}
+      },
+      build: {
+        pre_measure: null,
+        post_measure: null
+      },
+      cycle: {
+        compression_interval: 5,
+        circuit_breaker_threshold: 3,
+        require_doubt_before_verify: true,
+        require_challenge_before_verify: false,
+        auto_baseline_on_new_experiment: true
+      },
+      models: {
+        builder: "opus",
+        critic: "opus",
+        adversary: "opus",
+        verifier: "opus",
+        reframer: "opus",
+        compressor: "opus",
+        gatekeeper: "sonnet",
+        scout: "opus"
+      }
+    };
+    function configTemplate(answers) {
+      return JSON.stringify({
+        project: {
+          name: answers.name,
+          description: answers.description,
+          objective: answers.objective
+        },
+        metrics: {
+          command: answers.metricsCommand,
+          fixtures: {},
+          tracked: {}
+        },
+        build: {
+          pre_measure: answers.buildPre || null,
+          post_measure: answers.buildPost || null
+        },
+        cycle: {
+          compression_interval: 5,
+          circuit_breaker_threshold: 3,
+          require_doubt_before_verify: true,
+          require_challenge_before_verify: false,
+          auto_baseline_on_new_experiment: true
+        },
+        models: {
+          builder: "opus",
+          critic: "opus",
+          adversary: "opus",
+          verifier: "opus",
+          reframer: "opus",
+          compressor: "opus",
+          gatekeeper: "sonnet",
+          scout: "opus"
+        }
+      }, null, 2);
+    }
+    var fs23 = __toESM2(require("fs"));
+    function mkdirSafe3(dir) {
+      if (!fs23.existsSync(dir)) {
+        fs23.mkdirSync(dir, { recursive: true });
+      }
+    }
+    function validateProject2(checks) {
+      const results = [];
+      results.push(
+        checks.hasGitRepo ? { label: "Git repository", status: "pass", detail: "Detected" } : { label: "Git repository", status: "fail", detail: "Not a git repo \u2014 experiment branches will not work" }
+      );
+      results.push(
+        checks.hasObjective ? { label: "Project objective", status: "pass", detail: "Set in config" } : { label: "Project objective", status: "warn", detail: "Not set \u2014 agents lack goal context for maqasid checks" }
+      );
+      results.push(
+        checks.hasClaudeMd ? { label: "CLAUDE.md", status: "pass", detail: "Found \u2014 agents will have project context" } : { label: "CLAUDE.md", status: "warn", detail: "Not found \u2014 agents will lack project architecture context" }
+      );
+      const hasCommand = checks.metricsCommand && !checks.metricsCommand.includes(`echo '{"fixtures":{}}'`);
+      if (!hasCommand) {
+        results.push({ label: "Metrics command", status: "warn", detail: "Using default no-op \u2014 configure metrics.command for automatic regression detection" });
+      } else if (!checks.metricsCommandRunnable) {
+        results.push({ label: "Metrics command", status: "warn", detail: "Set but not runnable \u2014 check the command works: " + checks.metricsCommand });
+      } else {
+        results.push({ label: "Metrics command", status: "pass", detail: "Set and runnable" });
+      }
+      const fixtureEntries = Array.isArray(checks.fixtures) ? checks.fixtures : Object.keys(checks.fixtures);
+      if (fixtureEntries.length === 0) {
+        results.push({ label: "Fixtures", status: "warn", detail: "None defined \u2014 consider adding fixtures with gate flags for regression protection" });
+      } else {
+        const gateCount = Array.isArray(checks.fixtures) ? 0 : Object.values(checks.fixtures).filter((f) => f.gate).length;
+        if (gateCount === 0) {
+          results.push({ label: "Fixtures", status: "warn", detail: `${fixtureEntries.length} fixture(s) but none flagged as gate \u2014 no regression protection` });
+        } else {
+          results.push({ label: "Fixtures", status: "pass", detail: `${fixtureEntries.length} fixture(s), ${gateCount} gate(s)` });
+        }
+      }
+      const trackedCount = Object.keys(checks.tracked).length;
+      if (trackedCount === 0) {
+        results.push({ label: "Tracked metrics", status: "warn", detail: "None defined \u2014 regression detection disabled" });
+      } else {
+        results.push({ label: "Tracked metrics", status: "pass", detail: `${trackedCount} metric(s) tracked` });
+      }
+      results.push(
+        checks.preMeasure ? { label: "Build command", status: "pass", detail: "Set (pre_measure)" } : { label: "Build command", status: "warn", detail: "No pre_measure \u2014 builder must know how to build from CLAUDE.md" }
+      );
+      results.push(
+        checks.hasSynthesis ? { label: "Synthesis document", status: "pass", detail: "Found" } : { label: "Synthesis document", status: "warn", detail: "Empty \u2014 will be populated after first compression cycle" }
+      );
+      return results;
+    }
+    var _useColor = !process.env.NO_COLOR && process.stderr?.isTTY !== false;
+    function formatValidation2(checks) {
+      const lines = [];
+      for (const c of checks) {
+        const icon = c.status === "pass" ? _useColor ? "\x1B[32m\u2713\x1B[0m" : "\u2713" : c.status === "warn" ? _useColor ? "\x1B[33m\u26A0\x1B[0m" : "\u26A0" : _useColor ? "\x1B[31m\u2717\x1B[0m" : "\u2717";
+        lines.push(`  ${icon} ${c.label}: ${c.detail}`);
+      }
+      return lines.join("\n");
+    }
   }
 });
 
@@ -449,7 +1750,7 @@ var init_format = __esm({
 function getExtractionSchema(role) {
   switch (role) {
     case "builder":
-      return '{"decisions": [{"description": "string", "evidence_level": "proof|test|strong_consensus|consensus|analogy|judgment", "justification": "string"}]}';
+      return '{"decisions": [{"description": "string", "evidence_level": "proof|test|strong_consensus|consensus|analogy|judgment", "justification": "string"}], "abandon": {"reason": "string", "structural_constraint": "string"}}';
     case "critic":
       return '{"doubts": [{"claim_doubted": "string", "evidence_level_of_claim": "string", "evidence_for_doubt": "string", "severity": "minor|moderate|critical"}]}';
     case "adversary":
@@ -506,7 +1807,7 @@ async function extractStructuredData(role, markdown) {
   const tier1 = extractMajlisJsonBlock(markdown);
   if (tier1) {
     const parsed = tryParseJson(tier1);
-    if (parsed) return parsed;
+    if (parsed) return { data: parsed, tier: 1 };
     console.warn(`[majlis] Malformed JSON in <!-- majlis-json --> block for ${role}. Falling back.`);
   } else {
     console.warn(`[majlis] No <!-- majlis-json --> block found in ${role} output. Falling back.`);
@@ -514,15 +1815,18 @@ async function extractStructuredData(role, markdown) {
   const tier2 = extractViaPatterns(role, markdown);
   if (tier2 && hasData(tier2)) {
     console.warn(`[majlis] Used regex fallback for ${role}. Review extracted data.`);
-    return tier2;
+    return { data: tier2, tier: 2 };
   }
   console.warn(`[majlis] Regex fallback insufficient for ${role}. Using Haiku extraction.`);
   const tier3 = await extractViaHaiku(role, markdown);
-  if (tier3) return tier3;
+  if (tier3) {
+    console.warn(`[majlis] Tier 3 (Haiku) extraction used for ${role}. Data provenance degraded.`);
+    return { data: tier3, tier: 3 };
+  }
   console.error(
     `[majlis] FAILED to extract structured data from ${role} output. State machine will continue but data is missing. Manual review required.`
   );
-  return null;
+  return { data: null, tier: null };
 }
 function extractMajlisJsonBlock(markdown) {
   const match = markdown.match(/<!--\s*majlis-json\s*\n?([\s\S]*?)-->/);
@@ -592,6 +1896,23 @@ function extractViaPatterns(role, markdown) {
     });
   }
   if (doubts.length > 0) result.doubts = doubts;
+  if (role === "builder") {
+    const abandonPattern = /\[ABANDON\]\s*(.+?)(?:\n|$)[\s\S]*?(?:structural.?constraint|Constraint|CONSTRAINT)\s*[:=]\s*(.+?)(?:\n|$)/im;
+    const abandonMatch = markdown.match(abandonPattern);
+    if (abandonMatch) {
+      result.abandon = {
+        reason: abandonMatch[1].trim(),
+        structural_constraint: abandonMatch[2].trim()
+      };
+    }
+    const invalidMatch = markdown.match(/(?:HYPOTHESIS\s+INVALID|HYPOTHESIS\s+IMPOSSIBLE)\s*[:.\-—]\s*(.+?)(?:\n|$)/im);
+    if (invalidMatch && !result.abandon) {
+      result.abandon = {
+        reason: invalidMatch[1].trim(),
+        structural_constraint: "Extracted via regex \u2014 review original document"
+      };
+    }
+  }
   return result;
 }
 async function extractViaHaiku(role, markdown) {
@@ -631,7 +1952,7 @@ ${truncated}`;
   }
 }
 function hasData(output) {
-  return !!(output.decisions && output.decisions.length > 0 || output.grades && output.grades.length > 0 || output.doubts && output.doubts.length > 0 || output.challenges && output.challenges.length > 0 || output.findings && output.findings.length > 0 || output.guidance || output.reframe || output.compression_report || output.gate_decision || output.diagnosis);
+  return !!(output.decisions && output.decisions.length > 0 || output.grades && output.grades.length > 0 || output.doubts && output.doubts.length > 0 || output.challenges && output.challenges.length > 0 || output.findings && output.findings.length > 0 || output.guidance || output.reframe || output.compression_report || output.gate_decision || output.diagnosis || output.abandon);
 }
 function validateForRole(role, output) {
   const required = ROLE_REQUIRED_FIELDS[role];
@@ -846,6 +2167,8 @@ function buildPreToolUseGuards(role, cwd) {
     const configFile = path2.resolve(cwd, ".majlis", "config.json");
     const dbFile = path2.resolve(cwd, ".majlis", "majlis.db");
     const settingsFile = path2.resolve(cwd, ".claude", "settings.json");
+    const claudeDir = path2.resolve(cwd, ".claude");
+    const agentsDir = path2.resolve(cwd, ".majlis", "agents");
     const configGuard = async (input) => {
       const toolInput = input.tool_input ?? {};
       const filePath = toolInput.file_path ?? "";
@@ -854,6 +2177,9 @@ function buildPreToolUseGuards(role, cwd) {
         if (resolved === configFile || resolved === dbFile || resolved === settingsFile) {
           return { decision: "block", reason: `Builder may not modify framework files: ${filePath}` };
         }
+        if (isInsideDir(resolved, claudeDir) || isInsideDir(resolved, agentsDir)) {
+          return { decision: "block", reason: `Builder may not modify agent definitions or framework settings: ${filePath}` };
+        }
       }
       return {};
     };
@@ -867,6 +2193,8 @@ function buildPreToolUseGuards(role, cwd) {
     const configFile = path2.resolve(cwd, ".majlis", "config.json");
     const dbFile = path2.resolve(cwd, ".majlis", "majlis.db");
     const settingsFile = path2.resolve(cwd, ".claude", "settings.json");
+    const claudeDir = path2.resolve(cwd, ".claude");
+    const agentsDir = path2.resolve(cwd, ".majlis", "agents");
     const configGuard = async (input) => {
       const toolInput = input.tool_input ?? {};
       const filePath = toolInput.file_path ?? "";
@@ -875,6 +2203,9 @@ function buildPreToolUseGuards(role, cwd) {
         if (resolved === configFile || resolved === dbFile || resolved === settingsFile) {
           return { decision: "block", reason: `Verifier may not modify framework files: ${filePath}` };
         }
+        if (isInsideDir(resolved, claudeDir) || isInsideDir(resolved, agentsDir)) {
+          return { decision: "block", reason: `Verifier may not modify agent definitions or framework settings: ${filePath}` };
+        }
       }
       return {};
     };
@@ -947,14 +2278,17 @@ ${taskPrompt}`;
   if (artifactPath) {
     console.log(`[${role}] Artifact written to ${artifactPath}`);
   }
-  const structured = await extractStructuredData(role, markdown);
+  const { data: structured, tier: extractionTier } = await extractStructuredData(role, markdown);
   if (structured) {
     const { valid, missing } = validateForRole(role, structured);
     if (!valid) {
       console.warn(`[${role}] Output missing expected fields: ${missing.join(", ")}`);
     }
   }
-  return { output: markdown, structured, truncated };
+  if (extractionTier === 3) {
+    console.warn(`[${role}] WARNING: Structured output was reconstructed by Haiku (tier 3). Data provenance degraded.`);
+  }
+  return { output: markdown, structured, truncated, extractionTier };
 }
 async function spawnSynthesiser(context, projectRoot, opts) {
   const root = projectRoot ?? findProjectRoot() ?? process.cwd();
@@ -982,56 +2316,7 @@ ${taskPrompt}`;
     role: "synthesiser"
   });
   console.log(`[synthesiser] Complete (cost: $${costUsd.toFixed(4)})`);
-  return { output: markdown, structured: { guidance: markdown }, truncated };
-}
-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 = path2.join(
-    root,
-    "docs",
-    "experiments",
-    `${String(context.experiment?.id ?? 0).padStart(3, "0")}-${expSlug}.md`
-  );
-  const templatePath = path2.join(root, "docs", "experiments", "_TEMPLATE.md");
-  const template = fs2.existsSync(templatePath) ? fs2.readFileSync(templatePath, "utf-8") : "";
-  const currentDoc = fs2.existsSync(expDocPath) ? fs2.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):
-<partial_output>
-${partialOutput.slice(-3e3)}
-</partial_output>
-
-Here is the current experiment doc:
-<current_doc>
-${currentDoc}
-</current_doc>
-
-Here is the template that the experiment doc should follow:
-<template>
-${template}
-</template>
-
-Your job: Write a CLEAN experiment doc to ${expDocPath} using the Write tool.
-- Keep any valid content from the current doc
-- Fill in what you can infer from the partial output
-- Mark incomplete sections with "[TRUNCATED \u2014 ${role} did not finish]"
-- The doc MUST have the <!-- majlis-json --> block, even if decisions are empty
-- Do NOT include agent reasoning or thinking \u2014 only structured experiment content
-- Be concise. This is cleanup, not new work.`;
-  const { text: _markdown } = await runQuery({
-    prompt,
-    model: "haiku",
-    tools: ["Read", "Write"],
-    systemPrompt: `You are a Recovery Agent. You clean up experiment docs after truncated agent runs. Write clean, structured docs. Never include agent reasoning or monologue.`,
-    cwd: root,
-    maxTurns: 5,
-    label: "recovery",
-    role: "recovery"
-  });
-  console.log(`[recovery] Cleanup complete for ${expSlug}.`);
+  return { output: markdown, structured: { guidance: markdown }, truncated, extractionTier: null };
 }
 async function runQuery(opts) {
   let truncated = false;
@@ -1071,21 +2356,21 @@ async function runQuery(opts) {
           const toolName = block.name ?? "tool";
           const input = block.input ?? {};
           const detail = formatToolDetail(toolName, input);
-          process.stderr.write(`${DIM2}[${tag}]   ${CYAN2}${toolName}${RESET2}${DIM2}${detail}${RESET2}
+          process.stderr.write(`${DIM}[${tag}]   ${CYAN}${toolName}${RESET}${DIM}${detail}${RESET}
 `);
         }
       }
       if (hasText) {
         const preview = textParts[textParts.length - 1].slice(0, 120).replace(/\n/g, " ").trim();
         if (preview) {
-          process.stderr.write(`${DIM2}[${tag}]   writing: ${preview}${preview.length >= 120 ? "..." : ""}${RESET2}
+          process.stderr.write(`${DIM}[${tag}]   writing: ${preview}${preview.length >= 120 ? "..." : ""}${RESET}
 `);
         }
       }
     } else if (message.type === "tool_progress") {
       const elapsed = Math.round(message.elapsed_time_seconds);
       if (elapsed > 0 && elapsed % 5 === 0) {
-        process.stderr.write(`${DIM2}[${tag}]   ${message.tool_name} running (${elapsed}s)...${RESET2}
+        process.stderr.write(`${DIM}[${tag}]   ${message.tool_name} running (${elapsed}s)...${RESET}
 `);
       }
     } else if (message.type === "result") {
@@ -1170,7 +2455,7 @@ function writeArtifact(role, context, markdown, projectRoot) {
   fs2.writeFileSync(target, markdown);
   return target;
 }
-var fs2, path2, import_claude_agent_sdk2, ROLE_MAX_TURNS, CHECKPOINT_INTERVAL, DIM2, RESET2, CYAN2;
+var fs2, path2, import_claude_agent_sdk2, ROLE_MAX_TURNS, CHECKPOINT_INTERVAL;
 var init_spawn = __esm({
   "src/agents/spawn.ts"() {
     "use strict";
@@ -1179,6 +2464,7 @@ var init_spawn = __esm({
     import_claude_agent_sdk2 = require("@anthropic-ai/claude-agent-sdk");
     init_parse();
     init_connection();
+    init_format();
     ROLE_MAX_TURNS = {
       builder: 50,
       critic: 30,
@@ -1203,9 +2489,6 @@ var init_spawn = __esm({
       cartographer: 12,
       toolsmith: 10
     };
-    DIM2 = "\x1B[2m";
-    RESET2 = "\x1B[0m";
-    CYAN2 = "\x1B[36m";
   }
 });
 
@@ -1285,7 +2568,8 @@ var init_config = __esm({
       synthesis: 3e4,
       fragility: 15e3,
       experimentDoc: 15e3,
-      deadEnds: 15e3
+      deadEnds: 15e3,
+      experimentLineage: 15e3
     };
   }
 });
@@ -2009,7 +3293,7 @@ var init_init = __esm({
     path7 = __toESM(require("path"));
     init_connection();
     init_format();
-    import_shared = require("@majlis/shared");
+    import_shared = __toESM(require_dist());
   }
 });
 
@@ -2489,13 +3773,13 @@ function addSwarmMember(db, swarmRunId, slug, worktreePath) {
     INSERT INTO swarm_members (swarm_run_id, experiment_slug, worktree_path) VALUES (?, ?, ?)
   `).run(swarmRunId, slug, worktreePath);
 }
-function updateSwarmMember(db, swarmRunId, slug, finalStatus, overallGrade, costUsd, error) {
+function updateSwarmMember(db, swarmRunId, slug, finalStatus, overallGrade, costUsd, error2) {
   db.prepare(`
     UPDATE swarm_members SET final_status = ?, overall_grade = ?, cost_usd = ?, error = ?
     WHERE swarm_run_id = ? AND experiment_slug = ?
-  `).run(finalStatus, overallGrade, costUsd, error, swarmRunId, slug);
+  `).run(finalStatus, overallGrade, costUsd, error2, swarmRunId, slug);
 }
-function exportForCompressor(db, maxLength = 3e4) {
+function exportForCompressor(db, maxLength = 5e4) {
   const experiments = listAllExperiments(db);
   const sections = ["# Structured Data Export (from SQLite)\n"];
   sections.push("## Experiments");
@@ -2561,6 +3845,70 @@ function exportForCompressor(db, maxLength = 3e4) {
   }
   return full;
 }
+function exportExperimentLineage(db, subType, maxLength = 15e3) {
+  const experiments = subType ? db.prepare(`SELECT * FROM experiments WHERE sub_type = ? ORDER BY created_at`).all(subType) : listAllExperiments(db);
+  if (experiments.length === 0) return "";
+  const sections = ["## Experiment Lineage (from DB \u2014 canonical, not from synthesis)\n"];
+  for (const exp of experiments) {
+    sections.push(`### ${exp.slug} [${exp.status}]`);
+    if (exp.hypothesis) sections.push(`Hypothesis: ${exp.hypothesis}`);
+    const decisions = listDecisionsByExperiment(db, exp.id);
+    if (decisions.length > 0) {
+      sections.push("Decisions:");
+      for (const d of decisions) {
+        sections.push(`  - [${d.evidence_level}/${d.status}] ${d.description}`);
+      }
+    }
+    const beforeMetrics = getMetricsByExperimentAndPhase(db, exp.id, "before");
+    const afterMetrics = getMetricsByExperimentAndPhase(db, exp.id, "after");
+    if (beforeMetrics.length > 0 && afterMetrics.length > 0) {
+      sections.push("Metrics:");
+      for (const bm of beforeMetrics) {
+        const am = afterMetrics.find((a) => a.fixture === bm.fixture && a.metric_name === bm.metric_name);
+        if (am) {
+          const delta = am.metric_value - bm.metric_value;
+          const sign = delta >= 0 ? "+" : "";
+          sections.push(`  - ${bm.fixture}/${bm.metric_name}: ${bm.metric_value} \u2192 ${am.metric_value} (${sign}${delta.toFixed(4)})`);
+        }
+      }
+    }
+    const doubts = getDoubtsByExperiment(db, exp.id);
+    const resolved = doubts.filter((d) => d.resolution);
+    if (resolved.length > 0) {
+      sections.push("Doubt resolutions:");
+      for (const d of resolved) {
+        sections.push(`  - [${d.resolution}] ${d.claim_doubted}`);
+      }
+    }
+    const verifications = getVerificationsByExperiment(db, exp.id);
+    if (verifications.length > 0) {
+      sections.push("Grades:");
+      for (const v of verifications) {
+        sections.push(`  - ${v.component}: ${v.grade}${v.notes ? ` \u2014 ${v.notes}` : ""}`);
+      }
+    }
+    sections.push("");
+    const current = sections.join("\n");
+    if (current.length > maxLength - 500) {
+      sections.push(`[LINEAGE TRUNCATED \u2014 ${experiments.length - experiments.indexOf(exp) - 1} experiments omitted]`);
+      break;
+    }
+  }
+  const deadEnds = subType ? listDeadEndsBySubType(db, subType) : listAllDeadEnds(db);
+  if (deadEnds.length > 0) {
+    sections.push("### Dead Ends (structural constraints)");
+    for (const de of deadEnds) {
+      sections.push(`- [${de.category ?? "structural"}] ${de.approach}: ${de.structural_constraint}`);
+    }
+  }
+  const full = sections.join("\n");
+  if (full.length > maxLength) {
+    return full.slice(0, maxLength) + `
+
+[LINEAGE TRUNCATED at ${maxLength} chars]`;
+  }
+  return full;
+}
 function exportForDiagnostician(db, maxLength = 6e4) {
   const base = exportForCompressor(db, maxLength);
   const sections = [base];
@@ -2767,7 +4115,7 @@ var init_status = __esm({
     init_connection();
     init_queries();
     init_config();
-    import_shared2 = require("@majlis/shared");
+    import_shared2 = __toESM(require_dist());
     init_format();
   }
 });
@@ -3694,7 +5042,7 @@ function gitMerge(branch, cwd) {
       stdio: ["pipe", "pipe", "pipe"]
     });
   } catch (err) {
-    console.warn(`[majlis] Git merge of ${branch} failed \u2014 you may need to merge manually.`);
+    warn(`Git merge of ${branch} failed \u2014 you may need to merge manually.`);
   }
 }
 function gitRevert(branch, cwd) {
@@ -3723,7 +5071,7 @@ function gitRevert(branch, cwd) {
       }
     }
   } catch {
-    console.warn(`[majlis] Could not switch away from ${branch} \u2014 you may need to do this manually.`);
+    warn(`Could not switch away from ${branch} \u2014 you may need to do this manually.`);
   }
 }
 function appendToFragilityMap(projectRoot, expSlug, gaps) {
@@ -3850,9 +5198,18 @@ Output your gate_decision as "approve", "reject", or "flag" with reasoning.`
   const decision = result.structured?.gate_decision ?? "approve";
   const reason = result.structured?.reason ?? "";
   if (decision === "reject") {
-    updateExperimentStatus(db, exp.id, "gated");
-    warn(`Gate REJECTED for ${exp.slug}: ${reason}`);
-    warn(`Revise the hypothesis or run \`majlis revert\` to abandon.`);
+    insertDeadEnd(
+      db,
+      exp.id,
+      exp.hypothesis ?? exp.slug,
+      reason,
+      `Gate rejected: ${reason}`,
+      exp.sub_type,
+      "procedural"
+    );
+    adminTransitionAndPersist(db, exp.id, "gated", "dead_end" /* DEAD_END */, "revert");
+    warn(`Gate REJECTED for ${exp.slug}: ${reason}. Dead-ended.`);
+    return;
   } else {
     if (decision === "flag") {
       warn(`Gate flagged concerns for ${exp.slug}: ${reason}`);
@@ -3909,6 +5266,10 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
   }
   taskPrompt += "\n\nNote: The framework captures metrics automatically. Do NOT claim specific numbers unless quoting framework output.";
   const supplementaryContext = loadExperimentContext(exp, root);
+  const lineage = exportExperimentLineage(db, exp.sub_type);
+  if (lineage) {
+    taskPrompt += "\n\n" + lineage;
+  }
   const result = await spawnAgent("builder", {
     experiment: {
       id: exp.id,
@@ -3927,16 +5288,123 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
     synthesis,
     confirmedDoubts,
     supplementaryContext: supplementaryContext || void 0,
+    experimentLineage: lineage || void 0,
     taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
+  if (result.structured?.abandon) {
+    insertDeadEnd(
+      db,
+      exp.id,
+      exp.hypothesis ?? exp.slug,
+      result.structured.abandon.reason,
+      result.structured.abandon.structural_constraint,
+      exp.sub_type,
+      "structural"
+    );
+    adminTransitionAndPersist(db, exp.id, "building", "dead_end" /* DEAD_END */, "revert");
+    info(`Builder abandoned ${exp.slug}: ${result.structured.abandon.reason}`);
+    return;
+  }
   if (result.truncated && !result.structured) {
     warn(`Builder was truncated (hit max turns) without producing structured output.`);
-    await spawnRecovery("builder", result.output, {
-      experiment: { id: exp.id, slug: exp.slug, hypothesis: exp.hypothesis, status: "building", sub_type: exp.sub_type, builder_guidance: null }
-    }, root);
-    warn(`Experiment stays at 'building'. Run \`majlis build\` to retry or \`majlis revert\` to abandon.`);
+    const recovery = await extractStructuredData("builder", result.output);
+    if (recovery.data && !recovery.data.abandon) {
+      info(`Recovered structured output from truncated builder (tier ${recovery.tier}).`);
+      ingestStructuredOutput(db, exp.id, recovery.data);
+      if (config.build?.pre_measure) {
+        try {
+          const [cmd, ...cmdArgs] = config.build.pre_measure.split(/\s+/);
+          (0, import_node_child_process7.execFileSync)(cmd, cmdArgs, {
+            cwd: root,
+            encoding: "utf-8",
+            timeout: 3e4,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          storeBuilderGuidance(
+            db,
+            exp.id,
+            `Build verification failed after truncated recovery.
+Error: ${errMsg.slice(0, 500)}`
+          );
+          warn(`Build verification failed for ${exp.slug}. Staying at 'building'.`);
+          return;
+        }
+      }
+      if (config.metrics?.command) {
+        try {
+          const output = (0, import_node_child_process7.execSync)(config.metrics.command, {
+            cwd: root,
+            encoding: "utf-8",
+            timeout: 6e4,
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+          const parsed = parseMetricsOutput(output);
+          for (const m of parsed) {
+            insertMetric(db, exp.id, "after", m.fixture, m.metric_name, m.metric_value);
+          }
+          if (parsed.length > 0) info(`Captured ${parsed.length} post-build metric(s).`);
+        } catch {
+        }
+      }
+      gitCommitBuild(exp, root);
+      if (recovery.tier === 3) {
+        warn(`Builder output extracted via Haiku (tier 3). Data provenance degraded.`);
+        const existing = getBuilderGuidance(db, exp.id) ?? "";
+        storeBuilderGuidance(
+          db,
+          exp.id,
+          existing + "\n[PROVENANCE WARNING] Builder structured output was reconstructed by a secondary model (tier 3). Treat reported decisions with additional scrutiny."
+        );
+      }
+      updateExperimentStatus(db, exp.id, "built");
+      success(`Build complete for ${exp.slug} (recovered from truncation). Run \`majlis doubt\` or \`majlis challenge\` next.`);
+    } else if (recovery.data?.abandon) {
+      insertDeadEnd(
+        db,
+        exp.id,
+        exp.hypothesis ?? exp.slug,
+        recovery.data.abandon.reason,
+        recovery.data.abandon.structural_constraint,
+        exp.sub_type,
+        "structural"
+      );
+      adminTransitionAndPersist(db, exp.id, "building", "dead_end" /* DEAD_END */, "revert");
+      info(`Builder abandoned ${exp.slug} (recovered from truncation): ${recovery.data.abandon.reason}`);
+    } else {
+      const tail = result.output.slice(-2e3).trim();
+      if (tail) {
+        storeBuilderGuidance(
+          db,
+          exp.id,
+          `Builder was truncated. Last ~2000 chars of output:
+${tail}`
+        );
+      }
+      warn(`Experiment stays at 'building'. Run \`majlis build\` to retry or \`majlis revert\` to abandon.`);
+    }
   } else {
+    if (config.build?.pre_measure) {
+      try {
+        const [cmd, ...cmdArgs] = config.build.pre_measure.split(/\s+/);
+        (0, import_node_child_process7.execFileSync)(cmd, cmdArgs, {
+          cwd: root,
+          encoding: "utf-8",
+          timeout: 3e4,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        const guidance = `Build verification failed after builder completion. Code may be syntactically broken or incomplete.
+Error: ${errMsg.slice(0, 500)}`;
+        storeBuilderGuidance(db, exp.id, guidance);
+        warn(`Build verification failed for ${exp.slug}. Staying at 'building'.`);
+        warn(`Guidance stored for retry. Run \`majlis build\` to retry.`);
+        return;
+      }
+    }
     if (config.metrics?.command) {
       try {
         const output = (0, import_node_child_process7.execSync)(config.metrics.command, {
@@ -3955,6 +5423,15 @@ Build the experiment: ${exp.hypothesis}` : `Build the experiment: ${exp.hypothes
       }
     }
     gitCommitBuild(exp, root);
+    if (result.extractionTier === 3) {
+      warn(`Builder output extracted via Haiku (tier 3). Data provenance degraded.`);
+      const existing = getBuilderGuidance(db, exp.id) ?? "";
+      storeBuilderGuidance(
+        db,
+        exp.id,
+        existing + "\n[PROVENANCE WARNING] Builder structured output was reconstructed by a secondary model (tier 3). Treat reported decisions with additional scrutiny."
+      );
+    }
     updateExperimentStatus(db, exp.id, "built");
     success(`Build complete for ${exp.slug}. Run \`majlis doubt\` or \`majlis challenge\` next.`);
   }
@@ -4150,6 +5627,15 @@ async function doVerify(db, exp, root) {
   }
   updateExperimentStatus(db, exp.id, "verifying");
   const verifierSupplementaryContext = loadExperimentContext(exp, root);
+  const verifierLineage = exportExperimentLineage(db, exp.sub_type);
+  let verifierTaskPrompt = `Verify experiment ${exp.slug}: ${exp.hypothesis}. Check provenance and content. Test the ${doubts.length} doubt(s) and any adversarial challenges.` + metricsSection + doubtReference;
+  if (verifierLineage) {
+    verifierTaskPrompt += "\n\n" + verifierLineage;
+  }
+  const builderGuidanceForVerifier = getBuilderGuidance(db, exp.id);
+  if (builderGuidanceForVerifier?.includes("[PROVENANCE WARNING]")) {
+    verifierTaskPrompt += "\n\nNote: The builder's structured output was reconstructed by a secondary model (tier 3). Treat reported decisions with additional scrutiny.";
+  }
   const result = await spawnAgent("verifier", {
     experiment: {
       id: exp.id,
@@ -4163,7 +5649,8 @@ async function doVerify(db, exp, root) {
     challenges,
     metricComparisons: metricComparisons.length > 0 ? metricComparisons : void 0,
     supplementaryContext: verifierSupplementaryContext || void 0,
-    taskPrompt: `Verify experiment ${exp.slug}: ${exp.hypothesis}. Check provenance and content. Test the ${doubts.length} doubt(s) and any adversarial challenges.` + metricsSection + doubtReference
+    experimentLineage: verifierLineage || void 0,
+    taskPrompt: verifierTaskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
   if (result.truncated && !result.structured) {
@@ -4325,6 +5812,7 @@ var init_cycle = __esm({
     init_machine();
     init_types2();
     init_spawn();
+    init_parse();
     init_resolve();
     init_config();
     init_metrics();
@@ -5432,6 +6920,7 @@ async function swarm(args) {
     if (summary.bestExperiment && isMergeable(summary.bestExperiment.overallGrade)) {
       const best = summary.bestExperiment;
       info(`Best experiment: ${best.worktree.slug} (${best.overallGrade})`);
+      let merged = false;
       try {
         (0, import_node_child_process10.execFileSync)(
           "git",
@@ -5439,9 +6928,72 @@ async function swarm(args) {
           { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
         );
         success(`Merged ${best.worktree.slug} into main.`);
+        merged = true;
       } catch {
-        warn(`Git merge of ${best.worktree.slug} failed. Merge manually with:`);
-        info(`  git merge ${best.worktree.branch} --no-ff`);
+        warn(`Git merge of ${best.worktree.slug} failed (conflict). Attempting rebase...`);
+        try {
+          (0, import_node_child_process10.execFileSync)("git", ["merge", "--abort"], { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+        } catch {
+        }
+        try {
+          (0, import_node_child_process10.execFileSync)(
+            "git",
+            ["rebase", "main", best.worktree.branch],
+            { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+          );
+          info(`Rebase of ${best.worktree.slug} onto main succeeded. Re-verifying gates...`);
+          const config = loadConfig(root);
+          let gatesHold = true;
+          if (config.metrics?.command && best.experiment) {
+            try {
+              const output = (0, import_node_child_process10.execSync)(config.metrics.command, {
+                cwd: root,
+                encoding: "utf-8",
+                timeout: 6e4,
+                stdio: ["pipe", "pipe", "pipe"]
+              }).trim();
+              const parsed = parseMetricsOutput(output);
+              for (const m of parsed) {
+                insertMetric(db, best.experiment.id, "after", m.fixture, m.metric_name, m.metric_value);
+              }
+              const comparisons = compareMetrics(db, best.experiment.id, config);
+              const gateViolations = checkGateViolations(comparisons);
+              if (gateViolations.length > 0) {
+                gatesHold = false;
+                warn(`Gate violations after rebase:`);
+                for (const v of gateViolations) {
+                  warn(`  - ${v.fixture}/${v.metric}: ${v.before} \u2192 ${v.after} (delta: ${v.delta})`);
+                }
+              }
+            } catch {
+              warn("Could not re-capture metrics after rebase. Proceeding cautiously.");
+            }
+          }
+          if (gatesHold) {
+            (0, import_node_child_process10.execFileSync)("git", ["checkout", "main"], { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+            (0, import_node_child_process10.execFileSync)(
+              "git",
+              ["merge", "--ff-only", best.worktree.branch],
+              { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+            );
+            success(`Merged ${best.worktree.slug} into main (via rebase + ff).`);
+            merged = true;
+          } else {
+            warn(`Gate violations after rebase. NOT merging ${best.worktree.slug}.`);
+            info(`Manual resolution needed:`);
+            info(`  git checkout main && git merge ${best.worktree.branch} --no-ff`);
+          }
+        } catch {
+          try {
+            (0, import_node_child_process10.execFileSync)("git", ["rebase", "--abort"], { cwd: root, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+          } catch {
+          }
+          warn(`Rebase of ${best.worktree.slug} also failed. Manual merge required:`);
+          info(`  git merge ${best.worktree.branch} --no-ff`);
+        }
+      }
+      if (!merged) {
+        info(`${best.worktree.slug} was NOT merged automatically.`);
       }
     } else {
       info("No experiment achieved sound/good grade. Nothing merged.");
@@ -5594,6 +7146,7 @@ var init_swarm = __esm({
     init_types2();
     init_spawn();
     init_config();
+    init_metrics();
     init_worktree();
     init_runner();
     init_aggregate();
@@ -6165,6 +7718,7 @@ var init_resync = __esm({
 // src/cli.ts
 var fs22 = __toESM(require("fs"));
 var path23 = __toESM(require("path"));
+init_format();
 var VERSION2 = JSON.parse(
   fs22.readFileSync(path23.join(__dirname, "..", "package.json"), "utf-8")
 ).version;
@@ -6175,7 +7729,7 @@ async function main() {
     if (sigintCount >= 2) process.exit(130);
     const { requestShutdown: requestShutdown2 } = (init_shutdown(), __toCommonJS(shutdown_exports));
     requestShutdown2();
-    console.error("\n\x1B[33m[majlis] Interrupt received. Finishing current step...\x1B[0m");
+    warn("Interrupt received. Finishing current step...");
   });
   const args = process.argv.slice(2);
   if (args.includes("--version") || args.includes("-v")) {
@@ -6314,7 +7868,7 @@ async function main() {
     }
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(`\x1B[31m[majlis] Error: ${msg}\x1B[0m`);
+    error(`Error: ${msg}`);
     process.exit(1);
   }
 }