dw-kit 1.9.2 → 1.9.3

package/src/commands/voice.mjs

@@ -83,6 +83,12 @@ import { buildSessionTreeData } from '../lib/session-tree.mjs';
 import { startDebate, resolveDebateRoster } from '../lib/debate.mjs';
 import { createSseBroker } from '../lib/sse-broker.mjs';
 import { buildBoardData } from '../lib/board-data.mjs';
+import {
+  claimGoal, releaseGoal, attachSessionId, buildDriverPrompt, parseBudget, readClaim, listClaims,
+} from '../lib/goal-driver.mjs';
+import { startProgressWatcher, stopProgressWatcher } from '../lib/goal-progress.mjs';
+import { logGoalEvent } from '../lib/goal-events.mjs';
+import { killProcessTree } from '../lib/process-kill.mjs';
 
 const CACHE_DIR = '.dw/cache';
 const VOICE_TOKEN_PATH = '.dw/cache/voice.token';
@@ -989,6 +995,50 @@ if (document.readyState === 'loading') {
 </body></html>`;
 }
 
+// ─ goal-driver-mvp ST-8: claim reconcile + tree-kill ─
+//
+// Reconcile = sweep `.dw/cache/goal-claims/*.json`, drop any claim whose
+// linked session has terminated (status in exited/completed/failed/stopped
+// OR pid is dead). Without this, an agent that finishes cleanly leaves
+// the "Running…" pill stuck on the board until expires_at TTL fires.
+// Runs lazily on each /voice/board fetch + at the top of /voice/goal-start
+// so re-clicking Start always finds a fresh slot.
+//
+// Returns { released: string[] } so the caller can log how many stale
+// claims were collected on this pass.
+function reconcileGoalDrivers(rootDir) {
+  const out = { released: [] };
+  let claims;
+  try { claims = listClaims(rootDir); }
+  catch { return out; }
+  const GRACE_MS = 5_000; // don't release a claim younger than this (spawn race)
+  const now = Date.now();
+  for (const claim of claims) {
+    if (!claim.session_id) continue;
+    let s;
+    try { s = getSession(claim.session_id, rootDir); }
+    catch { continue; }
+    if (!s) continue;
+    const terminal = ['exited', 'completed', 'failed', 'stopped'].includes(s.status);
+    const pidDead = s.pid ? !isAlive(s.pid) : true;
+    if (!(terminal && pidDead)) continue;
+    const claimedMs = Date.parse(claim.claimed_at);
+    if (Number.isFinite(claimedMs) && (now - claimedMs) < GRACE_MS) continue;
+    releaseGoal(claim.goal_id, rootDir);
+    stopProgressWatcher(claim.goal_id);
+    logGoalEvent({
+      event: 'goal_driver_orphan_released',
+      goal_id: claim.goal_id,
+      session_id: claim.session_id,
+      claim_id: claim.claim_id,
+      session_status: s.status,
+      reason: 'session_terminal_pid_dead',
+    }, rootDir);
+    out.released.push(claim.goal_id);
+  }
+  return out;
+}
+
 // ─ F-49 Đợt 2: Kanban board page ─
 //
 // Self-contained HTML at /board?t=<token>. Polls /voice/board for JSON, then
@@ -1047,6 +1097,25 @@ function boardHtml(token) {
   .empty { color: var(--dim); font-style: italic; font-size: 12px; padding: 8px 0; }
   .toast { position: fixed; bottom: 16px; right: 16px; background: var(--card); border: 1px solid var(--accent); padding: 10px 14px; border-radius: 6px; font-size: 13px; max-width: 360px; box-shadow: 0 4px 12px rgba(0,0,0,0.4); }
   .toast.err { border-color: var(--err); }
+  .gtopline { display: flex; justify-content: space-between; align-items: flex-start; gap: 8px; }
+  .gtopline .ghead { min-width: 0; }
+  .goal-actions { display: flex; gap: 6px; flex-shrink: 0; }
+  .goal-start-btn { background: var(--accent); color: #0d1117; border: 0; border-radius: 4px; padding: 4px 10px; font-size: 11px; font-weight: 600; cursor: pointer; white-space: nowrap; }
+  .goal-start-btn:hover { filter: brightness(1.15); }
+  .goal-start-btn:disabled { cursor: not-allowed; opacity: 0.85; }
+  .goal-start-btn.running { background: var(--warn); color: #0d1117; animation: gd-pulse 1.4s ease-in-out infinite; }
+  .goal-stop-btn { background: var(--err); color: #fff; border: 0; border-radius: 4px; padding: 4px 10px; font-size: 11px; font-weight: 600; cursor: pointer; white-space: nowrap; }
+  .goal-stop-btn:hover { filter: brightness(1.15); }
+  @keyframes gd-pulse { 0%,100% { opacity: 1; } 50% { opacity: 0.55; } }
+  .gd-cap { color: var(--dim); font-size: 10px; margin-top: 2px; }
+  .gd-progress { margin-top: 6px; padding: 6px 8px; background: rgba(210, 153, 34, 0.08); border-left: 2px solid var(--warn); border-radius: 3px; }
+  .gd-progress .current { color: var(--warn); font-size: 12px; font-weight: 600; }
+  .gd-progress .current.bucket-pending { color: var(--dim); }
+  .gd-progress .stats { color: var(--dim); font-size: 11px; margin-top: 2px; }
+  .gd-progress .stats .alive { color: var(--ok); }
+  .gd-progress .stats .stale { color: var(--err); }
+  .gd-progress .pbar { height: 4px; background: var(--border); border-radius: 2px; margin-top: 4px; overflow: hidden; }
+  .gd-progress .pbar .pfill { height: 100%; background: var(--warn); transition: width 0.4s; }
 </style>
 </head><body>
 <div class="topbar">
@@ -1132,13 +1201,96 @@ function render(d) {
   for (const g of d.goals) {
     const gc = document.createElement('div');
     gc.className = 'goal-card cycle-' + (g.cycle || '');
+    gc.dataset.goalId = g.goal_id;
     const gid = document.createElement('div'); gid.className = 'gid';
     gid.textContent = (g.icon ? g.icon + ' ' : '') + g.goal_id;
     const gt = document.createElement('div'); gt.className = 'gtitle';
     gt.textContent = g.title;
     const gm = document.createElement('div'); gm.className = 'gmeta';
     gm.textContent = g.status + (g.target_date ? ' · ' + g.target_date : '') + (g.cycle ? ' · ' + g.cycle : '');
-    gc.appendChild(gid); gc.appendChild(gt); gc.appendChild(gm);
+    // ST-3: Start button per goal — disabled while claim is active.
+    const topline = document.createElement('div'); topline.className = 'gtopline';
+    const ghead = document.createElement('div'); ghead.className = 'ghead';
+    ghead.appendChild(gid); ghead.appendChild(gt);
+    topline.appendChild(ghead);
+    const startBtn = document.createElement('button');
+    startBtn.type = 'button';
+    startBtn.className = 'goal-start-btn' + (g.claim ? ' running' : '');
+    startBtn.disabled = !!g.claim;
+    const lang = (navigator.language || 'en').toLowerCase().startsWith('vi') ? 'vi' : 'en';
+    if (g.claim) {
+      startBtn.textContent = lang === 'vi' ? 'Đang chạy…' : 'Running…';
+      startBtn.title = lang === 'vi'
+        ? ('Session ' + (g.claim.session_id || '').slice(-8) + ' · cap ' + g.claim.max_minutes + ' phút')
+        : ('Session ' + (g.claim.session_id || '').slice(-8) + ' · cap ' + g.claim.max_minutes + 'm');
+    } else {
+      startBtn.textContent = lang === 'vi' ? 'Bắt đầu ▶' : 'Start ▶';
+      startBtn.title = lang === 'vi'
+        ? 'Spawn agent ngầm drive goal tới hoàn thành (cap 25 phút)'
+        : 'Spawn background driver to complete this goal (25-min cap)';
+    }
+    startBtn.onclick = (ev) => { ev.stopPropagation(); triggerGoalStart(g, lang); };
+    const actions = document.createElement('div'); actions.className = 'goal-actions';
+    actions.appendChild(startBtn);
+    if (g.claim) {
+      // Stop button only shown while a claim is active. Clicking it sends
+      // SIGTERM (tree-kill server-side), releases the claim, and re-renders.
+      const stopBtn = document.createElement('button');
+      stopBtn.type = 'button';
+      stopBtn.className = 'goal-stop-btn';
+      stopBtn.textContent = lang === 'vi' ? 'Dừng ◼' : 'Stop ◼';
+      stopBtn.title = lang === 'vi'
+        ? 'Gửi SIGTERM cho session + release claim'
+        : 'SIGTERM the session + release claim';
+      stopBtn.onclick = (ev) => { ev.stopPropagation(); triggerGoalStop(g, lang); };
+      actions.appendChild(stopBtn);
+    }
+    topline.appendChild(actions);
+    gc.appendChild(topline);
+    gc.appendChild(gm);
+    if (g.claim) {
+      const cap = document.createElement('div'); cap.className = 'gd-cap';
+      cap.textContent = (lang === 'vi' ? 'driver hết hạn lúc ' : 'driver expires ') + g.claim.expires_at;
+      gc.appendChild(cap);
+      // Live progress chunk: current subtask + X/Y + last-activity timer.
+      if (g.claim.progress) {
+        const pr = g.claim.progress;
+        const wrap = document.createElement('div'); wrap.className = 'gd-progress';
+        const cur = document.createElement('div');
+        cur.className = 'current bucket-' + (pr.current ? pr.current.status_bucket : 'idle');
+        if (pr.current) {
+          const icon = pr.current.status_bucket === 'in_progress' ? '▶ ' : '⬜ ';
+          cur.textContent = icon + pr.current.st_id + ' · ' + pr.current.title;
+        } else {
+          cur.textContent = (lang === 'vi' ? 'Không có subtask đang chạy' : 'No subtask currently in flight');
+        }
+        const stats = document.createElement('div'); stats.className = 'stats';
+        const doneStr = pr.done + '/' + pr.total + (lang === 'vi' ? ' xong' : ' done')
+          + ' · ' + pr.percent + '%';
+        stats.textContent = doneStr;
+        const sep = document.createElement('span'); sep.textContent = ' · ';
+        stats.appendChild(sep);
+        const ago = document.createElement('span');
+        const aliveInfo = formatActivity(pr.last_activity_at || g.claim.claimed_at, lang);
+        ago.className = aliveInfo.stale ? 'stale' : 'alive';
+        ago.textContent = aliveInfo.text;
+        stats.appendChild(ago);
+        if (pr.blocked > 0) {
+          const blk = document.createElement('span');
+          blk.style.color = 'var(--err)';
+          blk.textContent = ' · ' + pr.blocked + (lang === 'vi' ? ' blocked' : ' blocked');
+          stats.appendChild(blk);
+        }
+        const bar = document.createElement('div'); bar.className = 'pbar';
+        const fill = document.createElement('div'); fill.className = 'pfill';
+        fill.style.width = pr.percent + '%';
+        bar.appendChild(fill);
+        wrap.appendChild(cur);
+        wrap.appendChild(stats);
+        wrap.appendChild(bar);
+        gc.appendChild(wrap);
+      }
+    }
     if (g.progress && Number.isFinite(g.progress.percent)) {
       const bar = document.createElement('div'); bar.className = 'progress-bar';
       const fill = document.createElement('div'); fill.className = 'fill';
@@ -1212,6 +1364,71 @@ function bucketForStatus(s) {
   return 'terminal';
 }
 
+// Returns { text, stale } — relative-time label + a flag the UI can use to
+// flip "alive" green to "stale" red after 90s of silence.
+function formatActivity(iso, lang) {
+  const L = lang === 'vi' ? 'vi' : 'en';
+  if (!iso) return { text: L === 'vi' ? 'chưa có hoạt động' : 'no activity yet', stale: true };
+  const ms = Date.now() - Date.parse(iso);
+  if (!Number.isFinite(ms) || ms < 0) return { text: iso, stale: false };
+  const sec = Math.floor(ms / 1000);
+  const STALE_AT_MS = 90 * 1000;
+  const stale = ms > STALE_AT_MS;
+  let unit;
+  if (sec < 60) unit = sec + 's';
+  else if (sec < 3600) unit = Math.floor(sec / 60) + 'm';
+  else if (sec < 86400) unit = Math.floor(sec / 3600) + 'h';
+  else unit = Math.floor(sec / 86400) + 'd';
+  return {
+    text: L === 'vi' ? ('hoạt động ' + unit + ' trước') : (unit + ' ago'),
+    stale,
+  };
+}
+
+function triggerGoalStop(goal, lang) {
+  const L = lang === 'vi' ? 'vi' : 'en';
+  if (!confirm(L === 'vi'
+    ? ('Dừng driver cho ' + goal.goal_id + '? Session sẽ bị SIGTERM.')
+    : ('Stop driver for ' + goal.goal_id + '? The session will be SIGTERMed.'))) return;
+  showToast((L === 'vi' ? 'Đang dừng: ' : 'Stopping: ') + goal.goal_id + '…');
+  fetch('/voice/goal-stop', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'X-Voice-Token': TOKEN },
+    body: JSON.stringify({ goal_id: goal.goal_id }),
+  }).then((r) => r.json().then((j) => ({ status: r.status, j }))).then(({ status, j }) => {
+    if (j.ok) {
+      showToast((L === 'vi' ? 'Đã dừng · ' : 'Stopped · ') + (j.kill_method || ''));
+      setTimeout(loadBoard, 400);
+    } else if (status === 404) {
+      showToast(L === 'vi' ? 'Không có driver đang chạy' : 'No driver running', true);
+      setTimeout(loadBoard, 200);
+    } else {
+      showToast((L === 'vi' ? 'Lỗi: ' : 'Failed: ') + (j.error || 'unknown'), true);
+    }
+  }).catch((e) => showToast((L === 'vi' ? 'Lỗi mạng: ' : 'Network error: ') + e.message, true));
+}
+
+function triggerGoalStart(goal, lang) {
+  const L = lang === 'vi' ? 'vi' : 'en';
+  showToast((L === 'vi' ? 'Đang khởi động driver: ' : 'Driving: ') + goal.goal_id + '…');
+  fetch('/voice/goal-start', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'X-Voice-Token': TOKEN },
+    body: JSON.stringify({ goal_id: goal.goal_id, lang: L }),
+  }).then((r) => r.json().then((j) => ({ status: r.status, j }))).then(({ status, j }) => {
+    if (j.ok) {
+      const tail = (j.session_id || '').slice(-8);
+      showToast((L === 'vi' ? 'Driver chạy · ' : 'Driver running · ')
+        + tail + ' · cap ' + j.budget.max_minutes + (L === 'vi' ? ' phút' : 'm'));
+      setTimeout(loadBoard, 400);
+    } else if (status === 409) {
+      showToast(L === 'vi' ? 'Đã có driver chạy — xem cột Sessions' : 'Already driving — see Sessions column', true);
+    } else {
+      showToast((L === 'vi' ? 'Lỗi: ' : 'Failed: ') + (j.error || 'unknown'), true);
+    }
+  }).catch((e) => showToast((L === 'vi' ? 'Lỗi mạng: ' : 'Network error: ') + e.message, true));
+}
+
 function triggerSpawnForTask(task, goal) {
   const text = 'start agent for task ' + task.task_id + ' under goal ' + goal.goal_id;
   showToast('Asking orchestrator: ' + text);
@@ -1266,7 +1483,7 @@ es.addEventListener('message', (ev) => {
   let p; try { p = JSON.parse(ev.data); } catch { return; }
   if (!p || !p.event) return;
   const n = p.event;
-  if (n.startsWith('session.') || n.startsWith('goal.') || n === 'debate_completed' || n === 'debate_started') {
+  if (n.startsWith('session.') || n.startsWith('goal.') || n.startsWith('goal_driver_') || n === 'debate_completed' || n === 'debate_started') {
     scheduleRefresh();
   }
 });
@@ -1686,6 +1903,151 @@ export async function voiceCommand(opts = {}) {
         res.end(JSON.stringify({ ok: true, data: { roster, timeout_ms } }));
         return;
       }
+      // goal-driver-mvp ST-2: POST /voice/goal-start spawns an autonomous
+      // claude driver session for the supplied goal_id, gated by a per-goal
+      // claim file (.dw/cache/goal-claims/<id>.json). The spawned agent runs
+      // the F-43 workflow in a budgeted loop; we SIGTERM at the wall-clock
+      // cap and release the claim. See task.md + ADR-0014 (whitelist).
+      if (req.method === 'POST' && req.url === '/voice/goal-start') {
+        if (req.headers['x-voice-token'] !== token) {
+          res.writeHead(401, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: 'unauthorized' }));
+          return;
+        }
+        let body = '';
+        req.setEncoding('utf8');
+        req.on('data', (c) => { body += c; if (body.length > 8192) req.destroy(); });
+        req.on('end', async () => {
+          let parsed;
+          try { parsed = JSON.parse(body); }
+          catch { res.writeHead(400); res.end(JSON.stringify({ ok: false, error: 'bad json' })); return; }
+          const goalId = (parsed.goal_id || '').trim();
+          if (!/^G-[A-Za-z0-9_-]{1,64}$/.test(goalId)) {
+            res.writeHead(400); res.end(JSON.stringify({ ok: false, error: 'invalid goal_id' })); return;
+          }
+          const goalFile = join(rootDir, '.dw', 'goals', goalId, 'goal.md');
+          if (!existsSync(goalFile)) {
+            res.writeHead(404); res.end(JSON.stringify({ ok: false, error: `goal not found: ${goalId}` })); return;
+          }
+          const lang = (parsed.lang || 'en').toString().startsWith('vi') ? 'vi' : 'en';
+          const budgetOpts = {
+            max_iterations: parsed.max_iterations,
+            max_minutes: parsed.max_minutes,
+            lang,
+          };
+          // ST-8: sweep stale claims first so re-Start on a goal whose
+          // previous driver exited cleanly works without manual cleanup.
+          reconcileGoalDrivers(rootDir);
+          const claimResult = claimGoal(goalId, null, budgetOpts, rootDir);
+          if (!claimResult.ok) {
+            const code = claimResult.reason === 'already_claimed' ? 409 : 400;
+            res.writeHead(code, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: claimResult.reason, existing: claimResult.existing || null }));
+            return;
+          }
+          const claim = claimResult.claim;
+          const prompt = buildDriverPrompt(goalId, budgetOpts, rootDir);
+          let spawnResult;
+          try {
+            spawnResult = await executeAction({
+              name: 'start_session',
+              args: { agent: 'claude', goal: prompt },
+              rootDir,
+              lang: lang === 'vi' ? 'vi-VN' : 'en-US',
+            });
+          } catch (e) {
+            releaseGoal(goalId, rootDir);
+            res.writeHead(500); res.end(JSON.stringify({ ok: false, error: `spawn failed: ${e.message}` }));
+            return;
+          }
+          if (!spawnResult.ok) {
+            releaseGoal(goalId, rootDir);
+            res.writeHead(500); res.end(JSON.stringify({ ok: false, error: spawnResult.display || 'spawn failed' }));
+            return;
+          }
+          const sessionId = spawnResult.data && spawnResult.data.id;
+          if (sessionId) attachSessionId(goalId, sessionId, rootDir);
+          logGoalEvent({
+            event: 'goal_driver_started',
+            goal_id: goalId,
+            session_id: sessionId || null,
+            claim_id: claim.claim_id,
+            max_iterations: claim.max_iterations,
+            max_minutes: claim.max_minutes,
+            lang,
+          }, rootDir);
+          // Surface live progress: watch the linked task.md and emit a
+          // goal_driver_subtask_progress event whenever Section 3 status
+          // icons change. The events flow through the existing SSE broker
+          // (events-global.jsonl watcher) to the board UI.
+          const watchResult = startProgressWatcher(goalId, rootDir, ({ changes, snapshot }) => {
+            const done = snapshot.filter((s) => s.status_bucket === 'done').length;
+            const total = snapshot.length;
+            const current = snapshot.find((s) => s.status_bucket === 'in_progress')
+              || snapshot.find((s) => s.status_bucket === 'pending');
+            logGoalEvent({
+              event: 'goal_driver_subtask_progress',
+              goal_id: goalId,
+              session_id: sessionId || null,
+              claim_id: claim.claim_id,
+              changes,
+              done,
+              total,
+              current: current ? { st_id: current.st_id, title: current.title.slice(0, 120) } : null,
+            }, rootDir);
+          });
+          if (!watchResult.ok && watchResult.reason !== 'no_linked_task') {
+            logGoalEvent({
+              event: 'goal_driver_watch_failed',
+              goal_id: goalId,
+              claim_id: claim.claim_id,
+              reason: watchResult.reason,
+            }, rootDir);
+          }
+          // Wall-clock kill switch — the cap inside the prompt is advisory;
+          // this setTimeout is the enforcer. Released claim + SIGTERM on
+          // fire; unref so an idle server doesn't keep the process alive
+          // just for the timer.
+          const killTimer = setTimeout(() => {
+            try {
+              const s = sessionId ? getSession(sessionId, rootDir) : null;
+              if (s && s.pid && isAlive(s.pid)) {
+                // F-50 fix: tree-kill so the .cmd wrapper's claude.exe
+                // grandchild on Win32 doesn't survive as an orphan.
+                const killResult = killProcessTree(s.pid, 'SIGTERM');
+                updateSessionStatus(sessionId, { status: 'stopped' }, rootDir);
+                appendEvent(sessionId, {
+                  event: 'stopped', signal: 'SIGTERM',
+                  by: 'goal-driver-budget', kill_method: killResult.method,
+                }, rootDir);
+              }
+              logGoalEvent({
+                event: 'goal_driver_terminated',
+                goal_id: goalId,
+                session_id: sessionId || null,
+                claim_id: claim.claim_id,
+                reason: 'budget_exhausted',
+              }, rootDir);
+            } catch { /* best-effort */ }
+            stopProgressWatcher(goalId);
+            releaseGoal(goalId, rootDir);
+          }, claim.max_minutes * 60_000);
+          if (typeof killTimer.unref === 'function') killTimer.unref();
+
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({
+            ok: true,
+            session_id: sessionId,
+            claim_id: claim.claim_id,
+            goal_id: goalId,
+            budget: { max_iterations: claim.max_iterations, max_minutes: claim.max_minutes },
+            expires_at: claim.expires_at,
+            lang,
+          }));
+        });
+        return;
+      }
+
       // F-49 Đợt 2: Kanban board JSON + HTML page.
       if (req.method === 'GET' && req.url.startsWith('/voice/board')) {
         const urlObj = new URL(req.url, `http://localhost:${port}`);
@@ -1695,6 +2057,10 @@ export async function voiceCommand(opts = {}) {
           return;
         }
         try {
+          // ST-8: lazy reconcile drops stale claims whose session has
+          // exited cleanly. Without this, "Running…" sticks until the
+          // wall-clock TTL fires (up to max_minutes after natural exit).
+          reconcileGoalDrivers(rootDir);
           const data = buildBoardData(rootDir);
           res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' });
           res.end(JSON.stringify({ ok: true, data }, null, 2));
@@ -1704,6 +2070,69 @@ export async function voiceCommand(opts = {}) {
         }
         return;
       }
+      // goal-driver-mvp ST-8: POST /voice/goal-stop kills the driver
+      // session (tree-kill so the Win32 cmd.exe→claude.exe grandchild
+      // dies too), releases the claim, stops the watcher, and logs a
+      // goal_driver_stopped event for forensics.
+      if (req.method === 'POST' && req.url === '/voice/goal-stop') {
+        if (req.headers['x-voice-token'] !== token) {
+          res.writeHead(401, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: 'unauthorized' }));
+          return;
+        }
+        let body = '';
+        req.setEncoding('utf8');
+        req.on('data', (c) => { body += c; if (body.length > 4096) req.destroy(); });
+        req.on('end', () => {
+          let parsed;
+          try { parsed = JSON.parse(body); }
+          catch { res.writeHead(400); res.end(JSON.stringify({ ok: false, error: 'bad json' })); return; }
+          const goalId = (parsed.goal_id || '').trim();
+          if (!/^G-[A-Za-z0-9_-]{1,64}$/.test(goalId)) {
+            res.writeHead(400); res.end(JSON.stringify({ ok: false, error: 'invalid goal_id' })); return;
+          }
+          const claim = readClaim(goalId, rootDir);
+          if (!claim) {
+            res.writeHead(404); res.end(JSON.stringify({ ok: false, error: 'not_driving' })); return;
+          }
+          let killResult = { ok: true, method: 'no_session' };
+          let sessionStatus = 'unknown';
+          if (claim.session_id) {
+            const s = getSession(claim.session_id, rootDir);
+            if (s) {
+              sessionStatus = s.status;
+              if (s.pid && isAlive(s.pid)) {
+                killResult = killProcessTree(s.pid, 'SIGTERM');
+                updateSessionStatus(claim.session_id, { status: 'stopped' }, rootDir);
+                appendEvent(claim.session_id, {
+                  event: 'stopped', signal: 'SIGTERM',
+                  by: 'goal-driver-stop-button', kill_method: killResult.method,
+                }, rootDir);
+              }
+            }
+          }
+          stopProgressWatcher(goalId);
+          releaseGoal(goalId, rootDir);
+          logGoalEvent({
+            event: 'goal_driver_stopped',
+            goal_id: goalId,
+            session_id: claim.session_id || null,
+            claim_id: claim.claim_id,
+            kill_method: killResult.method,
+            kill_ok: killResult.ok,
+            prior_session_status: sessionStatus,
+            by: 'stop_button',
+          }, rootDir);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({
+            ok: true,
+            goal_id: goalId,
+            kill_method: killResult.method,
+            session_id: claim.session_id || null,
+          }));
+        });
+        return;
+      }
       if (req.method === 'GET' && (req.url === '/board' || req.url.startsWith('/board?'))) {
         // Token authorization happens in JSON fetch — the HTML itself is
         // public scaffolding (matches the / behavior).

package/src/lib/board-data.mjs

@@ -25,8 +25,10 @@
 
 import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
 import { join, basename } from 'node:path';
-import yaml from 'js-yaml';
 import { listSessions } from './session-store.mjs';
+import { readClaim } from './goal-driver.mjs';
+import { computeGoalProgress } from './goal-progress.mjs';
+import { parseSubtasks, readFrontmatter, listTaskDirs } from './task-md-utils.mjs';
 
 const GOALS_INDEX_PATH = '.dw/goals/goals-index.json';
 const GOALS_DIR = '.dw/goals';
@@ -42,62 +44,9 @@ function safeReadGoalsIndex(rootDir) {
   try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return { goals: {} }; }
 }
 
-// Extract frontmatter (between --- markers) from a markdown file. Returns
-// an object via js-yaml, or {} if absent / malformed.
-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 {}; }
-}
-
-// Section 3 Subtask Tracker parser. Matches the `| ST-N | title | status | date | notes |`
-// row pattern used across the repo. Returns an array of subtask rows.
-const STATUS_ICONS = {
-  '⬜': 'pending',
-  '🟡': 'in_progress',
-  '✅': 'done',
-  '🔴': 'blocked',
-  '⏸': 'paused',
-};
-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')) {
-    // | ST-1 | "Subtask title" | ✅ Done | 2026-05-25 | notes |
-    const m = line.match(/^\|\s*(ST-[\w.-]+)\s*\|\s*(.+?)\s*\|\s*([⬜🟡✅🔴⏸])\s*([A-Za-z ]+)?\s*\|\s*([^|]*)\|\s*([^|]*)\|/);
-    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;
-}
-
-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; }
-    });
-}
+// Parsers (parseSubtasks / readFrontmatter / listTaskDirs) live in
+// task-md-utils.mjs so goal-progress.mjs can share them without forming a
+// circular import via board-data.mjs.
 
 // ─ Public API ──────────────────────────────────────────────────────────────
 
@@ -145,6 +94,10 @@ export function buildBoardData(rootDir, opts = {}) {
   for (const [goal_id, g] of goalsIndexEntries) {
     if (g.archived_at) continue; // hide archived
     const tasks = (byGoal.get(goal_id) || []).slice(0, MAX_TASKS_PER_GOAL);
+    // goal-driver-mvp ST-6: attach live claim state (or null) so the board
+    // UI can render "Running…" disabled state on the Start button without
+    // a second roundtrip. readClaim auto-expires stale entries.
+    const claim = readClaim(goal_id, rootDir);
     goals.push({
       goal_id,
       title: g.title || goal_id,
@@ -157,6 +110,18 @@ export function buildBoardData(rootDir, opts = {}) {
       last_updated: g.last_updated || null,
       linked_task_ids: g.linked_task_ids || [],
       tasks,
+      claim: claim ? {
+        claim_id: claim.claim_id,
+        session_id: claim.session_id || null,
+        claimed_at: claim.claimed_at,
+        expires_at: claim.expires_at,
+        max_iterations: claim.max_iterations,
+        max_minutes: claim.max_minutes,
+        // ST-7 (goal-driver-mvp v2): live progress derived from the linked
+        // task.md Section 3 + last goal_driver_* event timestamp. null when
+        // no linked task is wired up.
+        progress: claim ? computeGoalProgress(goal_id, rootDir) : null,
+      } : null,
     });
   }
 
@@ -197,6 +162,7 @@ export function buildBoardData(rootDir, opts = {}) {
     subtasks_blocked: 0,
     sessions_running: sessions.filter((s) => s.status === 'running').length,
     sessions_total: sessions.length,
+    goals_driving: goals.filter((g) => g.claim).length,
   };
   for (const t of allTasks) {
     for (const st of t.subtasks) {