create-battle-plan 1.3.0 → 1.4.1

package/template/tools/events/archive.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+// tools/events/archive.js — move gated/completed/cancelled events from events.yml → events-archive.yml.
+// Mirrors tools/tasks/archive.js.
+//
+// An event is archivable when:
+//   - status ∈ {done, cancelled, no_show, rescheduled} AND gate_completed_at is set (normal path), OR
+//   - end-time > 14 days ago (auto-no-show sweep for stale scheduled events)
+//
+// Flags: --dry-run, --days N (override stale threshold)
+
+const E = require('./lib/events');
+
+const args = process.argv.slice(2);
+const dry = args.includes('--dry-run');
+const daysIdx = args.indexOf('--days');
+const staleDays = daysIdx >= 0 ? parseInt(args[daysIdx + 1], 10) : 14;
+
+const cutoff = new Date(Date.now() - staleDays * 86400 * 1000).toISOString();
+const live = E.load();
+const archive = E.loadArchive();
+
+const archivable = [];
+const remaining = [];
+for (const e of live.events) {
+  const terminal = ['done', 'cancelled', 'no_show', 'rescheduled'].includes(e.status);
+  const gated = !!e.gate_completed_at;
+  const ref = e.end || e.start;
+  const stale = ref && ref < cutoff;
+  if (terminal && (gated || stale)) {
+    archivable.push(e);
+  } else if (!terminal && stale) {
+    e.status = 'no_show';
+    archivable.push(e);
+  } else {
+    remaining.push(e);
+  }
+}
+
+console.log(`Archivable: ${archivable.length}  ·  Remaining in events.yml: ${remaining.length}`);
+for (const e of archivable) {
+  console.log(`  EVT-${e.id}  ${e.start.slice(0, 16).replace('T', ' ')}  [${e.status}]  ${e.title}`);
+}
+
+if (dry) { console.log('\nDry-run.'); process.exit(0); }
+if (!archivable.length) process.exit(0);
+
+const archiveIds = new Set(archive.events.map(e => e.id));
+for (const e of archivable) {
+  if (!archiveIds.has(e.id)) archive.events.push(e);
+}
+live.events = remaining;
+
+E.save(live);
+E.saveArchive(archive);
+console.log(`\nMoved ${archivable.length} event(s) to events-archive.yml.`);

package/template/tools/events/due-for-gate.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// tools/events/due-for-gate.js — events whose end-time has passed but no gate_completed_at yet.
+// The wrap-up skill walks these one-by-one and asks for: transcript path, hypothesis impacts,
+// spawned tasks, lead status change. Then stamps gate_completed_at and archives.
+// Flags: --json
+// Used by wrap-up (mandatory gate) and good-morning (warns when context-debt > 2 days old).
+
+const E = require('./lib/events');
+
+const asJson = process.argv.includes('--json');
+const events = E.dueForGate();
+
+if (asJson) {
+  console.log(JSON.stringify(events, null, 2));
+  process.exit(0);
+}
+
+if (!events.length) {
+  console.log('(no events due for wrap-up gate)');
+  process.exit(0);
+}
+
+console.log(`${events.length} event(s) past end-time, awaiting wrap-up gate:`);
+for (const e of events) {
+  const start = e.start.slice(0, 16).replace('T', ' ');
+  console.log(`  EVT-${e.id}  ${start}  [${e.type}]  ${e.title}`);
+  if (e.lead_id) console.log(`    lead: ${e.lead_id}`);
+  if (!e.transcript_path) console.log('    · transcript: MISSING');
+  if (!e.hypothesis_impacts || !e.hypothesis_impacts.length) console.log('    · hypothesis impacts: MISSING');
+  if (!e.spawned_tasks || !e.spawned_tasks.length) console.log('    · spawned tasks: none recorded');
+}

package/template/tools/events/lib/events.js

@@ -0,0 +1,221 @@
+// tools/events/lib/events.js — YAML reader/writer for events.yml + events-archive.yml.
+// Mirrors the shape of tools/tasks/lib/tasks.js — self-contained, no external YAML deps.
+// An "event" is something with a start datetime AND a counterparty (calls, demos, meetings,
+// dentist appointments). Deadline-only items (no time-of-day, no attendee) belong in tasks.yml.
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '../../..');
+const EVENTS_PATH = path.join(ROOT, 'events.yml');
+const ARCHIVE_PATH = path.join(ROOT, 'events-archive.yml');
+
+const VALID_STATUS = new Set(['scheduled', 'in_progress', 'done', 'cancelled', 'no_show', 'rescheduled']);
+// VALID_TYPE is intentionally permissive — adapt per project. The set below lists common types;
+// any string passes through (add.js validates against this set only for known categories).
+const VALID_TYPE = new Set(['demo', 'discovery', 'investor', 'admin', 'personal', 'unspecified', 'other']);
+
+const FIELD_ORDER = [
+  'id', 'title', 'start', 'end', 'type', 'status',
+  'attendees', 'lead_id', 'location', 'notes',
+  'source', 'created_at',
+  'transcript_path', 'spawned_tasks', 'hypothesis_impacts', 'gate_completed_at'
+];
+
+function today() { return new Date().toISOString().slice(0, 10); }
+function nowIso() { return new Date().toISOString(); }
+
+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 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 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 '[]';
+    return '[' + v.map(x => (typeof x === 'number' || typeof x === 'boolean') ? String(x) : serializeString(x)).join(', ') + ']';
+  }
+  return serializeString(v);
+}
+
+function loadFile(p) {
+  if (!fs.existsSync(p)) {
+    return { last_updated: today(), next_id: 1, events: [] };
+  }
+  const text = fs.readFileSync(p, 'utf8');
+  const lines = text.split('\n');
+  const result = { last_updated: today(), next_id: 1, events: [] };
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (/^\s*#/.test(line) || line.trim() === '') { i++; continue; }
+    if (/^events\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.events.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.events.push(cur);
+  result.next_id = typeof result.next_id === 'number' ? result.next_id : parseInt(result.next_id, 10) || 1;
+  result.events.forEach(e => {
+    if (typeof e.id === 'string') e.id = parseInt(e.id, 10);
+    for (const k of ['attendees', 'spawned_tasks', 'hypothesis_impacts']) {
+      if (e[k] && !Array.isArray(e[k])) e[k] = [e[k]];
+    }
+  });
+  return result;
+}
+
+function saveFile(p, state, header) {
+  state.last_updated = today();
+  const maxId = state.events.reduce((m, e) => Math.max(m, e.id || 0), 0);
+  if (state.next_id <= maxId) state.next_id = maxId + 1;
+  const out = [];
+  out.push(header);
+  out.push(`last_updated: ${state.last_updated}`);
+  out.push(`next_id: ${state.next_id}`);
+  out.push('events:');
+  for (const e of state.events) {
+    let first = true;
+    for (const k of FIELD_ORDER) {
+      if (!(k in e)) continue;
+      const prefix = first ? '  - ' : '    ';
+      out.push(`${prefix}${k}: ${serializeScalar(e[k])}`);
+      first = false;
+    }
+  }
+  fs.writeFileSync(p, out.join('\n') + '\n');
+}
+
+function load() { return loadFile(EVENTS_PATH); }
+function loadArchive() { return loadFile(ARCHIVE_PATH); }
+
+function save(state) {
+  saveFile(EVENTS_PATH, state,
+    '# events.yml — single source of truth for future time-based events (calls, demos, meetings).\n# Past/completed events live in events-archive.yml. Tasks (deadline-only, no time-span) live in tasks.yml.');
+}
+
+function saveArchive(state) {
+  saveFile(ARCHIVE_PATH, state,
+    '# events-archive.yml — past/completed events. Mirrors events.yml schema.\n# Wrap-up gate moves events here after transcript + insights captured.');
+}
+
+function nextId(state) {
+  // Shared ID space across events.yml + events-archive.yml. An event's ID never changes when archived.
+  const cur = state.next_id || 1;
+  const archived = loadArchive();
+  const maxArch = archived.events.reduce((m, e) => Math.max(m, e.id || 0), 0);
+  const id = Math.max(cur, maxArch + 1);
+  state.next_id = id + 1;
+  return id;
+}
+
+// Idempotent: matches on (id) first, then (lead_id + start) tuple. Safe to call from
+// retried flush-* scripts without creating duplicate rows for the same real-world event.
+function upsert(state, event) {
+  let idx = -1;
+  if (event.id) idx = state.events.findIndex(e => e.id === event.id);
+  if (idx < 0 && event.lead_id && event.start) {
+    idx = state.events.findIndex(e => e.lead_id === event.lead_id && e.start === event.start);
+  }
+  if (idx >= 0) {
+    state.events[idx] = { ...state.events[idx], ...event };
+    return { action: 'updated', event: state.events[idx] };
+  }
+  if (!event.id) event.id = nextId(state);
+  if (!event.created_at) event.created_at = nowIso();
+  state.events.push(event);
+  return { action: 'inserted', event };
+}
+
+function upcoming({ from = nowIso() } = {}) {
+  return load().events
+    .filter(e => e.start && e.start >= from && (e.status === 'scheduled' || e.status === 'in_progress' || e.status === 'done'))
+    .sort((a, b) => String(a.start).localeCompare(String(b.start)));
+}
+
+function todayEvents({ on = today() } = {}) {
+  return load().events
+    .filter(e => e.start && String(e.start).startsWith(on)
+      && (e.status === 'scheduled' || e.status === 'in_progress' || e.status === 'done'))
+    .sort((a, b) => String(a.start).localeCompare(String(b.start)));
+}
+
+function dueForGate({ now = nowIso() } = {}) {
+  return load().events
+    .filter(e => {
+      if (e.gate_completed_at) return false;
+      if (e.status === 'cancelled' || e.status === 'rescheduled') return false;
+      const endOrStart = e.end || e.start;
+      return endOrStart && endOrStart < now;
+    })
+    .sort((a, b) => String(a.start).localeCompare(String(b.start)));
+}
+
+// Lead-level lookup — used by metrics scripts to know if a lead ever had a call.
+// Unions events.yml + events-archive.yml so historical calls survive after archival.
+function leadHadCall(leadId) {
+  if (!leadId) return false;
+  const all = [...load().events, ...loadArchive().events];
+  return all.some(e => e.lead_id === leadId
+    && (e.status === 'done' || e.status === 'in_progress'
+        || (e.status === 'scheduled' && e.start && e.start < nowIso())));
+}
+
+function eventsByLead(leadId) {
+  if (!leadId) return [];
+  return [...load().events, ...loadArchive().events].filter(e => e.lead_id === leadId);
+}
+
+function defaultEnd(startIso, durationMin = 30) {
+  if (!startIso) return null;
+  const d = new Date(startIso);
+  if (isNaN(d.getTime())) return null;
+  d.setMinutes(d.getMinutes() + durationMin);
+  return d.toISOString();
+}
+
+module.exports = {
+  EVENTS_PATH, ARCHIVE_PATH, VALID_STATUS, VALID_TYPE, FIELD_ORDER,
+  today, nowIso, defaultEnd,
+  load, loadArchive, save, saveArchive, nextId, upsert,
+  upcoming, todayEvents, dueForGate, leadHadCall, eventsByLead
+};

package/template/tools/events/migrate-from-csv.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+// tools/events/migrate-from-csv.js — one-shot migration for installs that previously stored
+// scheduled calls as outreach/leads.csv:call_at. Splits the column into events.yml (future)
+// + events-archive.yml (past), then strips the call_at values from leads.csv.
+//
+// Idempotent — keys on (lead_id + start). Safe to re-run; already-present rows are skipped.
+// Profile A (base only) installs without leads.csv: the script no-ops with a helpful message.
+//
+// Run with --commit to persist; otherwise dry-run.
+
+const fs = require('fs');
+const path = require('path');
+const E = require('./lib/events');
+
+const commit = process.argv.includes('--commit');
+const todayStr = E.today();
+
+const LEADS_LIB = path.resolve(__dirname, '../outreach/lib/leads.js');
+if (!fs.existsSync(LEADS_LIB)) {
+  console.log('No outreach/lib/leads.js found — this install has no CSV to migrate from.');
+  console.log('events.yml + events-archive.yml will be created on first add.');
+  process.exit(0);
+}
+
+const L = require('../outreach/lib/leads');
+const rows = L.load();
+const withCallAt = rows.filter(r => r.call_at && String(r.call_at).trim() !== '');
+
+console.log(`Found ${withCallAt.length} leads with call_at set.`);
+if (withCallAt.length === 0) {
+  console.log('Nothing to migrate.');
+  process.exit(0);
+}
+
+const future = E.load();
+const archive = E.loadArchive();
+
+let nFuture = 0, nArchive = 0, nSkipped = 0;
+
+for (const r of withCallAt) {
+  const raw = String(r.call_at).trim();
+  // Bare YYYY-MM-DD → assume UTC midnight so date doesn't shift. Adapt offset if relevant.
+  const start = raw.length === 10 ? `${raw}T00:00:00+00:00` : raw;
+  const dateOnly = raw.slice(0, 10);
+  const isFuture = dateOnly >= todayStr;
+  const target = isFuture ? future : archive;
+  const status = isFuture ? 'scheduled' : 'done';
+  const name = [r.first_name, r.last_name].filter(Boolean).join(' ') || r.company || r.linkedin_url;
+  const title = `${status === 'done' ? 'Call' : 'Call (scheduled)'} — ${name}${r.company ? ` / ${r.company}` : ''}`;
+
+  const event = {
+    title,
+    start,
+    end: isFuture ? E.defaultEnd(start, 30) : null,
+    type: 'unspecified',
+    status,
+    attendees: [],
+    lead_id: r.linkedin_url || null,
+    location: null,
+    notes: null,
+    source: 'migrate-from-csv',
+  };
+
+  const existingIdx = target.events.findIndex(e => e.lead_id === event.lead_id && e.start === event.start);
+  if (existingIdx >= 0) { nSkipped++; continue; }
+
+  E.upsert(target, event);
+  if (isFuture) nFuture++; else nArchive++;
+}
+
+console.log(`Future events to insert:  ${nFuture}`);
+console.log(`Archive events to insert: ${nArchive}`);
+console.log(`Already-present skipped:  ${nSkipped}`);
+
+if (!commit) {
+  console.log('\nDry-run. Re-run with --commit to write events.yml + events-archive.yml + strip call_at.');
+  process.exit(0);
+}
+
+E.save(future);
+E.saveArchive(archive);
+console.log('\nWrote events.yml + events-archive.yml.');
+
+console.log('\nStripping call_at values from leads.csv...');
+let stripped = 0;
+for (const r of rows) {
+  if (r.call_at && r.call_at !== '') { r.call_at = ''; stripped++; }
+}
+L.save(rows);
+console.log(`Cleared call_at on ${stripped} rows. The column itself is dropped on next save once HEADERS is updated.`);

package/template/tools/events/upcoming.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// tools/events/upcoming.js — list scheduled events from now forward.
+// Flags: --json | --today (only events starting today) | --days N (next N days)
+// Used by render-today.js, good-morning, wrap-up.
+
+const E = require('./lib/events');
+
+const args = process.argv.slice(2);
+const asJson = args.includes('--json');
+const onlyToday = args.includes('--today');
+const daysIdx = args.indexOf('--days');
+const days = daysIdx >= 0 ? parseInt(args[daysIdx + 1], 10) : null;
+
+let events;
+if (onlyToday) {
+  events = E.todayEvents();
+} else if (days) {
+  const now = new Date();
+  const until = new Date(now.getTime() + days * 86400 * 1000).toISOString();
+  events = E.upcoming().filter(e => e.start <= until);
+} else {
+  events = E.upcoming();
+}
+
+if (asJson) {
+  console.log(JSON.stringify(events, null, 2));
+} else {
+  if (!events.length) { console.log('(no upcoming events)'); process.exit(0); }
+  for (const e of events) {
+    const time = e.start.length >= 16 ? e.start.slice(0, 16).replace('T', ' ') : e.start.slice(0, 10);
+    console.log(`EVT-${e.id}  ${time}  [${e.type}/${e.status}]  ${e.title}`);
+  }
+}

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

@@ -97,22 +97,33 @@ function renderTaskLine(t, openIds) {
   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));
+function loadEventsLib() {
+  // events.yml is part of the base template, but be defensive in case someone removed it.
+  const eventsLib = path.join(ROOT, 'tools/events/lib/events.js');
+  if (!fs.existsSync(eventsLib)) return null;
+  try { return require(eventsLib); } catch (e) { return null; }
+}
+
+function buildCallsSection() {
+  // events.yml is the single source of truth for time-based events.
+  const events = loadEventsLib();
+  if (!events) return null;
+  const calls = events.todayEvents();
   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}`);
+  for (const e of calls) {
+    const time = e.start && e.start.length >= 16 ? e.start.slice(11, 16) : 'TBD';
+    lines.push(`- ${time} — ${e.title}`);
   }
   return lines.join('\n');
 }
 
 function buildPulseSection(leads, metrics) {
-  if (!leads.length && !Object.keys(metrics).length) return null;
+  const events = loadEventsLib();
+  const upcomingEvents = events
+    ? events.upcoming().filter(e => e.start && e.start.slice(0, 10) > todayStr())
+    : [];
+  if (!leads.length && !Object.keys(metrics).length && !upcomingEvents.length) return null;
   const lines = ['## Pulse'];
   if (leads.length) {
     const pipeline = leads.filter(r => ['replied', 'call_booked', 'call_done', 'verbal', 'loi'].includes(r.status));
@@ -122,6 +133,10 @@ function buildPulseSection(leads, metrics) {
   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 (upcomingEvents.length) {
+    const fmt = upcomingEvents.slice(0, 5).map(e => `${e.start.slice(0, 10)} ${e.title}`).join(', ');
+    lines.push(`- Upcoming events (${upcomingEvents.length}): ${fmt}`);
+  }
   if (leads.length) {
     const warm = leads.filter(r => r.status === 'replied' && r.replied_at);
     const stale = warm.filter(r => {
@@ -269,7 +284,7 @@ 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);
+const callsBlock = buildCallsSection();
 if (callsBlock) sections.push(callsBlock);
 
 const pulseBlock = buildPulseSection(leads, metrics);