sandtable 0.3.0

package/src/builder/build.js

@@ -0,0 +1,1019 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { scan, loadConfig, normalizeCategory, DISPLAY_CATEGORIES, PRIMARY_CATEGORIES } = require('../scanner/scan');
+
+// ---- Markdown Table Parser (unchanged from v1) ----
+function parseMarkdownTables(content) {
+  const results = [];
+  const lines = content.split('\n');
+  let header = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (/^\|.+\|$/.test(line) && !/^\|[-| ]+\|$/.test(line)) {
+      if (!header) {
+        header = line.split('|').map(c => c.trim()).filter(Boolean);
+      } else {
+        const cols = line.split('|').map(c => c.trim()).filter(Boolean);
+        if (cols.length >= 2) {
+          const row = {};
+          header.forEach((h, idx) => { row[h] = cols[idx] || ''; });
+          results.push(row);
+        }
+      }
+    } else if (!/^\|[-| ]+\|$/.test(line)) {
+      header = null;
+    }
+  }
+  return results;
+}
+
+// ---- Primary Tree Builder ----
+function buildPrimaryTree(planFiles, allFiles, projectRoot) {
+  const elements = [];
+
+  // Collect task rows from task-board-like files
+  const taskRows = [];
+  for (const pf of planFiles) {
+    const fp = path.join(projectRoot, pf.path);
+    if (!fs.existsSync(fp)) continue;
+    const content = fs.readFileSync(fp, 'utf-8');
+    const tables = parseMarkdownTables(content);
+    const hasTaskCols = tables.length > 0 &&
+      (Object.keys(tables[0]).some(k => /任务|task|#/.test(k)));
+    if (hasTaskCols) {
+      for (const row of tables) {
+        taskRows.push({ ...row, _source: pf.path });
+      }
+    }
+  }
+
+  // Build phases from milestone/plan files with markdown tables
+  const milestoneFiles = planFiles.filter(f =>
+    f.elementType === 'milestone' ||
+    (f.summary && f.summary.type === 'milestone')
+  );
+
+  for (const mf of milestoneFiles) {
+    const fp = path.join(projectRoot, mf.path);
+    if (!fs.existsSync(fp)) continue;
+    const content = fs.readFileSync(fp, 'utf-8');
+    const rows = parseMarkdownTables(content);
+
+    const milestones = rows.map((row, i) => {
+      const keys = Object.keys(row);
+      const milestoneName = row[keys[0]] || '';
+      const version = row[keys[1]] || '';
+      const signal = row[keys[2]] || '';
+      const statusRaw = (row[keys[3]] || 'pending').toLowerCase();
+      const status = statusRaw.includes('in_progress') ? 'in_progress'
+        : statusRaw.includes('complete') ? 'completed'
+        : statusRaw.includes('block') ? 'blocked'
+        : 'pending';
+
+      // Match subtasks from task board
+      const subtasks = taskRows
+        .filter(tr => {
+          const taskName = tr[Object.keys(tr)[1]] || tr[Object.keys(tr)[0]] || '';
+          return taskName.includes(milestoneName) ||
+            milestoneName.includes(taskName.substring(0, 6));
+        })
+        .slice(0, 3)
+        .map(tr => {
+          const tKeys = Object.keys(tr);
+          const statusKey = tKeys.find(k => /状态|status/i.test(k));
+          const statusCol = statusKey ? tr[statusKey] : (tr[tKeys[4]] || tr[tKeys[3]] || '');
+          const isCompleted = /✅|\[x\]|completed|complete/i.test(statusCol);
+          const isInProgress = /⏳|\[\s*\]|in.progress/i.test(statusCol);
+          const typeKey = tKeys.find(k => /类型|type/i.test(k));
+          const typeCol = typeKey ? tr[typeKey] : (tr[tKeys[3]] || tr[tKeys[2]] || '');
+          return {
+            id: tr[tKeys[0]] || '',
+            name: tr[tKeys[1]] || tr[tKeys[0]] || '',
+            status: isCompleted ? 'completed' : isInProgress ? 'in_progress' : 'pending',
+            kind: 'primary',
+            elementType: 'subtask',
+            timeGroup: 'current',
+            timeLabel: '',
+            date: null,
+            source: { file: tr._source || mf.path, title: mf.title },
+            summary: '',
+            tags: [],
+            related: [],
+            children: [],
+          };
+        });
+
+      return {
+        id: 'ms-' + (milestoneName.replace(/^M/, '').substring(0, 10) || `M${i + 1}`),
+        kind: 'primary',
+        elementType: 'milestone',
+        category: 'roadmap',
+        name: version ? `${milestoneName} (${version})` : milestoneName,
+        status,
+        timeGroup: 'current',
+        timeLabel: signal,
+        date: mf.date || null,
+        source: { file: mf.path, title: mf.title },
+        summary: '',
+        tags: [],
+        related: [],
+        children: subtasks,
+        order: i + 1,
+      };
+    });
+
+    elements.push({
+      id: 'phase-' + (elements.length + 1),
+      kind: 'primary',
+      elementType: 'phase',
+      category: 'roadmap',
+      name: mf.summary ? mf.summary.summary : mf.title,
+      status: mf.summary ? mf.summary.status : 'in_progress',
+      timeGroup: 'current',
+      timeLabel: '',
+      date: mf.date || null,
+      source: { file: mf.path, title: mf.title },
+      summary: mf.summary ? (mf.summary.summary || '') : '',
+      tags: mf.summary ? (mf.summary.tags || []) : [],
+      related: mf.summary ? (mf.summary.related || []) : [],
+      children: milestones,
+      order: elements.length + 1,
+    });
+  }
+
+  // Fallback: default phase from any plan-category files with summaries
+  if (elements.length === 0 && planFiles.length > 0) {
+    const tasks = planFiles
+      .filter(f => f.summary)
+      .map(f => ({
+        id: 'task-' + f.path.replace(/[/.]/g, '-'),
+        kind: 'primary',
+        elementType: 'task',
+        category: 'roadmap',
+        name: f.summary.summary,
+        status: f.summary.status || 'pending',
+        timeGroup: 'current',
+        timeLabel: '',
+        date: f.date || null,
+        source: { file: f.path, title: f.title },
+        summary: f.summary.summary || '',
+        tags: f.summary.tags || [],
+        related: f.summary.related || [],
+        children: [],
+      }));
+
+    elements.push({
+      id: 'phase-default',
+      kind: 'primary',
+      elementType: 'phase',
+      category: 'roadmap',
+      name: '当前阶段',
+      status: 'in_progress',
+      timeGroup: 'current',
+      timeLabel: '',
+      date: null,
+      source: { file: '', title: '' },
+      summary: '',
+      tags: [],
+      related: [],
+      children: [{
+        id: 'ms-current',
+        kind: 'primary',
+        elementType: 'milestone',
+        category: 'roadmap',
+        name: '进行中',
+        status: 'in_progress',
+        timeGroup: 'current',
+        timeLabel: '',
+        date: null,
+        source: { file: '', title: '' },
+        summary: '',
+        tags: [],
+        related: [],
+        children: tasks,
+        order: 1,
+      }],
+      order: 1,
+    });
+  }
+
+  // Extract conclusion elements from files with type=conclusion
+  const conclusionFiles = allFiles.filter(f =>
+    f.elementType === 'conclusion' ||
+    (f.summary && f.summary.type === 'conclusion')
+  );
+  for (const cf of conclusionFiles) {
+    elements.push({
+      id: 'conclusion-' + cf.path.replace(/[/.]/g, '-'),
+      kind: 'primary',
+      elementType: 'conclusion',
+      category: 'roadmap',
+      name: cf.title,
+      status: cf.summary ? (cf.summary.status || 'completed') : 'completed',
+      timeGroup: 'past',
+      timeLabel: cf.date || '',
+      date: cf.date || null,
+      source: { file: cf.path, title: cf.title },
+      summary: cf.summary ? (cf.summary.summary || '') : '',
+      tags: cf.summary ? (cf.summary.tags || []) : [],
+      related: cf.summary ? (cf.summary.related || []) : [],
+      children: [],
+      order: 0,
+    });
+  }
+
+  return elements;
+}
+
+// ---- Secondary List Builder ----
+function buildSecondaryList(secondaryFiles) {
+  return secondaryFiles
+    .filter(f => f.hasSummary || f.elementType !== 'unknown')
+    .map((f, i) => ({
+      id: f.elementType + '-' + f.path.replace(/[/.]/g, '-'),
+      kind: 'secondary',
+      elementType: f.elementType,
+      category: f.category,
+      name: f.title,
+      status: f.summary ? (f.summary.status || 'unknown') : 'unknown',
+      timeGroup: 'current',
+      timeLabel: (f.date || f.modified).substring(0, 10),
+      date: f.date || f.modified,
+      source: { file: f.path, title: f.title },
+      summary: f.summary ? (f.summary.summary || '') : '',
+      tags: f.summary ? (f.summary.tags || []) : [],
+      related: f.summary ? (f.summary.related || []) : [],
+      children: [],
+      order: i,
+    }));
+}
+
+// ---- Time Group Classifier ----
+function classifyTimeGroup(element, timeRules, today) {
+  // Archive category → always archived (read-only historical docs)
+  if (element.category === 'archive') return 'archived';
+
+  const rules = timeRules || {};
+  const classifyBy = rules.classifyBy || 'status';
+
+  if (classifyBy === 'date') {
+    if (element.date && element.date < today) return 'past';
+    if (element.date && element.date > today) return 'future';
+    return 'current';
+  }
+
+  // classifyBy === 'status' (default)
+  const pastStatuses = rules.pastStatus || ['completed', 'cancelled'];
+  const currentStatuses = rules.currentStatus || ['in_progress', 'pending'];
+  const futureStatuses = rules.futureStatus || [];
+
+  if (pastStatuses.includes(element.status)) return 'past';
+  if (futureStatuses.includes(element.status) &&
+      !currentStatuses.includes(element.status)) return 'future';
+  return 'current';
+}
+
+// ---- Filter Type Manifest Builder ----
+function buildFilterTypes(files, secondaryTypesDefaultOff) {
+  const secondaryFiles = files.filter(f => f.kind === 'secondary');
+  const catCounts = {};
+
+  for (const f of secondaryFiles) {
+    const cat = normalizeCategory(f.elementType);
+    catCounts[cat] = (catCounts[cat] || 0) + 1;
+  }
+
+  const result = [];
+  for (const [cat, def] of Object.entries(DISPLAY_CATEGORIES)) {
+    // Skip primary-only categories (all their elementTypes are kind=primary, no secondary files)
+    if (PRIMARY_CATEGORIES && PRIMARY_CATEGORIES.has(cat)) continue;
+    const count = catCounts[cat] || 0;
+    if (count > 0) {
+      result.push({ type: cat, label: def.label, count, defaultEnabled: !secondaryTypesDefaultOff });
+    }
+  }
+
+  return result;
+}
+
+// ---- Conventions Builder (auto-extract from docs/conventions/) ----
+function buildConventions(files, projectRoot) {
+  var abbreviations = [];
+  var terms = [];
+
+  // Try to parse abbreviations.md
+  var abbrFile = files.find(function(f) { return f.path.indexOf('abbreviations') !== -1; });
+  if (abbrFile) {
+    var abbrPath = path.join(projectRoot, abbrFile.path);
+    if (fs.existsSync(abbrPath)) {
+      var content = fs.readFileSync(abbrPath, 'utf-8');
+      var rows = parseMarkdownTables(content);
+      for (var i = 0; i < rows.length; i++) {
+        var row = rows[i];
+        var keys = Object.keys(row);
+        if (keys.length >= 2) {
+          abbreviations.push({
+            abbr: row[keys[0]] || '',
+            full: row[keys[1]] || '',
+            note: row[keys[2]] || '',
+          });
+        }
+      }
+    }
+  }
+
+  // Try to parse terms.md
+  var termFile = files.find(function(f) { return f.path.indexOf('terms') !== -1 && f.path.indexOf('abbreviations') === -1; });
+  if (termFile) {
+    var termPath = path.join(projectRoot, termFile.path);
+    if (fs.existsSync(termPath)) {
+      var tContent = fs.readFileSync(termPath, 'utf-8');
+      var tRows = parseMarkdownTables(tContent);
+      for (var j = 0; j < tRows.length; j++) {
+        var tRow = tRows[j];
+        var tKeys = Object.keys(tRow);
+        if (tKeys.length >= 2) {
+          terms.push({
+            term: tRow[tKeys[0]] || '',
+            definition: tRow[tKeys[1]] || '',
+            source: tRow[tKeys[2]] || '',
+          });
+        }
+      }
+    }
+  }
+
+  // Auto-detect abbreviations from all doc content (pattern: ABC (Alpha Bravo Charlie))
+  var abbrSet = {};
+  for (var ai = 0; ai < abbreviations.length; ai++) {
+    abbrSet[abbreviations[ai].abbr] = true;
+  }
+  for (var fi = 0; fi < files.length; fi++) {
+    var f = files[fi];
+    if (!f.hasSummary) continue;
+    try {
+      var fp = path.join(projectRoot, f.path);
+      if (!fs.existsSync(fp)) continue;
+      var fContent = fs.readFileSync(fp, 'utf-8').substring(0, 2000);
+      // Match patterns like "MVP (Minimum Viable Product)" or "ABC — Alpha"
+      var autoMatches = fContent.match(/\b([A-Z]{2,6})\s*[（(]\s*([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\s*[）)]/g);
+      if (autoMatches) {
+        for (var am = 0; am < autoMatches.length; am++) {
+          var m = autoMatches[am].match(/\b([A-Z]{2,6})\s*[（(]\s*([^）)]+)\s*[）)]/);
+          if (m && !abbrSet[m[1]]) {
+            abbrSet[m[1]] = true;
+            abbreviations.push({ abbr: m[1], full: m[2].trim(), note: 'auto-detected' });
+          }
+        }
+      }
+    } catch (_) {}
+  }
+
+  return {
+    configured: abbreviations.length > 0 || terms.length > 0,
+    abbreviations: abbreviations,
+    terms: terms,
+  };
+}
+
+// ---- Agents Builder (unchanged from v1) ----
+function buildAgents(files, projectRoot) {
+  const agentFiles = files.filter(f => f.category === 'ops' && f.elementType === 'agent');
+  if (agentFiles.length === 0) {
+    return { roles: [] };
+  }
+
+  const roles = agentFiles.map(f => {
+    const roleMatch = f.title.match(/@(\w+)/) || f.path.match(/@(\w+)/);
+    const name = roleMatch ? `@${roleMatch[1]}` : f.title;
+
+    const filePath = path.join(projectRoot, f.path);
+    let modelTier = 'unknown';
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf-8').substring(0, 500);
+      if (/脑|brain|高算力/.test(content)) modelTier = 'brain';
+      else if (/手|hand|coder|实现/.test(content)) modelTier = 'hand';
+      else if (/测试|test|验收/.test(content)) modelTier = 'test';
+    }
+
+    return {
+      name,
+      file: f.path,
+      responsibility: f.summary ? f.summary.summary : '',
+      modelTier,
+      tasks: f.summary ? (f.summary.related || []) : [],
+    };
+  });
+
+  return { roles };
+}
+
+// ---- Brief Generator ----
+function generateBrief(files, maxLength) {
+  const limit = maxLength || 200;
+  const recentSummaries = files
+    .filter(f => f.summary && f.summary.summary)
+    .sort((a, b) => new Date(b.modified) - new Date(a.modified))
+    .slice(0, 10);
+
+  const brief = recentSummaries.length > 0
+    ? recentSummaries.map(f => f.summary.summary).join('；')
+    : '项目初始化中，尚未有摘要块数据。运行 `node src/cli/sandtable.js build` 来更新。';
+
+  return brief.substring(0, limit);
+}
+
+// ---- Event Stream Builder (§11 7 大事件类 + 8 字段 schema + 3 级优先级) ----
+
+// Priority constants
+var PRIORITY_MUST = '必记';
+var PRIORITY_SHOULD = '应记';
+var PRIORITY_CAN = '可记';
+
+var EVENT_TYPES = {
+  '1': '对齐与拍板',
+  '2': '规格演进',
+  '3': '代码变更',
+  '4': '测试与质量',
+  '5': '审批与交接',
+  '6': '运维与基建',
+  '7': '教训沉淀',
+};
+
+function classifyEventPriority(event) {
+  // 必记: user decisions, irreversible operations, anti-patterns, PR merge, 5-level alignment
+  if (event.type === '对齐与拍板') return PRIORITY_MUST;
+  if (event.type === '教训沉淀' && event.subtype === 'anti_pattern') return PRIORITY_MUST;
+  if (event.tags && (event.tags.indexOf('不可逆') !== -1 || event.tags.indexOf('红线') !== -1)) return PRIORITY_MUST;
+  if (event.impact === 'high') return PRIORITY_MUST;
+
+  // 应记: spec落盘/修订, milestone完成, 脑审批, 部署, 决策落盘
+  if (event.type === '规格演进') return PRIORITY_SHOULD;
+  if (event.type === '审批与交接') return PRIORITY_SHOULD;
+  if (event.type === '运维与基建') return PRIORITY_SHOULD;
+  if (event.impact === 'medium') return PRIORITY_SHOULD;
+
+  // 可记: role切换, branch切换, normal commit, fixture微调
+  return PRIORITY_CAN;
+}
+
+function buildEvents(files, projectRoot, config) {
+  var events = [];
+  var eventsCfg = (config && config.events) ? config.events : { gitLog: true, maxGitLogEntries: 100 };
+
+  // ---- Dual-track: load JSONL events (Track 1: AI manually recorded, higher quality) ----
+  var jsonlEvents = [];
+  var jsonlIds = {};
+  var jsonlDocKeys = {};
+  var sandtableDir = path.join(projectRoot, '.sandtable');
+  var eventLogPath = path.join(sandtableDir, 'event-log.jsonl');
+  var errorLogPath = path.join(sandtableDir, 'event-log.errors.jsonl');
+
+  if (fs.existsSync(eventLogPath)) {
+    try {
+      var jlContent = fs.readFileSync(eventLogPath, 'utf-8').trim();
+      if (jlContent) {
+        var jlLines = jlContent.split('\n');
+        for (var jli = 0; jli < jlLines.length; jli++) {
+          var jlLine = jlLines[jli].trim();
+          if (!jlLine) continue;
+          try {
+            var jevt = JSON.parse(jlLine);
+            if (jevt.id) {
+              jsonlIds[jevt.id] = true;
+              // Also track doc refs for dedup
+              if (jevt.ref && jevt.ref.doc) {
+                var docKey = jevt.typeId + '|' + jevt.ref.doc + '|' + (jevt.subtype || '');
+                jsonlDocKeys[docKey] = true;
+              }
+            }
+            // Auto-extract version from title (e.g. "v0.3") and append to tags
+            if (jevt.title && jevt.tags) {
+              var verMatch = jevt.title.match(/v\d+\.\d+/g);
+              if (verMatch) {
+                for (var vm = 0; vm < verMatch.length; vm++) {
+                  if (jevt.tags.indexOf(verMatch[vm]) === -1) {
+                    jevt.tags.push(verMatch[vm]);
+                  }
+                }
+              }
+            }
+            jsonlEvents.push(jevt);
+          } catch (parseErr) {
+            // Never silent — log parse failures
+            var errEntry = JSON.stringify({
+              timestamp: new Date().toISOString(),
+              line: jlLine.substring(0, 200),
+              error: parseErr.message,
+            });
+            try {
+              if (!fs.existsSync(sandtableDir)) fs.mkdirSync(sandtableDir, { recursive: true });
+              fs.appendFileSync(errorLogPath, errEntry + '\n');
+            } catch (_) {}
+            console.warn('event-log: JSONL parse error — see .sandtable/event-log.errors.jsonl');
+          }
+        }
+      }
+    } catch (readErr) {
+      // event-log.jsonl missing or unreadable — continue with auto events only
+    }
+  }
+
+  // Helper: check if an auto-generated event is a duplicate of a JSONL event
+  function isJsonlDuplicate(autoEvent) {
+    if (autoEvent.id && jsonlIds[autoEvent.id]) return true;
+    if (autoEvent.ref && autoEvent.ref.doc) {
+      var key = autoEvent.typeId + '|' + autoEvent.ref.doc + '|' + (autoEvent.subtype || '');
+      if (jsonlDocKeys[key]) return true;
+    }
+    return false;
+  }
+
+  // ---- Source 1: Git log → 代码变更事件 + 测试事件 ----
+  if (eventsCfg.gitLog !== false && fs.existsSync(path.join(projectRoot, '.git'))) {
+    try {
+      var maxEntries = eventsCfg.maxGitLogEntries || 100;
+      var _require = require('child_process');
+      var execSync = _require.execSync;
+      var gitLog = execSync(
+        'git log --pretty=format:"%H|%ad|%s|%an" --date=iso-strict --max-count=' + maxEntries,
+        { cwd: projectRoot, encoding: 'utf-8', timeout: 10000 }
+      ).trim();
+
+      if (gitLog) {
+        var lines = gitLog.split('\n');
+        for (var li = 0; li < lines.length; li++) {
+          var line = lines[li];
+          var parts = line.split('|');
+          if (parts.length < 3) continue;
+          var hash = parts[0].substring(0, 8);
+          var timestamp = parts[1]; // ISO 8601 with timezone, already hour-precision
+          var subject = parts.slice(2, -1).join('|');
+          var author = parts[parts.length - 1];
+
+          // Classify into §11 7 event categories
+          var eventType = '3'; // default: 代码变更
+          var subtype = 'commit';
+          var impact = 'low';
+          var msg = subject.toLowerCase();
+
+          if (/merge|pr\s*#|pull request/i.test(msg)) {
+            eventType = '3'; subtype = 'pr_merge'; impact = 'medium';
+          } else if (/security|vuln|漏洞/i.test(msg)) {
+            eventType = '3'; subtype = 'security_fix'; impact = 'high';
+          } else if (/revert|回滚|rollback/i.test(msg)) {
+            eventType = '3'; subtype = 'revert'; impact = 'medium';
+          } else if (/refactor|重构|拆分|extract/i.test(msg)) {
+            eventType = '2'; subtype = 'refactor'; impact = 'medium';
+          } else if (/feat|feature|新增|add\b/i.test(msg)) {
+            eventType = '2'; subtype = 'feature'; impact = 'medium';
+          } else if (/fix|bug|修复|hotfix/i.test(msg)) {
+            eventType = '3'; subtype = 'fix'; impact = 'low';
+          } else if (/doc|docs|文档|readme/i.test(msg)) {
+            eventType = '7'; subtype = 'doc'; impact = 'low';
+          } else if (/test|测试|fixture|spec/i.test(msg)) {
+            eventType = '4'; subtype = 'test'; impact = 'low';
+          } else if (/chore|ci|build|deploy|部署|上线/i.test(msg)) {
+            eventType = '6'; subtype = 'ops'; impact = 'medium';
+          }
+
+          // Extract tags
+          var tags = [];
+          var rMatch = subject.match(/\bR\d+\b/g);
+          if (rMatch) tags.push.apply(tags, rMatch);
+          var opMatch = subject.match(/\bOP-\d+\b/g);
+          if (opMatch) tags.push.apply(tags, opMatch);
+          if (/不可逆|irreversible/i.test(subject)) tags.push('不可逆');
+          if (/红线|red.?line/i.test(subject)) tags.push('红线');
+
+          var event = {
+            id: 'git-' + hash,
+            timestamp: timestamp,
+            type: EVENT_TYPES[eventType] || '代码变更',
+            typeId: eventType,
+            subtype: subtype,
+            title: subject,
+            ref: { commit: hash },
+            impact: impact,
+            actor: author,
+            tags: tags,
+          };
+          event.priority = classifyEventPriority(event);
+          if (!isJsonlDuplicate(event)) events.push(event);
+        }
+      }
+    } catch (e) {
+      // Git not available — skip
+    }
+  }
+
+  // Helper: normalize date to ISO 8601 hour-precision timestamp
+  function normalizeTimestamp(dateStr) {
+    if (!dateStr) return new Date().toISOString();
+    // If already has time component, use as-is
+    if (dateStr.indexOf('T') !== -1) return dateStr;
+    // Date-only string → set to noon local
+    return dateStr + 'T12:00:00+08:00';
+  }
+
+  // ---- Source 2: decisions/ files → 对齐与拍板 (type 1) ----
+  var decisionFiles = files.filter(function(f) { return f.elementType === 'decision' || (f.category === 'decision' && f.kind === 'primary'); });
+  for (var di = 0; di < decisionFiles.length; di++) {
+    var df = decisionFiles[di];
+    var dt = df.date || df.modified;
+    var event = {
+      id: 'dec-' + df.path.replace(/[/.]/g, '-'),
+      timestamp: normalizeTimestamp(dt),
+      type: EVENT_TYPES['1'],
+      typeId: '1',
+      subtype: 'decision_record',
+      title: df.title,
+      ref: { doc: df.path },
+      impact: 'high',
+      actor: '脑会话 (Opus)',
+      tags: (df.summary && df.summary.tags) ? df.summary.tags : [],
+    };
+    event.priority = classifyEventPriority(event);
+    if (!isJsonlDuplicate(event)) events.push(event);
+  }
+
+  // ---- Source 3: spec/refactor → 规格演进 (type 2) ----
+  var specFiles = files.filter(function(f) {
+    return f.elementType === 'spec' || f.elementType === 'refactor' ||
+           (f.category === 'spec' && f.kind === 'primary');
+  });
+  for (var si = 0; si < specFiles.length; si++) {
+    var sf = specFiles[si];
+    var sdt = sf.date || sf.modified;
+    var sTags = [];
+    var rM = (sf.path + ' ' + sf.title).match(/\bR\d+\b/g);
+    if (rM) sTags.push.apply(sTags, rM);
+    var oM = (sf.path + ' ' + sf.title).match(/\bOP-\d+\b/g);
+    if (oM) sTags.push.apply(sTags, oM);
+
+    var sEvent = {
+      id: 'spec-' + sf.path.replace(/[/.]/g, '-'),
+      timestamp: normalizeTimestamp(sdt),
+      type: EVENT_TYPES['2'],
+      typeId: '2',
+      subtype: 'spec_v1_release',
+      title: sf.title,
+      ref: { doc: sf.path },
+      impact: 'high',
+      actor: '脑会话 (Opus)',
+      tags: sTags,
+    };
+    sEvent.priority = classifyEventPriority(sEvent);
+    if (!isJsonlDuplicate(sEvent)) events.push(sEvent);
+  }
+
+  // ---- Source 4: convention/skills → 运维与基建 (type 6, skill_added) or 教训沉淀 (type 7, anti_pattern) ----
+  var skillFiles = files.filter(function(f) {
+    return f.category === 'convention' && (f.path.indexOf('skills/') !== -1 || f.path.indexOf('skill') !== -1);
+  });
+  for (var ki = 0; ki < skillFiles.length; ki++) {
+    var kf = skillFiles[ki];
+    var kdt = kf.date || kf.modified;
+    var apCount = 0;
+    try {
+      var skillPath = path.join(projectRoot, kf.path);
+      if (fs.existsSync(skillPath)) {
+        var content = fs.readFileSync(skillPath, 'utf-8');
+        var apM = content.match(/§7\.\d+/g);
+        if (apM) apCount = new Set(apM).size;
+      }
+    } catch (_) {}
+
+    var isAnti = apCount > 0;
+    var kEvent = {
+      id: 'skl-' + kf.path.replace(/[/.]/g, '-'),
+      timestamp: normalizeTimestamp(kdt),
+      type: EVENT_TYPES[isAnti ? '7' : '6'],
+      typeId: isAnti ? '7' : '6',
+      subtype: isAnti ? 'anti_pattern' : 'skill_added',
+      title: kf.title + (isAnti ? ' — ' + apCount + ' 个反模式' : ''),
+      ref: { doc: kf.path },
+      impact: apCount > 3 ? 'high' : 'medium',
+      actor: '次脑',
+      tags: isAnti ? ['反模式', '§7.X'] : [],
+    };
+    kEvent.priority = classifyEventPriority(kEvent);
+    if (!isJsonlDuplicate(kEvent)) events.push(kEvent);
+  }
+
+  // ---- Source 5: ops/runbook → 运维与基建 (type 6) ----
+  var opsFiles = files.filter(function(f) {
+    return f.category === 'ops' && (f.elementType === 'runbook' || f.elementType === 'agent');
+  });
+  for (var oi = 0; oi < opsFiles.length; oi++) {
+    var of = opsFiles[oi];
+    var odt = of.date || of.modified;
+    var oEvent = {
+      id: 'ops-' + of.path.replace(/[/.]/g, '-'),
+      timestamp: normalizeTimestamp(odt),
+      type: EVENT_TYPES['6'],
+      typeId: '6',
+      subtype: of.elementType === 'agent' ? 'agent_definition' : 'runbook_update',
+      title: of.title,
+      ref: { doc: of.path },
+      impact: 'medium',
+      actor: 'hand-agent',
+      tags: [],
+    };
+    oEvent.priority = classifyEventPriority(oEvent);
+    if (!isJsonlDuplicate(oEvent)) events.push(oEvent);
+  }
+
+  // ---- Source 6: archive/journal → 审批与交接 (type 5) ----
+  var journalFiles = files.filter(function(f) {
+    return f.category === 'archive' && f.kind === 'primary';
+  });
+  for (var ji = 0; ji < journalFiles.length; ji++) {
+    var jf = journalFiles[ji];
+    var jdt = jf.date || jf.modified;
+    var jEvent = {
+      id: 'hdl-' + jf.path.replace(/[/.]/g, '-'),
+      timestamp: normalizeTimestamp(jdt),
+      type: EVENT_TYPES['5'],
+      typeId: '5',
+      subtype: 'handover',
+      title: jf.title,
+      ref: { doc: jf.path },
+      impact: 'medium',
+      actor: 'PM',
+      tags: (jf.summary && jf.summary.tags) ? jf.summary.tags : [],
+    };
+    jEvent.priority = classifyEventPriority(jEvent);
+    if (!isJsonlDuplicate(jEvent)) events.push(jEvent);
+  }
+
+  // ---- Prepend JSONL events (Track 1 takes priority, appears first) ----
+  for (var ji = jsonlEvents.length - 1; ji >= 0; ji--) {
+    events.unshift(jsonlEvents[ji]);
+  }
+
+  // Sort by timestamp descending
+  events.sort(function(a, b) { return b.timestamp.localeCompare(a.timestamp); });
+
+  return events;
+}
+
+// ---- Main Timeline Builder ----
+function buildTimeline(files, projectRoot, config) {
+  const today = new Date().toISOString().substring(0, 10);
+  const timeRules = config ? config.timeRules : null;
+  const displayCfg = (config && config.display) ? config.display : {};
+  const maxBriefLength = displayCfg.maxBriefLength || 200;
+
+  // Step 1: Build primary tree from roadmap-category files
+  const planFiles = files.filter(f =>
+    f.kind === 'primary' && (f.category === 'roadmap' || f.elementType === 'phase' ||
+      f.elementType === 'milestone' || f.elementType === 'roadmap' || f.elementType === 'task' || f.elementType === 'subtask')
+  );
+
+  // Also include decision/refactor/conclusion type primary files
+  const otherPrimary = files.filter(f =>
+    f.kind === 'primary' && !planFiles.includes(f) &&
+    (f.elementType === 'decision' || f.elementType === 'conclusion' ||
+     f.elementType === 'refactor' || f.category === 'decision')
+  );
+
+  const primaryTree = buildPrimaryTree(planFiles, files, projectRoot);
+
+  // Build primary flat list for non-plan primary files
+  const primaryFlat = otherPrimary
+    .filter(f => f.hasSummary || f.elementType !== 'unknown')
+    .map((f, i) => ({
+      id: 'primary-' + f.path.replace(/[/.]/g, '-'),
+      kind: 'primary',
+      elementType: f.elementType,
+      category: f.category,
+      name: f.title,
+      status: f.summary ? (f.summary.status || 'completed') : 'completed',
+      timeGroup: 'past',
+      timeLabel: (f.date || f.modified).substring(0, 10),
+      date: f.date || f.modified,
+      source: { file: f.path, title: f.title },
+      summary: f.summary ? (f.summary.summary || '') : '',
+      tags: f.summary ? (f.summary.tags || []) : [],
+      related: f.summary ? (f.summary.related || []) : [],
+      children: [],
+      order: i,
+    }));
+
+  // Step 2: Build secondary flat list
+  const secondaryFiles = files.filter(f => f.kind === 'secondary');
+  const secondaryList = buildSecondaryList(secondaryFiles);
+
+  // Step 3: Merge all elements
+  const allElements = [...primaryTree, ...primaryFlat, ...secondaryList];
+
+  // Step 4: Classify every element into timeGroup
+  for (const el of allElements) {
+    el.timeGroup = classifyTimeGroup(el, timeRules, today);
+
+    // Also classify children
+    if (el.children) {
+      for (const child of el.children) {
+        child.timeGroup = classifyTimeGroup(child, timeRules, today);
+        if (child.children) {
+          for (const sub of child.children) {
+            sub.timeGroup = classifyTimeGroup(sub, timeRules, today);
+          }
+        }
+      }
+    }
+  }
+
+  // Step 5: Build filter type manifest
+  const filterTypes = buildFilterTypes(files, displayCfg.secondaryTypesDefaultOff !== false);
+
+  // Step 6: Build event stream
+  const events = buildEvents(files, projectRoot, config);
+
+  // Step 7: Generate brief
+  const brief = generateBrief(files, maxBriefLength);
+
+  return {
+    project: path.basename(projectRoot),
+    updated: new Date().toISOString(),
+    brief,
+    elements: allElements,
+    events,
+    filterTypes,
+    display: {
+      secondaryTypesDefaultOff: displayCfg.secondaryTypesDefaultOff !== false,
+      conventionsManualOnly: displayCfg.conventionsManualOnly !== false,
+      maxBriefLength,
+    },
+  };
+}
+
+// ---- Backward Compatibility: timeline → roadmap.json ----
+function timelineToRoadmapCompat(timeline) {
+  const phases = [];
+  for (const el of timeline.elements) {
+    if (el.kind === 'primary' && el.elementType === 'phase') {
+      phases.push({
+        id: el.id,
+        name: el.name,
+        status: el.status,
+        order: el.order || phases.length + 1,
+        milestones: (el.children || []).map(ch => ({
+          id: ch.id,
+          name: ch.name,
+          status: ch.status,
+          owner: ch.source ? ch.source.file : '',
+          subtasks: (ch.children || []).map(st => ({
+            id: st.id,
+            name: st.name,
+            status: st.status,
+            type: st.elementType || 'hand',
+          })),
+        })),
+      });
+    }
+  }
+  return {
+    project: timeline.project,
+    updated: timeline.updated,
+    brief: timeline.brief,
+    phases,
+  };
+}
+
+// ---- Backward Compatibility: timeline → journal-index.json ----
+function timelineToJournalCompat(timeline) {
+  const events = timeline.elements
+    .filter(e => e.kind === 'secondary')
+    .map(e => ({
+      date: e.date || '',
+      type: e.elementType,
+      title: e.name,
+      source: e.source ? e.source.file : '',
+      tags: e.tags || [],
+      summary: e.summary || '',
+      status: e.status || 'unknown',
+      related: e.related || [],
+    }));
+  return { events };
+}
+
+// ---- Token Summary ----
+function buildTokenSummary(projectRoot, config) {
+  var summary = { totalTokens: 0, totalCalls: 0, totalCost: 0, bySkill: {}, byDate: {} };
+  var tokenLogPath = path.join(projectRoot, '.sandtable', 'token-log.jsonl');
+
+  if (!fs.existsSync(tokenLogPath)) return summary;
+
+  try {
+    var lines = fs.readFileSync(tokenLogPath, 'utf-8').trim().split('\n');
+    for (var i = 0; i < lines.length; i++) {
+      if (!lines[i].trim()) continue;
+      try {
+        var entry = JSON.parse(lines[i]);
+        var tokens = (entry.tokensIn || 0) + (entry.tokensOut || 0);
+        var skill = entry.skill || 'unknown';
+        var date = (entry.timestamp || '').substring(0, 10);
+
+        summary.totalTokens += tokens;
+        summary.totalCalls += 1;
+        if (entry.cost) summary.totalCost += entry.cost;
+
+        if (!summary.bySkill[skill]) summary.bySkill[skill] = { tokens: 0, calls: 0 };
+        summary.bySkill[skill].tokens += tokens;
+        summary.bySkill[skill].calls += 1;
+
+        if (date) {
+          if (!summary.byDate[date]) summary.byDate[date] = { tokens: 0, calls: 0 };
+          summary.byDate[date].tokens += tokens;
+          summary.byDate[date].calls += 1;
+        }
+      } catch (e) {
+        // Skip malformed JSONL lines
+      }
+    }
+    summary.totalCost = Math.round(summary.totalCost * 10000) / 10000;
+  } catch (e) {
+    // File read error — return empty summary
+  }
+  return summary;
+}
+
+// ---- Main Build ----
+function build(projectRoot) {
+  const scanResult = scan(projectRoot);
+  const { files } = scanResult;
+  const config = loadConfig(projectRoot);
+
+  const timeline = buildTimeline(files, projectRoot, config);
+  const conventions = buildConventions(files, projectRoot);
+  const agents = buildAgents(files, projectRoot);
+  const brief = {
+    updated: new Date().toISOString(),
+    text: timeline.brief,
+  };
+
+  // Backward compat
+  const roadmap = timelineToRoadmapCompat(timeline);
+  const journalIndex = timelineToJournalCompat(timeline);
+
+  const dataDir = path.join(projectRoot, 'data');
+  if (!fs.existsSync(dataDir)) {
+    fs.mkdirSync(dataDir, { recursive: true });
+  }
+
+  // v2 outputs
+  fs.writeFileSync(path.join(dataDir, 'timeline.json'), JSON.stringify(timeline, null, 2));
+  fs.writeFileSync(path.join(dataDir, 'conventions.json'), JSON.stringify(conventions, null, 2));
+  fs.writeFileSync(path.join(dataDir, 'agents.json'), JSON.stringify(agents, null, 2));
+  fs.writeFileSync(path.join(dataDir, 'brief.json'), JSON.stringify(brief, null, 2));
+
+  // v1 backward compat outputs
+  fs.writeFileSync(path.join(dataDir, 'roadmap.json'), JSON.stringify(roadmap, null, 2));
+  fs.writeFileSync(path.join(dataDir, 'journal-index.json'), JSON.stringify(journalIndex, null, 2));
+
+  // Token summary from .sandtable/token-log.jsonl + transcript scanning
+  var tokenSummary = buildTokenSummary(projectRoot, config);
+  fs.writeFileSync(path.join(dataDir, 'token-summary.json'), JSON.stringify(tokenSummary, null, 2));
+
+  const primaryElements = timeline.elements.filter(e => e.kind === 'primary').length;
+  const secondaryElements = timeline.elements.filter(e => e.kind === 'secondary').length;
+
+  return {
+    builtAt: new Date().toISOString(),
+    outputs: [
+      'data/timeline.json',
+      'data/conventions.json',
+      'data/agents.json',
+      'data/brief.json',
+      'data/roadmap.json',
+      'data/journal-index.json',
+      'data/token-summary.json',
+    ],
+    stats: {
+      totalFiles: files.length,
+      filesWithSummary: files.filter(f => f.hasSummary).length,
+      primaryElements,
+      secondaryElements,
+      filterTypes: timeline.filterTypes.length,
+      agents: agents.roles.length,
+    },
+  };
+}
+
+module.exports = {
+  build, buildTimeline, buildPrimaryTree, buildSecondaryList,
+  classifyTimeGroup, buildFilterTypes, buildConventions,
+  buildAgents, timelineToRoadmapCompat, timelineToJournalCompat,
+  EVENT_TYPES, classifyEventPriority, buildTokenSummary,
+};
+
+if (require.main === module) {
+  const root = process.argv[2] || process.cwd();
+  const result = build(root);
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+}