buildline 0.5.1 → 0.7.0

package/README.md

@@ -134,9 +134,11 @@ Start at 2. Raise it as your gates and acceptance scenarios earn trust. [More on
 
 <img alt="buildline watch: features on tracks through spec, design, plan, build, verify, review and ship, with an inspector and live event log" src="docs/assets/watch.png">
 
-- a **comet** on the track means an agent can work on it now; a **blinking dot** means it waits on a PM, designer or engineer
+- a **comet** on the track means a Claude Code session is working on it right now, with its latest step; **NEEDS YOU** and **BLOCKED** mean an agent is waiting on your answer
+- run several sessions at once, one per feature: each gets its own track
 - the model under each station is the one that runs it
 - `↑↓` to inspect tasks and history, `⏎` to open the station on its model, `a` to approve, `q` to quit
+- a **chime** when a feature starts waiting on you or ships, so you can look away; `m` mutes it, `npx buildline sound off` turns it off for good (the dashboard chimes too)
 
 ## The dashboard
 
@@ -195,6 +197,7 @@ npx buildline watch                  live view of the line in the terminal
 npx buildline step <station> [id]    open a station on its model  --headless --model
 npx buildline models                 choose models  set <station|phase> <model> · check
 npx buildline run <id>               autopilot with Claude Code /goal  --headless
+npx buildline sound [on|off]         chime when a feature needs you or ships
 npx buildline gates                  run quality gates
 npx buildline doctor                 check the setup
 npx buildline update                 refresh managed files, keep your edits

package/bin/buildline.js

@@ -18,10 +18,11 @@ ${pc.bold('Commands')}
   ${pc.cyan('new')} "<title>"            open a feature  ${pc.dim('--type fix|feature|epic  --owner <name>  --parent <id>')}
   ${pc.cyan('approve')} <id> <stage>     record a human approval (spec | design | plan)  ${pc.dim('--by <name>')}
   ${pc.cyan('move')} <id> <station>      move a feature to a station  ${pc.dim('--note "<why>"')}
-  ${pc.cyan('watch')}                    live view of the line in your terminal  ${pc.dim('--shipped  --once  --no-intro')}
-  ${pc.cyan('ui')}                       open the dashboard in your browser  ${pc.dim('--port <n>  --no-open')}
+  ${pc.cyan('watch')}                    live view of the line in your terminal  ${pc.dim('--shipped  --once  --no-intro  --quiet')}
+  ${pc.cyan('ui')}                       open the dashboard in your browser  ${pc.dim('--port <n>  --no-open  --quiet')}
   ${pc.cyan('step')} <station> [id]      open a station in the CLI and model set for it  ${pc.dim('--model <m>  --headless  --print')}
   ${pc.cyan('models')}                   choose models per station  ${pc.dim('set <station|phase> <model> · check')}
+  ${pc.cyan('sound')} [on|off]           chime when a feature needs you or ships (watch and dashboard)
   ${pc.cyan('run')} [id]                 autopilot: build → verify → review with Claude Code /goal  ${pc.dim('--headless  --print')}
   ${pc.cyan('gates')} [names...]         run the quality gates
   ${pc.cyan('doctor')}                   check the setup
@@ -75,13 +76,14 @@ const { values: opts, positionals } = parseArgs({
     once: { type: 'boolean' },
     shipped: { type: 'boolean' },
     'no-intro': { type: 'boolean' },
+    quiet: { type: 'boolean', short: 'q' },
     help: { type: 'boolean', short: 'h' },
     version: { type: 'boolean', short: 'v' },
   },
 });
 
 const root = path.resolve(opts.cwd || process.cwd());
-const o = { ...opts, dryRun: opts['dry-run'], ci: opts['no-ci'] ? false : opts.ci, open: !opts['no-open'], intro: !opts['no-intro'] };
+const o = { ...opts, dryRun: opts['dry-run'], ci: opts['no-ci'] ? false : opts.ci, open: !opts['no-open'], intro: !opts['no-intro'], sound: !opts.quiet };
 const [cmd, ...rest] = positionals;
 
 async function main() {
@@ -117,6 +119,8 @@ async function main() {
       return cli.models(root, rest, o);
     case 'run':
       return cli.run(root, rest[0], o);
+    case 'sound':
+      return cli.sound(root, rest[0]);
     case 'gates':
       return cli.gates(root, rest);
     case 'doctor':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buildline",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Install an AI software factory into any project. A spec-driven pipeline for Claude Code (and any AGENTS.md-compatible agent), for developers, designers and product managers.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -7,7 +7,8 @@ import { detect, describeStack } from './detect.js';
 import { AGENTS, AUTONOMY, VERSION, makeConfig, plan, apply, removePlan, applyRemove, defaultGates } from './install.js';
 import { loadManifest } from './files.js';
 import { PHASES, MODEL_STATIONS, CLIS, modelFor, parseModel, parseModelList, describeModel, discoverModelOptions, checkModel, stationPrompt, launchArgs, externalClis } from './models.js';
-import { listFeatures, findFeature, createFeature, approve, setStatus, nextAction, STATIONS, TYPES } from './features.js';
+import { listFeatures, findFeature, createFeature, approve, setStatus, nextAction, moveBlocker, STATIONS, TYPES } from './features.js';
+import { chime } from './sound.js';
 
 const LOGO = [
   pc.yellow('  ┌┐ ┬ ┬┬┬  ┌┬┐┬  ┬┌┐┌┌─┐'),
@@ -270,6 +271,19 @@ export async function watch(root, opts = {}) {
   if (next?.action === 'ui') return (await import('./server.js')).serve(root, {});
 }
 
+export function sound(root, value) {
+  const config = loadConfig(root);
+  if (value) {
+    if (!['on', 'off'].includes(value)) throw new Error('Usage: buildline sound [on|off]');
+    if (value === 'on') delete config.sound;
+    else config.sound = false;
+    fs.writeFileSync(configPath(root), JSON.stringify(config, null, 2) + '\n');
+  }
+  const on = config.sound !== false;
+  console.log(`${on ? pc.green('♪') : pc.dim('♪')} Sound is ${on ? 'on' : 'off'}: ${on ? '`watch` and the dashboard chime when a feature needs you or ships.' : 'no chime.'} ${pc.dim(on ? 'Turn off: buildline sound off' : 'Turn on: buildline sound on')}`);
+  if (on && value === 'on') chime();
+}
+
 // ---- new / approve / move ----------------------------------------------------
 
 export async function newFeature(root, title, opts) {
@@ -310,6 +324,8 @@ export function moveFeature(root, ref, station, opts) {
   const f = findFeature(root, ref);
   if (!f) throw new Error(`No feature matching "${ref}".`);
   if (!STATIONS.includes(station)) throw new Error(`Station must be one of: ${STATIONS.join(', ')}`);
+  const blocker = opts.force ? null : moveBlocker(f, station, loadConfig(root).autonomy ?? 2);
+  if (blocker) throw new Error(blocker.replace(/node \.buildline\/bin\/feature\.mjs approve/, 'npx buildline approve') + ' Or pass --force.');
   setStatus(f, station, opts.note);
   console.log(`${pc.green('✔')} ${f.id} → ${station}`);
 }

package/src/features.js

@@ -3,6 +3,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { render, templatesDir } from './render.js';
+import { moveBlocker } from '../templates/bin/feature.mjs';
+
+export { moveBlocker };
 
 export const STATIONS = ['new', 'spec', 'design', 'plan', 'build', 'verify', 'review', 'ship', 'done'];
 export const TYPES = ['fix', 'feature', 'epic'];
@@ -126,9 +129,12 @@ export function nextAction(feature, autonomy = 2) {
       if (/TODO/.test(readSpecSection(feature, 'Acceptance') || 'TODO')) return { who: 'pm', text: 'needs requirements & acceptance', cmd: `/buildline-spec ${feature.id}` };
       return autonomy <= 3 && !a.spec ? { who: 'pm', text: 'waiting on spec approval', cmd: `buildline approve ${feature.id} spec` } : { who: 'agent', text: 'ready for design', cmd: `/buildline-design ${feature.id}` };
     case 'design':
+      if (autonomy <= 1 && a.design) return { who: 'agent', text: 'ready for a plan', cmd: `/buildline-plan ${feature.id}` };
       return { who: 'designer', text: 'needs UX / technical design', cmd: `/buildline-design ${feature.id}` };
     case 'plan':
-      return { who: 'eng', text: 'needs a task plan', cmd: `/buildline-plan ${feature.id}` };
+      if (!tasks.length) return { who: 'eng', text: 'needs a task plan', cmd: `/buildline-plan ${feature.id}` };
+      if (feature.type !== 'fix' && autonomy <= 2 && !a.plan) return { who: 'eng', text: 'waiting on plan approval', cmd: `buildline approve ${feature.id} plan` };
+      return { who: 'agent', text: 'ready to build', cmd: `/buildline-build ${feature.id}` };
     case 'build':
       if (feature.type !== 'fix' && autonomy <= 3 && !a.spec) return { who: 'pm', text: 'waiting on spec approval', cmd: `buildline approve ${feature.id} spec` };
       if (feature.type !== 'fix' && autonomy <= 2 && !a.plan && tasks.length) return { who: 'eng', text: 'waiting on plan approval', cmd: `buildline approve ${feature.id} plan` };
@@ -155,3 +161,73 @@ export function readSpecSection(feature, heading) {
     return null;
   }
 }
+
+// ---- live sessions -------------------------------------------------------------
+// Claude Code hooks write one file per session to .buildline/sessions/ (see
+// templates/bin/hook.mjs). A session that hasn't been heard from in a while has
+// most likely crashed or been closed without a SessionEnd.
+
+const WORKING_FOR = 10 * 60e3;
+const WAITING_FOR = 2 * 3600e3;
+
+export function readSessions(root, at = Date.now()) {
+  const dir = path.join(root, '.buildline', 'sessions');
+  const out = [];
+  // `tracked` says hooks are reporting here, so "no session" really means nobody is working.
+  out.tracked = fs.existsSync(dir);
+  if (!out.tracked) return out;
+  for (const name of fs.readdirSync(dir)) {
+    if (!name.endsWith('.json')) continue;
+    try {
+      const s = JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8'));
+      const age = at - new Date(s.lastAt);
+      if (s.state === 'working' && age < WORKING_FOR) out.push({ ...s, age });
+      else if (s.state === 'waiting' && age < WAITING_FOR) out.push({ ...s, age });
+    } catch {}
+  }
+  return Object.assign(out.sort((a, b) => a.age - b.age), { tracked: true });
+}
+
+/** Recent tool calls from live sessions, oldest first. */
+export function readActivity(root, limit = 200) {
+  try {
+    const text = fs.readFileSync(path.join(root, '.buildline', 'sessions', 'activity.jsonl'), 'utf8');
+    return text.split('\n').filter(Boolean).slice(-limit).flatMap((l) => {
+      try {
+        return [JSON.parse(l)];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * What's happening on a feature right now: live sessions on it, whether one is
+ * working or waiting for a reply. Where no hooks report (agents other than
+ * Claude Code), a feature whose files changed in the last two minutes counts as worked on.
+ */
+export function liveState(feature, sessions, at = Date.now()) {
+  const mine = sessions.filter((s) => s.feature === feature.id);
+  const working = mine.filter((s) => s.state === 'working');
+  const recent = at - new Date(feature.updated || 0) < 2 * 60e3;
+  return {
+    sessions: mine,
+    working: working.length > 0 || (!sessions.tracked && recent && !feature.blocked && feature.status !== 'done'),
+    waiting: !working.length && mine.some((s) => s.state === 'waiting'),
+  };
+}
+
+/** What the chime is for: 'waiting' when a feature needs a person, 'done' once it ships, else null. */
+export function attention(feature, live) {
+  if (feature.status === 'done') return 'done';
+  return feature.blocked || live?.waiting ? 'waiting' : null;
+}
+
+/** Ids whose attention changed to waiting or done since `before` (a Map from the last look). */
+export function newAttention(before, now) {
+  if (!before) return [];
+  return [...now].filter(([id, a]) => a && before.get(id) !== a).map(([id]) => id);
+}

package/src/install.js

@@ -140,6 +140,7 @@ export function buildEntries(root, config) {
   for (const f of ['spec.md', 'progress.md']) add(`.buildline/templates/${f}`, read(`feature/${f}`));
   add('.buildline/bin/gates.mjs', read('bin/gates.mjs'), { executable: true });
   add('.buildline/bin/hook.mjs', read('bin/hook.mjs'), { executable: true });
+  add('.buildline/bin/feature.mjs', read('bin/feature.mjs'), { executable: true });
   add('.buildline/features/.gitkeep', '');
   if (config.ci) add('.github/workflows/buildline.yml', render(read('ci/buildline.yml'), vars));
   return entries;
@@ -151,7 +152,7 @@ const HOOK_MARK = '.buildline/bin/hook.mjs';
 const hookCmd = (mode) => `node "$CLAUDE_PROJECT_DIR/.buildline/bin/hook.mjs" ${mode}`;
 
 export function settingsAllow(config) {
-  const allow = ['Bash(node .buildline/bin/gates.mjs)', 'Bash(node .buildline/bin/gates.mjs *)', 'Bash(npx buildline *)'];
+  const allow = ['Bash(node .buildline/bin/gates.mjs)', 'Bash(node .buildline/bin/gates.mjs *)', 'Bash(node .buildline/bin/feature.mjs *)', 'Bash(npx buildline *)'];
   for (const g of config.gates) allow.push(`Bash(${g.command})`, `Bash(${g.command} *)`);
   return [...new Set(allow)];
 }
@@ -169,13 +170,20 @@ export function mergeSettings(root, config) {
   }
   const before = JSON.stringify(settings);
   settings.hooks ??= {};
+  // One Buildline hook per event; older installs get their entry upgraded in place.
   const ensureHook = (event, matcher, mode) => {
     const groups = (settings.hooks[event] ??= []);
-    const present = groups.some((g) => (g.hooks || []).some((h) => h.command?.includes(HOOK_MARK)));
-    if (!present) groups.push({ ...(matcher ? { matcher } : {}), hooks: [{ type: 'command', command: hookCmd(mode) }] });
+    const ours = groups.find((g) => (g.hooks || []).some((h) => h.command?.includes(HOOK_MARK)));
+    if (!ours) return groups.push({ ...(matcher ? { matcher } : {}), hooks: [{ type: 'command', command: hookCmd(mode) }] });
+    if (matcher) ours.matcher = matcher;
+    else delete ours.matcher;
+    for (const h of ours.hooks) if (h.command?.includes(HOOK_MARK)) h.command = hookCmd(mode);
   };
   ensureHook('SessionStart', null, 'session-start');
-  ensureHook('PreToolUse', 'Edit|Write|MultiEdit', 'guard');
+  ensureHook('PreToolUse', null, 'pre');
+  ensureHook('UserPromptSubmit', null, 'prompt');
+  ensureHook('Stop', null, 'stop');
+  ensureHook('SessionEnd', null, 'session-end');
 
   settings.permissions ??= {};
   settings.permissions.allow ??= [];

package/src/server.js

@@ -8,7 +8,7 @@ import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import pc from 'picocolors';
-import { listFeatures, findFeature, createFeature, approve, setStatus, nextAction } from './features.js';
+import { listFeatures, findFeature, createFeature, approve, setStatus, nextAction, readSessions, liveState } from './features.js';
 import { AUTONOMY, VERSION } from './install.js';
 import { goalFor } from './cli.js';
 
@@ -33,11 +33,14 @@ function openBrowser(url) {
   } catch {}
 }
 
-function state(root) {
+function state(root, opts = {}) {
   const config = JSON.parse(fs.readFileSync(path.join(root, '.buildline', 'buildline.json'), 'utf8'));
+  if (opts.sound === false) config.sound = false;
+  const sessions = readSessions(root);
   const features = listFeatures(root).map(({ path: _p, ...f }) => ({
     ...f,
     next: nextAction({ ...f, path: _p }, config.autonomy),
+    live: liveState(f, sessions),
     goal: goalFor(f),
   }));
   const contextDir = path.join(root, '.buildline', 'context');
@@ -87,7 +90,7 @@ export function serve(root, opts = {}) {
       if (!url.pathname.startsWith('/api/')) return send(404, { error: 'Not found' });
       if (req.method !== 'GET' && req.headers['x-buildline-token'] !== token) return send(403, { error: 'Bad token' });
 
-      if (req.method === 'GET' && url.pathname === '/api/state') return send(200, state(root));
+      if (req.method === 'GET' && url.pathname === '/api/state') return send(200, state(root, opts));
 
       if (url.pathname === '/api/file') {
         if (req.method === 'GET') {

package/src/sound.js

@@ -0,0 +1,29 @@
+// The one sound Buildline makes: a short chime when a feature needs a person or
+// ships. Plays the system's own notification sound where there is one, and falls
+// back to the terminal bell. Off with `"sound": false` in buildline.json.
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+
+const PLAYERS = {
+  darwin: ['afplay', '/System/Library/Sounds/Glass.aiff'],
+  linux: ['paplay', '/usr/share/sounds/freedesktop/stereo/complete.oga'],
+};
+
+let last = 0;
+
+export function chime(out = process.stdout) {
+  if (Date.now() - last < 3000) return; // several features at once still make one sound
+  last = Date.now();
+  const bell = () => out.write('\x07');
+  const player = PLAYERS[process.platform];
+  if (!player || !fs.existsSync(player[1])) return bell();
+  try {
+    const child = spawn(player[0], [player[1]], { stdio: 'ignore', detached: true });
+    child.on('error', bell);
+    child.unref();
+  } catch {
+    bell();
+  }
+}
+
+export const soundOn = (config) => config?.sound !== false;

package/src/tui.js

@@ -7,7 +7,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import pc from 'picocolors';
-import { listFeatures, nextAction, approve } from './features.js';
+import { listFeatures, nextAction, approve, readSessions, readActivity, liveState, attention, newAttention } from './features.js';
+import { chime, soundOn } from './sound.js';
 import { modelFor, describeModel } from './models.js';
 import { AUTONOMY, VERSION } from './install.js';
 
@@ -41,6 +42,7 @@ const C = {
   amberDim: fg('#8a6a1a'),
   green: fg('#4ec27f'),
   red: fg('#f7768e'),
+  cyan: fg('#59c2e6'),
   flash: pc.isColorSupported ? (s) => `\x1b[48;5;94m\x1b[38;5;230m${s}\x1b[39m\x1b[49m` : null,
 };
 const WHO = {
@@ -102,11 +104,18 @@ function box(screen, x, y, w, h, title, { accent = false } = {}) {
 function loadState(root, showShipped) {
   const config = JSON.parse(fs.readFileSync(path.join(root, '.buildline', 'buildline.json'), 'utf8'));
   const all = listFeatures(root);
-  const features = all.filter((f) => showShipped || f.status !== 'done').map((f) => ({ ...f, next: nextAction(f, config.autonomy) }));
+  const sessions = readSessions(root);
+  const features = all
+    .filter((f) => showShipped || f.status !== 'done')
+    .map((f) => ({ ...f, next: nextAction(f, config.autonomy), live: liveState(f, sessions) }));
+  // Station history plus the live tool feed from running sessions, in time order.
+  const tools = readActivity(root).map((a) => ({ at: a.at, id: a.feature, station: a.tool, note: a.detail, tool: true, key: `t|${a.at}|${a.session}|${a.detail}` }));
   const events = all
     .flatMap((f) => (f.history || []).map((h) => ({ ...h, id: f.id, key: `${f.id}|${h.at}|${h.note}` })))
+    .concat(tools)
     .sort((a, b) => String(a.at).localeCompare(String(b.at)));
-  return { config, all, features, events };
+  const needs = new Map(all.map((f) => [f.id, attention(f, liveState(f, sessions))]));
+  return { config, all, features, events, sessions, needs };
 }
 
 const stationIndex = (status) => (status === 'new' ? 0 : status === 'done' ? TRACK.length : TRACK.indexOf(status));
@@ -114,6 +123,21 @@ const shortModel = (config, station) => {
   const m = modelFor(config, station);
   return m.cli === 'claude' && !m.model ? 'session' : describeModel(m).replace(/^claude-/, '');
 };
+const ago = (ms) => (ms < 60e3 ? `${Math.max(1, Math.round(ms / 1000))}s` : ms < 3600e3 ? `${Math.round(ms / 60e3)}m` : `${Math.round(ms / 3600e3)}h`);
+
+/** The NEXT UP cell: who or what the feature is waiting on right now. */
+function rowStatus(f, t) {
+  if (f.blocked) return ['BLOCKED', C.red];
+  if (f.live.working) {
+    const n = f.live.sessions.filter((x) => x.state === 'working').length;
+    return [`${SPINNER[t % SPINNER.length]} ${n > 1 ? `×${n} ` : ''}WORKING`, C.amberBold];
+  }
+  if (f.live.waiting) return ['NEEDS YOU', t % 12 < 8 ? C.red : C.faint];
+  if (f.next.who === 'agent') return ['AGENT', C.amberDim];
+  const who = WHO[f.next.who];
+  return who ? [who.label, who.color] : ['', null];
+}
+
 const hash = (s) => [...String(s)].reduce((h, c) => (h * 31 + c.charCodeAt(0)) >>> 0, 7);
 
 function timeLabel(iso) {
@@ -141,7 +165,9 @@ function drawTrack(line, x, f, seg, t) {
   const cur = stationIndex(f.status);
   const who = WHO[f.next.who];
   const skipped = (i) => f.type === 'fix' && i < 3 && cur >= 3;
-  const working = f.next.who === 'agent' && !f.blocked;
+  // The comet only runs while a session is actually working on this feature.
+  const working = f.live?.working && !f.blocked;
+  const idleAgent = f.next.who === 'agent' && !f.blocked && !f.live?.waiting;
   for (let i = 0; i < TRACK.length; i++) {
     const nx = x + i * seg;
     let node = ['○', C.faint];
@@ -149,6 +175,8 @@ function drawTrack(line, x, f, seg, t) {
     else if (i < cur) node = ['●', C.green];
     else if (i === cur && f.blocked) node = ['✖', t % 10 < 5 ? C.red : C.faint];
     else if (i === cur && working) node = [['◉', '◎', '◉', '●'][Math.floor(t / 3) % 4], C.amberBold];
+    else if (i === cur && f.live?.waiting) node = ['◉', t % 12 < 8 ? C.red : C.faint];
+    else if (i === cur && idleAgent) node = ['◉', C.amberDim];
     else if (i === cur) node = ['◉', t % 12 < 8 ? who?.color || C.amber : C.faint];
     line.put(nx, node[0], node[1]);
     if (i === TRACK.length - 1) break;
@@ -180,7 +208,8 @@ function render(st, ui, W, H) {
   const active = st.all.filter((f) => f.status !== 'done');
   const shipped = st.all.length - active.length;
   const tasks = active.flatMap((f) => f.tasks || []);
-  const waiting = active.filter((f) => ['pm', 'designer', 'eng', 'human'].includes(nextAction(f, config.autonomy).who)).length;
+  const waiting = features.filter((f) => f.status !== 'done' && !f.live.working && (f.live.waiting || ['pm', 'designer', 'eng', 'human'].includes(f.next.who))).length;
+  const sessionsWorking = st.sessions.filter((x) => x.state === 'working').length;
 
   // header
   const tall = W >= 96 && H >= 26;
@@ -196,6 +225,7 @@ function render(st, ui, W, H) {
     right(0, [[config.project || path.basename(ui.root), C.bold], ['  ·  ', C.faint], [AUTONOMY[config.autonomy]?.label || `L${config.autonomy}`, C.amber], ['  ·  ', C.faint], [live, C.green]]);
     right(1, [
       ['ACTIVE ', C.muted], [String(active.length), C.bold], ['   SHIPPED ', C.muted], [String(shipped), C.green],
+      ['   SESSIONS ', C.muted], [String(sessionsWorking), sessionsWorking ? C.amberBold : C.bold],
       ['   TASKS ', C.muted], [`${tasks.filter((x) => x.passes).length}/${tasks.length}`, C.bold],
       ['   WAITING ON PEOPLE ', C.muted], [String(waiting), waiting ? WHO.pm.color : C.bold],
     ]);
@@ -230,13 +260,13 @@ function render(st, ui, W, H) {
     if (seg >= 7) screen[top + 2].put(nx - Math.floor(m.length / 2), m, C.faint);
   });
   screen[top + 1].put(rx, 'FEATURE', C.muted);
-  screen[top + 1].put(W - 3 - 7, 'NEXT UP', C.muted);
+  screen[top + 1].put(W - 3 - 3, 'NOW', C.muted);
   const rowsAvail = lineH - 5;
   if (ui.sel < ui.scroll) ui.scroll = ui.sel;
   if (ui.sel >= ui.scroll + rowsAvail) ui.scroll = ui.sel - rowsAvail + 1;
   if (!features.length) {
     const line = screen[top + 4];
-    drawTrack(line, tx, { id: 'idle', status: 'spec', type: 'feature', next: { who: 'agent' } }, seg, t);
+    drawTrack(line, tx, { id: 'idle', status: 'spec', type: 'feature', next: { who: 'agent' }, live: { working: true, sessions: [] } }, seg, t);
     line.put(rx, 'the line is quiet · ', C.muted);
     line.put(rx + 20, 'npx buildline new "…"', C.amber);
   }
@@ -248,8 +278,8 @@ function render(st, ui, W, H) {
     line.put(2, selected ? '▸' : ' ', C.amberBold);
     line.put(4, f.id, flashing ? C.flash : selected ? C.amberBold : C.muted);
     drawTrack(line, tx, f, seg, t);
-    const who = WHO[f.next.who];
-    const whoW = 8;
+    const [label, labelColor] = rowStatus(f, t);
+    const whoW = 12;
     const ts = f.tasks || [];
     const roomy = W - 3 - whoW - rx >= 30;
     const barW = ts.length ? (roomy ? 11 : 5) : 0;
@@ -262,7 +292,7 @@ function render(st, ui, W, H) {
       if (roomy) bx = line.put(line.put(bx, '▰'.repeat(filled), C.green), '▱'.repeat(5 - filled), C.faint) + 1;
       line.put(bx, `${pass}/${ts.length}`, pass === ts.length ? C.green : C.muted);
     }
-    if (who) line.put(W - 3 - who.label.length, who.label, who.color);
+    if (label) line.put(W - 3 - [...label].length, label, labelColor);
   });
   if (features.length > rowsAvail) screen[top + lineH - 1].put(W - 16, ` ${ui.sel + 1}/${features.length} `, C.muted);
 
@@ -276,7 +306,7 @@ function render(st, ui, W, H) {
   }
 
   // footer
-  const keys = [['↑↓', 'select'], ['⏎', 'open'], ['a', 'approve'], ['u', 'dashboard'], ['s', ui.shipped ? 'hide shipped' : 'shipped'], ['q', 'quit']];
+  const keys = [['↑↓', 'select'], ['⏎', 'open'], ['a', 'approve'], ['u', 'dashboard'], ['s', ui.shipped ? 'hide shipped' : 'shipped'], ['m', ui.sound ? 'mute' : 'unmute'], ['q', 'quit']];
   let fx = 1;
   const foot = screen[H - 1];
   if (ui.message && ui.messageUntil > Date.now()) fx = foot.put(1, ` ${ui.message} `, C.flash);
@@ -306,6 +336,24 @@ function drawInspector(screen, st, f, x, y, w, h) {
     return a ? [[`${s} ✔ ${a.by}  `, C.green]] : [[`${s} ·  `, C.faint]];
   });
   add(['approvals ', C.muted], ...appr.flat());
+  if (f.blocked) {
+    const width = Math.max(10, w - 15);
+    const words = String(f.blocked).split(/\s+/);
+    const lines = [''];
+    for (const word of words) (lines.at(-1) + ' ' + word).trim().length > width ? lines.push(word) : (lines[lines.length - 1] = (lines.at(-1) + ' ' + word).trim());
+    lines.slice(0, 4).forEach((l, i) => add([i ? '           ' : '✖ blocked  ', C.red], [l, C.bold]));
+  }
+  for (const ses of f.live?.sessions || []) {
+    const on = ses.state === 'working';
+    add(
+      [on ? '● ' : '◌ ', on ? C.amberBold : C.red],
+      [`session ${String(ses.id).slice(0, 8)} `, C.muted],
+      [`${(ses.model ? String(ses.model) : shortModel(config, f.status)).replace(/^claude-/, '')} `, C.text],
+      [on ? `${ses.tool || 'thinking'} ` : 'waiting for your reply ', on ? C.cyan : C.red],
+      [on ? `${ses.detail || ''} ` : '', C.text],
+      [`· ${ago(ses.age)} ago`, C.faint],
+    );
+  }
   const ts = f.tasks || [];
   if (ts.length) {
     add();
@@ -324,7 +372,8 @@ function drawInspector(screen, st, f, x, y, w, h) {
   }
   add();
   const who = WHO[f.next.who];
-  add(['next ', C.muted], [who ? who.label + ' ' : '', who?.color || C.text], [f.next.text, C.text]);
+  if (f.blocked) add(['next ', C.muted], ['answer the question in the session that asked it', C.text]);
+  else add(['next ', C.muted], [who ? who.label + ' ' : '', who?.color || C.text], [f.next.text, C.text]);
   if (f.next.cmd) add(['❯ ', C.amberBold], [f.next.cmd, C.amber]);
   const room = h - 2 - rows.length - 2;
   const journey = (f.history || []).slice(-room);
@@ -346,9 +395,9 @@ function drawEvents(screen, st, ui, x, y, w, h) {
     const line = screen[y + 1 + r];
     const fresh = (ui.freshEvents.get(e.key) || 0) > Date.now();
     let cx = line.put(x + 2, timeLabel(e.at), C.faint);
-    cx = line.put(cx + 1, e.id, fresh ? C.flash : C.amber);
-    cx = line.put(cx + 1, String(e.station || '').padEnd(7), C.muted);
-    line.put(cx + 1, e.note || '', fresh ? C.bold : C.text, x + w - 2);
+    cx = line.put(cx + 1, e.id || '···', fresh ? C.flash : C.amber);
+    cx = line.put(cx + 1, clip(e.station || '', 7).padEnd(7), e.tool ? C.cyan : C.muted);
+    line.put(cx + 1, e.note || '', e.tool ? C.muted : fresh ? C.bold : C.text, x + w - 2);
   });
   if (!rows.length) screen[y + 1].put(x + 2, 'nothing yet', C.faint);
 }
@@ -399,8 +448,10 @@ export async function watch(root, opts = {}) {
   }
   const ui = { root, tick: 0, sel: 0, scroll: 0, flash: new Map(), freshEvents: new Map(), shipped: false, message: '', messageUntil: 0 };
   let st = loadState(root, ui.shipped);
+  ui.sound = opts.sound !== false && soundOn(st.config);
   let lastStatus = new Map(st.all.map((f) => [f.id, f.status]));
   let seen = new Set(st.events.map((e) => e.key));
+  let needs = st.needs;
 
   out.write('\x1b[?1049h\x1b[?25l');
   if (opts.intro !== false) await boot(out, st, root);
@@ -415,6 +466,8 @@ export async function watch(root, opts = {}) {
       if (lastStatus.has(f.id) && lastStatus.get(f.id) !== f.status) ui.flash.set(f.id, Date.now() + 2500);
     }
     for (const e of st.events) if (!seen.has(e.key)) ui.freshEvents.set(e.key, Date.now() + 4000);
+    if (newAttention(needs, st.needs).length && ui.sound) chime(out);
+    needs = st.needs;
     lastStatus = new Map(st.all.map((f) => [f.id, f.status]));
     seen = new Set(st.events.map((e) => e.key));
     ui.sel = Math.max(0, Math.min(ui.sel, st.features.length - 1));
@@ -449,6 +502,7 @@ export async function watch(root, opts = {}) {
       if (k === '\x1b[A' || k === 'k') ui.sel = Math.max(0, ui.sel - 1);
       else if (k === '\x1b[B' || k === 'j') ui.sel = Math.min(st.features.length - 1, ui.sel + 1);
       else if (k === 's') (ui.shipped = !ui.shipped), refresh();
+      else if (k === 'm') (ui.sound = !ui.sound), say(ui.sound ? '♪ sound on' : 'sound muted until you quit');
       else if (k === 'u') return done({ action: 'ui' });
       else if ((k === '\r' || k === '\n') && f) {
         if (f.status === 'done') say(`${f.id} has shipped`);