dave-code 1.1.0 → 1.2.0

package/bin/markdownRenderer.js

@@ -0,0 +1,264 @@
+const ANSI_RE = /\x1b\[[0-9;?]*[a-zA-Z]/g;
+const CONTROL_RE = /\x1b(?:\][\s\S]*?(?:\x07|\x1b\\)|[PX^_][\s\S]*?\x1b\\|(?:\[[0-?]*[ -/]*[@-~])|.)/g;
+
+const STYLE = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+  strike: '\x1b[9m',
+  brand: '\x1b[1;38;2;250;100;30m',
+  cyan: '\x1b[36m',
+  muted: '\x1b[90m',
+  code: '\x1b[38;5;223m',
+  codeBackground: '\x1b[48;5;236m'
+};
+
+function clean(text) {
+  return String(text ?? '')
+    .replace(CONTROL_RE, '')
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, '');
+}
+
+function width(text) {
+  let result = 0;
+  for (const char of String(text).replace(ANSI_RE, '')) {
+    const code = char.codePointAt(0);
+    result += (
+      (code >= 0x1100 && code <= 0x115f) ||
+      (code >= 0x2e80 && code <= 0xa4cf) ||
+      (code >= 0xac00 && code <= 0xd7a3) ||
+      (code >= 0xf900 && code <= 0xfaff) ||
+      (code >= 0xfe10 && code <= 0xfe6f) ||
+      (code >= 0xff00 && code <= 0xff60) ||
+      (code >= 0x1f300 && code <= 0x1faff)
+    ) ? 2 : 1;
+  }
+  return result;
+}
+
+function takeWidth(text, maxWidth) {
+  let value = '';
+  for (const char of text) {
+    if (width(value + char) > maxWidth) break;
+    value += char;
+  }
+  return value;
+}
+
+function wrapPlain(text, maxWidth) {
+  if (!text) return [''];
+  const lines = [];
+  let remaining = text;
+  while (width(remaining) > maxWidth) {
+    let part = takeWidth(remaining, maxWidth);
+    const lastSpace = Math.max(part.lastIndexOf(' '), part.lastIndexOf('\t'));
+    if (lastSpace > Math.floor(part.length * 0.45)) part = part.slice(0, lastSpace);
+    if (!part) part = [...remaining][0];
+    lines.push(part.trimEnd());
+    remaining = remaining.slice(part.length).trimStart();
+  }
+  lines.push(remaining);
+  return lines;
+}
+
+const SUPERSCRIPT = { '0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴', '5': '⁵', '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹', '+': '⁺', '-': '⁻', '=': '⁼', '(': '⁽', ')': '⁾', n: 'ⁿ', i: 'ⁱ' };
+const SUBSCRIPT = { '0': '₀', '1': '₁', '2': '₂', '3': '₃', '4': '₄', '5': '₅', '6': '₆', '7': '₇', '8': '₈', '9': '₉', '+': '₊', '-': '₋', '=': '₌', '(': '₍', ')': '₎', a: 'ₐ', e: 'ₑ', h: 'ₕ', i: 'ᵢ', j: 'ⱼ', k: 'ₖ', l: 'ₗ', m: 'ₘ', n: 'ₙ', o: 'ₒ', p: 'ₚ', r: 'ᵣ', s: 'ₛ', t: 'ₜ', u: 'ᵤ', v: 'ᵥ', x: 'ₓ' };
+
+function script(value, map, fallbackPrefix) {
+  const converted = [...value].map(char => map[char] || '').join('');
+  return converted.length === [...value].length ? converted : `${fallbackPrefix}(${value})`;
+}
+
+export function latexToUnicode(source) {
+  let value = clean(source).trim();
+  for (let pass = 0; pass < 4; pass++) {
+    value = value.replace(/\\frac\s*\{([^{}]+)\}\s*\{([^{}]+)\}/g, '($1)⁄($2)');
+    value = value.replace(/\\sqrt\s*\{([^{}]+)\}/g, '√($1)');
+  }
+  const replacements = {
+    '\\alpha': 'α', '\\beta': 'β', '\\gamma': 'γ', '\\delta': 'δ', '\\epsilon': 'ε', '\\theta': 'θ', '\\lambda': 'λ', '\\mu': 'μ', '\\pi': 'π', '\\rho': 'ρ', '\\sigma': 'σ', '\\phi': 'φ', '\\omega': 'ω',
+    '\\Delta': 'Δ', '\\Theta': 'Θ', '\\Lambda': 'Λ', '\\Pi': 'Π', '\\Sigma': 'Σ', '\\Phi': 'Φ', '\\Omega': 'Ω',
+    '\\times': '×', '\\cdot': '·', '\\div': '÷', '\\pm': '±', '\\leq': '≤', '\\le': '≤', '\\geq': '≥', '\\ge': '≥', '\\neq': '≠', '\\ne': '≠', '\\approx': '≈', '\\infty': '∞', '\\sum': '∑', '\\prod': '∏', '\\int': '∫', '\\partial': '∂', '\\nabla': '∇', '\\rightarrow': '→', '\\leftarrow': '←', '\\Rightarrow': '⇒', '\\in': '∈', '\\notin': '∉', '\\cup': '∪', '\\cap': '∩', '\\quad': '  ', '\\qquad': '    ', '\\;': ' ', '\\!': ''
+  };
+  for (const [from, to] of Object.entries(replacements).sort((a, b) => b[0].length - a[0].length)) {
+    value = value.split(from).join(to);
+  }
+  value = value
+    .replace(/\^\{([^{}]+)\}/g, (_, item) => script(item, SUPERSCRIPT, '^'))
+    .replace(/_\{([^{}]+)\}/g, (_, item) => script(item, SUBSCRIPT, '_'))
+    .replace(/\^([0-9n i+\-=])/g, (_, item) => script(item, SUPERSCRIPT, '^'))
+    .replace(/_([0-9aehijklmnoprstuvx+\-=])/g, (_, item) => script(item, SUBSCRIPT, '_'))
+    .replace(/\\(?:left|right|mathrm|mathbf|text)\b/g, '')
+    .replace(/[{}]/g, '')
+    .replace(/\\,/g, ' ')
+    .replace(/\\ /g, ' ');
+  return value;
+}
+
+function renderInline(source, useColor) {
+  const protectedValues = [];
+  const protect = value => {
+    const id = `\u0001${protectedValues.length}\u0002`;
+    protectedValues.push(value);
+    return id;
+  };
+  let value = source
+    .replace(/`([^`]+)`/g, (_, code) => protect(useColor ? `${STYLE.codeBackground}${STYLE.code} ${code} ${STYLE.reset}` : code))
+    .replace(/\\\(([^\n]+?)\\\)/g, (_, math) => protect(useColor ? `${STYLE.cyan}${latexToUnicode(math)}${STYLE.reset}` : latexToUnicode(math)))
+    .replace(/\$([^$\n]+)\$/g, (_, math) => protect(useColor ? `${STYLE.cyan}${latexToUnicode(math)}${STYLE.reset}` : latexToUnicode(math)));
+  value = value
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, url) => useColor ? `${STYLE.underline}${label}${STYLE.reset} ${STYLE.muted}(${url})${STYLE.reset}` : `${label} (${url})`)
+    .replace(/\*\*([^*]+)\*\*/g, (_, text) => useColor ? `${STYLE.bold}${text}${STYLE.reset}` : text)
+    .replace(/__([^_]+)__/g, (_, text) => useColor ? `${STYLE.bold}${text}${STYLE.reset}` : text)
+    .replace(/~~([^~]+)~~/g, (_, text) => useColor ? `${STYLE.strike}${text}${STYLE.reset}` : text)
+    .replace(/(?<!\*)\*([^*\n]+)\*(?!\*)/g, (_, text) => useColor ? `${STYLE.italic}${text}${STYLE.reset}` : text);
+  return value.replace(/\u0001(\d+)\u0002/g, (_, index) => protectedValues[Number(index)] || '');
+}
+
+function tableCells(line) {
+  return line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map(cell => cell.trim());
+}
+
+function isTableDivider(line) {
+  const cells = tableCells(line);
+  return cells.length > 0 && cells.every(cell => /^:?-{3,}:?$/.test(cell));
+}
+
+function renderTable(rows, maxWidth, useColor) {
+  const cells = rows.map(tableCells);
+  const columns = Math.max(...cells.map(row => row.length));
+  const rendered = cells.map(row => Array.from({ length: columns }, (_, index) => renderInline(row[index] || '', useColor)));
+  const widths = Array.from({ length: columns }, (_, column) => Math.max(1, ...rendered.map(row => width(row[column]))));
+  const totalWidth = widths.reduce((sum, item) => sum + item + 3, 1);
+  if (totalWidth > maxWidth) {
+    const output = [];
+    for (const row of rendered.slice(1)) {
+      row.forEach((value, index) => {
+        const heading = useColor ? `${STYLE.bold}${cells[0][index] || `Column ${index + 1}`}${STYLE.reset}` : (cells[0][index] || `Column ${index + 1}`);
+        output.push(`  ${heading}: ${value}`);
+      });
+      output.push('');
+    }
+    return output.slice(0, -1);
+  }
+  const border = (left, middle, right, fill = '─') => `${left}${widths.map(item => fill.repeat(item + 2)).join(middle)}${right}`;
+  const rowLine = (row, header = false) => `│${row.map((cell, index) => {
+    const padding = ' '.repeat(widths[index] - width(cell));
+    const value = header && useColor ? `${STYLE.bold}${cell}${STYLE.reset}` : cell;
+    return ` ${value}${padding} `;
+  }).join('│')}│`;
+  return [border('┌', '┬', '┐'), rowLine(rendered[0], true), border('├', '┼', '┤'), ...rendered.slice(1).map(row => rowLine(row)), border('└', '┴', '┘')];
+}
+
+export function renderTerminalMarkdown(markdown, { color = true, width: requestedWidth = 80 } = {}) {
+  const useColor = Boolean(color);
+  const maxWidth = Math.max(24, Math.min(Number(requestedWidth) || 80, 110));
+  const lines = clean(markdown).replace(/\r\n?/g, '\n').split('\n');
+  const output = [];
+  let inCode = false;
+  let codeLanguage = '';
+  let codeLines = [];
+  let inMath = false;
+  let mathLines = [];
+
+  const flushCode = () => {
+    const label = codeLanguage ? ` ${codeLanguage} ` : ' code ';
+    output.push(useColor ? `${STYLE.muted}┌─${label}${'─'.repeat(Math.max(0, maxWidth - width(label) - 2))}${STYLE.reset}` : `┌─${label}${'─'.repeat(Math.max(0, maxWidth - width(label) - 2))}`);
+    for (const codeLine of codeLines) {
+      const wrapped = wrapPlain(codeLine, maxWidth - 3);
+      for (const part of wrapped) {
+        const padding = ' '.repeat(Math.max(0, maxWidth - 2 - width(part)));
+        output.push(useColor ? `${STYLE.codeBackground}${STYLE.code}│ ${part}${padding}${STYLE.reset}` : `│ ${part}`);
+      }
+    }
+    output.push(useColor ? `${STYLE.muted}└${'─'.repeat(maxWidth - 1)}${STYLE.reset}` : `└${'─'.repeat(maxWidth - 1)}`);
+    codeLines = [];
+    codeLanguage = '';
+  };
+
+  const flushMath = () => {
+    const formula = latexToUnicode(mathLines.join(' '));
+    const left = Math.max(2, Math.floor((maxWidth - width(formula)) / 2));
+    output.push(`${' '.repeat(left)}${useColor ? `${STYLE.cyan}${STYLE.bold}${formula}${STYLE.reset}` : formula}`);
+    mathLines = [];
+  };
+
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    const fence = line.match(/^\s*```\s*([^`]*)$/);
+    if (fence) {
+      if (inCode) flushCode();
+      else codeLanguage = fence[1].trim();
+      inCode = !inCode;
+      continue;
+    }
+    if (inCode) {
+      codeLines.push(line);
+      continue;
+    }
+    const singleLineMath = line.match(/^\s*\$\$\s*(.+?)\s*\$\$\s*$/);
+    if (singleLineMath) {
+      mathLines = [singleLineMath[1]];
+      flushMath();
+      continue;
+    }
+    if (/^\s*(?:\$\$|\\\[|\\\])\s*$/.test(line)) {
+      if (inMath) flushMath();
+      inMath = !inMath;
+      continue;
+    }
+    if (inMath) {
+      mathLines.push(line);
+      continue;
+    }
+    if (line.includes('|') && index + 1 < lines.length && isTableDivider(lines[index + 1])) {
+      const table = [line];
+      index += 2;
+      while (index < lines.length && lines[index].includes('|') && lines[index].trim()) {
+        table.push(lines[index]);
+        index++;
+      }
+      index--;
+      output.push(...renderTable(table, maxWidth, useColor));
+      continue;
+    }
+    const heading = line.match(/^\s*(#{1,6})\s+(.+)$/);
+    if (heading) {
+      const text = renderInline(heading[2], useColor);
+      if (output.length && output.at(-1) !== '') output.push('');
+      output.push(useColor ? `${heading[1].length <= 2 ? STYLE.brand : STYLE.bold}${text}${STYLE.reset}` : text);
+      if (heading[1].length === 1) output.push(useColor ? `${STYLE.muted}${'─'.repeat(Math.min(width(heading[2]), maxWidth))}${STYLE.reset}` : '─'.repeat(Math.min(width(heading[2]), maxWidth)));
+      continue;
+    }
+    if (/^\s*(?:---+|___+|\*\*\*+)\s*$/.test(line)) {
+      output.push(useColor ? `${STYLE.muted}${'─'.repeat(maxWidth)}${STYLE.reset}` : '─'.repeat(maxWidth));
+      continue;
+    }
+    const quote = line.match(/^\s*>\s?(.*)$/);
+    if (quote) {
+      for (const part of wrapPlain(quote[1], maxWidth - 3)) output.push(`${useColor ? `${STYLE.muted}│${STYLE.reset}` : '│'} ${renderInline(part, useColor)}`);
+      continue;
+    }
+    const list = line.match(/^(\s*)([-+*]|\d+[.)])\s+(.+)$/);
+    if (list) {
+      const prefix = /^\d/.test(list[2]) ? `${list[2]} ` : '• ';
+      const indent = list[1].replace(/\t/g, '  ');
+      const available = Math.max(12, maxWidth - width(indent) - width(prefix));
+      wrapPlain(list[3], available).forEach((part, partIndex) => {
+        output.push(`${indent}${partIndex === 0 ? (useColor ? `${STYLE.brand}${prefix}${STYLE.reset}` : prefix) : ' '.repeat(width(prefix))}${renderInline(part, useColor)}`);
+      });
+      continue;
+    }
+    if (!line.trim()) {
+      if (output.at(-1) !== '') output.push('');
+      continue;
+    }
+    for (const part of wrapPlain(line, maxWidth)) output.push(renderInline(part, useColor));
+  }
+  if (inCode) flushCode();
+  if (inMath) flushMath();
+  while (output.at(-1) === '') output.pop();
+  return output.join('\n');
+}

package/bin/memoryManager.js

@@ -0,0 +1,182 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+const VERSION = 1;
+const CATEGORIES = new Set(['preference', 'convention', 'architecture', 'command', 'decision', 'debugging']);
+let memoryBaseDir = path.join(os.homedir(), '.dave-code-memory');
+
+export function setMemoryBaseDirForTesting(directory) {
+  memoryBaseDir = directory;
+}
+
+function canonicalRoot(workspaceRoot) {
+  const resolved = path.resolve(workspaceRoot || process.cwd());
+  try {
+    return fs.realpathSync.native(resolved).replace(/\\/g, '/').toLowerCase();
+  } catch {
+    return resolved.replace(/\\/g, '/').toLowerCase();
+  }
+}
+
+export function getMemoryFile(workspaceRoot) {
+  const hash = crypto.createHash('sha256').update(canonicalRoot(workspaceRoot)).digest('hex');
+  return path.join(memoryBaseDir, `${hash}.json`);
+}
+
+function atomicWrite(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+  const temp = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`);
+  fs.writeFileSync(temp, JSON.stringify(data, null, 2), { encoding: 'utf8', mode: 0o600 });
+  try { fs.chmodSync(temp, 0o600); } catch {}
+  try {
+    fs.renameSync(temp, filePath);
+  } catch (error) {
+    if (process.platform !== 'win32' || !fs.existsSync(filePath)) throw error;
+    fs.unlinkSync(filePath);
+    fs.renameSync(temp, filePath);
+  } finally {
+    if (fs.existsSync(temp)) fs.unlinkSync(temp);
+  }
+}
+
+function normalizeEntry(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const text = String(entry.text || '').trim().replace(/\s+/g, ' ');
+  if (!text || text.length > 600) return null;
+  return {
+    id: String(entry.id || crypto.randomUUID()),
+    category: CATEGORIES.has(entry.category) ? entry.category : 'decision',
+    text,
+    createdAt: Number(entry.createdAt) || Date.now(),
+    updatedAt: Number(entry.updatedAt) || Date.now(),
+    lastUsedAt: Number(entry.lastUsedAt) || 0,
+    sourceSessionId: String(entry.sourceSessionId || '')
+  };
+}
+
+export function loadMemoryStore(workspaceRoot) {
+  const filePath = getMemoryFile(workspaceRoot);
+  try {
+    if (!fs.existsSync(filePath)) return { version: VERSION, workspaceRoot: canonicalRoot(workspaceRoot), enabled: true, memories: [] };
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.memories)) throw new Error('Invalid memory schema.');
+    return {
+      version: VERSION,
+      workspaceRoot: canonicalRoot(workspaceRoot),
+      enabled: parsed.enabled !== false,
+      memories: parsed.memories.map(normalizeEntry).filter(Boolean).slice(-120)
+    };
+  } catch {
+    return { version: VERSION, workspaceRoot: canonicalRoot(workspaceRoot), enabled: true, memories: [] };
+  }
+}
+
+function saveMemoryStore(workspaceRoot, store) {
+  const normalized = {
+    version: VERSION,
+    workspaceRoot: canonicalRoot(workspaceRoot),
+    enabled: store.enabled !== false,
+    memories: (store.memories || []).map(normalizeEntry).filter(Boolean).slice(-120)
+  };
+  atomicWrite(getMemoryFile(workspaceRoot), normalized);
+  return normalized;
+}
+
+function tokens(text) {
+  const value = String(text || '').toLowerCase();
+  const result = new Set(value.match(/[a-z0-9_./-]{2,}/g) || []);
+  const cjk = [...value].filter(char => /[\u3400-\u9fff]/.test(char));
+  for (let index = 0; index < cjk.length - 1; index++) result.add(cjk[index] + cjk[index + 1]);
+  return result;
+}
+
+function memoryScore(memory, queryTokens) {
+  const memoryTokens = tokens(memory.text);
+  let overlap = 0;
+  for (const token of queryTokens) if (memoryTokens.has(token)) overlap++;
+  const categoryBoost = ['preference', 'convention', 'architecture'].includes(memory.category) ? 0.8 : 0;
+  const recency = Math.max(memory.updatedAt, memory.lastUsedAt || 0) / 1e13;
+  return overlap * 4 + categoryBoost + recency;
+}
+
+export function retrieveMemories(workspaceRoot, query, limit = 8) {
+  const store = loadMemoryStore(workspaceRoot);
+  if (!store.enabled || store.memories.length === 0) return [];
+  const queryTokens = tokens(query);
+  const ranked = store.memories
+    .map(memory => ({ memory, score: memoryScore(memory, queryTokens) }))
+    .filter(item => item.score >= 0.8)
+    .sort((a, b) => b.score - a.score || b.memory.updatedAt - a.memory.updatedAt)
+    .slice(0, Math.max(1, limit));
+  if (ranked.length > 0) {
+    const used = new Set(ranked.map(item => item.memory.id));
+    const now = Date.now();
+    for (const memory of store.memories) if (used.has(memory.id)) memory.lastUsedAt = now;
+    saveMemoryStore(workspaceRoot, store);
+  }
+  return ranked.map(item => item.memory);
+}
+
+function isSensitiveMemory(text) {
+  return /(?:-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|password|passwd|secret)\s*[:=]\s*\S+|\bsk-[a-z0-9_-]{12,}|\.env\b.*=)/i.test(text);
+}
+
+export function mergeMemoryCandidates(workspaceRoot, candidates, sourceSessionId = '') {
+  const store = loadMemoryStore(workspaceRoot);
+  if (!store.enabled) return { added: 0, updated: 0, total: store.memories.length };
+  let added = 0;
+  let updated = 0;
+  for (const candidate of Array.isArray(candidates) ? candidates : []) {
+    const text = String(candidate?.text || '').trim().replace(/\s+/g, ' ');
+    if (text.length < 12 || text.length > 500 || isSensitiveMemory(text)) continue;
+    const category = CATEGORIES.has(candidate.category) ? candidate.category : 'decision';
+    const key = text.toLocaleLowerCase();
+    const existing = store.memories.find(memory => memory.text.toLocaleLowerCase() === key);
+    if (existing) {
+      existing.updatedAt = Date.now();
+      existing.category = category;
+      updated++;
+    } else {
+      store.memories.push(normalizeEntry({ text, category, sourceSessionId }));
+      added++;
+    }
+  }
+  store.memories = store.memories
+    .sort((a, b) => Math.max(a.updatedAt, a.lastUsedAt) - Math.max(b.updatedAt, b.lastUsedAt))
+    .slice(-120);
+  saveMemoryStore(workspaceRoot, store);
+  return { added, updated, total: store.memories.length };
+}
+
+export function deleteMemory(workspaceRoot, memoryId) {
+  const store = loadMemoryStore(workspaceRoot);
+  const next = store.memories.filter(memory => memory.id !== memoryId);
+  if (next.length === store.memories.length) return false;
+  store.memories = next;
+  saveMemoryStore(workspaceRoot, store);
+  return true;
+}
+
+export function clearMemories(workspaceRoot) {
+  const store = loadMemoryStore(workspaceRoot);
+  store.memories = [];
+  saveMemoryStore(workspaceRoot, store);
+}
+
+export function setMemoryEnabled(workspaceRoot, enabled) {
+  const store = loadMemoryStore(workspaceRoot);
+  store.enabled = Boolean(enabled);
+  return saveMemoryStore(workspaceRoot, store);
+}
+
+export function memorySummary(workspaceRoot) {
+  const store = loadMemoryStore(workspaceRoot);
+  return { enabled: store.enabled, total: store.memories.length, memories: [...store.memories].sort((a, b) => b.updatedAt - a.updatedAt) };
+}
+
+export function formatMemoriesForPrompt(memories) {
+  if (!memories?.length) return '';
+  return memories.map(memory => `- [${memory.category}] ${memory.text}`).join('\n');
+}

package/bin/planManager.js

@@ -3,7 +3,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 
-const STORE_VERSION = 1;
+const STORE_VERSION = 2;
 const VALID_STATUSES = new Set(['ready', 'running', 'completed', 'blocked']);
 let plansBaseDir = path.join(os.homedir(), '.dave-code-plans');
 
@@ -79,7 +79,13 @@ function validateStoredPlan(plan) {
       content: String(plan.content || ''),
       createdAt: Number(plan.createdAt) || Date.now(),
       updatedAt: Number(plan.updatedAt) || Date.now(),
-      lastRun: plan.lastRun && typeof plan.lastRun === 'object' ? plan.lastRun : null
+      lastRun: plan.lastRun && typeof plan.lastRun === 'object' ? plan.lastRun : null,
+      workflowMode: plan.workflowMode === 'thunder' ? 'thunder' : 'highway',
+      teamId: plan.teamId ? String(plan.teamId) : null,
+      resourceProposal: plan.resourceProposal && typeof plan.resourceProposal === 'object' ? plan.resourceProposal : null,
+      teamSnapshot: plan.teamSnapshot && typeof plan.teamSnapshot === 'object' ? plan.teamSnapshot : null,
+      taskGraph: Array.isArray(plan.taskGraph) ? plan.taskGraph : [],
+      decisions: Array.isArray(plan.decisions) ? plan.decisions.map(String) : []
     };
   } catch {
     return null;
@@ -98,7 +104,7 @@ export function loadPlanStore(workspaceRoot) {
   const filePath = getPlansFile(workspaceRoot);
   try {
     const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    if (!parsed || parsed.version !== STORE_VERSION || !Array.isArray(parsed.plans)) {
+    if (!parsed || ![1, STORE_VERSION].includes(parsed.version) || !Array.isArray(parsed.plans)) {
       return emptyStore(workspaceRoot);
     }
     return {
@@ -153,7 +159,7 @@ export function findPlan(workspaceRoot, name) {
   return listPlans(workspaceRoot).find(plan => normalizeName(plan.name) === key) || null;
 }
 
-export function upsertPlan(workspaceRoot, { name, request, content }, { replace = false } = {}) {
+export function upsertPlan(workspaceRoot, { name, request, content, workflowMode = 'highway', teamId = null, resourceProposal = null, teamSnapshot = null, taskGraph = [], decisions = [] }, { replace = false } = {}) {
   const validName = validatePlanName(name);
   const validContent = String(content || '').trim();
   const missingSections = validatePlanContent(validContent);
@@ -172,7 +178,13 @@ export function upsertPlan(workspaceRoot, { name, request, content }, { replace
         content: validContent,
         createdAt: now,
         updatedAt: now,
-        lastRun: null
+        lastRun: null,
+        workflowMode: workflowMode === 'thunder' ? 'thunder' : 'highway',
+        teamId,
+        resourceProposal,
+        teamSnapshot,
+        taskGraph,
+        decisions
       }
     : {
         ...store.plans[index],
@@ -181,7 +193,13 @@ export function upsertPlan(workspaceRoot, { name, request, content }, { replace
         request: String(request || '').trim(),
         content: validContent,
         updatedAt: now,
-        lastRun: null
+        lastRun: null,
+        workflowMode: workflowMode === 'thunder' ? 'thunder' : 'highway',
+        teamId,
+        resourceProposal,
+        teamSnapshot,
+        taskGraph,
+        decisions
       };
 
   if (index === -1) store.plans.push(next);
@@ -231,9 +249,43 @@ export function deletePlan(workspaceRoot, planId) {
 }
 
 export function planStatusLines(workspaceRoot, limit = 4) {
-  const plans = listPlans(workspaceRoot);
+  const panel = planStatusPanel(workspaceRoot, limit);
   const symbols = { ready: '○', running: '▶', completed: '✓', blocked: '!' };
-  const lines = plans.slice(0, limit).map(plan => `${symbols[plan.status] || '○'} ${plan.name}`);
-  if (plans.length > limit) lines.push(`+${plans.length - limit} more`);
+  const lines = panel.items.map(plan => `${symbols[plan.status] || '○'} ${plan.name}`);
+  if (panel.hidden > 0) lines.push(`+${panel.hidden} more`);
   return lines;
 }
+
+/**
+ * Select plans for the persistent header panel. When active and completed plans
+ * coexist, reserve one slot for the most recently completed plan so completed
+ * work never disappears behind a long ready queue.
+ */
+export function planStatusPanel(workspaceRoot, limit = 4) {
+  const plans = listPlans(workspaceRoot);
+  const safeLimit = Math.max(1, Math.floor(Number(limit) || 4));
+  const active = plans.filter(plan => plan.status !== 'completed');
+  const completed = plans
+    .filter(plan => plan.status === 'completed')
+    .sort((a, b) => b.updatedAt - a.updatedAt);
+
+  let items;
+  if (active.length > 0 && completed.length > 0 && safeLimit > 1) {
+    items = [...active.slice(0, safeLimit - 1), completed[0]];
+  } else {
+    items = (active.length > 0 ? active : completed).slice(0, safeLimit);
+  }
+
+  return {
+    items,
+    total: plans.length,
+    hidden: Math.max(0, plans.length - items.length),
+    counts: {
+      ready: plans.filter(plan => plan.status === 'ready').length,
+      running: plans.filter(plan => plan.status === 'running').length,
+      blocked: plans.filter(plan => plan.status === 'blocked').length,
+      completed: completed.length,
+      active: active.length
+    }
+  };
+}