@cccarv82/freya 1.0.45 → 1.0.49

package/cli/index.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const fs = require('fs');
 const path = require('path');
 
 const { cmdInit } = require('./init');
@@ -59,7 +60,7 @@ async function run(argv) {
   const command = args[0];
 
   if (!command || command === 'help' || flags.has('--help') || flags.has('-h')) {
-    process.stdout.write(usage());
+    fs.writeSync(process.stdout.fd, usage());
     return;
   }
 
@@ -95,7 +96,7 @@ async function run(argv) {
   }
 
   process.stderr.write(`Unknown command: ${command}\n`);
-  process.stdout.write(usage());
+  fs.writeSync(process.stdout.fd, usage());
   process.exitCode = 1;
 }
 

package/cli/web.js

@@ -608,6 +608,107 @@ function run(cmd, args, cwd) {
   });
 }
 
+function isAllowedChatSearchPath(relPath) {
+  if (!relPath) return false;
+  if (relPath.startsWith('..')) return false;
+  return relPath.startsWith('data/') || relPath.startsWith('logs/') || relPath.startsWith('docs/');
+}
+
+async function copilotSearch(workspaceDir, query, opts = {}) {
+  const q = String(query || '').trim();
+  if (!q) return { ok: false, error: 'Missing query' };
+
+  const limit = Math.max(1, Math.min(20, Number(opts.limit || 8)));
+  const cmd = process.env.COPILOT_CMD || 'copilot';
+
+  const prompt = [
+    'Você é um buscador local de arquivos.',
+    'Objetivo: encontrar registros relevantes para a consulta do usuário.',
+    'Escopo: procure SOMENTE nos diretórios data/, logs/ e docs/ do workspace.',
+    'Use ferramentas para ler/consultar arquivos, mas não modifique nada.',
+    `Consulta do usuário: "${q}"`,
+    '',
+    'Responda APENAS com JSON válido (sem code fences) no formato:',
+    '{"summary":"<1-2 frases humanas>","matches":[{"file":"<caminho relativo>","date":"YYYY-MM-DD ou vazio","snippet":"<trecho curto>"}]}',
+    `Limite de matches: ${limit}.`,
+    'O resumo deve soar humano e mencionar a quantidade de registros encontrados.',
+    'A lista deve estar ordenada por relevância.'
+  ].join('\n');
+
+  const args = [
+    '-s',
+    '--no-color',
+    '--stream',
+    'off',
+    '-p',
+    prompt,
+    '--allow-all-tools',
+    '--add-dir',
+    workspaceDir
+  ];
+
+  const r = await run(cmd, args, workspaceDir);
+  const out = (r.stdout + r.stderr).trim();
+  if (r.code !== 0) return { ok: false, error: out || 'Copilot returned non-zero exit code.' };
+
+  const jsonText = extractFirstJsonObject(out) || out;
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch {
+    try {
+      parsed = JSON.parse(escapeJsonControlChars(jsonText));
+    } catch (e) {
+      return { ok: false, error: e.message || 'Copilot output not valid JSON.' };
+    }
+  }
+
+  const matchesRaw = Array.isArray(parsed.matches) ? parsed.matches : [];
+  const matches = matchesRaw
+    .map((m) => {
+      const fileRaw = String(m && m.file ? m.file : '').trim();
+      const dateRaw = String(m && m.date ? m.date : '').trim();
+      const snippetRaw = String(m && m.snippet ? m.snippet : '').trim();
+      let rel = fileRaw;
+      if (fileRaw.startsWith(workspaceDir)) {
+        rel = path.relative(workspaceDir, fileRaw).replace(/\\/g, '/');
+      }
+      return { file: rel.replace(/\\/g, '/'), date: dateRaw, snippet: snippetRaw };
+    })
+    .filter((m) => m.file && isAllowedChatSearchPath(m.file))
+    .slice(0, limit);
+
+  const summary = String(parsed.summary || '').trim();
+  return { ok: true, summary, matches };
+}
+
+function buildChatAnswer(query, matches, summary) {
+  const count = matches.length;
+  let summaryText = String(summary || '').trim();
+  if (!summaryText) {
+    if (count === 0) {
+      summaryText = `Não encontrei registros relacionados a "${query}".`;
+    } else {
+      summaryText = `Encontrei ${count} registro(s) relacionados a "${query}".`;
+    }
+  }
+
+  const lines = [];
+  lines.push(`Encontrei ${count} registro(s).`);
+  lines.push(`Resumo (${count} registro(s)): ${summaryText}`);
+
+  for (const m of matches) {
+    const parts = [];
+    if (m.date) parts.push(`**${m.date}**`);
+    if (m.file) parts.push('`' + m.file + '`');
+    const prefix = parts.length ? parts.join(' — ') + ':' : '';
+    const snippet = m.snippet ? String(m.snippet).trim() : '';
+    lines.push(`- ${prefix} ${snippet}`);
+  }
+
+  return lines.join('\n');
+}
+
 function openBrowser(url) {
   const { cmd, args } = guessOpenCmd();
   try {
@@ -1623,26 +1724,18 @@ async function cmdWeb({ port, dir, open, dev }) {
           const query = String(payload.query || '').trim();
           if (!query) return safeJson(res, 400, { error: 'Missing query' });
 
+          const copilotResult = await copilotSearch(workspaceDir, query, { limit: 8 });
+          if (copilotResult.ok) {
+            const matches = copilotResult.matches || [];
+            const answer = buildChatAnswer(query, matches, copilotResult.summary);
+            return safeJson(res, 200, { ok: true, sessionId, answer, matches });
+          }
+
           const indexMatches = searchIndex(workspaceDir, query, { limit: 8 });
           const matches = indexMatches.length
             ? indexMatches
             : searchWorkspace(workspaceDir, query, { limit: 8 });
-          if (!matches.length) {
-            return safeJson(res, 200, { ok: true, sessionId, answer: 'Não encontrei registro', matches: [] });
-          }
-
-          const lines = [];
-          lines.push(`Encontrei ${matches.length} registro(s):`);
-          for (const m of matches) {
-            const parts = [];
-            if (m.date) parts.push(`**${m.date}**`);
-            if (m.file) parts.push('`' + m.file + '`');
-            const prefix = parts.length ? parts.join(' — ') + ':' : '';
-            const snippet = m.snippet ? String(m.snippet).trim() : '';
-            lines.push(`- ${prefix} ${snippet}`);
-          }
-
-          const answer = lines.join('\n');
+          const answer = buildChatAnswer(query, matches, '');
           return safeJson(res, 200, { ok: true, sessionId, answer, matches });
         }
 
@@ -1948,17 +2041,17 @@ async function cmdWeb({ port, dir, open, dev }) {
       const targetOk = looksLikeFreyaWorkspace(target);
       const empty = looksEmptyWorkspace(target);
       if (!targetOk && !empty) {
-        process.stdout.write(`Dev seed: skipped (workspace not empty and not initialized) -> ${target}\n`);
+        fs.writeSync(process.stdout.fd, `Dev seed: skipped (workspace not empty and not initialized) -> ${target}\n`);
       } else {
         seedDevWorkspace(target);
-        process.stdout.write(`Dev seed: created demo files in ${target}\n`);
+        fs.writeSync(process.stdout.fd, `Dev seed: created demo files in ${target}\n`);
       }
     } catch (e) {
-      process.stdout.write(`Dev seed failed: ${e.message || String(e)}\n`);
+      fs.writeSync(process.stdout.fd, `Dev seed failed: ${e.message || String(e)}\n`);
     }
   }
 
-  process.stdout.write(`FREYA web running at ${url}\n`);
+  fs.writeSync(process.stdout.fd, `FREYA web running at ${url}\n`);
   if (open) openBrowser(url);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cccarv82/freya",
-  "version": "1.0.45",
+  "version": "1.0.49",
   "description": "Personal AI Assistant with local-first persistence",
   "scripts": {
     "health": "node scripts/validate-data.js",
@@ -24,6 +24,7 @@
   "files": [
     "bin",
     "cli",
+    "scripts",
     "templates",
     ".agent"
   ],

package/scripts/export-obsidian.js

@@ -0,0 +1,153 @@
+#!/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 });
+}
+
+function readJsonOrDefault(p, def) {
+  try {
+    if (!exists(p)) return def;
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return def;
+  }
+}
+
+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 blockersFile = path.join(workspaceDir, 'data', 'blockers', 'blocker-log.json');
+  const tasksFile = path.join(workspaceDir, 'data', 'tasks', 'task-log.json');
+
+  const blockersLog = readJsonOrDefault(blockersFile, { schemaVersion: 1, blockers: [] });
+  const tasksLog = readJsonOrDefault(tasksFile, { schemaVersion: 1, tasks: [] });
+
+  const blockers = Array.isArray(blockersLog.blockers) ? blockersLog.blockers : [];
+  const tasks = Array.isArray(tasksLog.tasks) ? tasksLog.tasks : [];
+
+  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 `data/tasks/task-log.json`',
+      ''
+    ].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();

package/scripts/generate-blockers-report.js

@@ -0,0 +1,215 @@
+const fs = require('fs');
+const path = require('path');
+
+const { toIsoDate, safeParseToMs, isWithinRange } = require('./lib/date-utils');
+
+const BLOCKERS_FILE = path.join(__dirname, '../data/blockers/blocker-log.json');
+const REPORT_DIR = path.join(__dirname, '../docs/reports');
+
+const SEVERITY_ORDER = {
+  CRITICAL: 0,
+  HIGH: 1,
+  MEDIUM: 2,
+  LOW: 3,
+};
+
+const RESOLVED_STATUSES = new Set(['RESOLVED', 'CLOSED', 'DONE', 'FIXED']);
+
+function normalizeStatus(blocker) {
+  const raw = blocker.status || blocker.state || blocker.currentStatus;
+  if (!raw) return 'UNKNOWN';
+  return String(raw).trim().toUpperCase();
+}
+
+function normalizeSeverity(blocker) {
+  const raw = blocker.severity || blocker.priority || blocker.level;
+  if (!raw) return 'UNSPECIFIED';
+  const value = String(raw).trim().toUpperCase();
+  if (value.includes('CRIT')) return 'CRITICAL';
+  if (value.includes('HIGH')) return 'HIGH';
+  if (value.includes('MED')) return 'MEDIUM';
+  if (value.includes('LOW')) return 'LOW';
+  return value;
+}
+
+function getCreatedAt(blocker) {
+  const candidates = [
+    blocker.createdAt,
+    blocker.created_at,
+    blocker.openedAt,
+    blocker.opened_at,
+    blocker.reportedAt,
+    blocker.reported_at,
+    blocker.date,
+    blocker.loggedAt,
+  ];
+  for (const value of candidates) {
+    const ms = safeParseToMs(value);
+    if (Number.isFinite(ms)) return ms;
+  }
+  return NaN;
+}
+
+function getResolvedAt(blocker) {
+  const candidates = [
+    blocker.resolvedAt,
+    blocker.resolved_at,
+    blocker.closedAt,
+    blocker.closed_at,
+    blocker.completedAt,
+  ];
+  for (const value of candidates) {
+    const ms = safeParseToMs(value);
+    if (Number.isFinite(ms)) return ms;
+  }
+  return NaN;
+}
+
+function isOpen(blocker) {
+  const status = normalizeStatus(blocker);
+  if (RESOLVED_STATUSES.has(status)) return false;
+  const resolvedAt = getResolvedAt(blocker);
+  return !Number.isFinite(resolvedAt);
+}
+
+function getBlockerTitle(blocker) {
+  return (
+    blocker.title ||
+    blocker.summary ||
+    blocker.description ||
+    blocker.content ||
+    blocker.text ||
+    'Untitled blocker'
+  );
+}
+
+function formatAgeDays(createdMs, nowMs) {
+  if (!Number.isFinite(createdMs)) return null;
+  const ageMs = Math.max(0, nowMs - createdMs);
+  return Math.floor(ageMs / (24 * 60 * 60 * 1000));
+}
+
+function ensureReportDir() {
+  if (!fs.existsSync(REPORT_DIR)) {
+    fs.mkdirSync(REPORT_DIR, { recursive: true });
+  }
+}
+
+function loadBlockers() {
+  if (!fs.existsSync(BLOCKERS_FILE)) {
+    return [];
+  }
+  try {
+    const raw = fs.readFileSync(BLOCKERS_FILE, 'utf8');
+    const data = JSON.parse(raw);
+    return Array.isArray(data.blockers) ? data.blockers : [];
+  } catch (err) {
+    console.error(`Error reading blockers file: ${err.message}`);
+    return [];
+  }
+}
+
+function generateReport() {
+  const now = new Date();
+  const nowMs = now.getTime();
+  const reportDate = toIsoDate(now);
+  const blockers = loadBlockers();
+
+  const statusCounts = new Map();
+  blockers.forEach(blocker => {
+    const status = normalizeStatus(blocker);
+    statusCounts.set(status, (statusCounts.get(status) || 0) + 1);
+  });
+
+  const openBlockers = blockers.filter(isOpen);
+  openBlockers.sort((a, b) => {
+    const severityA = normalizeSeverity(a);
+    const severityB = normalizeSeverity(b);
+    const rankA = SEVERITY_ORDER[severityA] ?? 99;
+    const rankB = SEVERITY_ORDER[severityB] ?? 99;
+    if (rankA !== rankB) return rankA - rankB;
+    const ageA = getCreatedAt(a);
+    const ageB = getCreatedAt(b);
+    const msA = Number.isFinite(ageA) ? ageA : Number.MAX_SAFE_INTEGER;
+    const msB = Number.isFinite(ageB) ? ageB : Number.MAX_SAFE_INTEGER;
+    return msA - msB;
+  });
+
+  const sevenDaysAgo = new Date(nowMs - 7 * 24 * 60 * 60 * 1000);
+  const resolvedRecent = blockers.filter(blocker => {
+    const resolvedAt = getResolvedAt(blocker);
+    if (!Number.isFinite(resolvedAt)) return false;
+    return isWithinRange(resolvedAt, sevenDaysAgo, now);
+  });
+  resolvedRecent.sort((a, b) => {
+    const msA = getResolvedAt(a);
+    const msB = getResolvedAt(b);
+    return msB - msA;
+  });
+
+  let report = `# Blockers Report - ${reportDate}\n\n`;
+  report += '## Summary\n';
+  report += `- Total blockers: ${blockers.length}\n`;
+  if (statusCounts.size === 0) {
+    report += '- Status counts: None\n\n';
+  } else {
+    report += '- Status counts:\n';
+    const statuses = Array.from(statusCounts.keys()).sort();
+    statuses.forEach(status => {
+      report += `  - ${status}: ${statusCounts.get(status)}\n`;
+    });
+    report += '\n';
+  }
+
+  report += '## Open Blockers\n';
+  if (openBlockers.length === 0) {
+    report += 'None.\n\n';
+  } else {
+    openBlockers.forEach(blocker => {
+      const title = getBlockerTitle(blocker);
+      const status = normalizeStatus(blocker);
+      const severity = normalizeSeverity(blocker);
+      const createdMs = getCreatedAt(blocker);
+      const createdDate = Number.isFinite(createdMs) ? toIsoDate(createdMs) : 'Unknown';
+      const ageDays = formatAgeDays(createdMs, nowMs);
+      const project = blocker.project || blocker.projectName || blocker.projectSlug;
+      const client = blocker.client || blocker.clientName || blocker.clientSlug;
+      const metaParts = [
+        `Status: ${status}`,
+        project ? `Project: ${project}` : null,
+        client ? `Client: ${client}` : null,
+        `Created: ${createdDate}`,
+        ageDays === null ? null : `Age: ${ageDays}d`,
+      ].filter(Boolean);
+      report += `- [${severity}] ${title} (${metaParts.join('; ')})\n`;
+    });
+    report += '\n';
+  }
+
+  report += '## Resolved Blockers (Last 7 Days)\n';
+  if (resolvedRecent.length === 0) {
+    report += 'None.\n';
+  } else {
+    resolvedRecent.forEach(blocker => {
+      const title = getBlockerTitle(blocker);
+      const severity = normalizeSeverity(blocker);
+      const resolvedMs = getResolvedAt(blocker);
+      const resolvedDate = Number.isFinite(resolvedMs) ? toIsoDate(resolvedMs) : 'Unknown';
+      const project = blocker.project || blocker.projectName || blocker.projectSlug;
+      const client = blocker.client || blocker.clientName || blocker.clientSlug;
+      const metaParts = [
+        project ? `Project: ${project}` : null,
+        client ? `Client: ${client}` : null,
+        `Resolved: ${resolvedDate}`,
+      ].filter(Boolean);
+      report += `- [${severity}] ${title} (${metaParts.join('; ')})\n`;
+    });
+  }
+
+  ensureReportDir();
+  const outputPath = path.join(REPORT_DIR, `blockers-${reportDate}.md`);
+  fs.writeFileSync(outputPath, report);
+  console.log(report);
+}
+
+generateReport();

package/scripts/generate-daily-summary.js

@@ -0,0 +1,107 @@
+const fs = require('fs');
+const path = require('path');
+
+const { safeParseToMs } = require('./lib/date-utils');
+const { safeReadJson, quarantineCorruptedFile } = require('./lib/fs-utils');
+
+const TASK_LOG_PATH = path.join(__dirname, '../data/tasks/task-log.json');
+const BLOCKERS_LOG_PATH = path.join(__dirname, '../data/blockers/blocker-log.json');
+const REPORT_DIR = path.join(__dirname, '../docs/reports');
+
+// --- Helper Logic ---
+const now = new Date();
+const oneDay = 24 * 60 * 60 * 1000;
+
+function isRecentlyCompleted(dateStr) {
+    const ms = safeParseToMs(dateStr);
+    if (!Number.isFinite(ms)) return false;
+    const diff = now.getTime() - ms;
+    // Consider "Yesterday" as anything completed in the last 24 hours for daily sync purposes
+    return diff >= 0 && diff <= oneDay;
+}
+
+function generateDailySummary() {
+    try {
+        if (!fs.existsSync(TASK_LOG_PATH)) {
+            console.log("**Ontem:** No task log found.\n**Hoje:** Set up task log.\n**Bloqueios:** None");
+            return;
+        }
+
+        const content = fs.readFileSync(TASK_LOG_PATH, 'utf8');
+        const json = JSON.parse(content);
+        
+        if (!json.tasks) {
+            console.log("**Ontem:** Invalid task log.\n**Hoje:** Fix task log.\n**Bloqueios:** None");
+            return;
+        }
+
+        let summary = "";
+
+        // 1. Ontem (Completed < 24h)
+        const completedRecently = json.tasks.filter(t => t.status === "COMPLETED" && isRecentlyCompleted(t.completedAt));
+        summary += "**Ontem:** ";
+        if (completedRecently.length > 0) {
+            summary += completedRecently.map(t => t.description).join(", ");
+        } else {
+            summary += "Nothing recorded";
+        }
+        summary += "\n";
+
+        // 2. Hoje (DO_NOW + PENDING)
+        const doNow = json.tasks.filter(t => t.status === "PENDING" && t.category === "DO_NOW");
+        summary += "**Hoje:** ";
+        if (doNow.length > 0) {
+            summary += doNow.map(t => t.description).join(", ");
+        } else {
+            summary += "Nothing planned";
+        }
+        summary += "\n";
+
+        // 3. Bloqueios (from blocker-log.json)
+        let blockersLine = "None";
+        if (fs.existsSync(BLOCKERS_LOG_PATH)) {
+            const res = safeReadJson(BLOCKERS_LOG_PATH);
+            if (!res.ok) {
+                if (res.error.type === 'parse') {
+                    quarantineCorruptedFile(BLOCKERS_LOG_PATH, res.error.message);
+                }
+            } else {
+                const blockers = (res.json.blockers || []).filter(b => {
+                    const st = (b.status || '').toUpperCase();
+                    return st === 'OPEN' || st === 'MITIGATING';
+                });
+                const sevOrder = { CRITICAL: 0, HIGH: 1, MEDIUM: 2, LOW: 3 };
+                blockers.sort((a, b) => {
+                    const sa = sevOrder[(a.severity || '').toUpperCase()] ?? 99;
+                    const sb = sevOrder[(b.severity || '').toUpperCase()] ?? 99;
+                    if (sa !== sb) return sa - sb;
+                    const ta = safeParseToMs(a.createdAt) || 0;
+                    const tb = safeParseToMs(b.createdAt) || 0;
+                    return ta - tb; // older first
+                });
+                if (blockers.length > 0) {
+                    blockersLine = blockers.slice(0, 3).map(b => b.title || b.description || b.id).join(", ");
+                }
+            }
+        }
+
+        summary += `**Bloqueios:** ${blockersLine}`;
+
+        console.log(summary);
+
+        // Write report file for UI (optional, but helps preview/history)
+        try {
+            fs.mkdirSync(REPORT_DIR, { recursive: true });
+            const date = new Date().toISOString().slice(0, 10);
+            const outPath = path.join(REPORT_DIR, `daily-${date}.md`);
+            fs.writeFileSync(outPath, `# Daily Summary — ${date}\n\n${summary}\n`, 'utf8');
+        } catch (e) {
+            // non-fatal
+        }
+
+    } catch (err) {
+        console.error("Error generating daily:", err.message);
+    }
+}
+
+generateDailySummary();