@cccarv82/freya 2.3.13 → 2.4.1

package/scripts/migrate-v1-v2.js

@@ -0,0 +1,184 @@
+const fs = require('fs');
+const path = require('path');
+const { defaultInstance: dl } = require('./lib/DataLayer');
+const DataManager = require('./lib/DataManager');
+
+const dataDir = path.join(__dirname, '..', 'data');
+const logsDir = path.join(__dirname, '..', 'logs', 'daily');
+
+console.log('--- Iniciando Migração V1 (JSON) para V2 (SQLite) ---');
+
+function migrateTasks() {
+    console.log('Migrando Tasks...');
+    const dm = new DataManager(dataDir, logsDir);
+    const tasks = dm.getTasksRaw();
+    const stmt = dl.db.prepare(`
+    INSERT OR IGNORE INTO tasks 
+    (id, project_slug, description, category, status, created_at, completed_at, metadata)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+    let count = 0;
+    // Tasks has: PENDING, COMPLETED, ARCHIVED
+    const processList = (list) => {
+        for (const t of list) {
+            const meta = { priority: t.priority, streamSlug: t.streamSlug };
+            stmt.run(
+                t.id,
+                t.projectSlug || null,
+                t.description,
+                t.category,
+                t.status,
+                t.createdAt || new Date().toISOString(),
+                t.completedAt || null,
+                JSON.stringify(meta)
+            );
+            count++;
+        }
+    };
+
+    const pending = tasks.filter(t => t.status === 'PENDING');
+    const completed = tasks.filter(t => t.status === 'COMPLETED');
+    const archived = tasks.filter(t => t.status === 'ARCHIVED');
+
+    processList(pending);
+    processList(completed);
+    processList(archived);
+
+    console.log(`✅ ${count} tasks migradas.`);
+}
+
+function migrateBlockers() {
+    console.log('Migrando Blockers...');
+    const dm = new DataManager(dataDir, logsDir);
+    const blockers = dm.getBlockersRaw();
+    const stmt = dl.db.prepare(`
+    INSERT OR IGNORE INTO blockers 
+    (id, project_slug, title, severity, status, owner, next_action, created_at, resolved_at, metadata)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+    let count = 0;
+    const processList = (list) => {
+        for (const b of list) {
+            const meta = { streamSlug: b.streamSlug };
+            stmt.run(
+                b.id,
+                b.projectSlug || null,
+                b.title,
+                b.severity || 'MEDIUM',
+                b.status || 'OPEN',
+                b.owner || null,
+                b.nextAction || null,
+                b.createdAt || new Date().toISOString(),
+                b.resolvedAt || null,
+                JSON.stringify(meta)
+            );
+            count++;
+        }
+    };
+
+    const open = blockers.filter(b => b.status === 'OPEN' || b.status === 'MITIGATING');
+    const resolved = blockers.filter(b => b.status === 'RESOLVED' || b.status === 'CLOSED');
+
+    processList(open);
+    processList(resolved);
+
+    console.log(`✅ ${count} blockers migrados.`);
+}
+
+function migrateProjects() {
+    console.log('Migrando Projetos...');
+    const clientsDir = path.join(dataDir, 'Clients');
+    if (!fs.existsSync(clientsDir)) return;
+
+    const insertProj = dl.db.prepare(`
+    INSERT OR IGNORE INTO projects (slug, client, name, is_active)
+    VALUES (?, ?, ?, ?)
+  `);
+
+    const getProjId = dl.db.prepare("SELECT id FROM projects WHERE slug = ?");
+
+    const insertHist = dl.db.prepare(`
+    INSERT INTO project_status_history (project_id, status_text, date)
+    VALUES (?, ?, ?)
+  `);
+
+    let pCount = 0;
+    let hCount = 0;
+
+    for (const clientSlug of fs.readdirSync(clientsDir)) {
+        const clientPath = path.join(clientsDir, clientSlug);
+        if (!fs.statSync(clientPath).isDirectory()) continue;
+
+        for (const projectSlug of fs.readdirSync(clientPath)) {
+            const projectPath = path.join(clientPath, projectSlug);
+            if (!fs.statSync(projectPath).isDirectory()) continue;
+
+            const statusPath = path.join(projectPath, 'status.json');
+            if (!fs.existsSync(statusPath)) continue;
+
+            let pData;
+            try {
+                pData = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+            } catch (e) { continue; }
+
+            const fullSlug = `${clientSlug}-${projectSlug}`;
+            const isActive = pData.active !== false ? 1 : 0;
+
+            insertProj.run(fullSlug, pData.client || clientSlug, pData.project || projectSlug, isActive);
+            pCount++;
+
+            const pRow = getProjId.get(fullSlug);
+            if (pRow && pData.history && Array.isArray(pData.history)) {
+                for (const log of pData.history) {
+                    let content = '';
+                    let date = new Date().toISOString();
+                    if (typeof log === 'string') {
+                        content = log;
+                    } else if (typeof log === 'object') {
+                        content = log.content || log.summary || JSON.stringify(log);
+                        date = log.date || date;
+                    }
+                    insertHist.run(pRow.id, content, date);
+                    hCount++;
+                }
+            }
+        }
+    }
+
+    console.log(`✅ ${pCount} projetos migrados, com ${hCount} atualizações de status.`);
+}
+
+function migrateLogs() {
+    console.log('Migrando Logs Diários...');
+    if (!fs.existsSync(logsDir)) {
+        console.log('Nenhum diretório de log encontrado.');
+        return;
+    }
+    const files = fs.readdirSync(logsDir).filter(f => f.endsWith('.md'));
+    const stmt = dl.db.prepare(`
+    INSERT OR IGNORE INTO daily_logs (date, raw_markdown)
+    VALUES (?, ?)
+  `);
+
+    let count = 0;
+    for (const file of files) {
+        const date = file.replace('.md', '');
+        const content = fs.readFileSync(path.join(logsDir, file), 'utf8');
+        stmt.run(date, content);
+        count++;
+    }
+    console.log(`✅ ${count} logs diários migrados.`);
+}
+
+// Transaction wrapper
+dl.db.transaction(() => {
+    migrateProjects();
+    migrateTasks();
+    migrateBlockers();
+    migrateLogs();
+})();
+
+console.log('--- Migração concluída com sucesso! ---');
+dl.close();

package/scripts/validate-data.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 
 const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+const SCHEMA = require('./lib/schema');
 
 const DATA_DIR = path.join(__dirname, '../data');
 
@@ -24,14 +25,14 @@ function validateTaskLog(json, file) {
     if (!task.status) errors.push(`Task[${index}] missing 'status'.`);
     if (!task.createdAt) errors.push(`Task[${index}] missing 'createdAt'.`);
 
-    const validCategories = ['DO_NOW', 'SCHEDULE', 'DELEGATE', 'IGNORE'];
+    const validCategories = SCHEMA.TASK.CATEGORIES;
     if (task.category && !validCategories.includes(task.category)) {
-        errors.push(`Task[${index}] invalid category '${task.category}'.`);
+      errors.push(`Task[${index}] invalid category '${task.category}'.`);
     }
 
-    const validStatuses = ['PENDING', 'COMPLETED', 'ARCHIVED'];
+    const validStatuses = SCHEMA.TASK.STATUSES;
     if (task.status && !validStatuses.includes(task.status)) {
-        errors.push(`Task[${index}] invalid status '${task.status}'.`);
+      errors.push(`Task[${index}] invalid status '${task.status}'.`);
     }
   });
 
@@ -54,9 +55,9 @@ function validateCareerLog(json, file) {
     if (!entry.type) errors.push(`Entry[${index}] missing 'type'.`);
     if (!entry.description) errors.push(`Entry[${index}] missing 'description'.`);
 
-    const validTypes = ['Achievement', 'Feedback', 'Certification', 'Goal'];
+    const validTypes = SCHEMA.CAREER.TYPES;
     if (entry.type && !validTypes.includes(entry.type)) {
-        errors.push(`Entry[${index}] invalid type '${entry.type}'.`);
+      errors.push(`Entry[${index}] invalid type '${entry.type}'.`);
     }
   });
 
@@ -66,19 +67,19 @@ function validateCareerLog(json, file) {
 function validateProjectStatus(json, file) {
   const errors = [];
   const requiredFields = ['client', 'project', 'active', 'currentStatus', 'lastUpdated', 'history'];
-  
+
   requiredFields.forEach(field => {
-      if (json[field] === undefined) errors.push(`Missing field '${field}'.`);
+    if (json[field] === undefined) errors.push(`Missing field '${field}'.`);
   });
 
   if (Array.isArray(json.history)) {
-      json.history.forEach((item, index) => {
-          if (!item.date) errors.push(`History[${index}] missing 'date'.`);
-          if (!item.type) errors.push(`History[${index}] missing 'type'.`);
-          if (!item.content) errors.push(`History[${index}] missing 'content'.`);
-      });
+    json.history.forEach((item, index) => {
+      if (!item.date) errors.push(`History[${index}] missing 'date'.`);
+      if (!item.type) errors.push(`History[${index}] missing 'type'.`);
+      if (!item.content) errors.push(`History[${index}] missing 'content'.`);
+    });
   } else if (json.history !== undefined) {
-      errors.push(`'history' must be an array.`);
+    errors.push(`'history' must be an array.`);
   }
 
   return errors;
@@ -94,8 +95,8 @@ function validateBlockerLog(json, file) {
     return errors;
   }
 
-  const validStatuses = ['OPEN', 'MITIGATING', 'RESOLVED'];
-  const validSeverities = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'];
+  const validStatuses = SCHEMA.BLOCKER.STATUSES;
+  const validSeverities = SCHEMA.BLOCKER.SEVERITIES;
 
   json.blockers.forEach((b, i) => {
     const prefix = `Blocker[${i}]`;
@@ -148,53 +149,49 @@ function validateData() {
 
     const files = walk(DATA_DIR);
     console.log(`Found ${files.length} json files.`);
-    
+
     let errorCount = 0;
 
     files.forEach(file => {
-        const relativePath = path.relative(DATA_DIR, file);
-        const result = safeReadJson(file);
-        if (!result.ok) {
-            if (result.error.type === 'parse') {
-                quarantineCorruptedFile(file, result.error.message);
-                console.warn(`⚠️ [${relativePath}] JSON parse failed; quarantined to _corrupted.`);
-            } else {
-                console.error(`❌ [${relativePath}] Read failed: ${result.error.message}`);
-            }
-            errorCount++;
-            return;
+      const relativePath = path.relative(DATA_DIR, file);
+      const result = safeReadJson(file);
+      if (!result.ok) {
+        if (result.error.type === 'parse') {
+          quarantineCorruptedFile(file, result.error.message);
+          console.warn(`⚠️ [${relativePath}] JSON parse failed; quarantined to _corrupted.`);
+        } else {
+          console.error(`❌ [${relativePath}] Read failed: ${result.error.message}`);
         }
+        errorCount++;
+        return;
+      }
 
-        const json = result.json;
+      const json = result.json;
 
-        let fileErrors = [];
+      let fileErrors = [];
 
-        // Route validation based on filename/path
-        if (file.endsWith('task-log.json')) {
-            fileErrors = validateTaskLog(json, relativePath);
-        } else if (file.endsWith('career-log.json')) {
-            fileErrors = validateCareerLog(json, relativePath);
-        } else if (file.endsWith('status.json')) {
-            fileErrors = validateProjectStatus(json, relativePath);
-        } else if (file.endsWith('blocker-log.json')) {
-            fileErrors = validateBlockerLog(json, relativePath);
-        } else {
-            // Optional: warn about unknown files, or ignore
-            // console.warn(`⚠️ [${relativePath}] Unknown JSON file type. Skipping schema validation.`);
-        }
+      // Route validation based on filename/path
+      if (file.endsWith('career-log.json')) {
+        fileErrors = validateCareerLog(json, relativePath);
+      } else if (file.endsWith('task-log.json') || file.endsWith('status.json') || file.endsWith('blocker-log.json')) {
+        // Obsoleted by SQLite, ignore
+      } else {
+        // Optional: warn about unknown files, or ignore
+        // console.warn(`⚠️ [${relativePath}] Unknown JSON file type. Skipping schema validation.`);
+      }
 
-        if (fileErrors.length > 0) {
-            console.error(`❌ [${relativePath}] Validation failed:`);
-            fileErrors.forEach(e => console.error(`   - ${e}`));
-            errorCount++;
-        }
+      if (fileErrors.length > 0) {
+        console.error(`❌ [${relativePath}] Validation failed:`);
+        fileErrors.forEach(e => console.error(`   - ${e}`));
+        errorCount++;
+      }
     });
 
     if (errorCount === 0) {
-        console.log('✅ All systems operational');
+      console.log('✅ All systems operational');
     } else {
-        console.error(`❌ Validation completed with errors in ${errorCount} file(s).`);
-        process.exit(1);
+      console.error(`❌ Validation completed with errors in ${errorCount} file(s).`);
+      process.exit(1);
     }
 
   } catch (err) {

package/scripts/validate-structure.js

@@ -7,6 +7,7 @@ const DATA_DIR = path.join(ROOT, 'data');
 const DOCS_DIR = path.join(ROOT, 'docs');
 const CLIENTS_DIR = path.join(DATA_DIR, 'Clients');
 
+const { defaultInstance: dl } = require('./lib/DataLayer');
 const errors = [];
 
 function exists(p) {
@@ -44,78 +45,31 @@ function parseFrontmatter(text) {
   return fm;
 }
 
-function validateDailyLogs() {
-  if (!exists(LOGS_DIR)) return;
-  const files = fs.readdirSync(LOGS_DIR)
-    .filter((f) => /^\d{4}-\d{2}-\d{2}\.md$/.test(f));
-
-  for (const name of files) {
-    const full = path.join(LOGS_DIR, name);
-    const body = readFileSafe(full);
-    const fm = parseFrontmatter(body);
-    const date = name.replace(/\.md$/, '');
-    if (!fm) {
-      errors.push(`Daily log missing frontmatter: ${path.relative(ROOT, full)}`);
-      continue;
-    }
-    const type = String(fm.Type || '').toLowerCase();
-    const fmDate = String(fm.Date || '').trim();
-    if (type !== 'daily') {
-      errors.push(`Daily log frontmatter Type must be 'daily': ${path.relative(ROOT, full)}`);
-    }
-    if (fmDate !== date) {
-      errors.push(`Daily log frontmatter Date must match filename (${date}): ${path.relative(ROOT, full)}`);
-    }
-  }
-}
-
+// Daily logs are now managed by SQLite in V2.
 function collectProjectSlugs() {
-  if (!exists(CLIENTS_DIR)) return [];
-  const slugs = [];
-  const files = walk(CLIENTS_DIR).filter((f) => f.endsWith('status.json'));
-  for (const file of files) {
-    const rel = path.relative(CLIENTS_DIR, path.dirname(file));
-    if (!rel) continue;
-    const slug = rel.split(path.sep).join('/').toLowerCase();
-    slugs.push(slug);
-  }
-  return Array.from(new Set(slugs));
+  return dl.db.prepare('SELECT slug FROM projects WHERE is_active = 1').all().map(p => p.slug.toLowerCase());
 }
 
 function validateProjectStatusHistory() {
-  if (!exists(CLIENTS_DIR)) return;
-  const files = walk(CLIENTS_DIR).filter((f) => f.endsWith('status.json'));
-  for (const file of files) {
-    const raw = readFileSafe(file);
-    if (!raw) continue;
-    try {
-      const json = JSON.parse(raw);
-      if (!Array.isArray(json.history)) {
-        errors.push(`status.json must include history array: ${path.relative(ROOT, file)}`);
-      }
-    } catch (e) {
-      errors.push(`Invalid JSON in status.json: ${path.relative(ROOT, file)}`);
-    }
+  const projects = dl.db.prepare('SELECT id, name FROM projects').all();
+  for (const p of projects) {
+    const historyCount = dl.db.prepare('SELECT count(*) as count FROM project_status_history WHERE project_id = ?').get(p.id).count;
+    // We don't strictly enforce history to exist for brand new projects, but if we did:
+    // if (historyCount === 0) errors.push(`Project missing status history: ${p.name}`);
   }
 }
 
 function validateTaskProjectSlugs() {
   const slugs = collectProjectSlugs();
-  if (!slugs.length) return; // no known slugs -> skip
-
-  const taskFile = path.join(DATA_DIR, 'tasks', 'task-log.json');
-  if (!exists(taskFile)) return;
+  if (!slugs.length) return;
 
-  let json;
-  try { json = JSON.parse(readFileSafe(taskFile) || '{}'); } catch { return; }
-  const tasks = Array.isArray(json.tasks) ? json.tasks : [];
+  const tasks = dl.db.prepare('SELECT id, description, project_slug FROM tasks').all();
 
   for (const task of tasks) {
-    if (!task || typeof task !== 'object') continue;
     const desc = String(task.description || '').toLowerCase();
     if (!desc) continue;
     const mentioned = slugs.find((slug) => desc.includes(slug));
-    if (mentioned && !task.projectSlug) {
+    if (mentioned && !task.project_slug) {
       errors.push(`Task missing projectSlug for mentioned project (${mentioned}): ${task.id || task.description}`);
     }
   }
@@ -135,7 +89,7 @@ function validateDocsHubs() {
 }
 
 function main() {
-  validateDailyLogs();
+  // validateDailyLogs(); removed context since migrated to SQLite
   validateProjectStatusHistory();
   validateTaskProjectSlugs();
   validateDocsHubs();

package/templates/base/scripts/build-vector-index.js

@@ -0,0 +1,85 @@
+const { defaultInstance: dl } = require('./lib/DataLayer');
+const { defaultEmbedder } = require('./lib/Embedder');
+
+/**
+ * Splits markdown text into overlapping chunks of approx maximum length
+ */
+function chunkText(text, maxChars = 800, overlap = 150) {
+    if (!text) return [];
+    const chunks = [];
+    let i = 0;
+    while (i < text.length) {
+        let end = i + maxChars;
+        if (end < text.length) {
+            // Find a newline or space to break at cleanly
+            const nextNewline = text.lastIndexOf('\n', end);
+            if (nextNewline > i + overlap) {
+                end = nextNewline;
+            } else {
+                const nextSpace = text.lastIndexOf(' ', end);
+                if (nextSpace > i + overlap) end = nextSpace;
+            }
+        }
+        chunks.push(text.slice(i, end).trim());
+        i = end - overlap;
+    }
+    return chunks;
+}
+
+async function buildVectorIndex() {
+    console.log('[RAG] Booting Embedding Engine...');
+    await defaultEmbedder.init();
+    console.log('[RAG] Model ready.');
+
+    // Find daily logs that haven't been indexed completely
+    const allLogs = dl.db.prepare('SELECT * FROM daily_logs').all();
+    let updatedCount = 0;
+
+    for (const log of allLogs) {
+        // Assume log is processed if we have *any* embedding for it.
+        // For total correctness, we would compare hash of raw_markdown, 
+        // but skipping if exists is enough for initialization.
+        const existing = dl.db.prepare(
+            "SELECT count(*) as count FROM document_embeddings WHERE reference_type = 'daily_log' AND reference_id = ?"
+        ).get(log.date);
+
+        if (existing && existing.count > 0) {
+            continue;
+        }
+
+        console.log(`[RAG] Generating embeddings for Daily Log: ${log.date}`);
+        const chunks = chunkText(`Daily Log Date: ${log.date}\n\n${log.raw_markdown}`);
+
+        const insertStmt = dl.db.prepare(`
+            INSERT INTO document_embeddings 
+            (reference_type, reference_id, chunk_index, text_chunk, embedding) 
+            VALUES (?, ?, ?, ?, ?)
+        `);
+
+        // Use transaction for speed
+        const insertTx = dl.db.transaction((chunksArr) => {
+            for (let i = 0; i < chunksArr.length; i++) {
+                insertStmt.run('daily_log', log.date, i, chunksArr[i].text, chunksArr[i].buffer);
+            }
+        });
+
+        // Compute vectors asynchronously (since transformers is async) then insert
+        const preparedChunks = [];
+        for (let i = 0; i < chunks.length; i++) {
+            const vector = await defaultEmbedder.embedText(chunks[i]);
+            const buffer = defaultEmbedder.vectorToBuffer(vector);
+            preparedChunks.push({ text: chunks[i], buffer });
+        }
+
+        insertTx(preparedChunks);
+        updatedCount++;
+    }
+
+    console.log(`[RAG] Vector Index Built. Processed ${updatedCount} un-indexed logs.`);
+}
+
+if (require.main === module) {
+    buildVectorIndex().catch(console.error);
+}
+
+module.exports = { buildVectorIndex };

package/templates/base/scripts/export-obsidian.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+function exists(p) {
+  try { fs.accessSync(p); return true; } catch { return false; }
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+const { defaultInstance: dl } = require('./lib/DataLayer');
+const DataManager = require('./lib/DataManager');
+
+function slugifyFileName(s) {
+  return String(s || '')
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9\-_/ ]+/g, '')
+    .replace(/[\s]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^[-/]+|[-/]+$/g, '')
+    .slice(0, 80) || 'note';
+}
+
+function yamlEscape(v) {
+  const s = String(v == null ? '' : v);
+  // quote always for safety
+  return JSON.stringify(s);
+}
+
+function fmtTags(tags) {
+  const uniq = Array.from(new Set(tags.filter(Boolean)));
+  return '[' + uniq.map((t) => yamlEscape(t)).join(', ') + ']';
+}
+
+function writeNote(baseDir, relPathNoExt, md) {
+  const outPath = path.join(baseDir, relPathNoExt + '.md');
+  ensureDir(path.dirname(outPath));
+  fs.writeFileSync(outPath, md, 'utf8');
+  return outPath;
+}
+
+function main() {
+  const workspaceDir = path.resolve(process.cwd());
+
+  const dm = new DataManager(path.join(workspaceDir, 'data'), path.join(workspaceDir, 'logs'));
+
+  const blockers = dm.getBlockersRaw();
+  const tasks = dm.getTasksRaw();
+
+  const notesRoot = path.join(workspaceDir, 'docs', 'notes');
+  ensureDir(notesRoot);
+
+  const created = [];
+
+  // Export OPEN blockers as incident notes
+  for (const b of blockers) {
+    if (!b || typeof b !== 'object') continue;
+    const status = String(b.status || '').toUpperCase();
+    if (status !== 'OPEN' && status !== 'MITIGATING') continue;
+
+    const title = String(b.title || '').trim();
+    if (!title) continue;
+
+    const projectSlug = String(b.projectSlug || '').trim();
+    const sev = String(b.severity || '').toUpperCase();
+
+    const tags = [];
+    if (projectSlug) projectSlug.split('/').forEach((p) => tags.push(p));
+    if (sev) tags.push(sev.toLowerCase());
+    tags.push('blocker');
+
+    const relBase = projectSlug ? path.join('incidents', projectSlug) : path.join('incidents', 'unclassified');
+    const fileBase = slugifyFileName(title);
+    const relPath = path.join(relBase, fileBase);
+
+    const md = [
+      '---',
+      `type: ${yamlEscape('incident')}`,
+      `id: ${yamlEscape(b.id || '')}`,
+      `title: ${yamlEscape(title)}`,
+      `status: ${yamlEscape(status)}`,
+      `severity: ${yamlEscape(sev || '')}`,
+      `projectSlug: ${yamlEscape(projectSlug)}`,
+      `createdAt: ${yamlEscape(b.createdAt || '')}`,
+      `tags: ${fmtTags(tags.map((t) => '#' + String(t).replace(/^#/, '')))}`,
+      '---',
+      '',
+      `# ${title}`,
+      '',
+      b.description ? `## Context\n${String(b.description).trim()}\n` : '',
+      b.nextAction ? `## Next action\n${String(b.nextAction).trim()}\n` : '',
+      '',
+      '## Links',
+      '- Related reports: see `docs/reports/`',
+      '- Related tasks: see F.R.E.Y.A. SQLite tasks table',
+      ''
+    ].filter(Boolean).join('\n');
+
+    const out = writeNote(notesRoot, relPath, md);
+    created.push(out);
+  }
+
+  // Export a daily index note (lightweight)
+  const today = new Date().toISOString().slice(0, 10);
+  const dailyNote = [
+    '---',
+    `type: ${yamlEscape('daily-index')}`,
+    `date: ${yamlEscape(today)}`,
+    '---',
+    '',
+    `# Daily Index ${today}`,
+    '',
+    '## Open blockers',
+    ...blockers
+      .filter((b) => b && (String(b.status || '').toUpperCase() === 'OPEN' || String(b.status || '').toUpperCase() === 'MITIGATING'))
+      .slice(0, 20)
+      .map((b) => {
+        const ps = b.projectSlug ? ` [${b.projectSlug}]` : '';
+        return `- ${String(b.title || '').trim()}${ps}`;
+      }),
+    '',
+    '## DO_NOW tasks',
+    ...tasks
+      .filter((t) => t && String(t.status || '').toUpperCase() === 'PENDING' && String(t.category || '') === 'DO_NOW')
+      .slice(0, 20)
+      .map((t) => {
+        const ps = t.projectSlug ? ` [${t.projectSlug}]` : '';
+        return `- [ ] ${String(t.description || '').trim()}${ps}`;
+      }),
+    ''
+  ].join('\n');
+
+  const dailyOut = writeNote(notesRoot, path.join('daily', today), dailyNote);
+  created.push(dailyOut);
+
+  process.stdout.write(JSON.stringify({ ok: true, created: created.map((p) => path.relative(workspaceDir, p).replace(/\\/g, '/')) }, null, 2) + '\n');
+}
+
+main();