great-cto 2.77.0 → 2.77.1

package/board/packages/board/lib/share.mjs

@@ -0,0 +1,143 @@
+import fs from 'fs';
+import path from 'path';
+import { GREAT_CTO_DIR, PUBLIC, SHARE_ENDPOINT } from './config.mjs';
+import { readProjectMd } from './projects.mjs';
+import { getMetrics } from './metrics.mjs';
+import { getTasks } from './beads.mjs';
+import { readVerdicts } from './verdicts.mjs';
+import { readDecisionsLog } from './fleet.mjs';
+
+// ── Resume — what happened recently for this project ─────────────────────
+// Returns a compact bundle for the "Resume" inbox card:
+//   - last 3 verdicts (APPROVED / DONE / etc.)
+//   - open gates (already in inbox, but cheap to include for one-shot fetch)
+//   - 3 most-recent WIP tasks (in_progress, sorted by updated_at desc)
+//   - last 5 decisions from the global log filtered to this project
+function getResume(cwd = process.cwd()) {
+  const tasks = getTasks(cwd);
+  const verdicts = readVerdicts(cwd)
+    .filter(v => ['APPROVED','DONE','PASS','BLOCKED','FAIL','REJECTED'].includes((v.verdict || '').toUpperCase()))
+    .slice(-3)
+    .reverse();
+  const openGates = tasks
+    .filter(t => t.is_gate && t.raw_status !== 'closed' && t.raw_status !== 'blocked')
+    .slice(0, 5);
+  const wip = tasks
+    .filter(t => t.raw_status === 'in_progress' || t.status === 'in_progress')
+    .sort((a, b) => (b.updated_at || '').localeCompare(a.updated_at || ''))
+    .slice(0, 3);
+  const slug = path.basename(cwd);
+  const projectDecisions = readDecisionsLog(50)
+    .filter(d => d.project === slug || d.project === path.basename(cwd))
+    .slice(0, 5);
+  return {
+    recent_verdicts: verdicts,
+    open_gates: openGates,
+    wip_tasks: wip,
+    decisions: projectDecisions,
+  };
+}
+
+function shareStatePath(cwd = process.cwd()) {
+  // Use slug from PROJECT.md if available, else basename of cwd
+  const meta = readProjectMd(cwd);
+  const slug = meta?.slug || path.basename(cwd);
+  return path.join(GREAT_CTO_DIR, `share-${slug}.json`);
+}
+function getShareState(cwd = process.cwd()) {
+  const file = shareStatePath(cwd);
+  try { if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch {}
+  return { enabled: false, url: null, hash: null, published_at: null };
+}
+function saveShareState(state, cwd = process.cwd()) {
+  fs.mkdirSync(GREAT_CTO_DIR, { recursive: true });
+  fs.writeFileSync(shareStatePath(cwd), JSON.stringify(state, null, 2));
+}
+
+async function publishReport(html) {
+  // POST to Cloudflare Worker
+  const { default: https } = await import('https');
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ html, ttl: 2592000 }); // 30 days
+    const url = new URL(SHARE_ENDPOINT);
+    const req = https.request({
+      hostname: url.hostname, path: url.pathname,
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) }
+    }, res => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch { reject(new Error('Invalid response: ' + data)); }
+      });
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+async function toggleShare(enable, cwd = process.cwd(), force = false) {
+  const state = getShareState(cwd);
+  // (enable && !state.enabled) → first publish
+  // (enable && state.enabled && force) → re-publish with fresh data (new URL)
+  if (enable && (!state.enabled || force)) {
+    // Generate and publish
+    // Share report is a marketing artifact — show LIFETIME numbers, not a
+    // rolling window. 365 days × 100 = effectively-lifetime cap for any project.
+    const html = generateShareHTML(getTasks(cwd), getMetrics(cwd, 36500), cwd);
+    try {
+      const result = await publishReport(html);
+      const newState = { enabled: true, url: result.url, hash: result.hash, published_at: new Date().toISOString() };
+      saveShareState(newState, cwd);
+      return newState;
+    } catch (e) {
+      return { error: e.message };
+    }
+  } else if (!enable && state.enabled) {
+    const newState = { ...state, enabled: false };
+    saveShareState(newState, cwd);
+    // Tell Cloudflare worker to mark this hash as paused
+    if (state.hash) {
+      try {
+        const { default: https } = await import('https');
+        await new Promise((resolve) => {
+          const body = JSON.stringify({ enabled: false });
+          const req = https.request({
+            hostname: 'greatcto.systems', path: `/r/${state.hash}`,
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) }
+          }, res => { res.on('data', () => {}); res.on('end', resolve); });
+          req.on('error', resolve);
+          req.write(body); req.end();
+        });
+      } catch {}
+    }
+    return newState;
+  }
+  return state;
+}
+
+function generateShareHTML(tasks, metrics, cwd = process.cwd()) {
+  const meta = readProjectMd(cwd);
+  const projectName = meta?.slug || path.basename(cwd);
+  const date = new Date().toLocaleDateString('en-US', { month: 'long', year: 'numeric' });
+  const done = tasks.filter(t => t.status === 'done' || t.status === 'closed');
+  const shareTemplate = fs.readFileSync(path.join(PUBLIC, 'share.html'), 'utf8');
+  // Use replaceAll: placeholders appear multiple times (title + script var)
+  // BH-22: substitute {{PAUSED}} before publish. The worker can still flip
+  // the stored pause flag independently via POST /r/<hash> {enabled:false}
+  // from toggleShare, but the published HTML must be valid on its own —
+  // shipping `const paused = {{PAUSED}};` literal triggers a SyntaxError
+  // and blanks the entire report if the worker forgets to post-process.
+  return shareTemplate
+    .replaceAll('{{PROJECT}}', projectName)
+    .replaceAll('{{DATE}}', date)
+    .replaceAll('{{METRICS_JSON}}', JSON.stringify(metrics))
+    .replaceAll('{{TASKS_JSON}}', JSON.stringify(done.slice(-20)))
+    .replaceAll('{{PAUSED}}', 'false');
+}
+
+export { getResume, shareStatePath, getShareState, saveShareState, publishReport, toggleShare, generateShareHTML };

package/board/packages/board/lib/sse.mjs

@@ -0,0 +1,20 @@
+import { sseClients } from './state.mjs';
+import { getTasks } from './beads.mjs';
+
+function broadcast(event, data) {
+  const msg = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+  for (const res of sseClients) {
+    try { res.write(msg); } catch { sseClients.delete(res); }
+  }
+}
+
+function broadcastTasks(cwd) {
+  const msg = `event: tasks\ndata: ${JSON.stringify(getTasks(cwd))}\n\n`;
+  for (const res of sseClients) {
+    if (res._gctoCwd === cwd) {
+      try { res.write(msg); } catch { sseClients.delete(res); }
+    }
+  }
+}
+
+export { broadcast, broadcastTasks };

package/board/packages/board/lib/state.mjs

@@ -0,0 +1,31 @@
+// ── In-process mutable singletons ───────────────────────────────────────────
+// Rule: only this module holds mutable shared state. Every module that needs
+// sseClients, bdCache, or notification history imports from here — no
+// top-level shared state anywhere else.
+
+const sseClients = new Set();
+const _reportRepublishDedupeSet = new Set(); // dedupe daily report republish
+
+// ── In-app notification history ────────────────────────────────────────────────
+// Persisted to ~/.great_cto/notif-history.json. Capped at 100 entries.
+// Each entry: { id, event, title, body, level, project, ts, read }
+const MAX_NOTIF_HISTORY = 100;
+// NOTE: kept as a mutable array (not a `let` rebind) so importing modules can
+// replace its contents in place (`notifHistory.length = 0; notifHistory.push(...items)`)
+// — ESM live bindings do not allow an importer to reassign an imported `let`.
+let notifHistory = [];
+
+// ── Beads data ─────────────────────────────────────────────────────────────────
+// Cache bdList output per cwd for BD_CACHE_TTL_MS. Invalidated when the project's
+// .beads/interactions.jsonl changes (the file watcher in watchBeads() calls
+// bdCacheInvalidate(cwd) before broadcasting). This avoids spawning `bd list`
+// on every API call when 5+ projects are open in tabs.
+const bdCache = new Map(); // cwd → { ts, data }
+
+export {
+  sseClients,
+  _reportRepublishDedupeSet,
+  MAX_NOTIF_HISTORY,
+  notifHistory,
+  bdCache,
+};

package/board/packages/board/lib/util.mjs

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import { PORT } from './config.mjs';
+
+/**
+ * Escape a single value for inclusion in a CSV cell.
+ * Quotes the value if it contains comma / quote / newline.
+ */
+function csvCell(v) {
+  if (v == null) return '';
+  const s = typeof v === 'string' ? v : JSON.stringify(v);
+  if (/[",\n]/.test(s)) return '"' + s.replace(/"/g, '""') + '"';
+  return s;
+}
+
+// Only same-origin (the board's own page) may make a state-changing request — a malicious page must not.
+function originAllowed(req) {
+  const o = req.headers.origin || req.headers.referer || '';
+  if (!o) return true; // same-origin fetch / curl with no Origin
+  // True same-origin: the browser's Origin matches the host this request arrived on
+  // (covers a tunnelled/hosted console at console.client.com, http or https).
+  const self = req.headers.host ? [`http://${req.headers.host}`, `https://${req.headers.host}`] : [];
+  return [`http://localhost:${PORT}`, `http://127.0.0.1:${PORT}`, ...self].some((e) => o === e || o.startsWith(e + '/'));
+}
+
+// Which surface an alert belongs to. Operate-side events (autopilot runtime: dead-letters,
+// connector health, case SLA, gate/safe-mode pushes) are the operator console's concern and
+// must not clutter the builder board's notifications — the two surfaces are separated.
+function eventSurface(event) {
+  return /^(autopilot\.|dead-letter|connector\.|sla\.)/.test(String(event || '')) ? 'operate' : 'builder';
+}
+
+function readFileSafe(p) {
+  try { return fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : null; } catch { return null; }
+}
+
+export { csvCell, originAllowed, eventSurface, readFileSafe };

package/board/packages/board/lib/verdicts.mjs

@@ -0,0 +1,168 @@
+import fs from 'fs';
+import path from 'path';
+import { GREAT_CTO_DIR } from './config.mjs';
+
+function readVerdicts(cwd = null) {
+  // Verdict attribution model:
+  //   1. cwd given → read project-local <cwd>/.great_cto/verdicts/
+  //      PLUS any global verdict line tagged `project=<slug>` matching cwd
+  //   2. cwd absent (cron jobs, fleet view) → read ALL global verdicts
+  //
+  // Project slug resolution: PROJECT.md `slug:` field, else basename(cwd).
+  let projectSlug = null;
+  if (cwd) {
+    try {
+      const md = fs.readFileSync(path.join(cwd, '.great_cto', 'PROJECT.md'), 'utf8');
+      const m = md.match(/^slug:\s*(.+)$/m);
+      projectSlug = m ? m[1].trim() : path.basename(cwd);
+    } catch { projectSlug = path.basename(cwd); }
+  }
+  // First read project-local verdicts when scoped
+  const projectVerdictDir = cwd ? path.join(cwd, '.great_cto', 'verdicts') : null;
+  const useProjectDir = projectVerdictDir
+    && fs.existsSync(projectVerdictDir)
+    && fs.readdirSync(projectVerdictDir).filter(f => f.endsWith('.log')).length > 0;
+  // For cwd-scoped reads, we collect from BOTH local AND tagged global lines
+  const verdictDirs = [];
+  if (useProjectDir) verdictDirs.push(projectVerdictDir);
+  if (!cwd) {
+    // Unscoped: read everything global
+    verdictDirs.push(path.join(GREAT_CTO_DIR, 'verdicts'));
+  }
+  const results = [];
+  // For scoped reads, also iterate global and filter by project= tag
+  const globalDir = path.join(GREAT_CTO_DIR, 'verdicts');
+  if (cwd && projectSlug && fs.existsSync(globalDir)) {
+    verdictDirs.push({ dir: globalDir, filterByProjectTag: projectSlug });
+  }
+  for (const entry of verdictDirs) {
+    const verdictDir = typeof entry === 'string' ? entry : entry.dir;
+    const projectTagFilter = typeof entry === 'string' ? null : entry.filterByProjectTag;
+    if (!fs.existsSync(verdictDir)) continue;
+    for (const file of fs.readdirSync(verdictDir)) {
+    const agent = file.replace('.log', '');
+    const lines = fs.readFileSync(path.join(verdictDir, file), 'utf8')
+      .split('\n').filter(Boolean);
+    for (const line of lines) {
+      // When reading global with a project filter, only include lines tagged
+      // with this project's slug.
+      if (projectTagFilter) {
+        const tagMatch = line.match(/\bproject=([^\s|]+)/);
+        if (!tagMatch || tagMatch[1] !== projectTagFilter) continue;
+      }
+      // Two formats agents emit in the wild:
+      //   space-separated:  "<ts> <verdict> <details> cost=$X"
+      //   pipe-separated:   "<ts> | <agent> | <verdict> | <details> | cost=$X"
+      // Pre-2026-05: parts[1] always took the 2nd whitespace token, which
+      // for the pipe form is "|", breaking /api/pipeline status mapping
+      // (verdicts displayed as "|" instead of APPROVED/DONE/BLOCKED).
+      // Now we detect the pipe form and parse it differently.
+      let ts, verdict;
+      if (line.includes(' | ')) {
+        const pipeParts = line.split('|').map(s => s.trim());
+        ts = pipeParts[0].trim();
+        // Pipe form: [ts, agent, verdict, details, cost]
+        // Verdict is at index 2 (after ts and agent name).
+        verdict = pipeParts[2] || '';
+      } else {
+        const parts = line.split(' ');
+        ts = parts[0];
+        verdict = parts[1] || '';
+      }
+      const costMatch = line.match(/\bcost=\$?(\d+\.?\d*)\b/i);
+      results.push({
+        ts,
+        agent,
+        verdict,
+        cost_usd: costMatch ? parseFloat(costMatch[1]) : null,
+        raw: line.replace(/\s*\bcost=\$?\d+\.?\d*\b/i, ''),
+      });
+    }
+  }
+  }  // end verdictDirs loop
+
+  // Fallback: enrich verdicts that lack cost_usd from .great_cto/cost-history.log.
+  // Format: "<ISO-ts> <agent> <cost_usd>" per line (written by scripts/log-verdict.sh).
+  // Match by ts (minute precision) + agent to avoid double-counting.
+  const histPath = path.join(GREAT_CTO_DIR, 'cost-history.log');
+  if (fs.existsSync(histPath)) {
+    const costByKey = new Map();
+    const lines = fs.readFileSync(histPath, 'utf8').split('\n').filter(Boolean);
+    for (const line of lines) {
+      const m = line.match(/^(\S+)\s+(\S+)\s+(\d+\.?\d*)/);
+      if (!m) continue;
+      const key = `${m[1].slice(0, 16)}|${m[2]}`;  // minute + agent
+      costByKey.set(key, parseFloat(m[3]));
+    }
+    for (const v of results) {
+      if (v.cost_usd != null) continue;
+      const key = `${(v.ts || '').slice(0, 16)}|${v.agent}`;
+      if (costByKey.has(key)) v.cost_usd = costByKey.get(key);
+    }
+  }
+
+  return results.sort((a, b) => a.ts.localeCompare(b.ts));
+}
+
+function readPlanCosts(cwd = process.cwd(), sinceMsAgo = null) {
+  const plansDir = path.join(cwd, 'docs/plans');
+  let totalLlmMin = 0, totalLlmUsd = 0, totalHumanUsd = 0, count = 0;
+  if (!fs.existsSync(plansDir)) return { llm_usd: 0, human_usd: 0, savings_x: 0, count: 0 };
+  const cutoff = sinceMsAgo != null ? Date.now() - sinceMsAgo : null;
+  for (const file of fs.readdirSync(plansDir).filter(f => f.endsWith('.md'))) {
+    const fp = path.join(plansDir, file);
+    // Skip plans outside the requested time window (use file mtime, same as
+    // getCostHistory — fixes BH-26 where readPlanCosts had no date filter and
+    // included all-time plans while getCostHistory only looked at the window).
+    if (cutoff != null && fs.statSync(fp).mtimeMs < cutoff) continue;
+    const content = fs.readFileSync(fp, 'utf8');
+    // Parse cost lines from PLAN-*.md.
+    // Use the SAME anchored regex as getCostHistory() so both endpoints agree
+    // on what constitutes a valid LLM/Human line. The old regex required a
+    // range ("0.5 – $2.30") and silently returned 0 for single-value plans
+    // ("LLM: ~$0.30"), causing /api/metrics to fall back to task-estimate and
+    // show a different number than /api/cost (BH-26: metrics ≠ cost tile).
+    const llmMatch   = content.match(/^[\s*_>\-]*LLM[^\n]*?\$(\d+\.?\d*)/im);
+    const humanMatch = content.match(/^[\s*_>\-]*Human[^\n]*?\$(\d[\d,]*\.?\d*)/im);
+    if (llmMatch) totalLlmUsd += parseFloat(llmMatch[1]);
+    // BH-25: /g — replace() with a string only strips the FIRST comma, so
+    // "$1,234,567" was silently truncated to 1234. getCostHistory at :413
+    // already uses /,/g; this was the divergent twin.
+    if (humanMatch) totalHumanUsd += parseFloat(humanMatch[1].replace(/,/g, ''));
+    count++;
+  }
+  return {
+    llm_usd: Math.round(totalLlmUsd * 100) / 100,
+    human_usd: Math.round(totalHumanUsd),
+    savings_x: totalLlmUsd > 0 ? Math.round(totalHumanUsd / totalLlmUsd) : 0,
+    count,
+  };
+}
+
+function readQAStats(cwd = process.cwd()) {
+  const qaDir = path.join(cwd, 'docs/qa-reports');
+  let passed = 0, failed = 0;
+  if (!fs.existsSync(qaDir)) return { pass_rate: null, passed: 0, failed: 0 };
+  for (const file of fs.readdirSync(qaDir).filter(f => f.endsWith('.md'))) {
+    const content = fs.readFileSync(path.join(qaDir, file), 'utf8');
+    // Accept any of:  "verdict: pass" / "**Verdict:** PASS" / "Status: PASSED" / "✅ pass" / "result: ✓"
+    if (/(?:verdict|status|result)\s*[:=]?\s*[*_`]*\s*(?:✅|✓|pass(?:ed)?)/i.test(content)) passed++;
+    else if (/(?:verdict|status|result)\s*[:=]?\s*[*_`]*\s*(?:❌|✗|fail(?:ed)?|block(?:ed)?)/i.test(content)) failed++;
+  }
+  const total = passed + failed;
+  return { pass_rate: total ? Math.round((passed / total) * 100) : null, passed, failed };
+}
+
+function readSecStats(cwd = process.cwd()) {
+  const secDir = path.join(cwd, 'docs/security');
+  let approved = 0, blocked = 0;
+  if (!fs.existsSync(secDir)) return { approved: 0, blocked: 0 };
+  for (const file of fs.readdirSync(secDir).filter(f => f.endsWith('.md'))) {
+    const content = fs.readFileSync(path.join(secDir, file), 'utf8');
+    if (/APPROVED/i.test(content)) approved++;
+    if (/BLOCKED/i.test(content)) blocked++;
+  }
+  return { approved, blocked };
+}
+
+export { readVerdicts, readPlanCosts, readQAStats, readSecStats };

package/board/packages/board/lib/watchers.mjs

@@ -0,0 +1,87 @@
+import fs from 'fs';
+import path from 'path';
+import { GREAT_CTO_DIR } from './config.mjs';
+import { sseClients } from './state.mjs';
+import { listProjects } from './projects.mjs';
+import { bdCacheInvalidate, getTasks } from './beads.mjs';
+import { getPipeline, getInbox } from './data-readers.mjs';
+
+// ── File watcher ───────────────────────────────────────────────────────────────
+function watchBeads() {
+  // Watch every registered project's beads files.
+  // Note: bd create only writes to dolt DB, NOT interactions.jsonl. So we must
+  // watch BOTH: (a) interactions.jsonl for status/priority changes (from bd
+  // update/close), and (b) the dolt manifest/journal for new-issue detection.
+  const projects = listProjects();
+  const dirs = projects.map(p => p.path);
+  if (!dirs.includes(process.cwd())) dirs.push(process.cwd());
+
+  const broadcast = (dir) => {
+    bdCacheInvalidate(dir);
+    for (const res of sseClients) {
+      if (res._gctoCwd === dir) {
+        try {
+          res.write(`event: tasks\ndata: ${JSON.stringify(getTasks(dir))}\n\n`);
+          res.write(`event: pipeline\ndata: ${JSON.stringify(getPipeline(dir))}\n\n`);
+          res.write(`event: inbox\ndata: ${JSON.stringify(getInbox(dir))}\n\n`);
+        } catch {}
+      }
+    }
+  };
+
+  // Debounce per-dir: dolt writes can fire 3-5 events in <50ms during a single
+  // bd command. Collapse them into one broadcast 200ms after the last event.
+  const debouncers = new Map();
+  const schedule = (dir) => {
+    if (debouncers.has(dir)) clearTimeout(debouncers.get(dir));
+    debouncers.set(dir, setTimeout(() => {
+      debouncers.delete(dir);
+      broadcast(dir);
+    }, 200));
+  };
+
+  for (const dir of dirs) {
+    // (a) interactions.jsonl — captures bd update/close
+    const interactionsFile = path.join(dir, '.beads', 'interactions.jsonl');
+    if (fs.existsSync(interactionsFile)) {
+      try { fs.watch(interactionsFile, () => schedule(dir)); } catch {}
+    }
+    // (b) dolt embeddeddolt directory (recursive) — captures bd create
+    const doltDir = path.join(dir, '.beads', 'embeddeddolt');
+    if (fs.existsSync(doltDir)) {
+      try { fs.watch(doltDir, { recursive: true }, () => schedule(dir)); } catch {}
+    }
+  }
+}
+
+// Watch ~/.great_cto/verdicts/ — push pipeline updates whenever an agent
+// emits a verdict (any project gets the broadcast for its own cwd).
+function watchVerdicts() {
+  const verdictDir = path.join(GREAT_CTO_DIR, 'verdicts');
+  if (!fs.existsSync(verdictDir)) {
+    try { fs.mkdirSync(verdictDir, { recursive: true }); } catch { return; }
+  }
+  let pushTimer = null;
+  const broadcastPipeline = () => {
+    if (pushTimer) clearTimeout(pushTimer);
+    // debounce: collapse a burst of writes (multiple agents finishing within ~150ms)
+    pushTimer = setTimeout(() => {
+      for (const res of sseClients) {
+        const dir = res._gctoCwd || process.cwd();
+        try {
+          res.write(`event: pipeline\ndata: ${JSON.stringify(getPipeline(dir))}\n\n`);
+          res.write(`event: inbox\ndata: ${JSON.stringify(getInbox(dir))}\n\n`);
+        } catch { sseClients.delete(res); }
+      }
+    }, 150);
+  };
+  try {
+    fs.watch(verdictDir, () => broadcastPipeline());
+    // Also watch each existing log file (some agents append to existing)
+    for (const f of fs.readdirSync(verdictDir).filter(x => x.endsWith('.log'))) {
+      try { fs.watch(path.join(verdictDir, f), () => broadcastPipeline()); } catch {}
+    }
+  } catch {}
+}
+
+export { watchBeads, watchVerdicts };