create-battle-plan 1.1.2 → 1.3.0

package/template/tools/tasks/flush-today.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+// tools/tasks/flush-today.js — reconciles docs/today.md checkbox edits back into tasks.yml.
+// Archives the processed file to docs/today-archive/YYYY-MM-DD.md.
+//
+// Recognized checkbox states (Obsidian Tasks plugin conventions):
+//   [ ]   open
+//   [x]   done
+//   [X]   done (case-insensitive)
+//   [-]   cancelled
+//   [/]   in-progress (treated as open; surfaces to today section)
+//
+// Tolerated inline metadata (emitted by Obsidian Tasks plugin):
+//   ✅ YYYY-MM-DD  -> done date (overrides today)
+//   📅 YYYY-MM-DD  -> due date (updates if changed)
+//   🛫 YYYY-MM-DD  -> snooze-until (sets status=snoozed)
+//   ⏫ / 🔼 / 🔽    -> priority (updates if changed)
+
+const fs = require('fs');
+const path = require('path');
+const tasks = require('./lib/tasks');
+
+const ROOT = path.resolve(__dirname, '../..');
+const TODAY_MD = path.join(ROOT, 'docs/today.md');
+const ARCHIVE_DIR = path.join(ROOT, 'docs/today-archive');
+
+if (!fs.existsSync(TODAY_MD)) {
+  console.error(`No ${path.relative(ROOT, TODAY_MD)} to flush. Run render-today.js first.`);
+  process.exit(1);
+}
+
+const text = fs.readFileSync(TODAY_MD, 'utf8');
+const lines = text.split('\n');
+
+const state = tasks.load();
+const byId = new Map(state.tasks.map(t => [t.id, t]));
+
+const LINE_RE = /^\s*-\s+\[([ xX\-/])\]\s+TASK-(\d+)\b/;
+const DUE_RE = /📅\s*(\d{4}-\d{2}-\d{2})/;
+const DONE_RE = /✅\s*(\d{4}-\d{2}-\d{2})/;
+const SNOOZE_RE = /🛫\s*(\d{4}-\d{2}-\d{2})/;
+
+function mapCheckbox(ch) {
+  if (ch === ' ') return 'open';
+  if (ch === 'x' || ch === 'X') return 'done';
+  if (ch === '-') return 'cancelled';
+  if (ch === '/') return 'in_progress';
+  return 'open';
+}
+
+let changed = 0;
+const changeLog = [];
+
+for (const line of lines) {
+  const m = line.match(LINE_RE);
+  if (!m) continue;
+  const state_ch = m[1];
+  const id = parseInt(m[2], 10);
+  const task = byId.get(id);
+  if (!task) {
+    console.warn(`⚠️  TASK-${id} in today.md not found in tasks.yml — skipping`);
+    continue;
+  }
+
+  const newStatus = mapCheckbox(state_ch);
+  const dueMatch = line.match(DUE_RE);
+  const doneMatch = line.match(DONE_RE);
+  const snoozeMatch = line.match(SNOOZE_RE);
+
+  const prevStatus = task.status;
+  const patch = {};
+
+  if (snoozeMatch) {
+    patch.status = 'snoozed';
+    patch.snoozed_until = snoozeMatch[1];
+  } else if (newStatus === 'done') {
+    patch.status = 'done';
+    patch.done_at = doneMatch ? doneMatch[1] : tasks.today();
+  } else if (newStatus === 'cancelled') {
+    patch.status = 'cancelled';
+    patch.done_at = doneMatch ? doneMatch[1] : tasks.today();
+  } else {
+    // newStatus is 'open' or 'in_progress'. Resurrect terminal-state tasks and
+    // honor open ↔ in_progress transitions.
+    if (prevStatus === 'done' || prevStatus === 'cancelled' || prevStatus === 'snoozed') {
+      patch.status = newStatus;
+      patch.done_at = null;
+      patch.snoozed_until = null;
+    } else if (prevStatus !== newStatus) {
+      patch.status = newStatus;
+    }
+  }
+
+  if (dueMatch && dueMatch[1] !== task.due) {
+    patch.due = dueMatch[1];
+  }
+
+  let thisChanged = false;
+  for (const k of Object.keys(patch)) {
+    if (task[k] !== patch[k]) {
+      task[k] = patch[k];
+      thisChanged = true;
+    }
+  }
+
+  if (thisChanged) {
+    changed++;
+    changeLog.push(`  TASK-${id} ${prevStatus} → ${task.status}${task.done_at ? ' (' + task.done_at + ')' : ''} · ${task.title}`);
+  }
+}
+
+if (changed === 0) {
+  console.log('No checkbox changes to flush.');
+  process.exit(0);
+}
+
+tasks.save(state);
+
+if (!fs.existsSync(ARCHIVE_DIR)) fs.mkdirSync(ARCHIVE_DIR, { recursive: true });
+const archivePath = path.join(ARCHIVE_DIR, `${tasks.today()}.md`);
+fs.copyFileSync(TODAY_MD, archivePath);
+
+console.log(`✓ Flushed ${changed} change(s) to tasks.yml`);
+for (const entry of changeLog) console.log(entry);
+console.log(`✓ Archived today.md → ${path.relative(ROOT, archivePath)}`);
+console.log('');
+console.log('Run `node tools/tasks/render-today.js` to regenerate docs/today.md.');

package/template/tools/tasks/lib/tasks.js

@@ -0,0 +1,177 @@
+const fs = require('fs');
+const path = require('path');
+
+const TASKS_PATH = path.resolve(__dirname, '../../../tasks.yml');
+
+const VALID_STATUS = new Set(['open', 'done', 'cancelled', 'snoozed', 'in_progress']);
+const VALID_PRIORITY = new Set([1, 2, 3]);
+
+// Default lane vocabulary. Adapt this to your project — lanes group tasks by
+// primary action, not topic. Update the LANE_KEYWORDS table in
+// tools/tasks/migrate-lanes.js if you change this set.
+const VALID_LANES = new Set(['build', 'outreach', 'discovery', 'infra', 'fundraising', 'meta']);
+
+// Minimal YAML reader/writer for our constrained schema.
+// Schema:
+//   last_updated: YYYY-MM-DD
+//   next_id: N
+//   last_triage_at: YYYY-MM-DD          # optional — set by /weekly-triage to suppress SessionStart nudge
+//   tasks:
+//     - id: N
+//       created: YYYY-MM-DD
+//       due: YYYY-MM-DD | null
+//       status: open|done|cancelled|snoozed|in_progress
+//       priority: 1|2|3
+//       lane: build|outreach|discovery|infra|fundraising|meta
+//       tags: [a, b]
+//       title: "..."
+//       context: "..."
+//       done_at: YYYY-MM-DD | null
+//       snoozed_until: YYYY-MM-DD | null
+//       implications: [docs/path-a.md, docs/path-b.md]   # optional — docs that should change when this task closes
+//       blocked_by: [TASK-IDs]                             # optional — task IDs that must close before this one is actionable
+
+const FIELD_ORDER = [
+  'id', 'created', 'due', 'status', 'priority', 'lane', 'tags',
+  'title', 'context', 'done_at', 'snoozed_until', 'implications', 'blocked_by'
+];
+
+function today() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function parseScalar(raw) {
+  const s = raw.trim();
+  if (s === '' || s === 'null' || s === '~') return null;
+  if (s === 'true') return true;
+  if (s === 'false') return false;
+  if (/^-?\d+$/.test(s)) return parseInt(s, 10);
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+  }
+  if (s.startsWith('[') && s.endsWith(']')) {
+    const inner = s.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(',').map(x => parseScalar(x.trim()));
+  }
+  return s;
+}
+
+function serializeScalar(v) {
+  if (v === null || v === undefined) return 'null';
+  if (typeof v === 'number' || typeof v === 'boolean') return String(v);
+  if (Array.isArray(v)) {
+    if (v.length === 0) return '[]';
+    // Preserve number/boolean primitives so int-arrays (e.g. blocked_by) don't
+    // get re-quoted as strings on round-trip.
+    return '[' + v.map(x => (typeof x === 'number' || typeof x === 'boolean') ? String(x) : serializeString(x)).join(', ') + ']';
+  }
+  return serializeString(v);
+}
+
+function serializeString(s) {
+  s = String(s);
+  if (s === '' || /^(null|true|false|~)$/.test(s) || /^-?\d+$/.test(s)) {
+    return '"' + s.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+  }
+  if (/[:#\[\]{},&*!|>'"%@`\n]|^[\s-?]/.test(s)) {
+    return '"' + s.replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+  }
+  return s;
+}
+
+function load() {
+  if (!fs.existsSync(TASKS_PATH)) {
+    return { last_updated: today(), next_id: 1, tasks: [] };
+  }
+  const text = fs.readFileSync(TASKS_PATH, 'utf8');
+  const lines = text.split('\n');
+
+  const result = { last_updated: today(), next_id: 1, tasks: [] };
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (/^\s*#/.test(line) || line.trim() === '') { i++; continue; }
+    if (/^tasks\s*:\s*$/.test(line)) { i++; break; }
+    const m = line.match(/^(\w+)\s*:\s*(.*)$/);
+    if (m) {
+      result[m[1]] = parseScalar(m[2]);
+    }
+    i++;
+  }
+
+  let cur = null;
+  for (; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*#/.test(line) || line.trim() === '') continue;
+    const listItem = line.match(/^\s*-\s+(\w+)\s*:\s*(.*)$/);
+    if (listItem) {
+      if (cur) result.tasks.push(cur);
+      cur = {};
+      cur[listItem[1]] = parseScalar(listItem[2]);
+      continue;
+    }
+    const field = line.match(/^\s+(\w+)\s*:\s*(.*)$/);
+    if (field && cur) {
+      cur[field[1]] = parseScalar(field[2]);
+    }
+  }
+  if (cur) result.tasks.push(cur);
+
+  result.next_id = typeof result.next_id === 'number' ? result.next_id : parseInt(result.next_id, 10) || 1;
+  result.tasks.forEach(t => {
+    if (typeof t.id === 'string') t.id = parseInt(t.id, 10);
+    if (typeof t.priority === 'string') t.priority = parseInt(t.priority, 10);
+    if (!Array.isArray(t.tags)) t.tags = t.tags ? [t.tags] : [];
+  });
+  return result;
+}
+
+function save(state) {
+  state.last_updated = today();
+  const maxId = state.tasks.reduce((m, t) => Math.max(m, t.id || 0), 0);
+  if (state.next_id <= maxId) state.next_id = maxId + 1;
+
+  const out = [];
+  out.push('# tasks.yml — structured task log. Source of truth for docs/today.md.');
+  out.push('# Never hand-edit while today.md has unflushed checkbox changes — flush first.');
+  out.push(`last_updated: ${state.last_updated}`);
+  out.push(`next_id: ${state.next_id}`);
+  if (state.last_triage_at) out.push(`last_triage_at: ${state.last_triage_at}`);
+  out.push('tasks:');
+  for (const t of state.tasks) {
+    let first = true;
+    for (const k of FIELD_ORDER) {
+      if (!(k in t)) continue;
+      const prefix = first ? '  - ' : '    ';
+      out.push(`${prefix}${k}: ${serializeScalar(t[k])}`);
+      first = false;
+    }
+    if (first) continue;
+  }
+  fs.writeFileSync(TASKS_PATH, out.join('\n') + '\n');
+}
+
+function nextId(state) {
+  const id = state.next_id;
+  state.next_id = id + 1;
+  return id;
+}
+
+function resolveSnoozed(state) {
+  const t = today();
+  let changed = 0;
+  for (const task of state.tasks) {
+    if (task.status === 'snoozed' && task.snoozed_until && task.snoozed_until <= t) {
+      task.status = 'open';
+      task.snoozed_until = null;
+      changed++;
+    }
+  }
+  return changed;
+}
+
+module.exports = {
+  TASKS_PATH, VALID_STATUS, VALID_PRIORITY, VALID_LANES, FIELD_ORDER,
+  today, load, save, nextId, resolveSnoozed
+};

package/template/tools/tasks/migrate-lanes.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+// tools/tasks/migrate-lanes.js — one-shot heuristic backfill of `lane` field.
+// Idempotent: skips tasks that already have a valid lane.
+//
+// Usage:
+//   node tools/tasks/migrate-lanes.js          # apply heuristic, write tasks.yml
+//   node tools/tasks/migrate-lanes.js --dry    # show classifications, write nothing
+//
+// Heuristic is intentionally generic. ADAPT the LANE_KEYWORDS table below to
+// your project's vocabulary. Two-pass design: tags first (curated, high
+// signal-to-noise), then title (less curated). Context is NEVER consulted —
+// it often contains incidental words that contaminate classification.
+//
+// Tasks that match no keyword bucket fall back to `meta`. Re-run anytime —
+// already-laned tasks stay put.
+
+const tasks = require('./lib/tasks');
+
+// Adapt these keyword buckets to your project. Lane order matters when a task
+// matches multiple — the first lane in this object wins.
+const LANE_KEYWORDS = {
+  build: [
+    'mvp', 'demo', 'arch', 'architecture', 'integrations', 'product',
+    'feature', 'build', 'ship', 'design', 'frontend', 'backend', 'api', 'ui'
+  ],
+  outreach: [
+    'outreach', 'blitz', 'cold-email', 'cold-dm', 'linkedin', 'template',
+    'cadence', 'pitch-copy', 'content', 'post', 'campaign', 'sequence'
+  ],
+  discovery: [
+    'warm', 'warm-intro', 'intro', 'intros', 'discovery', 'door-opener',
+    'follow-up', 'lead', 'customer', 'prospect', 'champion'
+  ],
+  infra: [
+    'infra', 'gcp', 'aws', 'dns', 'domain', 'ci', 'deploy', 'env',
+    'secrets', 'database', 'monitoring', 'logging'
+  ],
+  fundraising: [
+    'fundraising', 'investor', 'vc', 'angel', 'pitch', 'fund',
+    'accelerator', 'yc', 'spc', 'demo-day'
+  ]
+};
+
+const argv = process.argv.slice(2);
+const dryRun = argv.includes('--dry');
+
+function matchLane(needle) {
+  if (!needle) return null;
+  const lower = needle.toLowerCase();
+  for (const [lane, keywords] of Object.entries(LANE_KEYWORDS)) {
+    for (const kw of keywords) {
+      const re = new RegExp('\\b' + kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '\\b', 'i');
+      if (re.test(lower)) return lane;
+    }
+  }
+  return null;
+}
+
+function classify(task) {
+  if (task.lane && tasks.VALID_LANES.has(task.lane)) return { lane: task.lane, source: 'preserved' };
+  // Pass 1: tags (curated, high signal).
+  const tagsNeedle = (Array.isArray(task.tags) ? task.tags : []).join(' ');
+  const fromTags = matchLane(tagsNeedle);
+  if (fromTags) return { lane: fromTags, source: 'tags' };
+  // Pass 2: title (less curated).
+  const fromTitle = matchLane(task.title || '');
+  if (fromTitle) return { lane: fromTitle, source: 'title' };
+  return { lane: 'meta', source: 'fallback' };
+}
+
+const state = tasks.load();
+let changed = 0;
+let kept = 0;
+const summary = { tags: 0, title: 0, fallback: 0, preserved: 0 };
+
+for (const t of state.tasks) {
+  const { lane, source } = classify(t);
+  summary[source]++;
+  if (source === 'preserved') {
+    kept++;
+    continue;
+  }
+  if (t.lane !== lane) {
+    if (!dryRun) t.lane = lane;
+    changed++;
+    if (dryRun) {
+      console.log(`[dry] TASK-${t.id} → ${lane} (via ${source}): ${t.title}`);
+    }
+  }
+}
+
+if (!dryRun && changed > 0) tasks.save(state);
+
+console.log('');
+console.log(`Migration ${dryRun ? '(dry-run) ' : ''}complete.`);
+console.log(`  Preserved (already laned): ${kept}`);
+console.log(`  Classified via tags:       ${summary.tags}`);
+console.log(`  Classified via title:      ${summary.title}`);
+console.log(`  Fell back to meta:         ${summary.fallback}`);
+console.log(`  Total updated:             ${changed}`);
+if (dryRun) {
+  console.log('');
+  console.log('Re-run without --dry to apply.');
+}

package/template/tools/tasks/render-today.js

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+// tools/tasks/render-today.js — generates docs/today.md from tasks.yml (+ metrics.yml + optional outreach).
+// Idempotent. Safe to run multiple times per day.
+// Flags: --all (include full backlog instead of first 5), --quiet
+
+const fs = require('fs');
+const path = require('path');
+const tasks = require('./lib/tasks');
+
+const ROOT = path.resolve(__dirname, '../..');
+const TODAY_MD = path.join(ROOT, 'docs/today.md');
+const METRICS_YML = path.join(ROOT, 'metrics.yml');
+
+const args = process.argv.slice(2);
+const showAll = args.includes('--all');
+const quiet = args.includes('--quiet');
+
+function readMetrics() {
+  if (!fs.existsSync(METRICS_YML)) return {};
+  const text = fs.readFileSync(METRICS_YML, 'utf8');
+  const out = {};
+  for (const line of text.split('\n')) {
+    const m = line.match(/^(\w+)\s*:\s*(.+?)\s*(#.*)?$/);
+    if (m) {
+      const v = m[2].trim().replace(/^["']|["']$/g, '');
+      out[m[1]] = /^-?\d+$/.test(v) ? parseInt(v, 10) : v;
+    }
+  }
+  return out;
+}
+
+function readLeadsLight() {
+  // Optional — only available when the outreach add-on is installed.
+  const leadsCsv = path.join(ROOT, 'outreach/leads.csv');
+  const leadsLib = path.join(ROOT, 'tools/outreach/lib/leads.js');
+  if (!fs.existsSync(leadsCsv) || !fs.existsSync(leadsLib)) return [];
+  try {
+    const leads = require(leadsLib);
+    return leads.load();
+  } catch (e) {
+    return [];
+  }
+}
+
+function todayStr() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function weekdayName(date) {
+  return ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'][date.getDay()];
+}
+
+function priorityEmoji(p) {
+  if (p === 1) return '⏫';
+  if (p === 2) return '🔼';
+  if (p === 3) return '🔽';
+  return '';
+}
+
+// Lane vocabulary (mirrors VALID_LANES in lib/tasks.js). Drives display order
+// in today.md and the human-readable label per lane group. Adapt to your project.
+const LANE_DISPLAY = {
+  build: 'Build',
+  outreach: 'Outreach',
+  discovery: 'Discovery',
+  infra: 'Infra',
+  fundraising: 'Fundraising',
+  meta: 'Meta'
+};
+const LANE_ORDER = ['build', 'outreach', 'discovery', 'infra', 'fundraising', 'meta'];
+const PRIORITY_HEADERS = {
+  1: '### ⏫ Today (P1)',
+  2: '### 🔼 This week (P2)',
+  3: '### 🔽 Backlog (P3)'
+};
+
+function renderTaskLine(t, openIds) {
+  const parts = [];
+  const box = t.status === 'in_progress' ? '/' : ' ';
+  parts.push(`- [${box}] TASK-${t.id} ${t.title}`);
+  if (t.due) parts.push(`📅 ${t.due}`);
+  const pe = priorityEmoji(t.priority);
+  if (pe) parts.push(pe);
+  // Nested hashtag — Obsidian Tasks plugin treats this as a filterable lane group.
+  if (t.lane) parts.push(`#lane/${t.lane}`);
+  // Surface still-open blockers only — once the blocker closes, the token disappears
+  // from the daily surface. flush-today.js ignores this token (LINE_RE matches checkbox + TASK-N).
+  if (Array.isArray(t.blocked_by) && t.blocked_by.length) {
+    const stillOpen = openIds ? t.blocked_by.filter(id => openIds.has(id)) : t.blocked_by;
+    if (stillOpen.length) {
+      parts.push(`🚧 blocked-by:TASK-${stillOpen.join(',TASK-')}`);
+    }
+  }
+  if (Array.isArray(t.tags) && t.tags.length) {
+    parts.push(t.tags.map(x => '#' + x).join(' '));
+  }
+  return parts.join(' ');
+}
+
+function buildCallsSection(leads) {
+  const today = todayStr();
+  const calls = leads.filter(r => r.call_at && r.call_at.startsWith(today) && ['call_booked', 'replied'].includes(r.status));
+  if (calls.length === 0) return null;
+  const lines = ['## Calls & meetings'];
+  for (const c of calls) {
+    const name = [c.first_name, c.last_name].filter(Boolean).join(' ') || '(unnamed)';
+    const time = c.call_at.slice(11, 16) || 'TBD';
+    const note = c.title ? ` (${c.title})` : '';
+    lines.push(`- ${time} — ${name} / ${c.company}${note}`);
+  }
+  return lines.join('\n');
+}
+
+function buildPulseSection(leads, metrics) {
+  if (!leads.length && !Object.keys(metrics).length) return null;
+  const lines = ['## Pulse'];
+  if (leads.length) {
+    const pipeline = leads.filter(r => ['replied', 'call_booked', 'call_done', 'verbal', 'loi'].includes(r.status));
+    const by = s => pipeline.filter(r => r.status === s).length;
+    lines.push(`- Active: ${pipeline.length} (${by('call_booked')} call_booked · ${by('call_done')} call_done · ${by('verbal')} verbal · ${by('replied')} replied)`);
+  }
+  if (metrics.outreach_sent !== undefined) {
+    lines.push(`- Total sent: ${metrics.outreach_sent}${metrics.connections_sent !== undefined ? ` (${metrics.connections_sent} conn + ${metrics.inmails_sent} inmail)` : ''} · ${metrics.responses || 0} replies · ${metrics.discovery_calls || 0} calls · ${metrics.verbal_commitments || 0} verbal`);
+  }
+  if (leads.length) {
+    const warm = leads.filter(r => r.status === 'replied' && r.replied_at);
+    const stale = warm.filter(r => {
+      const d = new Date(r.replied_at);
+      const age = (Date.now() - d.getTime()) / (1000 * 60 * 60 * 24);
+      return age >= 2;
+    }).slice(0, 6);
+    if (stale.length) {
+      const names = stale.map(r => [r.first_name, r.last_name].filter(Boolean).join(' ').trim() || r.company).slice(0, 6);
+      lines.push(`- Needs reply (replied ≥2d ago): ${names.join(', ')}`);
+    }
+  }
+  return lines.length > 1 ? lines.join('\n') : null;
+}
+
+function buildQuerySections(state) {
+  const sections = [];
+  const open = state.tasks.filter(t => t.status === 'open' || t.status === 'in_progress');
+  const byP = p => open.filter(t => t.priority === p).length;
+
+  const commonOpts = [
+    'path includes today.md',
+    'not done',
+    'sort by due',
+    'hide backlink',
+    'hide edit button',
+    'hide task count'
+  ];
+
+  if (byP(1) > 0) {
+    sections.push([
+      '## Today',
+      '```tasks',
+      ...commonOpts,
+      'priority is high',
+      '```'
+    ].join('\n'));
+  }
+  if (byP(2) > 0) {
+    sections.push([
+      '## This week',
+      '```tasks',
+      ...commonOpts,
+      'priority is medium',
+      '```'
+    ].join('\n'));
+  }
+  if (byP(3) > 0) {
+    sections.push([
+      '## Backlog',
+      '```tasks',
+      ...commonOpts,
+      'priority is low',
+      '```'
+    ].join('\n'));
+  }
+
+  const snoozed = state.tasks.filter(t => t.status === 'snoozed');
+  if (snoozed.length) {
+    snoozed.sort((a, b) => (a.snoozed_until || '').localeCompare(b.snoozed_until || ''));
+    const lines = snoozed.slice(0, 5).map(t => `- TASK-${t.id} ${t.title} *(resurfaces ${t.snoozed_until || 'TBD'})*`);
+    sections.push('## Snoozed\n' + lines.join('\n'));
+  }
+
+  return sections;
+}
+
+function buildTaskDataSection(state) {
+  const open = state.tasks.filter(t => t.status === 'open' || t.status === 'in_progress');
+  const openIds = new Set(open.map(t => t.id));
+
+  // Group by priority, then lane.
+  const byPriority = { 1: [], 2: [], 3: [] };
+  for (const t of open) {
+    const p = byPriority[t.priority] || (byPriority[t.priority] = []);
+    p.push(t);
+  }
+
+  const out = [
+    '---',
+    '',
+    '## Task data',
+    '',
+    '*Source rows for the queries above. `flush-today.js` reads these. Editable — checkboxes, due dates, priorities, snooze (`🛫 YYYY-MM-DD`) all round-trip. Run `node tools/tasks/flush-today.js` after edits.*',
+    ''
+  ];
+
+  for (const priority of [1, 2, 3]) {
+    let pTasks = byPriority[priority] || [];
+    if (pTasks.length === 0) continue;
+
+    // P3 (backlog) is collapsed to first 5 unless --all.
+    if (priority === 3 && !showAll) pTasks = pTasks.slice(0, 5);
+
+    out.push(PRIORITY_HEADERS[priority] || `### P${priority}`);
+    out.push('');
+
+    // Group by lane within priority.
+    const byLane = {};
+    for (const t of pTasks) {
+      const lane = t.lane || 'meta';
+      (byLane[lane] = byLane[lane] || []).push(t);
+    }
+
+    const orderedLanes = [
+      ...LANE_ORDER.filter(l => byLane[l]),
+      ...Object.keys(byLane).filter(l => !LANE_ORDER.includes(l))
+    ];
+
+    for (const lane of orderedLanes) {
+      const laneTasks = byLane[lane];
+      laneTasks.sort((a, b) => {
+        if (a.due && b.due) return a.due.localeCompare(b.due);
+        if (a.due) return -1;
+        if (b.due) return 1;
+        return a.id - b.id;
+      });
+      out.push(`**${LANE_DISPLAY[lane] || lane}** (${laneTasks.length})`);
+      for (const t of laneTasks) out.push(renderTaskLine(t, openIds));
+      out.push('');
+    }
+  }
+
+  return out.join('\n').trimEnd();
+}
+
+// --- Main ---
+
+const state = tasks.load();
+const resurfaced = tasks.resolveSnoozed(state);
+if (resurfaced > 0) {
+  tasks.save(state);
+  if (!quiet) console.log(`↑ Resurfaced ${resurfaced} snoozed task(s) whose date has passed.`);
+}
+
+const metrics = readMetrics();
+const leads = readLeadsLight();
+
+const date = new Date();
+const header = `# Today · ${todayStr()} ${weekdayName(date)}`;
+
+const sections = [];
+sections.push(header);
+
+const preamble = `> *Your daily surface. Check the boxes in Obsidian, then flush with \`node tools/tasks/flush-today.js\`.*\n> *Underlying source of truth: \`tasks.yml\`. Never hand-edit that file while this doc has unflushed changes.*`;
+sections.push(preamble);
+
+const callsBlock = buildCallsSection(leads);
+if (callsBlock) sections.push(callsBlock);
+
+const pulseBlock = buildPulseSection(leads, metrics);
+if (pulseBlock) sections.push(pulseBlock);
+
+for (const s of buildQuerySections(state)) sections.push(s);
+
+sections.push(buildTaskDataSection(state));
+
+const now = new Date();
+const stamp = `${todayStr()} ${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
+sections.push(`*Generated ${stamp}. Queries above are live — edit checkboxes anywhere, then \`node tools/tasks/flush-today.js\`.*`);
+
+const content = sections.join('\n\n') + '\n';
+if (!fs.existsSync(path.dirname(TODAY_MD))) fs.mkdirSync(path.dirname(TODAY_MD), { recursive: true });
+fs.writeFileSync(TODAY_MD, content);
+if (!quiet) {
+  const openCount = state.tasks.filter(t => t.status === 'open').length;
+  const ipCount = state.tasks.filter(t => t.status === 'in_progress').length;
+  console.log(`✓ Wrote ${path.relative(ROOT, TODAY_MD)} (${openCount} open + ${ipCount} in_progress)`);
+}