create-battle-plan 1.2.0 → 1.4.0

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

@@ -3,28 +3,37 @@ const path = require('path');
 
 const TASKS_PATH = path.resolve(__dirname, '../../../tasks.yml');
 
-const VALID_STATUS = new Set(['open', 'done', 'cancelled', 'snoozed']);
+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
+//       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', 'tags',
-  'title', 'context', 'done_at', 'snoozed_until'
+  'id', 'created', 'due', 'status', 'priority', 'lane', 'tags',
+  'title', 'context', 'done_at', 'snoozed_until', 'implications', 'blocked_by'
 ];
 
 function today() {
@@ -53,7 +62,9 @@ function serializeScalar(v) {
   if (typeof v === 'number' || typeof v === 'boolean') return String(v);
   if (Array.isArray(v)) {
     if (v.length === 0) return '[]';
-    return '[' + v.map(x => serializeString(x)).join(', ') + ']';
+    // 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);
 }
@@ -126,6 +137,7 @@ function save(state) {
   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;
@@ -160,6 +172,6 @@ function resolveSnoozed(state) {
 }
 
 module.exports = {
-  TASKS_PATH, VALID_STATUS, VALID_PRIORITY, FIELD_ORDER,
+  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

@@ -57,34 +57,73 @@ function priorityEmoji(p) {
   return '';
 }
 
-function renderTaskLine(t) {
+// 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 = [];
-  parts.push(`- [ ] TASK-${t.id} ${t.title}`);
+  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));
+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));
@@ -94,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 => {
@@ -111,7 +154,7 @@ function buildPulseSection(leads, metrics) {
 
 function buildQuerySections(state) {
   const sections = [];
-  const open = state.tasks.filter(t => t.status === 'open');
+  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 = [
@@ -162,32 +205,62 @@ function buildQuerySections(state) {
 }
 
 function buildTaskDataSection(state) {
-  const open = state.tasks.filter(t => t.status === 'open');
-  open.sort((a, b) => {
-    if (a.priority !== b.priority) return a.priority - b.priority;
-    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;
-  });
-
-  let rendered = open;
-  if (!showAll) {
-    const highMed = open.filter(t => t.priority <= 2);
-    const low = open.filter(t => t.priority === 3).slice(0, 5);
-    rendered = [...highMed, ...low];
+  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 raw = rendered.map(renderTaskLine).join('\n');
-  return [
+  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.*',
-    '',
-    raw
-  ].join('\n');
+    ''
+  ];
+
+  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 ---
@@ -211,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);
@@ -228,4 +301,8 @@ sections.push(`*Generated ${stamp}. Queries above are live — edit checkboxes a
 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) console.log(`✓ Wrote ${path.relative(ROOT, TODAY_MD)} (${state.tasks.filter(t => t.status === 'open').length} open task(s))`);
+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)`);
+}

package/template/tools/tasks/triage-due.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+// tools/tasks/triage-due.js — lightweight SessionStart-hook nudge.
+//
+// Reads tasks.yml only. No git scans, no LLM calls, no per-doc checks.
+// Silent by default — outputs nothing when triage isn't due.
+// Only surfaces when one of the trigger conditions actually fires.
+//
+// Trigger conditions:
+//   1. Time-based:    last_triage_at >= TRIAGE_INTERVAL_DAYS ago, or never triaged with ≥30 open tasks
+//   2. Stale-task:    ≥ STALE_TASK_THRESHOLD open tasks with age ≥ STALE_AGE_DAYS
+//   3. Volume:        ≥ VOLUME_THRESHOLD open total
+//
+// Adjust thresholds for your project's task scale.
+//
+// Flags:
+//   --explain   write all signals to stderr (debug)
+//   --quiet     suppress nudge output (testing)
+
+const tasks = require('./lib/tasks');
+
+const TRIAGE_INTERVAL_DAYS = 7;
+const STALE_TASK_THRESHOLD = 20;
+const STALE_AGE_DAYS = 14;
+const VOLUME_THRESHOLD = 60;
+const NEVER_TRIAGED_MIN_OPEN = 30;
+
+const argv = process.argv.slice(2);
+const explain = argv.includes('--explain');
+const quiet = argv.includes('--quiet');
+
+function daysBetween(a, b) {
+  const ad = new Date(a);
+  const bd = new Date(b);
+  return Math.floor((bd - ad) / 86400000);
+}
+
+const state = tasks.load();
+const today = tasks.today();
+const open = state.tasks.filter(t => t.status === 'open' || t.status === 'in_progress');
+const stale = open.filter(t => {
+  if (!t.created) return false;
+  return daysBetween(t.created, today) >= STALE_AGE_DAYS;
+});
+
+const triggers = [];
+
+if (state.last_triage_at) {
+  const sinceDays = daysBetween(state.last_triage_at, today);
+  if (sinceDays >= TRIAGE_INTERVAL_DAYS) {
+    triggers.push({ kind: 'time', detail: `last triage ${sinceDays}d ago (interval ${TRIAGE_INTERVAL_DAYS}d)` });
+  }
+} else if (open.length >= NEVER_TRIAGED_MIN_OPEN) {
+  triggers.push({ kind: 'never_triaged', detail: `no last_triage_at recorded, ${open.length} open tasks` });
+}
+
+if (stale.length >= STALE_TASK_THRESHOLD) {
+  triggers.push({ kind: 'stale', detail: `${stale.length} open tasks ≥${STALE_AGE_DAYS}d old` });
+}
+
+if (open.length >= VOLUME_THRESHOLD) {
+  triggers.push({ kind: 'volume', detail: `${open.length} open tasks (threshold ${VOLUME_THRESHOLD})` });
+}
+
+if (explain) {
+  process.stderr.write(`triage-due check @ ${today}\n`);
+  process.stderr.write(`  open: ${open.length}, stale (≥${STALE_AGE_DAYS}d): ${stale.length}\n`);
+  process.stderr.write(`  last_triage_at: ${state.last_triage_at || '(never)'}\n`);
+  process.stderr.write(`  triggers: ${triggers.length ? triggers.map(t => t.kind).join(', ') : 'none'}\n`);
+}
+
+if (triggers.length === 0 || quiet) process.exit(0);
+
+const reasons = triggers.map(t => t.detail).join('; ');
+process.stdout.write(`📋 Weekly triage is due — ${reasons}. Run \`/weekly-triage\` when convenient.\n`);