@geraldmaron/construct 1.0.0 → 1.0.1

package/lib/dispatch-batch.js

@@ -0,0 +1,183 @@
+/**
+ * lib/dispatch-batch.js — Batch multiplexer for parallel agents.
+ *
+ * When orchestration policy returns a dispatch plan with parallel: true:
+ *   1. Check all agents use the same model tier AND same provider family.
+ *   2. Compose one shared system message (deduplicated static fragments).
+ *   3. Append N per-agent task suffixes as separate user messages.
+ *   4. Request structured JSON output with agent names as keys.
+ *   5. Fall back to sequential dispatch if tiers differ.
+ *
+ * Only activates when dispatchPlan.someParallel === true AND agents share the same model.
+ */
+import { composePrompt } from './prompt-composer.js';
+import { resolveProviderCapabilities } from './provider-capabilities.js';
+import { estimateTokensSync } from './token-engine.js';
+
+const MAX_BATCH_AGENTS = 5; // limit batch size for token budget
+
+/**
+ * Check if a dispatch plan can be batched.
+ *
+ * @param {Array} agents - [{ name, ... }]
+ * @param {object} dispatchPlan
+ * @returns {{ canBatch: boolean, reason: string, sharedModel: string }}
+ */
+export function canBatch(agents, dispatchPlan) {
+  if (!dispatchPlan?.someParallel) {
+    return { canBatch: false, reason: 'Dispatch plan does not request parallel execution' };
+  }
+
+  if (!Array.isArray(agents) || agents.length < 2) {
+    return { canBatch: false, reason: 'Need at least 2 agents for batch' };
+  }
+
+  if (agents.length > MAX_BATCH_AGENTS) {
+    return { canBatch: false, reason: `Batch size ${agents.length} exceeds max ${MAX_BATCH_AGENTS}` };
+  }
+
+  // Check all agents share the same model tier
+  const tiers = new Set();
+  const providers = new Set();
+
+  for (const agent of agents) {
+    tiers.add(agent.tier || 'standard');
+    providers.add(agent.provider || 'unknown');
+  }
+
+  if (tiers.size > 1) {
+    return { canBatch: false, reason: `Multiple tiers: ${[...tiers].join(', ')}` };
+  }
+
+  if (providers.size > 1) {
+    return { canBatch: false, reason: `Multiple providers: ${[...providers].join(', ')}` };
+  }
+
+  const sharedModel = agents[0].modelId || '';
+  return { canBatch: true, reason: null, sharedModel, sharedTier: [...tiers][0] };
+}
+
+/**
+ * Build a batch prompt for parallel agents.
+ *
+ * @param {Array} agents - [{ name, task, ... }]
+ * @param {object} options - { sharedModel, rootDir, ... }]
+ * @returns {Promise<{ system, messages, expectedTokens }>}
+ */
+export async function buildBatchPrompt(agents, {
+  rootDir = process.cwd(),
+  ...opts
+} = {}) {
+  if (!agents?.length) return null;
+
+  // Compose prompt for first agent (the template)
+  const first = await composePrompt(agents[0].name, {
+    rootDir,
+    task: agents[0].task,
+    intent: agents[0].intent,
+    workCategory: agents[0].workCategory,
+    ...opts,
+  });
+
+  // Extract shared system from first agent
+  const sharedSystem = first.system || '';
+  const staticEndIndex = first.staticEndIndex;
+
+  // Build per-agent suffixes
+  const agentSuffixes = [];
+  let totalSuffixTokens = 0;
+
+  for (let i = 0; i < agents.length; i++) {
+    const agent = agents[i];
+    const agentPrompt = await composePrompt(agent.name, {
+      rootDir,
+      task: agent.task,
+      intent: agent.intent,
+      workCategory: agent.workCategory,
+      injectLearnedPatterns: i === 0, // only inject once
+      ...opts,
+    });
+
+    // The dynamic part (after system)
+    const suffix = agentPrompt.messages?.[1]?.content || agentPrompt.system || '';
+    const suffixTokens = estimateTokensSync(suffix, { modelId: opts.sharedModel });
+
+    agentSuffixes.push({
+      agent: agent.name,
+      content: suffix,
+      tokens: suffixTokens,
+    });
+    totalSuffixTokens += suffixTokens;
+  }
+
+  const systemTokens = estimateTokensSync(sharedSystem, { modelId: opts.sharedModel });
+  const totalTokens = systemTokens + totalSuffixTokens;
+
+  // Build messages: one system + N user messages
+  const messages = [
+    { role: 'system', content: sharedSystem },
+    ...agentSuffixes.map(a => ({
+      role: 'user',
+      content: `Agent: ${a.agent}\n\n${a.content}`,
+    })),
+  ];
+
+  return {
+    system: sharedSystem,
+    messages,
+    expectedTokens: totalTokens,
+    agentSuffixes,
+    canSend: totalTokens < 30000, // conservative limit for batch
+  };
+}
+
+/**
+ * Parse a structured batch response.
+ *
+ * @param {string} responseText - LLM response with JSON
+ * @param {Array} agentNames
+ * @returns {object} - { agentName: responseText }
+ */
+export function parseBatchResponse(responseText, agentNames) {
+  if (!responseText || !Array.isArray(agentNames)) return {};
+
+  try {
+    // Try to parse as JSON
+    const parsed = JSON.parse(responseText);
+    if (typeof parsed === 'object' && parsed !== null) {
+      // Check if response has agent keys
+      const result = {};
+      for (const name of agentNames) {
+        result[name] = parsed[name] || parsed[name.replace(/^cx-/, '')] || '';
+      }
+      return result;
+    }
+  } catch {
+    // Not JSON — return full text as fallback
+  }
+
+  // Fallback: split by agent headers
+  const result = {};
+  const lines = responseText.split('\n');
+  let currentAgent = null;
+  let currentText = [];
+
+  for (const line of lines) {
+    const agentMatch = line.match(/^Agent:\s*(cx-[^\s]+)/);
+    if (agentMatch) {
+      if (currentAgent) {
+        result[currentAgent] = currentText.join('\n').trim();
+      }
+      currentAgent = agentMatch[1];
+      currentText = [];
+    } else {
+      currentText.push(line);
+    }
+  }
+
+  if (currentAgent) {
+    result[currentAgent] = currentText.join('\n').trim();
+  }
+
+  return result;
+}

package/lib/distill.mjs

@@ -1,20 +1,23 @@
 #!/usr/bin/env node
 /**
- * lib/distill.mjs — <one-line purpose>
+ * lib/distill.mjs — Query-focused document distillation for large context windows.
  *
- * <2–6 line summary.>
+ * Chunks local files, scores relevance against a query, and returns the top-k
+ * evidence blocks with citations. Backs the MCP distill tool and the RAG
+ * knowledge layer for shrinking context before LLM calls.
  */
 import { readdirSync, statSync, readFileSync, writeFileSync, existsSync, mkdirSync, openSync, readSync, closeSync } from 'fs';
 import { join, extname, relative, dirname, basename } from 'path';
 import { execSync, spawnSync } from 'child_process';
 import { homedir } from 'os';
 import { getActiveOverlays } from './headhunt.mjs';
+import {
+  EXTRACTABLE_DOCUMENT_EXTS,
+  UTF8_TEXT_EXTS,
+  extractDocumentText as extractSharedDocumentText,
+} from './document-extract.mjs';
 
-const TEXT_EXTS = new Set([
-  '.md', '.txt', '.rst', '.adoc', '.json', '.yaml', '.yml', '.toml',
-  '.js', '.mjs', '.ts', '.tsx', '.jsx', '.py', '.go', '.rs', '.sh', '.bash',
-  '.html', '.css', '.csv', '.xml', '.env', '.env.example', '.conf', '.ini', '.tf', '.hcl',
-]);
+const TEXT_EXTS = EXTRACTABLE_DOCUMENT_EXTS;
 
 const SKIP_DIRS = new Set(['node_modules', '.git', '.next', 'dist', 'build', '__pycache__', '.cache']);
 const MAX_FILE_BYTES = 80_000;
@@ -180,7 +183,17 @@ function readFiles(files, dir, options = {}) {
     if (chunks.length >= MAX_FILES) break;
     if (totalBytes >= MAX_TOTAL_BYTES) break;
     try {
-      const bounded = readBoundedText(file.path, file.size);
+      const bounded = UTF8_TEXT_EXTS.has(file.ext)
+        ? readBoundedText(file.path, file.size)
+        : (() => {
+            const extracted = extractSharedDocumentText(file.path, { maxChars: MAX_FILE_BYTES });
+            return {
+              content: extracted.text,
+              truncated: extracted.truncated,
+              sampledBytes: Math.min(file.size, MAX_FILE_BYTES),
+              originalBytes: file.size,
+            };
+          })();
       totalBytes += bounded.sampledBytes;
       if (bounded.truncated) truncatedFileCount += 1;
       chunks.push(...chunkContent(relative(dir, file.path), bounded.content, {

package/lib/doc-stamp.mjs

@@ -0,0 +1,164 @@
+/**
+ * lib/doc-stamp.mjs — Auditability stamps for Construct-generated documents.
+ *
+ * Provides:
+ *   uuidv7()          — time-ordered UUID (RFC 9562) for document identity
+ *   bodyHash(text)    — SHA-256 of document body for tamper detection
+ *   stampFrontmatter  — inject/update audit block at top of a markdown string
+ *   verifyStamp       — verify body_hash against current content
+ *   parseStamp        — extract stamp fields from a document string
+ *
+ * Design:
+ *   - Zero npm dependencies (Node built-ins only)
+ *   - Stamp is a YAML-fenced block at the very top of the file, before any
+ *     other content. Markdown renderers show it as a metadata block.
+ *   - body_hash covers everything after the closing --- of the stamp block,
+ *     trimmed, so whitespace-only edits do not break verification.
+ *   - generator field is intentionally short (no version pinning) so the
+ *     stamp survives construct upgrades without false-positive hash mismatches.
+ */
+
+import { createHash, randomBytes } from 'node:crypto';
+
+// ---------------------------------------------------------------------------
+// UUIDv7 — RFC 9562 §5.7
+// Top 48 bits: Unix ms timestamp. Next 4 bits: version=7. Next 12 bits:
+// random seq. Next 2 bits: variant=10. Remaining 62 bits: random.
+// ---------------------------------------------------------------------------
+export function uuidv7() {
+  const ms = BigInt(Date.now());
+  const rand = randomBytes(10);
+  // Build 128-bit value as two 64-bit halves
+  const hi =
+    ((ms & 0xffffffffffffn) << 16n) |
+    (7n << 12n) |
+    (BigInt(rand[0] & 0x0f) << 8n) |
+    BigInt(rand[1]);
+  const lo =
+    (0x8000000000000000n) |
+    (BigInt(rand[2] & 0x3f) << 56n) |
+    (BigInt(rand[3]) << 48n) |
+    (BigInt(rand[4]) << 40n) |
+    (BigInt(rand[5]) << 32n) |
+    (BigInt(rand[6]) << 24n) |
+    (BigInt(rand[7]) << 16n) |
+    (BigInt(rand[8]) << 8n) |
+    BigInt(rand[9]);
+
+  const hex = hi.toString(16).padStart(16, '0') + lo.toString(16).padStart(16, '0');
+  return `${hex.slice(0,8)}-${hex.slice(8,12)}-${hex.slice(12,16)}-${hex.slice(16,20)}-${hex.slice(20)}`;
+}
+
+// ---------------------------------------------------------------------------
+// Content hash — SHA-256 of trimmed body text
+// ---------------------------------------------------------------------------
+export function bodyHash(bodyText) {
+  return 'sha256:' + createHash('sha256').update(bodyText.trim(), 'utf8').digest('hex');
+}
+
+// ---------------------------------------------------------------------------
+// Stamp block helpers
+// ---------------------------------------------------------------------------
+const STAMP_OPEN = '---';
+const STAMP_CLOSE = '---';
+const STAMP_MARKER = 'cx_doc_id:';
+
+/**
+ * Returns true if the document already has a Construct stamp block.
+ */
+export function hasStamp(content) {
+  if (!content.startsWith(STAMP_OPEN)) return false;
+  const rest = content.slice(3);
+  return rest.includes(STAMP_MARKER);
+}
+
+/**
+ * Split document into { stampBlock, body }.
+ * stampBlock includes the opening and closing --- lines.
+ * body is everything after the closing ---.
+ * Returns null if no stamp found.
+ */
+function splitStamp(content) {
+  if (!content.startsWith(STAMP_OPEN + '\n')) return null;
+  const afterOpen = content.slice(4);
+  const closeIdx = afterOpen.indexOf('\n' + STAMP_CLOSE + '\n');
+  if (closeIdx === -1) return null;
+  const stampBlock = STAMP_OPEN + '\n' + afterOpen.slice(0, closeIdx) + '\n' + STAMP_CLOSE;
+  const body = afterOpen.slice(closeIdx + STAMP_CLOSE.length + 2);
+  return { stampBlock, body };
+}
+
+/**
+ * Inject a new audit stamp at the top of a markdown string.
+ * If a stamp already exists it is replaced (id preserved, hash updated).
+ *
+ * @param {string} content   - Raw markdown content (may already have a stamp)
+ * @param {object} options
+ *   generator   {string}  - Short generator label (default: 'construct')
+ *   sessionId   {string}  - Construct session ID if available
+ *   model       {string}  - Model name/version if available
+ *   preserve_id {boolean} - Keep existing cx_doc_id if present (default: true)
+ */
+export function stampFrontmatter(content, {
+  generator = 'construct',
+  sessionId = null,
+  model = null,
+  preserve_id = true,
+} = {}) {
+  const existing = hasStamp(content) ? splitStamp(content) : null;
+  const existingFields = existing ? parseStamp(content) : {};
+
+  const id = (preserve_id && existingFields.cx_doc_id) ? existingFields.cx_doc_id : uuidv7();
+  const createdAt = existingFields.created_at || new Date().toISOString();
+  const updatedAt = new Date().toISOString();
+
+  // Body is everything after stamp (or all content if no prior stamp)
+  const body = existing ? existing.body : content;
+  const hash = bodyHash(body);
+
+  const lines = [
+    STAMP_OPEN,
+    `cx_doc_id: ${id}`,
+    `created_at: ${createdAt}`,
+    `updated_at: ${updatedAt}`,
+    `generator: ${generator}`,
+  ];
+  if (model) lines.push(`model: ${model}`);
+  if (sessionId) lines.push(`session_id: ${sessionId}`);
+  lines.push(`body_hash: ${hash}`);
+  lines.push(STAMP_CLOSE);
+  lines.push('');
+
+  return lines.join('\n') + body;
+}
+
+/**
+ * Parse stamp fields from a stamped document.
+ * Returns {} if no stamp found.
+ */
+export function parseStamp(content) {
+  const parts = splitStamp(content);
+  if (!parts) return {};
+  const fields = {};
+  for (const line of parts.stampBlock.split('\n')) {
+    const m = line.match(/^(\w+):\s*(.+)$/);
+    if (m) fields[m[1]] = m[2].trim();
+  }
+  return fields;
+}
+
+/**
+ * Verify that the stored body_hash matches the current body.
+ * Returns { valid: true } or { valid: false, reason, stored, computed }.
+ */
+export function verifyStamp(content) {
+  const parts = splitStamp(content);
+  if (!parts) return { valid: false, reason: 'no stamp found' };
+  const fields = parseStamp(content);
+  if (!fields.body_hash) return { valid: false, reason: 'no body_hash in stamp' };
+  const computed = bodyHash(parts.body);
+  if (computed !== fields.body_hash) {
+    return { valid: false, reason: 'body_hash mismatch', stored: fields.body_hash, computed };
+  }
+  return { valid: true, id: fields.cx_doc_id, created_at: fields.created_at };
+}

package/lib/doc-verify.mjs

@@ -0,0 +1,119 @@
+/**
+ * lib/doc-verify.mjs — CLI handler for `construct doc verify`
+ *
+ * Walks one file or a directory tree, checks every stamped .md file for
+ * body_hash integrity, and reports pass/fail/unstamped counts.
+ *
+ * Usage:
+ *   construct doc verify [path]   [--json]
+ *
+ * Exit codes:
+ *   0  all stamped files pass (or no stamped files found)
+ *   1  one or more stamped files fail verification
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { verifyStamp, hasStamp } from './doc-stamp.mjs';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+
+function walkMd(target) {
+  const stat = fs.statSync(target);
+  if (stat.isFile()) return target.endsWith('.md') ? [target] : [];
+  const files = [];
+  for (const entry of fs.readdirSync(target, { withFileTypes: true })) {
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    const full = path.join(target, entry.name);
+    if (entry.isDirectory()) files.push(...walkMd(full));
+    else if (entry.isFile() && entry.name.endsWith('.md')) files.push(full);
+  }
+  return files;
+}
+
+export function runDocVerifyCli(args) {
+  const jsonMode = args.includes('--json');
+  const targetArg = args.find(a => !a.startsWith('--'));
+  const target = path.resolve(targetArg ?? process.cwd());
+
+  if (!fs.existsSync(target)) {
+    console.error(`construct doc verify: path not found: ${target}`);
+    process.exit(1);
+  }
+
+  const files = walkMd(target);
+  const results = { pass: [], fail: [], unstamped: [] };
+
+  for (const file of files) {
+    const content = fs.readFileSync(file, 'utf8');
+    if (!hasStamp(content)) {
+      results.unstamped.push(file);
+      continue;
+    }
+    const v = verifyStamp(content);
+    if (v.valid) results.pass.push({ file, id: v.id, created_at: v.created_at });
+    else results.fail.push({ file, reason: v.reason, stored: v.stored, computed: v.computed });
+  }
+
+  if (jsonMode) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    const rel = f => path.relative(process.cwd(), f);
+    for (const r of results.fail) {
+      console.log(`  FAIL  ${rel(r.file)}`);
+      console.log(`        ${r.reason}`);
+    }
+    for (const r of results.pass) {
+      console.log(`  ok    ${rel(r.file)}  [${r.id}]`);
+    }
+    if (results.unstamped.length) {
+      console.log(`\n  ${results.unstamped.length} file(s) have no stamp (not generated by construct).`);
+    }
+    const summary = `\n  ${results.pass.length} passed, ${results.fail.length} failed, ${results.unstamped.length} unstamped`;
+    console.log(summary);
+  }
+
+  if (results.fail.length > 0) process.exit(1);
+}
+
+/**
+ * Install the prepare-commit-msg git hook into the nearest .git/hooks/ directory.
+ */
+export function runDocInstallHooksCli(_args) {
+  const src = path.join(__dirname, 'git-hooks', 'prepare-commit-msg');
+  if (!fs.existsSync(src)) {
+    console.error(`construct doc install-hooks: hook source not found: ${src}`);
+    process.exit(1);
+  }
+
+  // Walk up from cwd to find .git
+  let dir = process.cwd();
+  let gitDir = null;
+  while (true) {
+    const candidate = path.join(dir, '.git');
+    if (fs.existsSync(candidate)) { gitDir = candidate; break; }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  if (!gitDir) {
+    console.error('construct doc install-hooks: not inside a git repository');
+    process.exit(1);
+  }
+
+  const hooksDir = path.join(gitDir, 'hooks');
+  fs.mkdirSync(hooksDir, { recursive: true });
+  const dest = path.join(hooksDir, 'prepare-commit-msg');
+
+  if (fs.existsSync(dest)) {
+    console.log(`  already installed: ${path.relative(process.cwd(), dest)}`);
+    return;
+  }
+
+  fs.copyFileSync(src, dest);
+  fs.chmodSync(dest, 0o755);
+  console.log(`  installed: ${path.relative(process.cwd(), dest)}`);
+  console.log('\n  Set CONSTRUCT_MODEL and CONSTRUCT_SESSION_ID in your shell or Construct config to populate trailers.');
+}

package/lib/docs-routing.mjs

@@ -0,0 +1,89 @@
+/**
+ * lib/docs-routing.mjs — suggests documentation lanes for files based on content and naming.
+ *
+ * Maps file paths and content patterns to documentation sections (prds, adrs, rfcs, etc.)
+ * for automatic documentation organization.
+ */
+
+import path from 'node:path';
+
+export const DOC_LANE_DIRS = {
+  adrs: 'adr',
+  briefs: 'briefs',
+  changelogs: 'changelogs',
+  intake: 'intake',
+  memos: 'memos',
+  meetings: 'meetings',
+  notes: 'notes',
+  onboarding: 'onboarding',
+  postmortems: 'postmortems',
+  prds: 'prds',
+  rfcs: 'rfcs',
+  runbooks: 'runbooks',
+};
+
+export function docLaneDir(laneKey) {
+  return DOC_LANE_DIRS[laneKey] ?? laneKey;
+}
+
+export function suggestDocsLaneForFile(filePath, content = '') {
+  const fileName = path.basename(filePath).toLowerCase();
+
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (frontmatterMatch) {
+    const frontmatter = frontmatterMatch[1];
+    const typeMatch = frontmatter.match(/type:\s*(prd|adr|rfc|memo|runbook|brief|meeting|note)/i);
+    if (typeMatch) {
+      const type = typeMatch[1].toLowerCase();
+      if (type === 'adr') return 'adrs';
+      if (type === 'prd') return 'prds';
+      if (type === 'rfc') return 'rfcs';
+      if (type === 'memo') return 'memos';
+      if (type === 'runbook') return 'runbooks';
+      if (type === 'brief') return 'briefs';
+      if (type === 'meeting') return 'meetings';
+      if (type === 'note') return 'notes';
+    }
+  }
+
+  const prdPatterns = ['prd', 'product', 'requirement', 'spec', 'feature'];
+  const adrPatterns = ['adr', 'architecture', 'design', 'decision'];
+  const rfcPatterns = ['rfc', 'request', 'comment', 'proposal'];
+  const memoPatterns = ['memo', 'memorandum'];
+  const runbookPatterns = ['runbook', 'run book', 'operational', 'procedure'];
+  const briefPatterns = ['brief', 'one-pager', 'signal', 'evidence', 'research'];
+  const changelogPatterns = ['changelog', 'release-notes', 'releases'];
+  const onboardingPatterns = ['onboarding', 'setup', 'getting-started', 'local-setup'];
+  const postmortemPatterns = ['postmortem', 'incident-report', 'incident', 'sev-'];
+  const meetingPatterns = ['meeting', 'minutes', 'retro', 'standup', 'agenda', 'sync', '1-1', '1:1'];
+  const notePatterns = ['note', 'notes', 'scratchpad', 'journal'];
+
+  const checkPatterns = (patterns) => patterns.some((p) => fileName.includes(p));
+
+  if (checkPatterns(prdPatterns)) return 'prds';
+  if (checkPatterns(adrPatterns)) return 'adrs';
+  if (checkPatterns(rfcPatterns)) return 'rfcs';
+  if (checkPatterns(memoPatterns)) return 'memos';
+  if (checkPatterns(runbookPatterns)) return 'runbooks';
+  if (checkPatterns(briefPatterns)) return 'briefs';
+  if (checkPatterns(changelogPatterns)) return 'changelogs';
+  if (checkPatterns(onboardingPatterns)) return 'onboarding';
+  if (checkPatterns(postmortemPatterns)) return 'postmortems';
+  if (checkPatterns(meetingPatterns)) return 'meetings';
+  if (checkPatterns(notePatterns)) return 'notes';
+
+  const preview = content.slice(0, 4000).toLowerCase();
+  if (preview.includes('product requirement') || preview.includes('user story') || preview.includes('acceptance criteria')) return 'prds';
+  if (preview.includes('architecture decision') || preview.includes('design decision') || preview.includes('we decided')) return 'adrs';
+  if (preview.includes('request for comments') || preview.includes('please comment') || preview.includes('drawbacks')) return 'rfcs';
+  if (preview.includes('decision memo') || preview.includes('memorandum')) return 'memos';
+  if (preview.includes('runbook') || preview.includes('operational procedure') || preview.includes('troubleshooting')) return 'runbooks';
+  if (preview.includes('signal') || preview.includes('evidence') || preview.includes('competitive analysis') || preview.includes('research brief')) return 'briefs';
+  if (preview.includes('## added') || preview.includes('## changed') || preview.includes('## fixed') || preview.includes('release notes')) return 'changelogs';
+  if (preview.includes('local setup') || preview.includes('getting started') || preview.includes('prerequisites')) return 'onboarding';
+  if (preview.includes('postmortem') || preview.includes('incident report') || (preview.includes('root cause') && preview.includes('timeline') && preview.includes('impact'))) return 'postmortems';
+  if (preview.includes('meeting notes') || preview.includes('meeting minutes') || preview.includes('attendees') && preview.includes('action items')) return 'meetings';
+  if (preview.includes('notes') || preview.includes('working notes')) return 'notes';
+
+  return null;
+}