majlis 0.8.4 → 0.9.0

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,33 @@ 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'));
     `);
       }
     ];
@@ -1781,10 +1822,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) {
@@ -3985,6 +4026,37 @@ 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 exportForCompressor(db, maxLength = 5e4) {
   const experiments = listAllExperiments(db);
   const sections = ["# Structured Data Export (from SQLite)\n"];
@@ -4043,6 +4115,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 +4274,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) + `
@@ -4358,7 +4479,7 @@ 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 */
     };
   }
 });
@@ -5014,6 +5135,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 +5207,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,
@@ -5288,6 +5421,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 +5463,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 +5587,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 +5606,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 +5700,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 +5729,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 +6008,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 +6027,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 +6053,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();
@@ -8193,12 +8394,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 +8896,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 +8945,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
@@ -8404,6 +8986,13 @@ 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.0",
   "description": "Multi-agent workflow CLI for structured doubt, independent verification, and compressed knowledge",
   "bin": {
     "majlis": "./dist/cli.js"