majlis 0.8.4 → 0.9.1

package/dist/cli.js

@@ -75,6 +75,20 @@ function statusColor(status2) {
       return yellow(status2);
   }
 }
+function gradeColor(grade) {
+  switch (grade) {
+    case "sound":
+      return green(grade);
+    case "good":
+      return cyan(grade);
+    case "weak":
+      return yellow(grade);
+    case "rejected":
+      return red(grade);
+    default:
+      return grade;
+  }
+}
 function evidenceColor(level) {
   switch (level) {
     case "proof":
@@ -375,6 +389,58 @@ var init_migrations = __esm({
       (db) => {
         db.exec(`
       ALTER TABLE experiments ADD COLUMN gate_rejection_reason TEXT;
+    `);
+      },
+      // Migration 008: v7 → v8 — Pilot integration: notes, journal, hypothesis file, provenance
+      (db) => {
+        db.exec(`
+      CREATE TABLE notes (
+        id INTEGER PRIMARY KEY,
+        session_id INTEGER REFERENCES sessions(id),
+        experiment_id INTEGER REFERENCES experiments(id),
+        tag TEXT,
+        content TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE INDEX idx_notes_session ON notes(session_id);
+      CREATE INDEX idx_notes_experiment ON notes(experiment_id);
+
+      CREATE TABLE journal_entries (
+        id INTEGER PRIMARY KEY,
+        session_id INTEGER REFERENCES sessions(id),
+        content TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+      CREATE INDEX idx_journal_session ON journal_entries(session_id);
+
+      ALTER TABLE experiments ADD COLUMN hypothesis_file TEXT;
+      ALTER TABLE experiments ADD COLUMN provenance TEXT DEFAULT 'cycle'
+        CHECK(provenance IN ('cycle', 'catch-up', 'absorb'));
+    `);
+      },
+      // Migration 009: v8 → v9 — Chain invalidation, objective history, audit proposals
+      (db) => {
+        db.exec(`
+      ALTER TABLE experiments ADD COLUMN chain_weakened_by TEXT;
+
+      CREATE TABLE objective_history (
+        id INTEGER PRIMARY KEY,
+        objective_text TEXT NOT NULL,
+        previous_text TEXT,
+        reason TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'manual' CHECK(source IN ('manual', 'audit')),
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE audit_proposals (
+        id INTEGER PRIMARY KEY,
+        proposed_objective TEXT NOT NULL,
+        reason TEXT NOT NULL,
+        audit_output TEXT,
+        status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'accepted', 'rejected')),
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        resolved_at DATETIME
+      );
     `);
       }
     ];
@@ -1665,46 +1731,31 @@ See \`docs/workflow.md\` for the full cycle. See \`.claude/agents/\` for role de
 
 ### Session Discipline
 - One intent per session. Declare it with \`majlis session start "intent"\`.
-- Stray thoughts \u2192 Telegram (Scribe) or docs/inbox/.
+- Stray thoughts \u2192 \`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.
+- Run \`majlis brief\` for a context dump of the current experiment state.
 
-### 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/\`).
+### Capturing Observations
+- \`majlis note "text" --tag hypothesis\` \u2014 save observations to the DB (injected into agent contexts).
+- \`majlis journal "text"\` \u2014 timestamped breadcrumbs during manual hacking.
+- \`majlis catch-up "description" --diff HEAD~3..HEAD\` \u2014 create experiment retroactively from manual work.
 
-### 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.
+### Chain Integrity
+- If an experiment you depend on is dead-ended, your experiment is flagged as "weakened chain".
+- Run \`majlis status\` to see chain warnings. Revert or proceed at your own risk.
 
-### 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\`.
+### Verification Review
+- If \`require_human_verify\` is enabled, experiments pause at \`verified\` for human review.
+- Run \`majlis resolve\` to proceed or \`majlis resolve --reject\` to dead-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.
+### Purpose Audit
+- Circuit breaker trips (3+ failures on a sub-type) trigger a Maqasid Check.
+- If the audit proposes an objective rewrite, run \`majlis audit --accept\` or \`--reject\`.
 
 ### Compression Trigger
 - Run \`majlis status\` \u2014 it will warn when compression is due.
@@ -1712,6 +1763,11 @@ See \`docs/workflow.md\` for the full cycle. See \`.claude/agents/\` for role de
 ### Current State
 Run \`majlis status\` for live experiment state and cycle position.
 `;
+    function claudeMdContent(name, objective) {
+      return `# ${name}
+
+${objective ? `**Objective:** ${objective}
+` : ""}${CLAUDE_MD_SECTION2}`;
     }
     var DEFAULT_CONFIG3 = {
       project: {
@@ -1781,10 +1837,10 @@ Run \`majlis status\` for live experiment state and cycle position.
         }
       }, null, 2);
     }
-    var fs23 = __toESM2(require("fs"));
+    var fs24 = __toESM2(require("fs"));
     function mkdirSafe3(dir) {
-      if (!fs23.existsSync(dir)) {
-        fs23.mkdirSync(dir, { recursive: true });
+      if (!fs24.existsSync(dir)) {
+        fs24.mkdirSync(dir, { recursive: true });
       }
     }
     function validateProject2(checks) {
@@ -2704,7 +2760,8 @@ var init_config = __esm({
         circuit_breaker_threshold: 3,
         require_doubt_before_verify: true,
         require_challenge_before_verify: false,
-        auto_baseline_on_new_experiment: true
+        auto_baseline_on_new_experiment: true,
+        require_human_verify: false
       },
       models: {}
     };
@@ -3641,7 +3698,7 @@ ${cmd.body}
     const existing = fs8.readFileSync(claudeMdPath, "utf-8");
     if (existing.includes("## Majlis Protocol")) {
       const replaced = existing.replace(
-        /## Majlis Protocol[\s\S]*?(?=\n## [^M]|\n## $|$)/,
+        /## Majlis Protocol[\s\S]*?(?=\n## (?!#)(?!Majlis Protocol)|$)/,
         import_shared.CLAUDE_MD_SECTION.trim()
       );
       if (replaced !== existing) {
@@ -3738,6 +3795,36 @@ function clearGateRejection(db, experimentId) {
     UPDATE experiments SET gate_rejection_reason = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?
   `).run(experimentId);
 }
+function findDependents(db, slug) {
+  const dependents = [];
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [slug];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) continue;
+    visited.add(current);
+    const rows = db.prepare(
+      `SELECT * FROM experiments WHERE depends_on = ? AND status NOT IN ('merged', 'dead_end')`
+    ).all(current);
+    for (const row of rows) {
+      dependents.push(row);
+      queue.push(row.slug);
+    }
+  }
+  return dependents;
+}
+function setChainWeakened(db, experimentId, slug) {
+  db.prepare(`
+    UPDATE experiments SET chain_weakened_by = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
+  `).run(slug, experimentId);
+}
+function cascadeChainInvalidation(db, slug) {
+  const dependents = findDependents(db, slug);
+  for (const dep of dependents) {
+    setChainWeakened(db, dep.id, slug);
+  }
+  return dependents.length;
+}
 function insertDecision(db, experimentId, description, evidenceLevel, justification) {
   const stmt = db.prepare(`
     INSERT INTO decisions (experiment_id, description, evidence_level, justification)
@@ -3985,6 +4072,59 @@ function updateSwarmMember(db, swarmRunId, slug, finalStatus, overallGrade, cost
     WHERE swarm_run_id = ? AND experiment_slug = ?
   `).run(finalStatus, overallGrade, costUsd, error2, swarmRunId, slug);
 }
+function insertNote(db, sessionId, experimentId, tag, content) {
+  const stmt = db.prepare(`
+    INSERT INTO notes (session_id, experiment_id, tag, content) VALUES (?, ?, ?, ?)
+  `);
+  const result = stmt.run(sessionId, experimentId, tag, content);
+  return db.prepare("SELECT * FROM notes WHERE id = ?").get(result.lastInsertRowid);
+}
+function getNotesBySession(db, sessionId) {
+  return db.prepare("SELECT * FROM notes WHERE session_id = ? ORDER BY created_at").all(sessionId);
+}
+function getNotesByExperiment(db, experimentId) {
+  return db.prepare("SELECT * FROM notes WHERE experiment_id = ? ORDER BY created_at").all(experimentId);
+}
+function getRecentNotes(db, limit = 20) {
+  return db.prepare("SELECT * FROM notes ORDER BY created_at DESC LIMIT ?").all(limit);
+}
+function insertJournalEntry(db, sessionId, content) {
+  const stmt = db.prepare(`
+    INSERT INTO journal_entries (session_id, content) VALUES (?, ?)
+  `);
+  const result = stmt.run(sessionId, content);
+  return db.prepare("SELECT * FROM journal_entries WHERE id = ?").get(result.lastInsertRowid);
+}
+function getJournalBySession(db, sessionId) {
+  return db.prepare("SELECT * FROM journal_entries WHERE session_id = ? ORDER BY created_at").all(sessionId);
+}
+function storeHypothesisFile(db, experimentId, filePath) {
+  db.prepare(`
+    UPDATE experiments SET hypothesis_file = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?
+  `).run(filePath, experimentId);
+}
+function insertObjectiveHistory(db, objectiveText, previousText, reason, source) {
+  db.prepare(`
+    INSERT INTO objective_history (objective_text, previous_text, reason, source)
+    VALUES (?, ?, ?, ?)
+  `).run(objectiveText, previousText, reason, source);
+}
+function insertAuditProposal(db, proposedObjective, reason, auditOutput) {
+  db.prepare(`
+    INSERT INTO audit_proposals (proposed_objective, reason, audit_output)
+    VALUES (?, ?, ?)
+  `).run(proposedObjective, reason, auditOutput);
+}
+function getPendingAuditProposal(db) {
+  return db.prepare(
+    `SELECT * FROM audit_proposals WHERE status = 'pending' ORDER BY created_at DESC LIMIT 1`
+  ).get();
+}
+function resolveAuditProposal(db, id, status2) {
+  db.prepare(`
+    UPDATE audit_proposals SET status = ?, resolved_at = CURRENT_TIMESTAMP WHERE id = ?
+  `).run(status2, id);
+}
 function exportForCompressor(db, maxLength = 5e4) {
   const experiments = listAllExperiments(db);
   const sections = ["# Structured Data Export (from SQLite)\n"];
@@ -4043,6 +4183,28 @@ function exportForCompressor(db, maxLength = 5e4) {
       sections.push(`- [${d.severity}] ${d.claim_doubted} (exp: ${d.experiment_slug})`);
     }
   }
+  const notes = db.prepare(`
+    SELECT n.*, s.intent as session_intent FROM notes n
+    LEFT JOIN sessions s ON n.session_id = s.id
+    ORDER BY n.created_at
+  `).all();
+  if (notes.length > 0) {
+    sections.push("\n## Pilot Notes (fold into narrative \u2014 these are human/pilot observations)");
+    for (const n of notes) {
+      sections.push(`- ${n.tag ? `[${n.tag}] ` : ""}${n.content}`);
+    }
+  }
+  const journal2 = db.prepare(`
+    SELECT j.*, s.intent as session_intent FROM journal_entries j
+    LEFT JOIN sessions s ON j.session_id = s.id
+    ORDER BY j.created_at
+  `).all();
+  if (journal2.length > 0) {
+    sections.push("\n## Journal (fold into timeline \u2014 breadcrumbs from manual hacking sessions)");
+    for (const j of journal2) {
+      sections.push(`- [${j.created_at}] ${j.content}`);
+    }
+  }
   const full = sections.join("\n");
   if (full.length > maxLength) {
     return full.slice(0, maxLength) + `
@@ -4180,6 +4342,33 @@ function exportForDiagnostician(db, maxLength = 6e4) {
       sections.push(`- ${f.slug}: ${f.approach} (${f.source}) ${f.contradicts_current ? "[CONTRADICTS CURRENT]" : ""}`);
     }
   }
+  const notes = db.prepare(`
+    SELECT n.*, e.slug as exp_slug, s.intent as session_intent
+    FROM notes n
+    LEFT JOIN experiments e ON n.experiment_id = e.id
+    LEFT JOIN sessions s ON n.session_id = s.id
+    ORDER BY n.created_at
+  `).all();
+  if (notes.length > 0) {
+    sections.push("\n## Pilot Notes");
+    for (const n of notes) {
+      const ctx = n.exp_slug ? ` (exp: ${n.exp_slug})` : n.session_intent ? ` (session: ${n.session_intent})` : "";
+      sections.push(`- ${n.tag ? `[${n.tag}] ` : ""}${n.content}${ctx}`);
+    }
+  }
+  const journal2 = db.prepare(`
+    SELECT j.*, s.intent as session_intent
+    FROM journal_entries j
+    LEFT JOIN sessions s ON j.session_id = s.id
+    ORDER BY j.created_at
+  `).all();
+  if (journal2.length > 0) {
+    sections.push("\n## Journal Entries");
+    for (const j of journal2) {
+      const ctx = j.session_intent ? ` (session: ${j.session_intent})` : "";
+      sections.push(`- [${j.created_at}] ${j.content}${ctx}`);
+    }
+  }
   const full = sections.join("\n");
   if (full.length > maxLength) {
     return full.slice(0, maxLength) + `
@@ -4269,6 +4458,32 @@ async function status(isJson) {
     ]);
     console.log(table(["Sub-Type", "Failures", "Status"], cbRows));
   }
+  const weakenedExps = experiments.filter((e) => e.chain_weakened_by);
+  if (weakenedExps.length > 0) {
+    console.log();
+    for (const e of weakenedExps) {
+      warn(`${e.slug} depends on ${e.chain_weakened_by} (dead-ended)`);
+    }
+    console.log(`  Use \`majlis revert <slug>\` to abandon, or proceed at your own risk.`);
+  }
+  if (config.cycle.require_human_verify) {
+    const verifiedExps = experiments.filter((e) => e.status === "verified");
+    for (const e of verifiedExps) {
+      const grades = getVerificationsByExperiment(db, e.id);
+      console.log(`
+  ${bold(e.slug)}: awaiting human review (verified)`);
+      for (const g of grades) {
+        console.log(`    ${g.component}: ${gradeColor(g.grade)}${g.notes ? ` \u2014 ${g.notes}` : ""}`);
+      }
+      console.log(`  Run \`majlis resolve\` or \`majlis resolve --reject\``);
+    }
+  }
+  const pendingProposal = getPendingAuditProposal(db);
+  if (pendingProposal) {
+    console.log();
+    warn(`Pending objective rewrite: "${pendingProposal.proposed_objective}"`);
+    console.log(`  Run \`majlis audit --accept\` or \`majlis audit --reject\``);
+  }
   if (judgmentDecisions.length > 0) {
     console.log(`
   ${yellow(`${judgmentDecisions.length} judgment-level decisions`)} (provisional targets for doubt)`);
@@ -4358,7 +4573,8 @@ var init_types2 = __esm({
       revert: (current, target) => target === "dead_end" /* DEAD_END */ && !isTerminalStatus(current),
       circuit_breaker: (current, target) => target === "dead_end" /* DEAD_END */ && !isTerminalStatus(current),
       error_recovery: (current, target) => target === "dead_end" /* DEAD_END */ && !isTerminalStatus(current),
-      bootstrap: (current, target) => current === "classified" /* CLASSIFIED */ && target === "reframed" /* REFRAMED */
+      bootstrap: (current, target) => current === "classified" /* CLASSIFIED */ && target === "reframed" /* REFRAMED */ || current === "classified" /* CLASSIFIED */ && target === "built" /* BUILT */,
+      objective_reset: (current, target) => target === "classified" /* CLASSIFIED */ && !isTerminalStatus(current)
     };
   }
 });
@@ -4697,6 +4913,8 @@ async function resolve2(db, exp, projectRoot) {
           incrementSubTypeFailure(db, exp.sub_type, exp.id, "rejected");
         }
       })();
+      const weakened = cascadeChainInvalidation(db, exp.slug);
+      if (weakened > 0) warn(`Weakened chain: ${weakened} downstream experiment(s) depend on ${exp.slug}.`);
       info(`Experiment ${exp.slug} DEAD-ENDED (rejected). Constraint recorded.`);
       break;
     }
@@ -4833,6 +5051,8 @@ async function resolveDbOnly(db, exp, projectRoot) {
           incrementSubTypeFailure(db, exp.sub_type, exp.id, "rejected");
         }
       })();
+      const weakened = cascadeChainInvalidation(db, exp.slug);
+      if (weakened > 0) warn(`Weakened chain: ${weakened} downstream experiment(s) depend on ${exp.slug}.`);
       info(`Experiment ${exp.slug} DEAD-ENDED (rejected). Constraint recorded.`);
       break;
     }
@@ -4958,6 +5178,31 @@ async function resolveCmd(args) {
   if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
   const db = getDb(root);
   const exp = resolveExperimentArg(db, args);
+  if (args.includes("--reject")) {
+    transition(exp.status, "resolved" /* RESOLVED */);
+    const reason = getFlagValue(args, "--reason") ?? "Human rejected after verification review";
+    db.transaction(() => {
+      insertDeadEnd(
+        db,
+        exp.id,
+        exp.hypothesis ?? exp.slug,
+        reason,
+        `Human rejection: ${reason}`,
+        exp.sub_type,
+        "procedural"
+      );
+      updateExperimentStatus(db, exp.id, "resolved");
+      updateExperimentStatus(db, exp.id, "dead_end");
+      if (exp.sub_type) {
+        incrementSubTypeFailure(db, exp.sub_type, exp.id, "rejected");
+      }
+    })();
+    handleDeadEndGit(exp, root);
+    const weakened = cascadeChainInvalidation(db, exp.slug);
+    if (weakened > 0) warn(`Weakened chain: ${weakened} downstream experiment(s) depend on ${exp.slug}.`);
+    info(`Experiment ${exp.slug} dead-ended by human rejection: ${reason}`);
+    return;
+  }
   transition(exp.status, "resolved" /* RESOLVED */);
   await resolve2(db, exp, root);
 }
@@ -5014,6 +5259,7 @@ Check: (a) stale references \u2014 does the hypothesis reference specific lines,
 Output your gate_decision as "approve", "reject", or "flag" with reasoning.`
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
+  printStepSummary("gate", result.structured);
   const decision = result.structured?.gate_decision ?? "approve";
   const reason = result.structured?.reason ?? "";
   if (decision === "reject") {
@@ -5085,6 +5331,17 @@ Your experiment doc: ${expDocRelPath(exp)}`;
   if (lineage) {
     taskPrompt += "\n\n" + lineage;
   }
+  const pilotNotes = loadPilotNotes(db, exp.id);
+  if (pilotNotes) taskPrompt += pilotNotes;
+  if (exp.hypothesis_file) {
+    const hypoContent = readFileOrEmpty(path11.join(root, exp.hypothesis_file));
+    if (hypoContent) {
+      taskPrompt += `
+
+## Structured Hypothesis (from pilot)
+${hypoContent.slice(0, 8e3)}`;
+    }
+  }
   const result = await spawnAgent("builder", {
     experiment: {
       id: exp.id,
@@ -5119,6 +5376,8 @@ Your experiment doc: ${expDocRelPath(exp)}`;
     );
     adminTransitionAndPersist(db, exp.id, "building", "dead_end" /* DEAD_END */, "revert");
     handleDeadEndGit(exp, root);
+    const weakened = cascadeChainInvalidation(db, exp.slug);
+    if (weakened > 0) warn(`Weakened chain: ${weakened} downstream experiment(s) depend on ${exp.slug}.`);
     info(`Builder abandoned ${exp.slug}: ${result.structured.abandon.reason}`);
     return;
   }
@@ -5189,6 +5448,8 @@ Error: ${errMsg.slice(0, 500)}`
       );
       adminTransitionAndPersist(db, exp.id, "building", "dead_end" /* DEAD_END */, "revert");
       handleDeadEndGit(exp, root);
+      const weakenedTrunc = cascadeChainInvalidation(db, exp.slug);
+      if (weakenedTrunc > 0) warn(`Weakened chain: ${weakenedTrunc} downstream experiment(s) depend on ${exp.slug}.`);
       info(`Builder abandoned ${exp.slug} (recovered from truncation): ${recovery.data.abandon.reason}`);
     } else {
       const tail = result.output.slice(-2e3).trim();
@@ -5288,6 +5549,7 @@ ${gitDiff}
     taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
+  printStepSummary("challenge", result.structured);
   if (result.truncated && !result.structured) {
     warn(`Adversary was truncated without structured output. Experiment stays at current status.`);
   } else {
@@ -5329,6 +5591,7 @@ ${experimentDoc}
     taskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
+  printStepSummary("doubt", result.structured);
   if (result.truncated && !result.structured) {
     warn(`Critic was truncated without structured output. Experiment stays at current status.`);
   } else {
@@ -5452,6 +5715,8 @@ async function doVerify(db, exp, root) {
   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 verifierPilotNotes = loadPilotNotes(db, exp.id);
+  if (verifierPilotNotes) verifierTaskPrompt += verifierPilotNotes;
   const result = await spawnAgent("verifier", {
     experiment: {
       id: exp.id,
@@ -5469,6 +5734,7 @@ async function doVerify(db, exp, root) {
     taskPrompt: verifierTaskPrompt
   }, root);
   ingestStructuredOutput(db, exp.id, result.structured);
+  printStepSummary("verify", result.structured);
   if (result.truncated && !result.structured) {
     warn(`Verifier was truncated without structured output. Experiment stays at 'verifying'.`);
     return;
@@ -5562,6 +5828,20 @@ ${content.slice(0, 8e3)}
   }
   return sections.join("\n\n");
 }
+function loadPilotNotes(db, experimentId) {
+  const expNotes = getNotesByExperiment(db, experimentId);
+  const session2 = getActiveSession(db);
+  const sessionNotes = session2 ? getNotesBySession(db, session2.id) : [];
+  const seenIds = new Set(expNotes.map((n) => n.id));
+  const allNotes = [...expNotes, ...sessionNotes.filter((n) => !seenIds.has(n.id))].slice(-10);
+  if (allNotes.length === 0) return "";
+  let section = "\n\n## Pilot Notes\n";
+  for (const n of allNotes) {
+    section += `- ${n.tag ? `[${n.tag}] ` : ""}${n.content}
+`;
+  }
+  return section;
+}
 function expDocRelPath(exp) {
   return `docs/experiments/${String(exp.id).padStart(3, "0")}-${exp.slug}.md`;
 }
@@ -5577,6 +5857,38 @@ function resolveExperimentArg(db, args) {
   }
   return exp;
 }
+function printStepSummary(step, structured) {
+  if (!structured) return;
+  if (step === "gate") {
+    const decision = structured.gate_decision ?? "approve";
+    const reason = structured.reason ?? "";
+    header(`Gate: ${decision}`);
+    if (reason) console.log(`  ${reason.slice(0, 150)}`);
+  }
+  if (step === "doubt" && structured.doubts) {
+    const critical = structured.doubts.filter((d) => d.severity === "critical").length;
+    const moderate = structured.doubts.filter((d) => d.severity === "moderate").length;
+    const minor = structured.doubts.filter((d) => d.severity === "minor").length;
+    header(`Doubt Summary: ${structured.doubts.length} doubt(s) \u2014 ${critical} critical, ${moderate} moderate, ${minor} minor`);
+    for (const d of structured.doubts.slice(0, 3)) {
+      console.log(`  [${d.severity}] ${d.claim_doubted.slice(0, 100)}`);
+    }
+  }
+  if (step === "challenge" && structured.challenges) {
+    header(`Challenge Summary: ${structured.challenges.length} challenge(s)`);
+    for (const c of structured.challenges.slice(0, 3)) {
+      console.log(`  ${c.description.slice(0, 100)}`);
+    }
+  }
+  if (step === "verify" && structured.grades) {
+    const grades = structured.grades.map((g) => g.grade);
+    const worst = ["rejected", "weak", "good", "sound"].find((g) => grades.includes(g)) ?? grades[0] ?? "unknown";
+    header(`Verification Summary: overall=${worst}`);
+    for (const g of structured.grades) {
+      console.log(`  ${g.component}: ${gradeColor(g.grade)}`);
+    }
+  }
+}
 function ingestStructuredOutput(db, experimentId, structured) {
   if (!structured) return;
   db.transaction(() => {
@@ -5824,6 +6136,8 @@ async function newExperiment(args) {
   const dependsOn = getFlagValue(args, "--depends-on") ?? null;
   const contextArg = getFlagValue(args, "--context") ?? null;
   const contextFiles = contextArg ? contextArg.split(",").map((f) => f.trim()) : null;
+  const skipGate = args.includes("--skip-gate");
+  const fromFile = getFlagValue(args, "--from-file") ?? null;
   if (dependsOn) {
     const depExp = getExperimentBySlug(db, dependsOn);
     if (!depExp) {
@@ -5841,7 +6155,18 @@ async function newExperiment(args) {
   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, subType ?? "unclassified").replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
+    let 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]);
+    if (fromFile) {
+      const hypoPath = path12.join(root, fromFile);
+      if (fs12.existsSync(hypoPath)) {
+        const hypoContent = fs12.readFileSync(hypoPath, "utf-8");
+        logContent += "\n\n## Structured Hypothesis (from pilot)\n\n" + hypoContent;
+        storeHypothesisFile(db, exp.id, fromFile);
+        info(`Hypothesis file: ${fromFile}`);
+      } else {
+        warn(`Hypothesis file not found: ${fromFile}`);
+      }
+    }
     const logPath = path12.join(root, docRelPath);
     fs12.writeFileSync(logPath, logContent);
     info(`Created experiment log: ${docRelPath}`);
@@ -5856,6 +6181,10 @@ async function newExperiment(args) {
       warn("Auto-baseline failed \u2014 run `majlis baseline` manually.");
     }
   }
+  if (skipGate) {
+    updateExperimentStatus(db, exp.id, "gated");
+    success(`Gate skipped (pilot-verified). Run \`majlis build\` next.`);
+  }
 }
 async function revert(args) {
   const root = findProjectRoot();
@@ -5979,6 +6308,8 @@ ${gitDiff.slice(0, 15e3)}
   if (exp.gate_rejection_reason) clearGateRejection(db, exp.id);
   adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "revert");
   handleDeadEndGit(exp, root);
+  const weakened = cascadeChainInvalidation(db, exp.slug);
+  if (weakened > 0) warn(`Weakened chain: ${weakened} downstream experiment(s) depend on ${exp.slug}.`);
   info(`Experiment ${exp.slug} reverted to dead-end.`);
   info(`Constraint: ${structuralConstraint.slice(0, 120)}${structuralConstraint.length > 120 ? "..." : ""}`);
 }
@@ -6349,6 +6680,50 @@ async function audit(args) {
   const root = findProjectRoot();
   if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
   const db = getDb(root);
+  if (args.includes("--accept")) {
+    const proposal = getPendingAuditProposal(db);
+    if (!proposal) {
+      warn("No pending audit proposal to accept.");
+      return;
+    }
+    const config2 = loadConfig(root);
+    const previousObjective = config2.project?.objective ?? "";
+    const configPath = path15.join(root, ".majlis", "config.json");
+    const rawConfig = JSON.parse(fs15.readFileSync(configPath, "utf-8"));
+    rawConfig.project = rawConfig.project || {};
+    rawConfig.project.objective = proposal.proposed_objective;
+    fs15.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + "\n");
+    resetConfigCache();
+    insertObjectiveHistory(db, proposal.proposed_objective, previousObjective, proposal.reason, "audit");
+    const activeExps = listActiveExperiments(db);
+    for (const exp of activeExps) {
+      insertNote(
+        db,
+        null,
+        exp.id,
+        "objective-change",
+        `Objective changed: "${previousObjective}" \u2192 "${proposal.proposed_objective}"`
+      );
+      adminTransitionAndPersist(db, exp.id, exp.status, "classified" /* CLASSIFIED */, "objective_reset");
+    }
+    resolveAuditProposal(db, proposal.id, "accepted");
+    autoCommit(root, `audit: accept objective rewrite`);
+    success(`Objective updated: "${proposal.proposed_objective}"`);
+    if (activeExps.length > 0) {
+      info(`${activeExps.length} active experiment(s) reset to classified.`);
+    }
+    return;
+  }
+  if (args.includes("--reject")) {
+    const proposal = getPendingAuditProposal(db);
+    if (!proposal) {
+      warn("No pending audit proposal to reject.");
+      return;
+    }
+    resolveAuditProposal(db, proposal.id, "rejected");
+    info("Audit proposal rejected.");
+    return;
+  }
   const objective = args.filter((a) => !a.startsWith("--")).join(" ");
   const config = loadConfig(root);
   const experiments = listAllExperiments(db);
@@ -6398,13 +6773,33 @@ Answer these questions:
 2. Is the current classification serving that objective? Or has the taxonomy become self-referential?
 3. What would we do differently if we started from scratch with what we now know?
 4. Is there a simpler formulation? If the classification has grown complex, something may be wrong.
+5. If the classification is fundamentally misaligned, propose a rewrite.
+   Include: <!-- majlis-json {"objective_rewrite": {"proposed_objective": "...", "reason": "..."}} -->
+   Only include objective_rewrite if genuinely needed.
 
 Output: either "classification confirmed \u2014 continue" or "re-classify from X" with a specific proposal.`;
   const result = await spawnAgent("builder", {
     synthesis,
     taskPrompt: auditPrompt
   }, root);
-  success("Purpose audit complete. Review the output above.");
+  const structured = result.structured;
+  let rewrite = structured?.objective_rewrite;
+  if (!rewrite && result.output) {
+    const extracted = await extractStructuredData("builder", result.output);
+    rewrite = extracted.data?.objective_rewrite;
+  }
+  if (rewrite) {
+    insertAuditProposal(db, rewrite.proposed_objective, rewrite.reason, result.output.slice(0, 5e3));
+    console.log();
+    header("Objective Rewrite Proposed");
+    console.log(`  Current:  ${config.project?.objective ?? "(none)"}`);
+    console.log(`  Proposed: ${rewrite.proposed_objective}`);
+    console.log(`  Reason:   ${rewrite.reason}`);
+    console.log();
+    info("Run `majlis audit --accept` or `majlis audit --reject`.");
+  } else {
+    success("Purpose audit complete. Review the output above.");
+  }
 }
 var fs15, path15;
 var init_audit = __esm({
@@ -6414,8 +6809,12 @@ var init_audit = __esm({
     path15 = __toESM(require("path"));
     init_connection();
     init_queries();
+    init_machine();
+    init_types2();
     init_spawn();
+    init_parse();
     init_config();
+    init_git();
     init_format();
   }
 });
@@ -6473,6 +6872,8 @@ async function runNextStep(db, exp, config, root, isJson, overrideGate = false)
     );
     adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "circuit_breaker");
     handleDeadEndGit(exp, root);
+    const weakened = cascadeChainInvalidation(db, exp.slug);
+    if (weakened > 0) warn(`Weakened chain: ${weakened} downstream experiment(s) depend on ${exp.slug}.`);
     warn("Experiment dead-ended. Triggering Maqasid Check (purpose audit).");
     await audit([config.project?.objective ?? ""]);
     return;
@@ -6487,6 +6888,9 @@ async function runNextStep(db, exp, config, root, isJson, overrideGate = false)
       return;
     }
   }
+  if (exp.chain_weakened_by) {
+    warn(`Experiment ${exp.slug} depends on ${exp.chain_weakened_by} (dead-ended). Chain integrity weakened.`);
+  }
   const sessionsSinceCompression = getSessionsSinceCompression(db);
   if (sessionsSinceCompression >= config.cycle.compression_interval) {
     warn(
@@ -6505,6 +6909,11 @@ async function runNextStep(db, exp, config, root, isJson, overrideGate = false)
     }));
     return;
   }
+  if (nextStep === "resolved" /* RESOLVED */ && config.cycle.require_human_verify) {
+    info(`${exp.slug} verified. Human review required.`);
+    info("Run `majlis resolve` to proceed or `majlis resolve --reject` to dead-end.");
+    return;
+  }
   info(`${exp.slug}: ${exp.status} \u2192 ${nextStep}`);
   await executeStep(nextStep, exp, root);
 }
@@ -6522,6 +6931,21 @@ async function runAutoLoop(db, exp, config, root, isJson) {
       info("Stopping auto mode. Use `majlis next --override-gate` or `majlis revert`.");
       break;
     }
+    if (exp.chain_weakened_by) {
+      warn(`Experiment ${exp.slug} has weakened chain (depends on dead-ended ${exp.chain_weakened_by}). Auto-dead-ending.`);
+      insertDeadEnd(
+        db,
+        exp.id,
+        exp.hypothesis ?? exp.slug,
+        `Upstream dependency ${exp.chain_weakened_by} is dead-ended`,
+        `Chain invalidated: depends on ${exp.chain_weakened_by}`,
+        exp.sub_type,
+        "procedural"
+      );
+      adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "circuit_breaker");
+      handleDeadEndGit(exp, root);
+      continue;
+    }
     if (isTerminal(exp.status)) {
       success(`Experiment ${exp.slug} reached terminal state: ${exp.status}`);
       break;
@@ -6539,6 +6963,8 @@ async function runAutoLoop(db, exp, config, root, isJson) {
       );
       adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "circuit_breaker");
       handleDeadEndGit(exp, root);
+      const weakened = cascadeChainInvalidation(db, exp.slug);
+      if (weakened > 0) warn(`Weakened chain: ${weakened} downstream experiment(s) depend on ${exp.slug}.`);
       await audit([config.project?.objective ?? ""]);
       break;
     }
@@ -6547,6 +6973,10 @@ async function runAutoLoop(db, exp, config, root, isJson) {
     const expHasDoubts = hasDoubts(db, exp.id);
     const expHasChallenges = hasChallenges(db, exp.id);
     const nextStep = determineNextStep(exp, valid, expHasDoubts, expHasChallenges);
+    if (nextStep === "resolved" /* RESOLVED */ && config.cycle.require_human_verify) {
+      info("Pausing at verified \u2014 human review required.");
+      break;
+    }
     info(`[${iteration}/${MAX_ITERATIONS}] ${exp.slug}: ${exp.status} \u2192 ${nextStep}`);
     await executeStep(nextStep, exp, root);
   }
@@ -6707,6 +7137,8 @@ async function run(args) {
           "revert"
         );
         handleDeadEndGit(afterStep, root);
+        const w1 = cascadeChainInvalidation(db, afterStep.slug);
+        if (w1 > 0) warn(`Weakened chain: ${w1} downstream experiment(s) depend on ${afterStep.slug}.`);
         continue;
       }
     } catch (err) {
@@ -6725,6 +7157,8 @@ async function run(args) {
         );
         adminTransitionAndPersist(db, exp.id, exp.status, "dead_end" /* DEAD_END */, "error_recovery");
         handleDeadEndGit(exp, root);
+        const w2 = cascadeChainInvalidation(db, exp.slug);
+        if (w2 > 0) warn(`Weakened chain: ${w2} downstream experiment(s) depend on ${exp.slug}.`);
       } catch (innerErr) {
         const innerMsg = innerErr instanceof Error ? innerErr.message : String(innerErr);
         warn(`Could not record dead-end: ${innerMsg}`);
@@ -8193,12 +8627,368 @@ var init_resync = __esm({
   }
 });
 
+// src/commands/note.ts
+var note_exports = {};
+__export(note_exports, {
+  note: () => note
+});
+async function note(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  const content = args.filter((a) => !a.startsWith("--")).join(" ");
+  if (!content) {
+    throw new Error(
+      'Usage: majlis note "text" [--tag <tag>] [--experiment <slug>]'
+    );
+  }
+  const tag = getFlagValue(args, "--tag");
+  const expSlug = getFlagValue(args, "--experiment");
+  const session2 = getActiveSession(db);
+  let experimentId = null;
+  if (expSlug) {
+    const exp = getExperimentBySlug(db, expSlug);
+    if (!exp) throw new Error(`Experiment not found: ${expSlug}`);
+    experimentId = exp.id;
+  } else {
+    const latest = getLatestExperiment(db);
+    experimentId = latest?.id ?? null;
+  }
+  insertNote(db, session2?.id ?? null, experimentId, tag ?? null, content);
+  success(`Note saved${tag ? ` [${tag}]` : ""}${expSlug ? ` \u2192 ${expSlug}` : ""}`);
+}
+var init_note = __esm({
+  "src/commands/note.ts"() {
+    "use strict";
+    init_connection();
+    init_queries();
+    init_config();
+    init_format();
+  }
+});
+
+// src/commands/journal.ts
+var journal_exports = {};
+__export(journal_exports, {
+  journal: () => journal
+});
+async function journal(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  const content = args.filter((a) => !a.startsWith("--")).join(" ");
+  if (!content) {
+    throw new Error('Usage: majlis journal "text"');
+  }
+  const session2 = getActiveSession(db);
+  insertJournalEntry(db, session2?.id ?? null, content);
+  success(`Journal entry saved (${(/* @__PURE__ */ new Date()).toLocaleTimeString()})`);
+}
+var init_journal = __esm({
+  "src/commands/journal.ts"() {
+    "use strict";
+    init_connection();
+    init_queries();
+    init_format();
+  }
+});
+
+// src/commands/brief.ts
+var brief_exports = {};
+__export(brief_exports, {
+  brief: () => brief
+});
+async function brief(args, isJson) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  const plain = args.includes("--plain");
+  const short = args.includes("--short");
+  const exp = getLatestExperiment(db);
+  const session2 = getActiveSession(db);
+  const deadEnds = exp?.sub_type ? listStructuralDeadEndsBySubType(db, exp.sub_type) : listStructuralDeadEnds(db);
+  const doubts = exp ? getDoubtsByExperiment(db, exp.id) : [];
+  const challenges = exp ? getChallengesByExperiment(db, exp.id) : [];
+  const verifications = exp ? getVerificationsByExperiment(db, exp.id) : [];
+  const beforeMetrics = exp ? getMetricsByExperimentAndPhase(db, exp.id, "before") : [];
+  const afterMetrics = exp ? getMetricsByExperimentAndPhase(db, exp.id, "after") : [];
+  const notes = getRecentNotes(db, 5);
+  if (isJson) {
+    const data = {
+      experiment: exp ? {
+        slug: exp.slug,
+        status: exp.status,
+        hypothesis: exp.hypothesis,
+        sub_type: exp.sub_type
+      } : null,
+      dead_ends: deadEnds.slice(0, 5).map((d) => ({
+        id: d.id,
+        structural_constraint: d.structural_constraint
+      })),
+      doubts: doubts.map((d) => ({
+        claim: d.claim_doubted,
+        severity: d.severity,
+        resolution: d.resolution
+      })),
+      challenges: challenges.map((c) => ({
+        description: c.description
+      })),
+      verifications: verifications.map((v) => ({
+        component: v.component,
+        grade: v.grade,
+        notes: v.notes
+      })),
+      metrics: beforeMetrics.map((bm) => {
+        const am = afterMetrics.find(
+          (a) => a.fixture === bm.fixture && a.metric_name === bm.metric_name
+        );
+        return {
+          fixture: bm.fixture,
+          metric: bm.metric_name,
+          before: bm.metric_value,
+          after: am?.metric_value ?? null
+        };
+      }),
+      notes: notes.map((n) => ({
+        tag: n.tag,
+        content: n.content
+      })),
+      session: session2 ? { intent: session2.intent } : null
+    };
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  const lines = [];
+  lines.push(bold("[majlis] Context Brief"));
+  lines.push("");
+  if (exp) {
+    lines.push(bold("Experiment"));
+    lines.push(`  Slug:       ${cyan(exp.slug)}`);
+    lines.push(`  Status:     ${statusColor(exp.status)}`);
+    if (exp.hypothesis) lines.push(`  Hypothesis: ${exp.hypothesis}`);
+    if (exp.sub_type) lines.push(`  Sub-type:   ${dim(exp.sub_type)}`);
+  } else {
+    lines.push(dim("No active experiment."));
+  }
+  if (deadEnds.length > 0) {
+    lines.push("");
+    lines.push(bold("Dead Ends"));
+    for (const d of deadEnds.slice(0, 5)) {
+      lines.push(`  - ${dim(`[DE-${d.id}]`)} ${d.structural_constraint}`);
+    }
+    if (deadEnds.length > 5) {
+      lines.push(dim(`  ... and ${deadEnds.length - 5} more`));
+    }
+  }
+  if (exp && POST_DOUBT_STATES.has(exp.status)) {
+    if (doubts.length > 0) {
+      lines.push("");
+      lines.push(bold("Doubts"));
+      for (const d of doubts) {
+        const res = d.resolution ? dim(` (${d.resolution})`) : yellow(" (pending)");
+        lines.push(`  - [${d.severity}] ${d.claim_doubted}${res}`);
+      }
+    }
+    if (challenges.length > 0) {
+      lines.push("");
+      lines.push(bold("Challenges"));
+      for (const c of challenges) {
+        lines.push(`  - ${c.description}`);
+      }
+    }
+    if (verifications.length > 0) {
+      lines.push("");
+      lines.push(bold("Verifications"));
+      for (const v of verifications) {
+        const note2 = v.notes ? dim(` \u2014 ${v.notes}`) : "";
+        lines.push(`  - ${v.component}: ${gradeColor(v.grade)}${note2}`);
+      }
+    }
+  }
+  if (notes.length > 0) {
+    lines.push("");
+    lines.push(bold("Recent Notes"));
+    for (const n of notes) {
+      const tag = n.tag ? dim(`[${n.tag}] `) : "";
+      lines.push(`  - ${tag}${n.content}`);
+    }
+  }
+  if (beforeMetrics.length > 0) {
+    lines.push("");
+    lines.push(bold("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 ? "+" : "";
+        const color = delta >= 0 ? green : red;
+        lines.push(`  - ${bm.fixture}/${bm.metric_name}: ${bm.metric_value} -> ${am.metric_value} ${color(`(${sign}${delta.toFixed(4)})`)}`);
+      } else {
+        lines.push(`  - ${bm.fixture}/${bm.metric_name}: ${bm.metric_value} ${dim("(no after)")}`);
+      }
+    }
+  }
+  if (session2) {
+    lines.push("");
+    lines.push(bold("Session"));
+    lines.push(`  Intent: ${session2.intent}`);
+  }
+  lines.push("");
+  let output = lines.join("\n");
+  if (plain) {
+    output = stripAnsi(output);
+  }
+  if (short && output.length > 3e3) {
+    output = output.slice(0, 2986) + "\n[TRUNCATED]";
+  }
+  process.stdout.write(output);
+}
+var POST_DOUBT_STATES;
+var init_brief = __esm({
+  "src/commands/brief.ts"() {
+    "use strict";
+    init_connection();
+    init_queries();
+    init_format();
+    POST_DOUBT_STATES = /* @__PURE__ */ new Set([
+      "doubted",
+      "challenged",
+      "scouted",
+      "verifying",
+      "verified",
+      "resolved",
+      "compressed",
+      "merged",
+      "dead_end"
+    ]);
+  }
+});
+
+// src/commands/catchup.ts
+var catchup_exports = {};
+__export(catchup_exports, {
+  catchUp: () => catchUp
+});
+async function catchUp(args) {
+  const root = findProjectRoot();
+  if (!root) throw new Error("Not in a Majlis project. Run `majlis init` first.");
+  const db = getDb(root);
+  const description = args.filter((a) => !a.startsWith("--")).join(" ");
+  if (!description) {
+    throw new Error('Usage: majlis catch-up "description of what was done"');
+  }
+  const subType = getFlagValue(args, "--sub-type") ?? null;
+  const diffRange = getFlagValue(args, "--diff");
+  if (!diffRange) {
+    throw new Error("--diff is required for catch-up. Example: --diff HEAD~3..HEAD or --diff main..my-branch");
+  }
+  let diffStat = "";
+  try {
+    diffStat = (0, import_node_child_process13.execFileSync)("git", ["diff", "--stat", diffRange], {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    warn(`Could not get diff stat for range ${diffRange}.`);
+  }
+  let slug = await generateSlug(description, root);
+  let attempt = 0;
+  while (getExperimentBySlug(db, slug + (attempt ? `-${attempt}` : ""))) {
+    attempt++;
+  }
+  if (attempt > 0) slug = `${slug}-${attempt}`;
+  const allExps = db.prepare("SELECT COUNT(*) as count FROM experiments").get();
+  const num = allExps.count + 1;
+  const exp = createExperiment(db, slug, "catch-up", description, subType, null, null, null);
+  db.prepare("UPDATE experiments SET provenance = ? WHERE id = ?").run("catch-up", exp.id);
+  let journalSection = "";
+  const session2 = getActiveSession(db);
+  if (session2) {
+    const entries = getJournalBySession(db, session2.id);
+    if (entries.length > 0) {
+      journalSection = entries.map((e) => `- [${e.created_at}] ${e.content}`).join("\n");
+    }
+  }
+  const docContent = [
+    `# ${description}`,
+    "",
+    `- Branch: catch-up (retroactive)`,
+    `- Status: built (catch-up)`,
+    `- Sub-type: ${subType ?? "unclassified"}`,
+    `- Date: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+    `- Provenance: catch-up`,
+    "",
+    "## Hypothesis",
+    description,
+    "",
+    "## Approach",
+    `Implemented manually (catch-up). Changes captured from \`${diffRange}\`.`,
+    "",
+    "## Files Changed",
+    diffStat || "(no diff stat available)",
+    "",
+    "## Journal",
+    journalSection || "(no journal entries)",
+    ""
+  ].join("\n");
+  const docRelPath = `docs/experiments/${String(exp.id).padStart(3, "0")}-${slug}.md`;
+  const docFullPath = path23.join(root, docRelPath);
+  const docsDir = path23.dirname(docFullPath);
+  if (!fs22.existsSync(docsDir)) {
+    fs22.mkdirSync(docsDir, { recursive: true });
+  }
+  fs22.writeFileSync(docFullPath, docContent);
+  autoCommit(root, `catch-up: ${slug}`);
+  const config = loadConfig(root);
+  if (config.metrics?.command) {
+    try {
+      const output = (0, import_node_child_process13.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} metric(s).`);
+    } catch {
+      warn("Could not capture metrics.");
+    }
+  }
+  adminTransitionAndPersist(db, exp.id, "classified" /* CLASSIFIED */, "built" /* BUILT */, "bootstrap");
+  success(`Catch-up experiment created: ${slug} (now at 'built')`);
+  info(`Run \`majlis doubt\` when ready to evaluate.`);
+}
+var fs22, path23, import_node_child_process13;
+var init_catchup = __esm({
+  "src/commands/catchup.ts"() {
+    "use strict";
+    fs22 = __toESM(require("fs"));
+    path23 = __toESM(require("path"));
+    import_node_child_process13 = require("child_process");
+    init_connection();
+    init_queries();
+    init_machine();
+    init_types2();
+    init_config();
+    init_spawn();
+    init_metrics();
+    init_git();
+    init_format();
+  }
+});
+
 // src/cli.ts
-var fs22 = __toESM(require("fs"));
-var path23 = __toESM(require("path"));
+var fs23 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 init_format();
 var VERSION2 = JSON.parse(
-  fs22.readFileSync(path23.join(__dirname, "..", "package.json"), "utf-8")
+  fs23.readFileSync(path24.join(__dirname, "..", "package.json"), "utf-8")
 ).version;
 async function main() {
   let sigintCount = 0;
@@ -8339,6 +9129,26 @@ async function main() {
         await resync2(rest);
         break;
       }
+      case "note": {
+        const { note: note2 } = await Promise.resolve().then(() => (init_note(), note_exports));
+        await note2(rest);
+        break;
+      }
+      case "journal": {
+        const { journal: journal2 } = await Promise.resolve().then(() => (init_journal(), journal_exports));
+        await journal2(rest);
+        break;
+      }
+      case "brief": {
+        const { brief: brief2 } = await Promise.resolve().then(() => (init_brief(), brief_exports));
+        await brief2(rest, isJson);
+        break;
+      }
+      case "catch-up": {
+        const { catchUp: catchUp2 } = await Promise.resolve().then(() => (init_catchup(), catchup_exports));
+        await catchUp2(rest);
+        break;
+      }
       default:
         console.error(`Unknown command: ${command}`);
         printHelp();
@@ -8368,10 +9178,15 @@ Experiments:
     --sub-type TYPE          Classify by problem sub-type
     --depends-on SLUG        Block building until dependency is merged
     --context FILE,FILE      Inject domain-specific docs into agent context
+    --skip-gate              Skip gatekeeper (pilot-verified hypothesis)
+    --from-file FILE         Inject structured hypothesis from markdown file
   baseline                   Capture metrics snapshot (before)
   measure                    Capture metrics snapshot (after)
   compare [--json]           Compare before/after, detect regressions
   revert                     Revert experiment, log to dead-end
+  catch-up "description"     Create experiment retroactively from manual work
+    --diff RANGE             Git diff range (required, e.g. HEAD~3..HEAD)
+    --sub-type TYPE          Classify by problem sub-type
 
 Cycle:
   next [experiment] [--auto] Determine and execute next cycle step
@@ -8382,6 +9197,8 @@ Cycle:
   verify [experiment]        Spawn verifier agent
   gate [experiment]          Spawn gatekeeper agent
   resolve [experiment]       Route based on verification grades
+    --reject                 Force dead-end (human override)
+    --reason "text"          Reason for rejection (with --reject)
   compress                   Spawn compressor agent
 
 Classification:
@@ -8398,12 +9215,21 @@ Queries:
 
 Audit:
   audit "objective"          Maqasid check \u2014 is the frame right?
+    --accept                 Accept pending objective rewrite
+    --reject                 Reject pending objective rewrite
   diagnose ["focus area"]    Deep diagnosis \u2014 root causes, patterns, gaps
 
 Sessions:
   session start "intent"     Declare session intent
   session end                Log accomplished/unfinished/fragility
 
+Pilot:
+  note "text"                Save an observation to the DB
+    --tag TAG                Tag the note (hypothesis, code-pointer, etc.)
+    --experiment SLUG        Attach to a specific experiment
+  journal "text"             Timestamped breadcrumb during manual hacking
+  brief [--plain] [--short]  Pilot-friendly context dump for Claude Code
+
 Orchestration:
   run "goal"                 Autonomous orchestration until goal met
   swarm "goal" [--parallel N] Run N experiments in parallel worktrees

package/package.json

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