undertone

1// undertone: plays your Claude Code sessions as music.
2//
3// This mod sends what the session does (turns, tool calls, edits, commits, which checks fail and
4// pass, permission prompts, coter-kit's checklist) to the undertone bridge on 127.0.0.1, which
5// streams it to the page in your browser, along with how many coter-kit questions wait on you in
6// each project. Only event types, tool names, check names (test, typecheck, lint, build), project
7// names, counts and a scheduled-run flag leave the session: never prompt text, file paths or commands.
8//
9//   /undertone          start the bridge if it isn't running and open the page
10//   /undertone status   is the bridge up, and is this session sending
11//   /undertone off|on   stop or resume sending this session's events
12//   /undertone stop     stop the bridge; sessions won't start it again until /undertone or npm start
13//
14// The bridge is simply there: the first session starts it detached (it belongs to no session) and
15// it leaves on its own after a quiet hour. The `bridge` setting "manual" turns that off.
16
17import { analyzeCommand, outcomes } from './commands.js'
18import { countWaiting } from './waiting.js'
19
20const DEFAULT_PORT = 4747
21const CHECKLIST_TOOL = 'mcp__coter-kit__checklist'
22const REMEMBER_TOOL = 'mcp__coter-kit__remember'
23const DOWN_BACKOFF_MS = 15_000
24const HEARTBEAT_MS = 60_000
25const WAITING_EVERY_MS = 120_000
26// While the bridge is down, events wait (heartbeats don't): at most this many, this long
27const HOLD_MAX = 500
28const HOLD_MS = 5 * 60_000
29// A bridge seen this recently that stops answering is started again, at most once a minute
30const RESTART_IF_SEEN_MS = 30 * 60_000
31const RESTART_EVERY_MS = 60_000
32
33let port = DEFAULT_PORT
34let base = 'http://127.0.0.1:' + DEFAULT_PORT
35let lane = null // { lane, project, label }
36let sending = true
37let queue = [] // { e, at } — at is stamped by the first flush that tries to send it
38let flushTimer = null
39let downUntil = 0
40let lastHealthy = 0
41let lastRestartTry = 0
42let autoRestart = true
43let bridgeMode = 'auto' // auto: the first session starts the bridge; manual: only /undertone or npm start
44let checksFailing = false
45let brainDir = ''
46let lastWaiting = ''
47let started = false // timers and the command are set up once per module load
48let scheduled = false // this session is a scheduled run: it plays quietly and never calls you
49let promptSeen = false
50
51function kindOf(tool) {
52  if (/^(Read|Grep|Glob|LS|NotebookRead)$/.test(tool)) return 'read'
53  if (/^(Edit|Write|MultiEdit|NotebookEdit)$/.test(tool)) return 'edit'
54  if (/^(Bash|PowerShell)$/.test(tool)) return 'run'
55  if (/^(WebFetch|WebSearch)$/.test(tool) || /browser|chrome/i.test(tool)) return 'web'
56  if (/^(Agent|Task)$/.test(tool)) return 'agent'
57  return 'other'
58}
59
60// mcp__server__tool -> tool, so the page never sees server ids
61const shortTool = (tool) => String(tool || '').split('__').pop().slice(0, 40)
62
63// From the path alone: a worktree under .claude/worktrees/<name> plays as "<project> · <name>"
64function laneFor(root, id) {
65  const parts = String(root || '').replace(/\\/g, '/').replace(/\/+$/, '').split('/')
66  let project = parts[parts.length - 1] || 'session'
67  let label = project
68  const wt = parts.lastIndexOf('worktrees')
69  if (wt > 1 && parts[wt - 1] === '.claude' && parts[wt + 1]) {
70    project = parts[wt - 2] || project
71    label = project + ' · ' + parts[wt + 1]
72  }
73  return { lane: String(id || 'session').slice(0, 8), project, label }
74}
75
76// From git, when it answers: any linked worktree (a sibling folder such as ~/GitHub/EO7-sprites
77// too) plays as "<main checkout> · <worktree folder>"
78const leaf = (p) => p.replace(/\/+$/, '').split('/').pop()
79async function gitNames($, root) {
80  try {
81    const r = await $.process.run(['git', 'rev-parse', '--show-toplevel', '--git-common-dir'], { cwd: root, timeoutMs: 3000 })
82    if (r.exitCode !== 0) return null
83    const [top, common] = String(r.stdout || '').trim().split('\n').map((s) => s.trim().replace(/\\/g, '/'))
84    if (!top || !common) return null
85    const commonAbs = /^(\/|[A-Za-z]:\/)/.test(common) ? common : top.replace(/\/+$/, '') + '/' + common
86    const main = commonAbs.replace(/\/+$/, '').replace(/\/\.git$/, '')
87    if (main === commonAbs.replace(/\/+$/, '')) return null // a bare or unusual layout: trust the path
88    const project = leaf(main)
89    return { project, label: main === top.replace(/\/+$/, '') ? project : project + ' · ' + leaf(top) }
90  } catch {
91    return null
92  }
93}
94
95async function laneNow($) {
96  const root = await $.session.root()
97  const fromPath = laneFor(root, await $.session.id())
98  const fromGit = await gitNames($, root)
99  return fromGit ? { ...fromPath, ...fromGit } : fromPath
100}
101
102function enqueue($, e) {
103  queue.push({ e, at: null })
104  if (!flushTimer) flushTimer = $.clock.after(120, () => { flushTimer = null; return flush($) })
105}
106
107function emit($, type, extra) {
108  if (!lane || !sending) return
109  enqueue($, { type, ...lane, ...(scheduled ? { scheduled: true } : {}), ...extra })
110}
111
112// Batches go out about every 120 ms. While the bridge is down they wait (500 events, 5 minutes)
113// and go out in order once it's back; a bridge that was running is started again.
114async function flush($) {
115  if (!queue.length) return
116  const now = await $.clock.now()
117  for (const q of queue) if (q.at == null) q.at = now
118  queue = queue.filter((q) => now - q.at <= HOLD_MS)
119  if (queue.length > HOLD_MAX) queue.splice(0, queue.length - HOLD_MAX)
120  if (now < downUntil) return
121  const batch = queue
122  queue = []
123  try {
124    const r = await $.http.fetch(base + '/event', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(batch.map((q) => q.e)) })
125    if (!r.ok) throw new Error('bridge answered ' + r.status)
126    lastHealthy = now
127    downUntil = 0
128  } catch {
129    downUntil = now + DOWN_BACKOFF_MS
130    queue = batch.filter((q) => q.e.type !== 'alive').concat(queue)
131    if (autoRestart && (bridgeMode === 'auto' || (lastHealthy && now - lastHealthy < RESTART_IF_SEEN_MS)) && now - lastRestartTry >= RESTART_EVERY_MS) {
132      lastRestartTry = now
133      void ensureBridge($).then((ok) => { if (ok) flush($) })
134    }
135  }
136}
137
138// ---------------------------------------------------------------- waiting on you (coter-kit's brain)
139
140const safeJson = (line) => { try { return JSON.parse(line) } catch { return null } }
141
142async function listDir($, dir) {
143  try {
144    return await $.fs.list(dir)
145  } catch {
146    return []
147  }
148}
149
150async function readText($, path) {
151  try {
152    const r = await $.fs.read(path)
153    return typeof r === 'string' ? r : r && typeof r.text === 'string' ? r.text : ''
154  } catch {
155    return ''
156  }
157}
158
159// Every machine's journal rows; countWaiting (hooks/waiting.js) does the counting
160async function readWaiting($) {
161  let dir = brainDir
162  if (!dir) {
163    const home = (await $.env.get('HOME')) || (await $.env.get('USERPROFILE')) || ''
164    if (!home) return {}
165    dir = String(home).replace(/\\/g, '/') + '/.claude/coter-brain'
166  }
167  const journal = dir.replace(/\/+$/, '') + '/journal'
168  const rows = []
169  for (const device of await listDir($, journal)) {
170    if (device.kind !== 'dir') continue
171    for (const f of await listDir($, journal + '/' + device.name)) {
172      if (!f.name.endsWith('.jsonl')) continue
173      for (const line of (await readText($, journal + '/' + device.name + '/' + f.name)).split('\n')) {
174        const row = safeJson(line)
175        if (row) rows.push(row)
176      }
177    }
178  }
179  return countWaiting(rows, await $.clock.now())
180}
181
182// Sends the counts when they change (the bridge keeps the newest for pages that connect later)
183async function sendWaiting($, force) {
184  const by = await readWaiting($)
185  const key = JSON.stringify(by)
186  if (key === lastWaiting && !force) return
187  lastWaiting = key
188  emit($, 'waiting', { projects: by, count: Object.values(by).reduce((a, b) => a + b, 0) })
189}
190
191async function healthy($) {
192  try {
193    const r = await $.http.fetch(base + '/health')
194    const ok = r.ok && r.text.includes('"undertone"')
195    if (ok) lastHealthy = await $.clock.now()
196    return ok
197  } catch {
198    return false
199  }
200}
201
202async function undertoneHome($) {
203  const own = await $.env.get('UNDERTONE_HOME')
204  if (own) return String(own).replace(/\\/g, '/')
205  const home = (await $.env.get('HOME')) || (await $.env.get('USERPROFILE')) || ''
206  return home ? String(home).replace(/\\/g, '/') + '/.undertone' : ''
207}
208
209// `/undertone stop` leaves this marker; sessions don't start the bridge again until `/undertone`
210async function stoppedOnPurpose($) {
211  const home = await undertoneHome($)
212  return !!home && (await listDir($, home)).some((f) => f.name === 'stopped')
213}
214
215// Starts a bridge that belongs to no session (bridge/launch.mjs): it outlives whatever started it
216// and leaves on its own after a quiet hour (--auto). `resume` lifts a deliberate /undertone stop.
217async function startDetached($, resume) {
218  const argv = ['node', String($.plugin.root).replace(/\\/g, '/') + '/bridge/launch.mjs', String(port), '--auto', ...(resume ? ['--resume'] : [])]
219  try {
220    const r = await $.process.run(argv, { timeoutMs: 15_000 })
221    return r.exitCode === 0
222  } catch (err) {
223    $.ui.log('undertone: could not start the bridge: ' + (err && err.message ? err.message : err))
224    return false
225  }
226}
227
228async function ensureBridge($, resume) {
229  if (await healthy($)) return true
230  if (!resume && (await stoppedOnPurpose($))) return false
231  if (!(await startDetached($, resume))) return false
232  for (let i = 0; i < 20; i++) {
233    await $.clock.sleep(150)
234    if (await healthy($)) {
235      downUntil = 0
236      return true
237    }
238  }
239  return false
240}
241
242async function openPage($) {
243  const url = base + '/'
244  const windows = (await $.env.get('OS')) === 'Windows_NT'
245  const tries = windows ? [['cmd', '/c', 'start', '', url]] : [['open', url], ['xdg-open', url]]
246  for (const argv of tries) {
247    try {
248      const r = await $.process.run(argv, { timeoutMs: 5000 })
249      if (r.exitCode === 0) return true
250    } catch {}
251  }
252  return false
253}
254
255export function register(on, options) {
256  port = Number(options && options.port) || DEFAULT_PORT
257  base = 'http://127.0.0.1:' + port
258  brainDir = String((options && options.brainDir) || '').replace(/\\/g, '/')
259  bridgeMode = options && options.bridge === 'manual' ? 'manual' : 'auto'
260
261  // Fires on startup, /resume, /clear, compaction and /branch: the lane is refreshed every time,
262  // the timers and the command are set up once
263  on('session.start', async ($, e, next) => {
264    const now = await laneNow($)
265    if (lane && lane.lane !== now.lane) {
266      if (sending) enqueue($, { type: 'session.end', ...lane, ...(scheduled ? { scheduled: true } : {}) })
267      scheduled = false
268      promptSeen = false
269    }
270    lane = now
271    emit($, 'session.start')
272    if (!started) {
273      started = true
274      try {
275        await $.command.register({ name: 'undertone', description: 'Play this session as music: start the bridge and open the page', argumentHint: '[status|off|on|stop]' })
276      } catch (err) {
277        $.ui.log('undertone: could not add /undertone: ' + (err && err.message ? err.message : err))
278      }
279      // A heartbeat, so a session that closes without saying goodbye leaves the page within minutes
280      $.clock.every(HEARTBEAT_MS, () => emit($, 'alive'))
281      $.clock.every(WAITING_EVERY_MS, () => sendWaiting($))
282    }
283    $.clock.after(1500, () => sendWaiting($, true))
284    // The first session starts the bridge, off the session's own startup path
285    if (bridgeMode === 'auto' && sending) {
286      $.clock.after(0, async () => {
287        if (await healthy($)) return
288        lastRestartTry = await $.clock.now()
289        if (await ensureBridge($)) { downUntil = 0; await flush($) }
290      })
291    }
292    return next(e)
293  })
294
295  on('session.end', async ($, e, next) => {
296    emit($, 'session.end')
297    await flush($)
298    return next(e)
299  })
300
301  on('prompt.submit', async ($, e, next) => {
302    // A scheduled task's run starts with its <scheduled-task …> prompt. Only the flag leaves.
303    if (!promptSeen) {
304      promptSeen = true
305      if (/^\s*<scheduled-task[\s>]/.test(String(e.text || ''))) scheduled = true
306    }
307    emit($, 'prompt')
308    return next(e)
309  })
310
311  on('turn.start', async ($, e, next) => {
312    emit($, 'turn.start')
313    return next(e)
314  })
315
316  on('turn.complete', async ($, e, next) => {
317    if (!e.agentId) emit($, 'turn.end')
318    return next(e)
319  })
320
321  // Claude Code asking for you: a permission prompt, or idle and waiting for input
322  on('classic.Notification', async ($, e, next) => {
323    const kind = String(e.notification_type || '') + ' ' + String(e.message || '')
324    const reason = /permission|elicitation|approve/i.test(kind) ? 'permission' : /idle|waiting for your input/i.test(kind) ? 'idle' : null
325    if (reason) emit($, 'attention', { reason })
326    return next(e)
327  })
328
329  on('tool.call', async ($, e, next) => {
330    // coter-kit's own tools answer without calling next, so read them on the way in
331    if (e.tool === CHECKLIST_TOOL && Array.isArray(e.items)) {
332      emit($, 'checklist', { done: e.items.filter((it) => it && it.status === 'done').length, total: e.items.length })
333    }
334    if (e.tool === REMEMBER_TOOL && Array.isArray(e.notes)) {
335      for (const n of e.notes) {
336        if (n && n.kind === 'waiting') emit($, 'waiting.open')
337        else if (n && n.kind === 'decision' && n.resolves) emit($, 'waiting.resolve')
338      }
339      // coter-kit writes the note after this call; read the new counts once it has
340      $.clock.after(2000, () => sendWaiting($))
341    }
342
343    const result = await next(e)
344    if (!result || result.deny) return result
345
346    emit($, 'tool', { tool: shortTool(e.tool), kind: kindOf(e.tool) })
347    // Commits, pushes and which checks passed or failed (hooks/commands.js); never the command
348    if (e.tool === 'Bash' && typeof e.command === 'string') {
349      for (const o of outcomes(analyzeCommand(e.command), !result.isError)) {
350        emit($, o.type, o.check ? { check: o.check, source: 'command' } : {})
351      }
352    }
353    return result
354  })
355
356  // coter-kit's checks block the stop when they fail; a clean stop after that means they pass
357  on('classic.Stop', async ($, e, next) => {
358    const result = await next(e)
359    if (result && result.block) {
360      checksFailing = true
361      emit($, 'fail', { check: 'checks', source: 'checks' })
362    } else if (checksFailing) {
363      checksFailing = false
364      emit($, 'pass', { check: 'checks', source: 'checks' })
365    }
366    return result
367  })
368
369  on('command.run', { command: 'undertone' }, async ($, e) => {
370    const arg = String(e.args || '').trim().toLowerCase()
371
372    if (arg === 'off') {
373      emit($, 'session.end')
374      await flush($)
375      sending = false
376      return { text: 'undertone: this session stopped sending events. `/undertone on` brings it back.' }
377    }
378    if (arg === 'on') {
379      sending = true
380      downUntil = 0
381      emit($, 'session.start')
382      return { text: 'undertone: this session is sending events again.' }
383    }
384    if (arg === 'status') {
385      const up = await healthy($)
386      return {
387        text: 'undertone: bridge ' + (up ? 'running at ' + base : 'not running') +
388          '; this session (' + (lane ? lane.label : '?') + ') is ' + (sending ? 'sending' : 'not sending') + ' events' +
389          (scheduled ? ' as a scheduled run' : '') + (autoRestart ? '' : '; restarting the bridge is off') + '.',
390      }
391    }
392    if (arg === 'stop') {
393      autoRestart = false
394      if (!(await healthy($))) return { text: 'undertone: no bridge is running. This session won\'t start one until `/undertone`.' }
395      let r = null
396      try {
397        r = await $.http.fetch(base + '/shutdown', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ sticky: true }) })
398      } catch {}
399      // A bridge from before 0.6 has no /shutdown
400      if (!r || !r.ok) return { text: 'undertone: the bridge at ' + base + ' did not stop (it may be older than 0.6). Stop it where it runs (Ctrl-C, or end its process). This session won\'t restart it.' }
401      return { text: 'undertone: bridge stopped. Sessions won\'t start it again until `/undertone` (or `npm start`).' }
402    }
403
404    autoRestart = true
405    if (!(await ensureBridge($, true))) {
406      return { text: 'undertone: the bridge did not start. Run `npm start` in ' + $.plugin.root + ' to see why.' }
407    }
408    downUntil = 0
409    const opened = await openPage($)
410    emit($, 'session.start')
411    return {
412      text: 'undertone is running at ' + base + (opened ? ' (opened in your browser)' : '') +
413        '. Press Play on the page. This session plays as "' + (lane ? lane.label : 'session') + '".',
414    }
415  })
416}
417

1// What a Bash command did, as far as undertone cares: did it commit, did it push, which checks
2// (tests, typecheck, lint, build) did it run, and can its exit code be trusted as theirs.
3// Pure; only booleans and short check names come out, never the command.
4//
5//   analyzeCommand(cmd)        -> { commit, push, checks: [{ check, reportable }] }
6//   outcomes(analysis, ok)     -> the events to send: commit, push, pass/fail with `check`
7
8const base = (w) => String(w || '').split('/').pop()
9
10// Heredoc bodies are data, not commands: drop the lines up to the closing word
11function stripHeredocs(cmd) {
12  const out = []
13  let end = null
14  for (const line of String(cmd).split('\n')) {
15    if (end) { if (line.trim() === end) end = null; continue }
16    out.push(line)
17    const m = /<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1/.exec(line)
18    if (m) end = m[2]
19  }
20  return out.join('\n')
21}
22
23// Splits on unquoted && || ; | & and newlines. Quoted strings are emptied (so a commit message
24// can't look like a command) and comments dropped. Each segment remembers the operator after it.
25function segments(cmd) {
26  const segs = []
27  let cur = ''
28  let q = null
29  const cut = (op) => { if (cur.trim()) segs.push({ text: cur.trim(), op }); else if (segs.length && op) segs[segs.length - 1].op = segs[segs.length - 1].op || op; cur = '' }
30  for (let i = 0; i < cmd.length; i++) {
31    const c = cmd[i]
32    const n = cmd[i + 1]
33    if (q) {
34      if (c === '\\' && q === '"') { i++; continue }
35      if (c === q) { q = null; cur += '""' }
36      continue
37    }
38    if (c === "'" || c === '"') { q = c; continue }
39    if (c === '\\') { cur += n || ''; i++; continue }
40    if (c === '#' && (i === 0 || /\s/.test(cmd[i - 1]))) { while (i + 1 < cmd.length && cmd[i + 1] !== '\n') i++; continue }
41    if (c === '\n' || c === ';') { cut(';'); continue }
42    if (c === '&' && n === '&') { cut('&&'); i++; continue }
43    if (c === '|' && n === '|') { cut('||'); i++; continue }
44    if (c === '|') { cut('|'); if (n === '&') i++; continue }
45    if (c === '&' && n !== '>' && cmd[i - 1] !== '>' && cmd[i - 1] !== '<') { cut('&'); continue }
46    cur += c
47  }
48  cut(null)
49  return segs
50}
51
52const WRAPPERS = new Set(['time', 'env', 'sudo', 'nohup', 'command', 'exec'])
53function words(text) {
54  const ws = text.split(/\s+/).filter(Boolean)
55  while (ws.length && (WRAPPERS.has(ws[0]) || /^[A-Za-z_][A-Za-z0-9_]*=/.test(ws[0]))) ws.shift()
56  return ws
57}
58
59function scriptCheck(script) {
60  const s = String(script || '').toLowerCase()
61  if (/^tests?($|:)/.test(s) || s === 'e2e') return 'test'
62  if (/typecheck|type-check|^tsc$|^types$/.test(s)) return 'typecheck'
63  if (/^lint/.test(s)) return 'lint'
64  if (/^build/.test(s)) return 'build'
65  if (s === 'check') return 'checks'
66  return null
67}
68
69// The check a segment runs, as "<family>" or "<family>:<tool>" when the tool says something
70function classify(ws) {
71  const cmd = base(ws[0])
72  const rest = ws.slice(1)
73  const sub = rest.find((w) => !w.startsWith('-'))
74  switch (cmd) {
75    case 'npm': case 'pnpm': case 'yarn': case 'bun': {
76      if (cmd === 'bun' && rest[0] === 'test') return 'test:bun'
77      let script = rest[0]
78      if (script === 'run' || script === 'run-script') script = rest.slice(1).find((w) => !w.startsWith('-'))
79      if (cmd === 'npm' && script === 't') script = 'test'
80      return scriptCheck(script)
81    }
82    case 'npx': case 'pnpx': case 'bunx': {
83      const i = rest.findIndex((w) => !w.startsWith('-'))
84      return i < 0 ? null : classify(rest.slice(i))
85    }
86    case 'tsc': return 'typecheck:tsc'
87    case 'jest': case 'vitest': case 'mocha': case 'playwright': case 'pytest': return 'test:' + cmd
88    case 'mypy': return 'typecheck:mypy'
89    case 'eslint': return 'lint:eslint'
90    case 'ruff': return sub === 'check' ? 'lint:ruff' : null
91    case 'python': case 'python3': {
92      const i = rest.indexOf('-m')
93      const mod = i >= 0 ? rest[i + 1] : null
94      return { pytest: 'test:pytest', unittest: 'test:unittest', mypy: 'typecheck:mypy', py_compile: 'typecheck:python' }[mod] || null
95    }
96    case 'dotnet': return { build: 'build:dotnet', test: 'test:dotnet' }[sub] || null
97    case 'cargo': return { build: 'build:cargo', test: 'test:cargo', check: 'typecheck:cargo', clippy: 'lint:cargo' }[sub] || null
98    case 'go': return { build: 'build:go', test: 'test:go', vet: 'lint:go' }[sub] || null
99    case 'make': {
100      const target = rest.find((w) => !w.startsWith('-') && !w.includes('='))
101      if (!target) return 'build'
102      return { test: 'test', check: 'checks', build: 'build', lint: 'lint', typecheck: 'typecheck' }[target] || null
103    }
104    case 'claude': return rest[0] === 'plugin' && rest[1] === 'test' ? 'test:claude' : null
105    case 'node': return rest.includes('--test') ? 'test:node' : null
106    default: return null
107  }
108}
109
110// git's subcommand after its global options (-C dir, -c k=v, --no-pager, ...)
111function gitSub(ws) {
112  if (base(ws[0]) !== 'git') return null
113  for (let i = 1; i < ws.length; i++) {
114    const w = ws[i]
115    if (w === '-C' || w === '-c' || w === '--git-dir' || w === '--work-tree' || w === '--namespace') { i++; continue }
116    if (w.startsWith('-')) continue
117    return { sub: w, args: ws.slice(i + 1) }
118  }
119  return null
120}
121
122export function analyzeCommand(cmd) {
123  const segs = segments(stripHeredocs(cmd))
124  const result = { commit: false, push: false, checks: [] }
125  let pipefail = false
126  for (let k = 0; k < segs.length; k++) {
127    const ws = words(segs[k].text)
128    if (!ws.length) continue
129    if (/\bpipefail\b/.test(segs[k].text)) pipefail = true
130    const g = gitSub(ws)
131    if (g && g.sub === 'commit' && !g.args.includes('--dry-run')) result.commit = true
132    if (g && g.sub === 'push' && !g.args.includes('--dry-run') && !g.args.includes('-n')) result.push = true
133    const check = classify(ws)
134    if (!check) continue
135    // The command's exit code is this check's only if nothing after it can mask it: from here to
136    // the end only `&&` (and a pipe when pipefail is set). `;`, `||` (`|| true`), a plain pipe
137    // (`| tail`) or `&` (background) all hide it.
138    let reportable = true
139    for (let j = k; j < segs.length - 1; j++) {
140      const op = segs[j].op
141      if (op === '&&') continue
142      if (op === '|' && pipefail) continue
143      reportable = false
144      break
145    }
146    if (segs[segs.length - 1].op === '&') reportable = false
147    result.checks.push({ check, reportable })
148  }
149  return result
150}
151
152// A failure with more than one check in the chain can't say which failed, so it says nothing
153export function outcomes(a, ok) {
154  const out = []
155  if (ok && a.commit) out.push({ type: 'commit' })
156  if (ok && a.push) out.push({ type: 'push' })
157  const checks = a.checks.filter((c) => c.reportable)
158  if (ok) for (const c of checks) out.push({ type: 'pass', check: c.check })
159  else if (checks.length === 1) out.push({ type: 'fail', check: checks[0].check })
160  return out
161}
162

1// How many coter-kit questions wait on you, per project, from the brain's journal rows.
2// Pure, so it can be tested without a brain on disk.
3//
4// Read the way coter-kit reads them: status rows applied in time order, unanswered questions
5// dropped after 30 days. On top of that, the same question saved twice (two devices, a minute
6// apart) counts once. Only `waiting` notes count: never threads (coter-kit 0.6.1 saves every
7// question as a waiting note) and never handoffs.
8//
9// coter-kit plans a live status file (its build plan, M2). When that ships, read it instead of
10// the journal; until then this mirrors coter-kit's own reader.
11
12const TTL_MS = 30 * 86_400_000
13const norm = (t) => String(t || '').trim().toLowerCase().replace(/\s+/g, ' ')
14
15export function countWaiting(rows, now) {
16  const entries = new Map()
17  const ops = []
18  for (const row of rows) {
19    if (!row || typeof row !== 'object') continue
20    if (row.op) ops.push(row)
21    else if (row.id && row.kind) entries.set(row.id, row)
22  }
23  ops.sort((a, b) => a.at - b.at)
24  for (const op of ops) {
25    const e = entries.get(op.ref)
26    if (e && op.op === 'status') entries.set(op.ref, { ...e, status: op.status, updatedAt: op.at })
27  }
28  const seen = new Set()
29  const by = {}
30  for (const e of entries.values()) {
31    if (e.kind !== 'waiting' || e.status !== 'active' || now - (e.updatedAt || e.at) > TTL_MS) continue
32    const project = e.project || 'every project'
33    const key = project + '\u0000' + norm(e.text)
34    if (seen.has(key)) continue
35    seen.add(key)
36    by[project] = (by[project] || 0) + 1
37  }
38  return by
39}
40