dw-kit 1.9.2 → 1.10.0

package/src/lib/goal-progress.mjs

@@ -0,0 +1,193 @@
+// goal-progress.mjs — read-only progress derivation + task.md file watcher
+// for the /board per-goal driver UX.
+//
+// "Driver running" is not enough — users need to see WHICH subtask is in
+// flight, how many are done, and how long since the agent last touched
+// state. This module derives those signals from the linked task.md
+// (Section 3 status icons) + the events-global.jsonl tail, and watches
+// the task file so subtask-flip events flow into the SSE broker without
+// the agent needing to call any new CLI surface.
+//
+// Per ADR-0001: zero-dep, Node built-ins only.
+
+import { existsSync, readFileSync, watch as fsWatch } from 'node:fs';
+import { join } from 'node:path';
+import { parseSubtasks, readFrontmatter, listTaskDirs } from './task-md-utils.mjs';
+import { eventsGlobalFile } from './goal-events.mjs';
+
+const WATCH_DEBOUNCE_MS = 300;
+const EVENTS_TAIL_SCAN_LINES = 500; // enough for ~hours of activity
+
+// ─ Linked-task resolution ─────────────────────────────────────────────────
+
+/**
+ * Find the canonical linked task path for a goal_id. The first task whose
+ * frontmatter declares `parent_goal_id: <goalId>` wins; returns absolute
+ * path or null when unmatched.
+ */
+export function findLinkedTaskPath(goalId, rootDir = process.cwd()) {
+  const dirs = listTaskDirs(rootDir);
+  for (const taskName of dirs) {
+    const p = join(rootDir, '.dw', 'tasks', taskName, 'task.md');
+    const fm = readFrontmatter(p);
+    if (fm && fm.parent_goal_id === goalId) return p;
+  }
+  return null;
+}
+
+// ─ Snapshot + diff ─────────────────────────────────────────────────────────
+
+/**
+ * Parse the current Section 3 snapshot from a task.md path. Returns the
+ * array of subtask rows (same shape as parseSubtasks).
+ */
+export function snapshotSubtasks(taskPath) {
+  return parseSubtasks(taskPath);
+}
+
+/**
+ * Diff two snapshots; returns the rows whose status_bucket changed. Each
+ * change carries { st_id, title, from, to }.
+ */
+export function diffSubtasks(before, after) {
+  const map = new Map((before || []).map((s) => [s.st_id, s]));
+  const out = [];
+  for (const a of after || []) {
+    const b = map.get(a.st_id);
+    if (!b) {
+      out.push({ st_id: a.st_id, title: clip(a.title, 120), from: 'new', to: a.status_bucket });
+    } else if (b.status_bucket !== a.status_bucket) {
+      out.push({ st_id: a.st_id, title: clip(a.title, 120), from: b.status_bucket, to: a.status_bucket });
+    }
+  }
+  return out;
+}
+
+function clip(s, n) {
+  if (typeof s !== 'string') return '';
+  return s.length <= n ? s : s.slice(0, n) + '…';
+}
+
+// ─ Progress derivation ─────────────────────────────────────────────────────
+
+/**
+ * Compute the live progress summary for a goal. Returns null if no linked
+ * task is found; otherwise an object with done/total/percent + the
+ * current/next subtask + the last-activity timestamp.
+ */
+export function computeGoalProgress(goalId, rootDir = process.cwd()) {
+  const taskPath = findLinkedTaskPath(goalId, rootDir);
+  if (!taskPath) return null;
+  const subs = snapshotSubtasks(taskPath);
+  const total = subs.length;
+  const done = subs.filter((s) => s.status_bucket === 'done').length;
+  const blocked = subs.filter((s) => s.status_bucket === 'blocked').length;
+  // Prefer an explicit 🟡 In Progress row; fall back to the first ⬜ Pending
+  // as the "next up" so the card always shows what the driver is on /
+  // about to start.
+  const current = subs.find((s) => s.status_bucket === 'in_progress')
+    || subs.find((s) => s.status_bucket === 'pending');
+  const fm = readFrontmatter(taskPath);
+  const percent = total > 0 ? Math.round((done / total) * 100) : 0;
+  return {
+    task_id: fm.task_id || null,
+    task_path: relativizePath(taskPath, rootDir),
+    done,
+    total,
+    blocked,
+    percent,
+    current: current ? {
+      st_id: current.st_id,
+      title: clip(current.title, 120),
+      status_bucket: current.status_bucket,
+      status_icon: current.status_icon,
+    } : null,
+    last_activity_at: lastGoalDriverEventAt(goalId, rootDir),
+  };
+}
+
+function relativizePath(abs, rootDir) {
+  const sep = process.platform === 'win32' ? '\\' : '/';
+  const prefix = rootDir.endsWith(sep) ? rootDir : rootDir + sep;
+  return abs.startsWith(prefix) ? abs.slice(prefix.length).replace(/\\/g, '/') : abs;
+}
+
+/**
+ * Tail-scan events-global.jsonl for the most recent `goal_driver_*` event
+ * tagged with the given goal_id. Returns the ISO timestamp or null.
+ */
+export function lastGoalDriverEventAt(goalId, rootDir = process.cwd()) {
+  const file = eventsGlobalFile(rootDir);
+  if (!existsSync(file)) return null;
+  let txt;
+  try { txt = readFileSync(file, 'utf8'); } catch { return null; }
+  const lines = txt.split('\n').filter(Boolean);
+  const start = Math.max(0, lines.length - EVENTS_TAIL_SCAN_LINES);
+  for (let i = lines.length - 1; i >= start; i--) {
+    try {
+      const e = JSON.parse(lines[i]);
+      if (e && e.goal_id === goalId && typeof e.event === 'string'
+        && (e.event.startsWith('goal_driver_') || e.event === 'goal_driver_subtask_progress')) {
+        return e.ts || null;
+      }
+    } catch { /* skip malformed */ }
+  }
+  return null;
+}
+
+// ─ Watcher ─────────────────────────────────────────────────────────────────
+//
+// fs.watch on a single file is well-supported across POSIX + Win32 (per
+// sse-broker.mjs precedent). Debounced because Win32 fires twice per save.
+
+const watchers = new Map(); // goalId → { taskPath, watcher, debounceTimer, lastSnapshot }
+
+/**
+ * Begin watching the task.md for the goal. `onChange` is invoked with
+ * { goalId, changes, snapshot, taskPath } after each settled write.
+ * Idempotent — calling twice on the same goalId reuses the existing watcher.
+ *
+ * Returns { ok, taskPath } so callers can confirm a watcher was actually
+ * attached (a goal with no linked task is a no-op success).
+ */
+export function startProgressWatcher(goalId, rootDir, onChange) {
+  if (watchers.has(goalId)) {
+    return { ok: true, taskPath: watchers.get(goalId).taskPath, reused: true };
+  }
+  const taskPath = findLinkedTaskPath(goalId, rootDir);
+  if (!taskPath) return { ok: false, reason: 'no_linked_task' };
+  const initial = snapshotSubtasks(taskPath);
+  const state = { taskPath, watcher: null, debounceTimer: null, lastSnapshot: initial };
+  try {
+    state.watcher = fsWatch(taskPath, { persistent: false }, () => {
+      if (state.debounceTimer) clearTimeout(state.debounceTimer);
+      state.debounceTimer = setTimeout(() => {
+        let current;
+        try { current = snapshotSubtasks(taskPath); }
+        catch { return; }
+        const changes = diffSubtasks(state.lastSnapshot, current);
+        state.lastSnapshot = current;
+        if (changes.length === 0) return;
+        try { onChange({ goalId, changes, snapshot: current, taskPath }); }
+        catch { /* listener errors must not crash the watcher */ }
+      }, WATCH_DEBOUNCE_MS);
+    });
+  } catch (err) {
+    return { ok: false, reason: 'watch_failed', error: err.message };
+  }
+  watchers.set(goalId, state);
+  return { ok: true, taskPath };
+}
+
+/** Stop watching the task.md for the goal. Idempotent. */
+export function stopProgressWatcher(goalId) {
+  const s = watchers.get(goalId);
+  if (!s) return { ok: true, reused: false };
+  if (s.debounceTimer) { try { clearTimeout(s.debounceTimer); } catch { /* */ } }
+  try { s.watcher.close(); } catch { /* already closed */ }
+  watchers.delete(goalId);
+  return { ok: true, reused: true };
+}
+
+/** Test/debug — return the count of active watchers. */
+export function activeWatcherCount() { return watchers.size; }

package/src/lib/overnight-digest.mjs

@@ -0,0 +1,241 @@
+// Morning-review digest builder for Overnight Autopilot (ADR-0023).
+//
+// An unattended overnight run emits events to .dw/events-global.jsonl; this
+// module turns a run's events into ONE scannable artifact a human reads cold
+// the next morning. Pure functions (buildDigest/summarizeRun) so the output is
+// deterministic and unit-testable; writeDigest handles the filesystem.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+export const DIGEST_SCHEMA_VERSION = 'overnight-digest@v1';
+export const DIGEST_FILE = 'OVERNIGHT.md';
+
+// Event types the autopilot loop emits (subset of events-global.jsonl).
+const EV_DONE = 'subtask_completed';
+const EV_AUTO = 'gate_auto_approved';
+const EV_PARK = 'parked';
+const EV_STOP = 'hard_stop';
+const EV_WRAP = 'overnight_wrapup';
+
+/**
+ * Reduce a run's events into counts + grouped items.
+ * @param {object[]} events
+ */
+export function summarizeRun(events = []) {
+  const done = [];
+  const autoApproved = [];
+  const parked = [];
+  const hardStops = [];
+  let stopReason = 'unknown';
+  let wrapupSeen = false;
+
+  for (const e of events) {
+    switch (e && e.event) {
+      case EV_DONE: done.push(e); break;
+      case EV_AUTO: autoApproved.push(e); break;
+      case EV_PARK: parked.push(e); break;
+      case EV_STOP: hardStops.push(e); break;
+      case EV_WRAP: wrapupSeen = true; if (e.stop_reason) stopReason = e.stop_reason; break;
+      default: break;
+    }
+  }
+
+  return {
+    counts: {
+      done: done.length,
+      parked: parked.length,
+      hardStops: hardStops.length,
+      autoApproved: autoApproved.length,
+    },
+    stopReason,
+    wrapupSeen,
+    done,
+    autoApproved,
+    parked,
+    hardStops,
+  };
+}
+
+/**
+ * The machine-readable read-contract object (overnight-digest@v1). OVERNIGHT.md
+ * is for humans; this is what the schema describes and adapters consume.
+ */
+// Coerce a possibly-missing/odd value to a string or undefined — so projected
+// items always satisfy the overnight-digest@v1 schema regardless of raw event
+// shape (round-3 verify: malformed events must not produce schema-invalid JSON).
+const str = (v) => (v == null ? undefined : String(v));
+const strArr = (v) => (Array.isArray(v) ? v.map(String) : undefined);
+const int = (v) => { const n = Math.trunc(Number(v)); return Number.isFinite(n) ? n : undefined; };
+const nnInt = (v) => { const n = int(v); return n != null && n >= 0 ? n : undefined; }; // schema minimum:0
+const bool = (v) => (typeof v === 'boolean' ? v : undefined);
+const prune = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined));
+
+// Project an evidence object to the schema-typed shape so OVERNIGHT.json stays
+// valid even if an event stored loose types (e.g. tests.exit as a string).
+function projectEvidence(ev) {
+  if (!ev || typeof ev !== 'object') return undefined;
+  const out = {};
+  if (ev.tests && typeof ev.tests === 'object') {
+    out.tests = prune({ command: str(ev.tests.command), passed: int(ev.tests.passed), failed: int(ev.tests.failed), exit: int(ev.tests.exit) });
+  }
+  if (ev.review && typeof ev.review === 'object') {
+    out.review = prune({ critical: nnInt(ev.review.critical), warning: nnInt(ev.review.warning), suggestion: nnInt(ev.review.suggestion) });
+  }
+  if (ev.diff && typeof ev.diff === 'object') {
+    out.diff = prune({ files: int(ev.diff.files), insertions: int(ev.diff.insertions), deletions: int(ev.diff.deletions), within_scope: bool(ev.diff.within_scope) });
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+
+export function buildDigestData({ events = [], date = new Date().toISOString().slice(0, 10), goal = null } = {}) {
+  const s = summarizeRun(events);
+  return {
+    schema_version: DIGEST_SCHEMA_VERSION,
+    date,
+    goal,
+    counts: s.counts,
+    stopReason: s.stopReason,
+    wrapupSeen: s.wrapupSeen,
+    done: s.done.map((e) => prune({ subtask: str(e.subtask), commit: str(e.commit), summary: str(e.summary) })),
+    autoApproved: s.autoApproved.map((e) => prune({ gate: str(e.gate), task: e.task == null ? null : String(e.task), reason: str(e.reason), evidence: projectEvidence(e.evidence) })),
+    parked: s.parked.map((e) => prune({ item: str(e.item), question: str(e.question), options: strArr(e.options) })),
+    hardStops: s.hardStops.map((e) => prune({ gate: str(e.gate), blocker: str(e.blocker), reason: str(e.reason) })),
+  };
+}
+
+function line(...parts) { return parts.join(' '); }
+
+/**
+ * Render the morning-review digest as Markdown.
+ * @param {object} params
+ * @param {object[]} params.events  run events
+ * @param {string} [params.date]    ISO date string for the header
+ * @param {string} [params.goal]    goal id/title the run pursued
+ */
+export function buildDigest({ events = [], date = new Date().toISOString().slice(0, 10), goal = null } = {}) {
+  const s = summarizeRun(events);
+  const out = [];
+
+  out.push(`# Overnight Autopilot — ${date}`);
+  out.push('');
+  out.push(`> ${DIGEST_SCHEMA_VERSION} · auto-generated from \`.dw/events-global.jsonl\`. Read cold, act on the **⏸ Parked** section, then review the diff.`);
+  if (goal) out.push(`> Goal: ${goal}`);
+  out.push('');
+
+  // 1. Verdict line
+  out.push('## Verdict');
+  out.push(line(
+    `✅ ${s.counts.done} done`,
+    `· ⏸ ${s.counts.parked} parked`,
+    `· 🛑 ${s.counts.hardStops} hard-stops`,
+    `· ⚡ ${s.counts.autoApproved} auto-approved`,
+    `· ⌛ stopped: ${s.stopReason}`,
+  ));
+  // No wrap-up event despite work having happened = the loop may have died
+  // mid-run without the graceful stop ADR-0023 promises. Surface that loudly.
+  // Zero-activity (no events at all) is "no run", not a crash — don't warn
+  // (round-2 verify: 5.4 false-positive fix).
+  const hadActivity = s.counts.done + s.counts.parked + s.counts.hardStops + s.counts.autoApproved > 0;
+  if (!s.wrapupSeen && hadActivity) {
+    out.push('');
+    out.push('> 🛑 **NO WRAP-UP event found — the run may have crashed.** Inspect the working tree and tests manually before resuming; an irreversible step may have been left half-done.');
+  }
+  out.push('');
+
+  // 2. Done
+  out.push('## ✅ Done');
+  if (s.done.length === 0) {
+    out.push('_Nothing completed this run._');
+  } else {
+    for (const e of s.done) {
+      const sha = e.commit ? ` \`${String(e.commit).slice(0, 9)}\`` : '';
+      out.push(`- ${e.subtask || e.summary || 'subtask'}${sha}${e.summary && e.subtask ? ` — ${e.summary}` : ''}`);
+    }
+  }
+  out.push('');
+
+  // 3. Auto-approved
+  out.push('## ⚡ Auto-approved (Trust Mode)');
+  if (s.autoApproved.length === 0) {
+    out.push('_No gates were auto-approved._');
+  } else {
+    for (const e of s.autoApproved) {
+      out.push(`- **${e.gate || 'gate'}**${e.task ? ` (${e.task})` : ''} — ${e.reason || 'trusted'}`);
+      // EVD verify (ADR-0023 §evidence): show the BASIS, not just the outcome,
+      // so a human can spot a call they'd have made differently.
+      const ev = e.evidence;
+      if (ev && typeof ev === 'object') {
+        const bits = [];
+        if (ev.tests) bits.push(`tests ${ev.tests.passed ?? '?'}/${ev.tests.failed ?? '?'} ${Number(ev.tests.exit) === 0 ? '✓' : '✗'}`);
+        if (ev.review) bits.push(`${ev.review.critical ?? '?'} Critical · ${ev.review.warning ?? 0} Warning`);
+        if (ev.diff) bits.push(`diff +${ev.diff.insertions ?? '?'}/−${ev.diff.deletions ?? '?'} in ${ev.diff.files ?? '?'} files${ev.diff.within_scope === false ? ' ⚠ OUT OF SCOPE' : ''}`);
+        if (bits.length) out.push(`    basis: ${bits.join(' · ')}`);
+      }
+    }
+  }
+  out.push('');
+
+  // 4. Parked for you — the section the human acts on
+  out.push('## ⏸ Parked for you');
+  if (s.parked.length === 0) {
+    out.push('_Nothing parked — the agent did not hit an ambiguous or irreversible decision._');
+  } else {
+    for (const e of s.parked) {
+      out.push(`- **${e.item || 'decision'}** — ${e.question || 'needs your call'}`);
+      if (Array.isArray(e.options) && e.options.length) {
+        out.push(`  - options: ${e.options.join(' · ')}`);
+      }
+    }
+  }
+  out.push('');
+
+  // 5. Hard-stops hit
+  out.push('## 🛑 Hard-stops hit');
+  if (s.hardStops.length === 0) {
+    out.push('_No Guard or Critical hard-stop fired._');
+  } else {
+    for (const e of s.hardStops) {
+      out.push(`- **${e.gate || e.blocker || 'hard-stop'}** — ${e.reason || e.blocker || 'blocked'}`);
+    }
+  }
+  out.push('');
+
+  // 6. Review next
+  out.push('## Review next');
+  out.push('```bash');
+  out.push('git log --oneline --since="12 hours ago"   # what landed overnight');
+  out.push('git diff main...HEAD                         # full diff to review');
+  out.push('dw goal status                              # outcome progress');
+  out.push('# resume the loop after you clear parked items:');
+  out.push('dw goal --auto=full --trust');
+  out.push('```');
+  out.push('');
+
+  return out.join('\n');
+}
+
+/**
+ * Write the digest to OVERNIGHT.md, rotating any prior run into
+ * .dw/cache/overnight/{date}.md so history is kept but the root stays a single
+ * current file.
+ */
+export function writeDigest(rootDir, content, { date = new Date().toISOString().slice(0, 10) } = {}) {
+  const target = join(rootDir, DIGEST_FILE);
+  if (existsSync(target)) {
+    const archiveDir = join(rootDir, '.dw', 'cache', 'overnight');
+    if (!existsSync(archiveDir)) mkdirSync(archiveDir, { recursive: true });
+    // Avoid clobbering a prior same-day run's archive (review round 2: W-1).
+    let archive = join(archiveDir, `${date}.md`);
+    for (let n = 1; existsSync(archive); n++) archive = join(archiveDir, `${date}-${n}.md`);
+    try {
+      renameSync(target, archive);
+    } catch (e) {
+      try { process.stderr.write(`⚠  overnight: could not rotate prior ${DIGEST_FILE} (${e.message}) — overwriting.\n`); } catch { /* stderr closed */ }
+    }
+  }
+  const dir = dirname(target);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(target, content, 'utf8');
+  return target;
+}

package/src/lib/process-kill.mjs

@@ -0,0 +1,77 @@
+// process-kill.mjs — cross-platform "kill the whole tree" helper.
+//
+// The session-runtime spawns claude via a .cmd shim on Win32 (PATHEXT
+// resolution requirement) and via the binary directly on POSIX. A plain
+// `process.kill(pid, 'SIGTERM')` only signals the shim, leaving the real
+// claude.exe as an orphan grandchild — friction F-50 from the
+// session-runtime-mvp task. This module is the documented fix.
+//
+// Strategy:
+//   Win32 → `taskkill /T /F /PID <pid>` (kills the process tree).
+//   POSIX → try process-group kill first (`process.kill(-pid, ...)` works
+//           when the child was spawned with `detached: true`, which makes
+//           it the group leader), then fall back to plain pid kill.
+//
+// Returns `{ ok, method, error? }` so callers can log forensic detail.
+
+import { execFileSync } from 'node:child_process';
+
+const POSIX_GROUP_KILL_NEGATIVE = true; // documents the Unix-isms
+
+/**
+ * Kill the process tree rooted at `pid` using the best per-platform path.
+ * Idempotent — repeated calls on a dead pid return { ok: false, error:
+ * 'ESRCH' } and do not throw.
+ */
+export function killProcessTree(pid, signal = 'SIGTERM') {
+  if (typeof pid !== 'number' || !Number.isFinite(pid) || pid <= 0) {
+    return { ok: false, method: 'invalid', error: 'invalid pid' };
+  }
+  if (process.platform === 'win32') {
+    return killWindowsTree(pid);
+  }
+  return killPosixTree(pid, signal);
+}
+
+function killWindowsTree(pid) {
+  // execFileSync with explicit argv avoids any shell-escaping pitfall.
+  try {
+    execFileSync('taskkill', ['/T', '/F', '/PID', String(pid)], {
+      stdio: 'ignore', windowsHide: true, timeout: 5000,
+    });
+    return { ok: true, method: 'taskkill_tree' };
+  } catch (err) {
+    // taskkill exits non-zero when the pid is already dead — treat that as
+    // success-by-virtue-of-being-already-gone, but report it.
+    const msg = err && err.message ? err.message : String(err);
+    if (/not found|0x80070057/i.test(msg)) {
+      return { ok: true, method: 'taskkill_already_gone' };
+    }
+    return { ok: false, method: 'taskkill', error: msg };
+  }
+}
+
+function killPosixTree(pid, signal) {
+  // Process group kill: if the child was spawned `detached: true`, it is
+  // the leader of its own process group with PGID === pid. Sending the
+  // signal to -pid hits every descendant in that group.
+  if (POSIX_GROUP_KILL_NEGATIVE) {
+    try {
+      process.kill(-pid, signal);
+      return { ok: true, method: 'kill_group' };
+    } catch (err) {
+      if (err && err.code === 'ESRCH') {
+        // Group doesn't exist (child wasn't a group leader); fall through
+        // to the single-pid path.
+      } else if (err && err.code === 'EPERM') {
+        return { ok: false, method: 'kill_group', error: 'EPERM' };
+      }
+    }
+  }
+  try {
+    process.kill(pid, signal);
+    return { ok: true, method: 'kill_pid' };
+  } catch (err) {
+    return { ok: false, method: 'kill_pid', error: err && err.code ? err.code : err.message };
+  }
+}

package/src/lib/task-md-utils.mjs

@@ -0,0 +1,78 @@
+// task-md-utils.mjs — shared parsers for task.md v3 files.
+//
+// Used by board-data.mjs + goal-progress.mjs. Extracted into its own module
+// to break the cycle that would otherwise form between those two
+// (board-data attaches progress.computeGoalProgress, goal-progress reads the
+// same parseSubtasks board-data uses).
+//
+// Per ADR-0001: zero-dep beyond js-yaml.
+
+import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import yaml from 'js-yaml';
+
+const TASKS_DIR = '.dw/tasks';
+
+const STATUS_ICONS = {
+  '⬜': 'pending',
+  '🟡': 'in_progress',
+  '✅': 'done',
+  '🔴': 'blocked',
+  '⏸': 'paused',
+};
+
+/** Extract frontmatter (between --- markers) from a markdown file. */
+export function readFrontmatter(file) {
+  if (!existsSync(file)) return {};
+  let txt;
+  try { txt = readFileSync(file, 'utf8'); } catch { return {}; }
+  const m = txt.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return {};
+  try { return yaml.load(m[1]) || {}; } catch { return {}; }
+}
+
+/**
+ * Parse Section 3 Subtask Tracker rows from a task.md.
+ * Returns rows shaped { st_id, title, status_bucket, status_icon, status_label, date, notes }.
+ */
+export function parseSubtasks(taskPath) {
+  if (!existsSync(taskPath)) return [];
+  let txt;
+  try { txt = readFileSync(taskPath, 'utf8'); } catch { return []; }
+  const sec = txt.match(/^## 3\.[^\n]*\n([\s\S]*?)(?=^## 4\.|$(?![\s\S]))/m);
+  if (!sec) return [];
+  const out = [];
+  for (const line of sec[1].split('\n')) {
+    // `u` flag is essential — 🟡 (U+1F7E1) and 🔴 (U+1F534) are surrogate
+    // pairs; the character class would otherwise match the low surrogate
+    // instead of the emoji, silently dropping in_progress / blocked rows.
+    const m = line.match(/^\|\s*(ST-[\w.-]+)\s*\|\s*(.+?)\s*\|\s*([⬜🟡✅🔴⏸])\s*([A-Za-z ]+)?\s*\|\s*([^|]*)\|\s*([^|]*)\|/u);
+    if (!m) continue;
+    const icon = m[3];
+    const statusBucket = STATUS_ICONS[icon] || 'unknown';
+    const statusLabel = (m[4] || '').trim();
+    out.push({
+      st_id: m[1].trim(),
+      title: m[2].replace(/`/g, '').trim(),
+      status_bucket: statusBucket,
+      status_icon: icon,
+      status_label: statusLabel,
+      date: m[5].trim(),
+      notes: m[6].trim().slice(0, 160),
+    });
+  }
+  return out;
+}
+
+/** List task directories under `.dw/tasks/` (skipping archive + dotfiles). */
+export function listTaskDirs(rootDir) {
+  const dir = join(rootDir, TASKS_DIR);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((entry) => {
+      if (entry.startsWith('.') || entry === 'archive') return false;
+      try { return statSync(join(dir, entry)).isDirectory(); } catch { return false; }
+    });
+}
+
+export { TASKS_DIR, STATUS_ICONS };

package/src/lib/tls-helpers.mjs

@@ -10,12 +10,33 @@
 //
 // F-24 fix (G-rgoal-realtime-orch KR-A production-readiness).
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync, statSync } from 'node:fs';
+import { join, delimiter } from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { networkInterfaces } from 'node:os';
 import { resolveCommandPath } from './spawn-helpers.mjs';
 
+// Whether `cmd` is actually an executable on PATH.
+//
+// `resolveCommandPath` is spawn-oriented: on POSIX it returns `found: true`
+// unconditionally (spawn resolves PATH itself), so it CANNOT answer "is this
+// binary installed?" — trusting its `.found` here false-positived `mkcert` on
+// any Linux box without it. So on POSIX we walk PATH and check for an
+// executable regular file; on Win32 `resolveCommandPath` already does a real
+// PATH+PATHEXT walk, so we defer to it.
+function commandInstalled(cmd) {
+  if (process.platform === 'win32') return resolveCommandPath(cmd).found;
+  const dirs = (process.env.PATH || '').split(delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    const p = join(dir, cmd);
+    try {
+      const st = statSync(p);
+      if (st.isFile() && (st.mode & 0o111) !== 0) return true; // any exec bit
+    } catch { /* not here — keep looking */ }
+  }
+  return false;
+}
+
 const TLS_DIR_REL = '.dw/cache/voice/tls';
 const KEY_FILE = 'key.pem';
 const CERT_FILE = 'cert.pem';
@@ -29,10 +50,11 @@ const CERT_DAYS = 3650; // 10y — local cert; we don't rotate often
  * Returns { name: 'mkcert' | 'openssl' | 'none', path: string | null }
  */
 export function detectTlsProvider() {
-  const mkcert = resolveCommandPath('mkcert');
-  if (mkcert.found) return { name: 'mkcert', path: mkcert.path, needsShell: mkcert.needsShell };
-  const openssl = resolveCommandPath('openssl');
-  if (openssl.found) return { name: 'openssl', path: openssl.path, needsShell: openssl.needsShell };
+  for (const name of ['mkcert', 'openssl']) {
+    if (!commandInstalled(name)) continue;
+    const r = resolveCommandPath(name); // path + needsShell details
+    return { name, path: r.path, needsShell: r.needsShell };
+  }
   return { name: 'none', path: null, needsShell: false };
 }