mindforge-cc 1.0.5 → 2.0.0-alpha.4

package/bin/memory/knowledge-indexer.js

@@ -0,0 +1,172 @@
+/**
+ * MindForge v2 — Knowledge Indexer
+ * TF-IDF inspired relevance scoring for fast knowledge retrieval.
+ * Provides tag-based and text-based search across the knowledge graph.
+ *
+ * Design note: We use a simple in-memory index rebuilt on each query
+ * (not persisted) because the knowledge base stays small (< 10K entries
+ * for a typical project). Rebuild time < 50ms for 1K entries.
+ */
+'use strict';
+
+const Store = require('./knowledge-store');
+
+// ── Stopwords (excluded from TF-IDF scoring) ──────────────────────────────────
+const STOPWORDS = new Set([
+  'the', 'a', 'an', 'is', 'it', 'in', 'on', 'at', 'to', 'for', 'of', 'and',
+  'or', 'but', 'not', 'this', 'that', 'with', 'from', 'by', 'be', 'are',
+  'was', 'were', 'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would',
+  'could', 'should', 'may', 'might', 'can', 'use', 'using', 'used', 'when',
+  'where', 'which', 'what', 'how', 'why', 'who', 'all', 'any', 'some', 'we',
+  'our', 'they', 'their', 'we', 'you', 'your', 'my', 'its',
+]);
+
+// ── Tokenizer ─────────────────────────────────────────────────────────────────
+function tokenize(text) {
+  if (!text) return [];
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9\s_-]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 2 && !STOPWORDS.has(w));
+}
+
+// ── Build in-memory index ─────────────────────────────────────────────────────
+function buildIndex(entries) {
+  const index = new Map(); // token → [{ id, count }]
+  const docTokenCounts = new Map(); // id → token count
+
+  for (const entry of entries) {
+    if (entry.deprecated) continue;
+
+    const text   = `${entry.topic} ${entry.content} ${(entry.tags || []).join(' ')}`;
+    const tokens = tokenize(text);
+    const counts = {};
+
+    for (const tok of tokens) {
+      counts[tok] = (counts[tok] || 0) + 1;
+    }
+
+    docTokenCounts.set(entry.id, tokens.length);
+
+    for (const [tok, count] of Object.entries(counts)) {
+      if (!index.has(tok)) index.set(tok, []);
+      index.get(tok).push({ id: entry.id, count });
+    }
+  }
+
+  return { index, docTokenCounts, N: entries.length };
+}
+
+// ── TF-IDF scoring ────────────────────────────────────────────────────────────
+function tfidfScore(queryTokens, entryId, index, docTokenCounts, N) {
+  let score = 0;
+  const docLen = docTokenCounts.get(entryId) || 1;
+
+  for (const qTok of queryTokens) {
+    const postings = index.get(qTok) || [];
+    const df       = postings.length; // Document frequency
+    if (df === 0) continue;
+
+    const posting  = postings.find(p => p.id === entryId);
+    if (!posting) continue;
+
+    const tf  = posting.count / docLen;              // Term frequency (normalized)
+    const idf = Math.log((N + 1) / (df + 1)) + 1;   // Smoothed IDF
+    score += tf * idf;
+  }
+
+  return score;
+}
+
+// ── Main search function ──────────────────────────────────────────────────────
+/**
+ * Search knowledge base with TF-IDF scoring.
+ * @param {string} queryText - Natural language query
+ * @param {object} filters   - Optional filters { type, tags, minConfidence }
+ * @param {number} limit     - Max results to return
+ * @returns {object[]} Ranked results
+ */
+function search(queryText, filters = {}, limit = 10) {
+  const allEntries = Store.readAll(filters.includeGlobal);
+  const active     = allEntries.filter(e => !e.deprecated);
+
+  // Apply filters
+  let candidates = active;
+  if (filters.type)          candidates = candidates.filter(e => e.type === filters.type);
+  if (filters.minConfidence) candidates = candidates.filter(e => e.confidence >= filters.minConfidence);
+  if (filters.tags?.length) {
+    const filterTags = filters.tags.map(t => t.toLowerCase());
+    candidates = candidates.filter(e =>
+      (e.tags || []).some(t => filterTags.includes(t.toLowerCase()))
+    );
+  }
+
+  if (candidates.length === 0) return [];
+
+  const queryTokens = tokenize(queryText);
+  if (queryTokens.length === 0) {
+    // No meaningful query tokens — return by confidence
+    return candidates
+      .sort((a, b) => b.confidence - a.confidence)
+      .slice(0, limit);
+  }
+
+  const { index, docTokenCounts, N } = buildIndex(candidates);
+
+  // Score each candidate
+  const scored = candidates.map(entry => {
+    const textScore = tfidfScore(queryTokens, entry.id, index, docTokenCounts, N);
+    // Combine TF-IDF score with confidence, but only if there's a text match
+    const finalScore = textScore > 0
+      ? textScore * 0.7 + entry.confidence * 0.3
+      : 0;
+    return { entry, score: finalScore };
+  });
+
+  return scored
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map(s => s.entry);
+}
+
+/**
+ * Load session context: retrieve the most relevant memories for the current session.
+ * @param {object} context - { techStack, phase, topic, project }
+ * @returns {object} Categorized memories for session start display
+ */
+function loadSessionContext(context = {}) {
+  const { techStack = [], phase, topic = '', project } = context;
+
+  const allEntries = Store.readAll(true); // Include global knowledge
+  const active     = allEntries.filter(e => !e.deprecated && e.confidence >= 0.5);
+
+  // Build query from context
+  const queryText = [
+    topic,
+    ...(techStack || []),
+  ].join(' ');
+
+  const { index, docTokenCounts, N } = buildIndex(active);
+  const queryTokens = tokenize(queryText);
+
+  // Score all active entries
+  const scored = active.map(e => ({
+    entry: e,
+    score: queryTokens.length > 0
+      ? tfidfScore(queryTokens, e.id, index, docTokenCounts, N) * 0.6 + e.confidence * 0.4
+      : e.confidence,
+  })).sort((a, b) => b.score - a.score);
+
+  // Bucket by type, top N per bucket
+  const preferences  = scored.filter(s => s.entry.type === 'team_preference').slice(0, 5).map(s => s.entry);
+  const decisions    = scored.filter(s => s.entry.type === 'architectural_decision').slice(0, 8).map(s => s.entry);
+  const bugPatterns  = scored.filter(s => s.entry.type === 'bug_pattern').slice(0, 5).map(s => s.entry);
+  const codePatterns = scored.filter(s => s.entry.type === 'code_pattern').slice(0, 5).map(s => s.entry);
+  const domain       = scored.filter(s => s.entry.type === 'domain_knowledge').slice(0, 3).map(s => s.entry);
+
+  return { preferences, decisions, bugPatterns, codePatterns, domain };
+}
+
+module.exports = { search, loadSessionContext, buildIndex, tfidfScore, tokenize };

package/bin/memory/knowledge-store.js

@@ -0,0 +1,319 @@
+/**
+ * MindForge v2 — Knowledge Store
+ * Append-only JSONL knowledge base with CRUD-like operations.
+ *
+ * Philosophy:
+ * - NEVER delete entries — deprecate instead (audit trail)
+ * - NEVER update entries in-place — append new version, deprecate old
+ * - All writes are atomic (append to JSONL is atomic on POSIX)
+ * - Reads are always full scan + in-memory filter (files stay small)
+ */
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+const crypto = require('crypto');
+
+// ── Paths ─────────────────────────────────────────────────────────────────────
+let baseDir = process.cwd();
+let globalBaseDir = os.homedir();
+
+/**
+ * Configure the base directory for memory (useful for testing).
+ */
+function setBaseDir(dir) {
+  baseDir = dir;
+}
+
+/**
+ * Configure the global base directory (useful for testing).
+ */
+function setGlobalDir(dir) {
+  globalBaseDir = dir;
+}
+
+function getPaths() {
+  const memoryDir = path.join(baseDir, '.mindforge', 'memory');
+  const globalDir = path.join(globalBaseDir, '.mindforge');
+  return {
+    MEMORY_DIR:       memoryDir,
+    GLOBAL_DIR:       globalDir,
+    KB_PATH:          path.join(memoryDir, 'knowledge-base.jsonl'),
+    GLOBAL_KB_PATH:   path.join(globalDir, 'global-knowledge-base.jsonl'),
+    DECISION_PATH:    path.join(memoryDir, 'decision-library.jsonl'),
+    PATTERN_PATH:     path.join(memoryDir, 'pattern-library.jsonl'),
+    PREFERENCES_PATH: path.join(memoryDir, 'team-preferences.jsonl'),
+  };
+}
+
+/**
+ * Generates a UUID v4.
+ */
+function generateId() {
+  return crypto.randomUUID();
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function getFilePath(type) {
+  const paths = getPaths();
+  switch (type) {
+    case 'architectural_decision': return paths.DECISION_PATH;
+    case 'code_pattern':           return paths.PATTERN_PATH;
+    case 'team_preference':        return paths.PREFERENCES_PATH;
+    default:                       return paths.KB_PATH; // bug_pattern, domain_knowledge, all others
+  }
+}
+
+// ── Write operations ──────────────────────────────────────────────────────────
+
+/**
+ * Append a new knowledge entry.
+ * @param {object} entry - Entry data (without id, timestamp, times_referenced)
+ * @returns {string} The new entry's ID
+ */
+function add(entry) {
+  const paths = getPaths();
+  ensureDir(paths.MEMORY_DIR);
+
+  if (!entry.type)    throw new Error('Knowledge entry requires a "type" field');
+  if (!entry.topic)   throw new Error('Knowledge entry requires a "topic" field');
+  if (!entry.content) throw new Error('Knowledge entry requires a "content" field');
+
+  const id = entry.id || generateId();
+  const now = new Date().toISOString();
+
+  const full = {
+    id,
+    timestamp: now,
+    type:              entry.type,
+    topic:             entry.topic.slice(0, 80), // Enforce max topic length
+    content:           entry.content,
+    source:            entry.source || 'manual',
+    project:           entry.project || readProjectName(),
+    confidence:        Math.min(1.0, Math.max(0.0, entry.confidence ?? 0.7)),
+    tags:              Array.isArray(entry.tags) ? entry.tags : [],
+    linked_adrs:       Array.isArray(entry.linked_adrs) ? entry.linked_adrs : [],
+    times_referenced:  entry.times_referenced || 0,
+    last_referenced:   entry.last_referenced || null,
+    deprecated:        false,
+    deprecated_by:     null,
+    // Type-specific fields
+    ...(entry.decision     && { decision:     entry.decision }),
+    ...(entry.rationale    && { rationale:    entry.rationale }),
+    ...(entry.alternatives && { alternatives: entry.alternatives }),
+    ...(entry.adr_reference && { adr_reference: entry.adr_reference }),
+    ...(entry.pattern_type && { pattern_type: entry.pattern_type }),
+    ...(entry.language     && { language:     entry.language }),
+    ...(entry.example_good && { example_good: entry.example_good }),
+    ...(entry.example_bad  && { example_bad:  entry.example_bad }),
+    ...(entry.bug_category && { bug_category: entry.bug_category }),
+    ...(entry.root_cause   && { root_cause:   entry.root_cause }),
+    ...(entry.fix          && { fix:          entry.fix }),
+    ...(entry.preference   && { preference:   entry.preference }),
+    ...(entry.strength     && { strength:     entry.strength }),
+    ...(entry.domain       && { domain:       entry.domain }),
+    ...(entry.tech_stack   && { tech_stack:   entry.tech_stack }),
+  };
+
+  const filePath = getFilePath(entry.type);
+  fs.appendFileSync(filePath, JSON.stringify(full) + '\n');
+
+  // Also append to unified knowledge-base.jsonl for cross-type queries
+  if (filePath !== paths.KB_PATH) {
+    fs.appendFileSync(paths.KB_PATH, JSON.stringify(full) + '\n');
+  }
+
+  return id;
+}
+
+/**
+ * Deprecate an entry (never hard-delete).
+ */
+function deprecate(id, reason, supersededBy = null) {
+  const paths = getPaths();
+  const entries = readAll();
+  const entry   = entries.find(e => e.id === id);
+  if (!entry) throw new Error(`Knowledge entry not found: ${id}`);
+
+  // Append a deprecation marker (new entry with same id, deprecated=true)
+  const filePath = getFilePath(entry.type);
+  const deprecated = {
+    ...entry,
+    deprecated:        true,
+    deprecated_by:     supersededBy,
+    deprecated_reason: reason,
+    deprecated_at:     new Date().toISOString(),
+  };
+
+  fs.appendFileSync(filePath, JSON.stringify(deprecated) + '\n');
+  if (filePath !== paths.KB_PATH) {
+    fs.appendFileSync(paths.KB_PATH, JSON.stringify(deprecated) + '\n');
+  }
+
+  return id;
+}
+
+/**
+ * Reinforce an entry (increase confidence, increment reference count).
+ */
+function reinforce(id) {
+  const paths = getPaths();
+  const entries   = readAll();
+  const entry     = entries.find(e => e.id === id && !e.deprecated);
+  if (!entry) return;
+
+  const reinforced = {
+    ...entry,
+    confidence:       Math.min(1.0, entry.confidence + 0.05),
+    times_referenced: entry.times_referenced + 1,
+    last_referenced:  new Date().toISOString(),
+  };
+
+  const filePath = getFilePath(entry.type);
+  fs.appendFileSync(filePath, JSON.stringify(reinforced) + '\n');
+  if (filePath !== paths.KB_PATH) {
+    fs.appendFileSync(paths.KB_PATH, JSON.stringify(reinforced) + '\n');
+  }
+}
+
+// ── Read operations ───────────────────────────────────────────────────────────
+
+/**
+ * Read all entries from a JSONL file.
+ * Handles the append pattern: later entries with same ID supersede earlier ones.
+ */
+function readFile(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+
+  const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+  const byId  = new Map(); // Later entries (same ID) win
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      byId.set(entry.id, entry); // Last write wins
+    } catch {
+      // Skip malformed lines — never crash on corrupt JSONL
+    }
+  }
+
+  return [...byId.values()];
+}
+
+function readAll(includeGlobal = false) {
+  const paths = getPaths();
+  let entries = readFile(paths.KB_PATH);
+  if (includeGlobal && fs.existsSync(paths.GLOBAL_KB_PATH)) {
+    const globalEntries = readFile(paths.GLOBAL_KB_PATH).map(e => ({ ...e, global: true }));
+    entries = [...entries, ...globalEntries];
+  }
+  return entries;
+}
+
+function readByType(type) {
+  return readFile(getFilePath(type)).filter(e => e.type === type);
+}
+
+// ── Query operations ──────────────────────────────────────────────────────────
+
+/**
+ * Query the knowledge base.
+ * Returns entries sorted by relevance score (confidence × recency × tag overlap).
+ */
+function query(params = {}) {
+  const {
+    tags          = [],
+    topic,
+    type,
+    minConfidence = 0.3,
+    limit         = 20,
+    includeGlobal = false,
+    includeDeprecated = false,
+    project,
+  } = params;
+
+  let entries = readAll(includeGlobal);
+
+  // Filter
+  if (!includeDeprecated) entries = entries.filter(e => !e.deprecated);
+  if (type)               entries = entries.filter(e => e.type === type);
+  if (project)            entries = entries.filter(e => !e.project || e.project === project);
+  entries = entries.filter(e => e.confidence >= minConfidence);
+
+  // Score entries by relevance
+  const scored = entries.map(e => ({
+    entry: e,
+    score: scoreRelevance(e, { tags, topic }),
+  }));
+
+  return scored
+    .filter(s => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map(s => s.entry);
+}
+
+function scoreRelevance(entry, { tags = [], topic = '' }) {
+  let score = entry.confidence; // Base score from confidence
+
+  // Tag overlap
+  const entryTags = entry.tags || [];
+  const tagOverlap = tags.filter(t => entryTags.some(et => et.toLowerCase() === t.toLowerCase())).length;
+  score += tagOverlap * 0.2;
+
+  // Topic text match
+  if (topic) {
+    const topicWords = topic.toLowerCase().split(/\s+/);
+    const entryText  = `${entry.topic} ${entry.content}`.toLowerCase();
+    const wordMatches = topicWords.filter(w => w.length > 3 && entryText.includes(w)).length;
+    score += (wordMatches / Math.max(topicWords.length, 1)) * 0.3;
+  }
+
+  // Recency boost (entries referenced in last 30 days get a small boost)
+  if (entry.last_referenced) {
+    const daysSince = (Date.now() - new Date(entry.last_referenced).getTime()) / 86_400_000;
+    if (daysSince < 30) score += 0.1 * (1 - daysSince / 30);
+  }
+
+  // Penalty for very low reference count (may be noisy)
+  if (entry.times_referenced === 0) score *= 0.9;
+
+  return score;
+}
+
+// ── Project name helper ───────────────────────────────────────────────────────
+function readProjectName() {
+  const projectMd = path.join(process.cwd(), '.planning', 'PROJECT.md');
+  if (!fs.existsSync(projectMd)) return 'unknown';
+  const match = fs.readFileSync(projectMd, 'utf8').match(/^# (.+)/m);
+  return match?.[1]?.trim().slice(0, 50) || 'unknown';
+}
+
+// ── Statistics ────────────────────────────────────────────────────────────────
+function stats() {
+  const all    = readAll();
+  const active = all.filter(e => !e.deprecated);
+  const byType = {};
+  for (const e of active) {
+    byType[e.type] = (byType[e.type] || 0) + 1;
+  }
+  return {
+    total_entries:      all.length,
+    active_entries:     active.length,
+    deprecated_entries: all.length - active.length,
+    by_type:            byType,
+    avg_confidence:     active.length
+      ? active.reduce((s, e) => s + e.confidence, 0) / active.length
+      : 0,
+  };
+}
+
+module.exports = {
+  add, deprecate, reinforce,
+  readAll, readByType, readFile, query, stats,
+  setBaseDir, setGlobalDir, getPaths,
+};

package/bin/memory/session-memory-loader.js

@@ -0,0 +1,137 @@
+/**
+ * MindForge v2 — Session Memory Loader
+ * Loads relevant knowledge at session start and formats it for CLAUDE.md injection.
+ *
+ * Called at session boot to populate the agent with accumulated knowledge
+ * before any task begins.
+ */
+'use strict';
+
+const fs      = require('fs');
+const path    = require('path');
+const Indexer = require('./knowledge-indexer');
+const Store   = require('./knowledge-store');
+
+/**
+ * Load relevant session context from the knowledge graph.
+ * Returns a formatted string for injection into agent context at session start.
+ *
+ * @param {object} opts
+ * @param {string[]} opts.techStack  - Tech stack from PROJECT.md (for relevance filtering)
+ * @param {string}   opts.phase      - Current phase description
+ * @param {string}   opts.topic      - Current task/topic focus
+ * @param {number}   opts.maxEntries - Maximum entries to load (default: 20)
+ */
+function loadForSession(opts = {}) {
+  const { techStack = [], phase = '', topic = '', maxEntries = 20 } = opts;
+
+  const context = Indexer.loadSessionContext({ techStack, phase, topic });
+  const allLoaded = [
+    ...context.preferences,
+    ...context.decisions,
+    ...context.bugPatterns,
+    ...context.codePatterns,
+    ...context.domain,
+  ];
+
+  if (allLoaded.length === 0) {
+    return { formatted: '', entries: [], count: 0 };
+  }
+
+  // Reinforce all loaded entries (they are being actively used)
+  for (const entry of allLoaded) {
+    try { Store.reinforce(entry.id); } catch (e) { /* ignore cleanup errors */ }
+  }
+
+  const formatted = formatForContext(context);
+
+  return {
+    formatted,
+    entries:     allLoaded,
+    count:       allLoaded.length,
+    preferences: context.preferences.length,
+    decisions:   context.decisions.length,
+    bugPatterns: context.bugPatterns.length,
+    codePatterns: context.codePatterns.length,
+    domain:      context.domain.length,
+  };
+}
+
+/**
+ * Format loaded knowledge entries for agent context injection.
+ */
+function formatForContext(context) {
+  const sections = [];
+
+  if (context.preferences.length > 0) {
+    sections.push('### Team Preferences');
+    context.preferences.forEach(e => {
+      sections.push(`- [${(e.confidence * 100).toFixed(0)}% confidence] ${e.topic}: ${e.content.slice(0, 200)}`);
+    });
+  }
+
+  if (context.decisions.length > 0) {
+    sections.push('\n### Architectural Decisions (from this project)');
+    context.decisions.forEach(e => {
+      const adr = e.adr_reference ? ` (${e.adr_reference})` : '';
+      sections.push(`- ${e.topic}${adr}: ${e.content.slice(0, 200)}`);
+    });
+  }
+
+  if (context.bugPatterns.length > 0) {
+    sections.push('\n### Bug Patterns to Avoid');
+    context.bugPatterns.forEach(e => {
+      sections.push(`- ⚠️  ${e.topic}: ${e.root_cause?.slice(0, 150) || e.content.slice(0, 150)}`);
+      if (e.fix) sections.push(`  Fix: ${e.fix.slice(0, 100)}`);
+    });
+  }
+
+  if (context.domain.length > 0) {
+    sections.push('\n### Domain Knowledge');
+    context.domain.forEach(e => {
+      sections.push(`- ${e.topic}: ${e.content.slice(0, 200)}`);
+    });
+  }
+
+  return sections.join('\n');
+}
+
+/**
+ * Read tech stack from PROJECT.md for relevance filtering.
+ */
+function readTechStack() {
+  const projectMd = path.join(process.cwd(), '.planning', 'PROJECT.md');
+  if (!fs.existsSync(projectMd)) return [];
+  const content = fs.readFileSync(projectMd, 'utf8');
+  // Extract tech stack section
+  const techSection = content.match(/## Tech stack\n+([\s\S]*?)(?=\n##|$)/i)?.[1] || '';
+  return techSection
+    .split('\n')
+    .map(l => l.replace(/^[-*•]\s*/, '').split(/[\s,/]/).filter(w => w.length > 2))
+    .flat()
+    .filter(Boolean)
+    .slice(0, 20);
+}
+
+/**
+ * Generate the memory header displayed at session start.
+ */
+function generateSessionHeader(loadResult) {
+  if (loadResult.count === 0) {
+    return '🧠 Knowledge Base — no relevant memories for this session\n';
+  }
+
+  const lines = [
+    `🧠 Knowledge Base — ${loadResult.count} relevant memories loaded:`,
+  ];
+
+  if (loadResult.preferences > 0)  lines.push(`  Preferences  : ${loadResult.preferences}`);
+  if (loadResult.decisions > 0)    lines.push(`  Decisions    : ${loadResult.decisions}`);
+  if (loadResult.bugPatterns > 0)  lines.push(`  Bug patterns : ${loadResult.bugPatterns}`);
+  if (loadResult.codePatterns > 0) lines.push(`  Code patterns: ${loadResult.codePatterns}`);
+  if (loadResult.domain > 0)       lines.push(`  Domain       : ${loadResult.domain}`);
+
+  return lines.join('\n');
+}
+
+module.exports = { loadForSession, readTechStack, generateSessionHeader, formatForContext };

package/bin/migrations/0.1.0-to-0.5.0.js

@@ -13,13 +13,12 @@ module.exports = {
     if (!handoff.implicit_knowledge) handoff.implicit_knowledge = [];
     if (!handoff.quality_signals)    handoff.quality_signals    = [];
     fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
-    console.log(`    • HANDOFF.json: added intelligence layer fields`);
+    console.log('    • HANDOFF.json: added intelligence layer fields');
   },
 };
 
 // bin/migrations/0.5.0-to-0.6.0.js
 'use strict';
-const fs = require('fs');
 module.exports = {
   fromVersion: '0.5.0',
   toVersion:   '0.6.0',
@@ -32,6 +31,6 @@ module.exports = {
     if (!Array.isArray(handoff.recent_commits)) handoff.recent_commits = [];
     if (!Array.isArray(handoff.recent_files))   handoff.recent_files   = [];
     fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
-    console.log(`    • HANDOFF.json: added distribution platform fields`);
+    console.log('    • HANDOFF.json: added distribution platform fields');
   },
 };

package/bin/migrations/0.5.0-to-0.6.0.js

@@ -12,6 +12,6 @@ module.exports = {
     if (!Array.isArray(handoff.recent_commits)) handoff.recent_commits = [];
     if (!Array.isArray(handoff.recent_files))   handoff.recent_files   = [];
     fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
-    console.log(`    • HANDOFF.json: added distribution platform fields`);
+    console.log('    • HANDOFF.json: added distribution platform fields');
   },
 };

package/bin/migrations/0.6.0-to-1.0.0.js

@@ -32,7 +32,7 @@ module.exports = {
       }
 
       fs.writeFileSync(paths.handoff, JSON.stringify(handoff, null, 2) + '\n');
-      console.log(`    • HANDOFF.json: added plugin_api_version, normalised arrays`);
+      console.log('    • HANDOFF.json: added plugin_api_version, normalised arrays');
     }
 
     // ── 2. AUDIT.jsonl ────────────────────────────────────────────────────────
@@ -59,7 +59,7 @@ module.exports = {
         fs.writeFileSync(paths.audit, updated.join('\n') + '\n');
         console.log(`    • AUDIT.jsonl: backfilled session_id in ${modified} of ${lines.length} entries`);
       } else {
-        console.log(`    • AUDIT.jsonl: all entries already have session_id`);
+        console.log('    • AUDIT.jsonl: all entries already have session_id');
       }
     }
 
@@ -93,7 +93,7 @@ module.exports = {
         fs.appendFileSync(paths.state,
           `\n\n---\n*Migrated to MindForge v1.0.0 schema on ${new Date().toISOString().slice(0,10)}*\n`
         );
-        console.log(`    • STATE.md: added v1.0.0 migration note`);
+        console.log('    • STATE.md: added v1.0.0 migration note');
       }
     }
   },