@renzrollon/interlock 1.3.1 → 1.4.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "interlock",
   "displayName": "Interlock",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "Autonomous spec-driven development orchestration for Claude Code, layered on OpenSpec. Onboard a repo, produce a reviewed spec, then ship it start-to-commit with parallel agents and a deterministic gate spine.",
   "author": {
     "name": "Carl Rollon",

package/CHANGELOG.md

@@ -5,6 +5,44 @@ All notable changes to this project are documented here.
 The format follows Keep a Changelog 1.1.0, and
 this project adheres to Semantic Versioning 2.0.0.
 
+## 1.4.1 — 2026-10-09
+
+### Changed
+
+- **The ship meter pane reads as a timeline.** In 1.4.0 the `agents` section was a flat list in first-seen order: relay pings, the planner and lane workers were interleaved, nothing said when anything happened, and lanes that ran in parallel looked like lanes that ran in turn.
+  - **The `timeline` section replaces it.** There is one line per CLI step as it crossed, such as `run-batch · wave 2 · batch 1/2 · 3 in parallel` or `verify · wave 2 · skipped: <reason>`. The relay agent that carried the step is folded into that line: `cli <id>`, its served model, its request count and its duration.
+  - **Each step's agents** are indented beneath it in the order they started, with name, id, model, turn word and a dim requests-and-tokens line. A spawn no agent has picked up yet reads `waiting`. A relay whose line printed no step, such as `interlock limits`, stands at its own time, and agents nothing names are listed last under `unmatched`.
+  - **Every timed line has a local `HH:MM:SS` gutter**, blank where the clock gave no reading, never a guessed time.
+  - **The header** reads `started <date> <time> · last activity <time>`, replacing `last activity <ISO>`.
+  - **Durations** read `41.2s`, `2m 14s` or `1h 03m`, replacing `134.2s`.
+  - **Wave cards group their lanes by batch**, under a line with the batch's dispatch time and `N in parallel` or `1 lane`. The lanes are indented beneath it and no longer repeat the batch cell. A lane's note adds its duration once its turn ended.
+  - **Each section's body is indented** under its heading.
+  - **Relay token figures:** a relay's token breakdown is no longer drawn. The trajectory's `agent-result` line still carries it.
+  - **New modules:** the words and the order come from two new Node-free modules, `lib/meter-time.mjs` and `lib/meter-timeline.mjs`, pinned by `test/spine/meter-time.test.mjs` and `test/spine/meter-timeline.test.mjs`.
+  - **Layout probe:** a probe on 2.1.295 showed the gutter keeps a hanging indent when a line wraps, inside a card too. The pane is as tall as the engine seats it, and a long run scrolls.
+  - **Unchanged:** `interlock waves --format board` prints exactly what it printed before.
+
+### Fixed
+
+- **A run resumed across the 1.4.0 upgrade does not re-run its lanes.** The 1.4.0 entry said it would, because the runtime caches an agent by its label. The runtime keys an agent on its prompt and its options together, the label among them, but a lane's label is the title its step carried, and on a resume the completed relays hand back the steps they first printed. So every lane the run had already dispatched is spawned under its old title and returns its saved result. `docs/04` now says the replay cache keys on the prompt and the options, not on the prompt text alone, and says why an upgrade does not rename the lanes a resume replays.
+- **`docs/07` no longer says the board names a lane exactly as its spawn.** Since 1.4.0 the spawn is shown as `task 1.1 · …`, while the board, the briefing file, the worktree and the trajectory line name the lane by its label, `1.1`.
+
+## 1.4.0 — 2026-10-09
+
+### Changed
+
+- **A lane's worker is shown as `task 1.1 · <gist>`.** `/workflows`, `interlock-run`'s log, the meter's rows and toasts and the Mermaid plan all name a lane by `laneTitle`, which read `1.1 · Add the relaunch guard`. A bare `1.1` among `plan-waves`, `cli-3 · run next` and `verify` looked like an outline number rather than a worker. The title now opens with what the agent is doing: `task 1.1 · …` for a one-task lane and `tasks 1.1+2 · …` for a lane of several. The 48-character cap still applies to the label and gist, so a gist is cut where it was and `interlock waves --format board` prints byte-for-byte what it printed before. The label (`1.1`, `1.1+2`) is unchanged and still names the briefing file, the worktree, the trajectory line and `run record-batch`. Non-lane spawns keep their labels as titles. The workflow runtime caches an agent by its label, so resuming a run from `/workflows` that started before this upgrade re-runs its lane agents.
+- **The ship meter names every agent on the Workflow host.** On that host every agent row and turn-end toast read `lane unknown`. The meter joined an agent to its lane only through `agent.spawn`, which the host never raises for a workflow agent, so the board's lane notes never left `served ?` either. Every run agent's first act is to read its own briefing, so the meter now joins on that read. A `Read` whose path names a dispatched spawn's briefing, or a Bash command that names it (a worker that `cat`s it), matches the agent to that spawn's row by the same briefing hash. A new `tool.call` observer on `Read` makes that join and passes the call on unchanged. An agent is named by its spawn's title (`task 1.1 · …`, `plan-waves`, `verify`). A relay ping is named by its own `interlock` line (`cli · run next`). An agent seen doing neither reads `unmatched agent`, and one line beneath the rows says why. The pane and the toast now use one name; before, the pane printed the label and the toast the title.
+- **The meter pane draws in your theme's colours.** Every colour is a theme key, so the pane follows a light, dark or colour-blind theme. A probe on 2.1.295 showed theme keys resolve in a module's pane and an unknown key renders uncoloured.
+  - State words: `success`, `error` and `warning` for `ok`, `failed` and `current`, replacing raw green, red and yellow.
+  - Names: lane labels and agent names in `suggestion`, bold.
+  - Headings: the run header and section headings in `claude`.
+  - Cards: the card of the wave holding a `current` lane is bordered in `warning`; every other card stays dim.
+  - Agent rows: an agent's turn word in `warning` while running, `success` for `answer` and `error` for any other host word, with relay pings dim.
+  - Warnings: the quiet word and banners in `warning`.
+  - Refusals: the guard-denial line, and the launch-guard line when it refuses, in `error`.
+  - Uncoloured, as before: the context, cost and plan-window lines (colour there would read as a threshold) and a `RED` marker in a wave title. The rules are `lib/meter-palette.mjs`'s, a Node-free module pinned by `test/spine/meter-palette.test.mjs`.
+
 ## 1.3.1 — 2026-10-08
 
 ### Changed

package/hooks/mod.mjs

@@ -65,10 +65,31 @@
 // with an overlay built from the steps alone (the cursor, the ids each recorded
 // batch names, the skipped verifications, the halt). No file is read for it.
 // The module lays those rows as one bordered card per wave, wraps the gist,
-// and colours only the state word the renderer chose. It keys the lanes,
+// and colours the state word the renderer chose and the lane's label. It keys the lanes,
 // appends what the host observed of a lane, and speaks every fallback: a CLI
 // that relays no plan, a pane narrower than the board, a renderer that throws.
 //
+// THE AGENTS' NAMES AND THE PALETTE. The
+// Workflow host raises no `agent.spawn` for a Workflow agent, so the spawn
+// event's join never fires there. Every run agent's first act is to read its
+// own briefing, and that Read or Bash call names the spawn's briefing path:
+// the module joins the agent to the spawn's row by it, through the same
+// briefing hash. A driver line from an agent no row names marks a relay; any
+// other agent reads `unmatched agent`, said once beneath the rows. Every colour
+// is a theme key from `lib/meter-palette.mjs` and names a meaning, never a
+// threshold: the engine's own figures carry none.
+//
+// THE STEP TIMELINE. The agents list's place is a timeline: one line per step
+// as it crossed, the agent whose Bash call printed it folded into that line,
+// the agents a step spawned one indent beneath it in the order they started,
+// relays no step names at their own time, and the agents nothing names last.
+// Every timed line carries the local `HH:MM:SS` of a reading the module took
+// itself (the launch's, a step's stamp, an agent's first request), blank
+// where the clock gave none; durations are humanised. The order and the
+// step's words are `lib/meter-timeline.mjs`'s, the time words
+// `lib/meter-time.mjs`'s. Within a wave card the lanes sit beneath their
+// batch's sub-header, timed by when that batch was first dispatched.
+//
 // THE SESSION START (show-preflight-and-interrupted-runs-at-session-start
 // design D5-D8). Outside a run the module draws two things, both from the
 // report `hooks/preflight.mjs` leaves at `.claude/ship/preflight.json`: the
@@ -101,7 +122,10 @@
 import { drawPlanBoardRows } from '../lib/draw-plan.mjs'
 import { decideLaunch, emptyRecord, isAcceptedLaunch, isShipLaunch, withLaunch, withPrompt } from '../lib/launch-rule.mjs'
 import { LIMITS } from '../lib/limits.mjs'
+import { PALETTE, stateProps, turnProps } from '../lib/meter-palette.mjs'
 import { TICK_MS, quietMs, quietWord } from '../lib/meter-quiet.mjs'
+import { clockText, durationText, stampText } from '../lib/meter-time.mjs'
+import { BATCH_ACTIONS, batchText, laneCountText, planWaveCount, stepText, timeline } from '../lib/meter-timeline.mjs'
 import { guardDenialLine, guardOf, guardReason, launchGuardLine } from '../lib/meter-refusals.mjs'
 import {
   adoptPreflight,
@@ -144,8 +168,6 @@ const UNPLACED_TOAST = '/interlock-meter opens the ship meter'
 const NO_LANES_LINE = 'no lanes dispatched yet'
 const UNRELAYED_LINE = 'plan structure not relayed by this CLI'
 const BOARD_FAILED_LINE = 'wave board could not be drawn'
-// The actions that dispatch a batch of lanes, and so place the board's cursor on one.
-const BATCH_ACTIONS = new Set(['run-batch', 'test-wave'])
 // The session start's two panes, each opened by the command of its name (design D6).
 const PREFLIGHT_PANE = 'interlock-preflight'
 const HANDOFF_PANE = 'interlock-handoff'
@@ -166,6 +188,23 @@ const GUARD = 'interlock guard'
 const DRIVER_LINE = /^interlock\s/
 // The bootstrap line a lane's spawn prompt carries (as `lib/agent-usage.mjs` reads it).
 const BRIEFING_SHA = /Expected sha256: ([0-9a-f]{64})/g
+// What an agent row and a turn-end toast read for an agent no row and no driver line names.
+const UNMATCHED = 'unmatched agent'
+const UNMATCHED_LINE = 'unmatched: no briefing read or interlock line seen from this agent yet'
+// The characters a briefing path may stand behind in a Read path or a command,
+// and the ones that would make it part of a longer file name after it.
+const PATH_BEFORE = /[\s\/'"=]/
+const PATH_AFTER = /[\w.+-]/
+/** The props a name is drawn with: a lane label, a spawn's title, a joined agent's name. */
+const NAME_PROPS = { bold: true, color: PALETTE.identity }
+const DIM = { dimColor: true }
+// The timeline's gutter: `HH:MM:SS` and two spaces, and how far a section body
+// and a child line sit in from what holds them (layout probe P3, Claude Code 2.1.295).
+const GUTTER_COLUMNS = 10
+const INDENT = 2
+const NO_STEP_LINE = 'no step has crossed yet'
+/** The props the run header and each section heading are drawn with. */
+const HEADING_PROPS = { bold: true, color: PALETTE.accent }
 const TOKEN_FIELDS = ['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens']
 // The classic session-start sources that start the session over, as the person
 // typed them (design D4). `startup` and `compact` are not among them.
@@ -208,6 +247,13 @@ function freshRun() {
     // activity (null until the clock answers), the word it makes, and the one
     // interval that recomputes it, known by its handle and its generation.
     lastActivityAt: null,
+    // The reading the last stamp took (null when the clock failed), and the
+    // launch's own: the timeline's times, never guessed.
+    stampedAt: null,
+    launchedAt: null,
+    // Every step applied, in crossing order, and the time each batch was first dispatched, by `<waveIndex>:<batchIndex>`.
+    steps: [],
+    batchAt: new Map(),
     quietWord: null,
     tick: null,
     generation: 0,
@@ -286,7 +332,8 @@ function position() {
   if (run.change) parts.push(run.change)
   if (run.action) parts.push(run.action)
   if (run.wave !== undefined && run.wave !== null) parts.push(`wave ${run.wave}`)
-  if (isInt(run.batchIndex) && isInt(run.batchCount)) parts.push(`batch ${run.batchIndex + 1}/${run.batchCount}`)
+  const batch = batchText(run.batchIndex, run.batchCount)
+  if (batch) parts.push(batch)
   return parts.join(' · ')
 }
 
@@ -354,6 +401,7 @@ async function stamp($) {
   const held = run
   const now = await clockNow($)
   if (held !== run) return false
+  run.stampedAt = now
   if (now !== null) run.lastActivityAt = run.lastActivityAt === null ? now : Math.max(run.lastActivityAt, now)
   return setWord(null)
 }
@@ -611,6 +659,72 @@ async function noteSpawn($, input, spawned) {
   return spawned
 }
 
+/** Whether `text` names `path` whole: behind its start or a separator, and not followed by more of a file name. */
+function namesPath(text, path) {
+  for (let at = text.indexOf(path); at !== -1; at = text.indexOf(path, at + 1)) {
+    const before = at === 0 ? '' : text[at - 1]
+    const after = text[at + path.length] ?? ''
+    if ((before === '' || PATH_BEFORE.test(before)) && (after === '' || !PATH_AFTER.test(after))) return true
+  }
+  return false
+}
+
+/**
+ * The Workflow host's join: it raises no
+ * `agent.spawn` for a Workflow agent, but every run agent's first act is to
+ * read its own briefing. A Read path or a Bash command that names a
+ * dispatched spawn's briefing path joins the agent to that spawn's row,
+ * through the same briefing hash the spawn event joins on. The first briefing
+ * an agent reads wins; an agent that names none is left as it was, and no
+ * agent record is made for it. Never throws.
+ */
+function noteBriefing($, agentId, text) {
+  try {
+    const id = str(agentId)
+    if (!id || typeof text !== 'string') return
+    const known = run.agents.get(id)
+    if (known && known.sha) return
+    const said = text.split('\\').join('/')
+    for (const r of run.rows.values()) {
+      if (!r.sha || !r.promptPath) continue
+      if (!namesPath(said, r.promptPath.split('\\').join('/'))) continue
+      agentOf(id).sha = r.sha
+      $.ui.invalidate('ui.render')
+      return
+    }
+  } catch (err) {
+    $.ui.log(`interlock meter: a briefing read was not joined to its lane: ${messageOf(err)}`, { to: 'debug' })
+  }
+}
+
+/**
+ * `run next` for `interlock run next --results … --json`: the subcommand a
+ * driver line relays, as `workflows/ship.js` names its relay (`argv.slice(0, 2)`),
+ * the second word dropped when it is a flag or a shell operator.
+ */
+function relayOf(command) {
+  const words = command.trim().split(/\s+/).slice(1, 3)
+  if (!words.length || !words[0]) return null
+  const second = words[1]
+  return second && !/^(--|[;&|<>])/.test(second) ? `${words[0]} ${second}` : words[0]
+}
+
+/** An agent that ran a driver line before any briefing named it is a relay, shown by what it relayed. Never throws. */
+function noteRelay($, agentId, command) {
+  try {
+    const id = str(agentId)
+    if (!id) return
+    const known = run.agents.get(id)
+    if (known && known.sha) return
+    const relay = relayOf(command)
+    if (!relay || (known && known.relay === relay)) return
+    agentOf(id).relay = relay
+    $.ui.invalidate('ui.render')
+  } catch (err) {
+    $.ui.log(`interlock meter: a driver line was not read for its agent: ${messageOf(err)}`, { to: 'debug' })
+  }
+}
+
 /**
  * A clear, resume or fork ends the run the meter holds, before the chain
  * beneath runs. Any other source, and a non-interactive session, changes
@@ -658,11 +772,14 @@ function drawSpecPane($, e) {
   return h(Box, { flexDirection: 'column' }, ...specPaneLines(spec).map(l => h(Box, { key: l.key }, h(Text, props(l), l.text))))
 }
 
-/** The launch guard's ruling now, over the record its branch would read, in the rule's words (design D5). */
+/**
+ * The launch guard's ruling now, over the record its branch would read, in the
+ * rule's words (design D5), and whether that ruling refuses the next launch.
+ */
 async function launchGuardText($) {
   const { record, now } = await guardFacts($)
   const ruling = decideLaunch(record, now)
-  return launchGuardLine(ruling, now)
+  return { text: launchGuardLine(ruling, now), refused: now !== null && ruling.decision !== 'allow' && Boolean(ruling.reason) }
 }
 
 /** Names, once per run record, a step that crossed with no live run (design D4). */
@@ -719,14 +836,27 @@ function agentOf(id) {
       reason: null,
       durationMs: null,
       sha: null,
+      // The two words after `interlock` in the first driver line it ran while no row named it.
+      relay: null,
       // Whether its turn end has been spoken: once per agent per run (speak-lane-turn-ends design D1).
-      endToasted: false
+      endToasted: false,
+      // The reading at its first request, taken once (null when the clock failed then), and at its turn end.
+      stepped: false,
+      firstAt: null,
+      endAt: null
     }
     run.agents.set(id, a)
   }
   return a
 }
 
+/** The agent's first request, timed once by the stamp just taken: a later reading never moves it. */
+function firstRequest(a) {
+  if (a.stepped) return
+  a.stepped = true
+  a.firstAt = run.stampedAt
+}
+
 /** Field by field: a field one request omitted leaves that figure unknown (`null`), never a guessed zero (design D5). */
 function addUsage(a, usage) {
   a.requests++
@@ -812,7 +942,34 @@ function takeBoard($, record) {
   if (record.action === 'halt') run.halt = { reason: str(record.reason) || (run.halt ? run.halt.reason : null) }
 }
 
-async function applyRecord($, record) {
+/**
+ * One step as the timeline draws it, its fields the record's own: the time the
+ * stamp read, its position, a skip or halt reason, the size of a plan summary
+ * it carried, the agent whose Bash call printed it, and the spawns it named.
+ */
+function noteStep(record, relayId, spawns) {
+  const step = {
+    n: run.steps.length,
+    at: run.stampedAt,
+    action: record.action,
+    wave: record.wave,
+    waveIndex: record.waveIndex,
+    batchIndex: record.batchIndex,
+    batchCount: record.batchCount,
+    skipped: record.skipped,
+    reason: record.reason,
+    planWaves: isPlanSummary(record.plan) ? planWaveCount(record.plan) : null,
+    relayId: str(relayId),
+    spawns
+  }
+  run.steps.push(step)
+  if (BATCH_ACTIONS.has(record.action) && isInt(record.waveIndex) && isInt(record.batchIndex)) {
+    const at = `${record.waveIndex}:${record.batchIndex}`
+    if (!run.batchAt.has(at)) run.batchAt.set(at, step.at)
+  }
+}
+
+async function applyRecord($, record, relayId) {
   const held = run
   await stamp($)
   if (held !== run) return
@@ -822,8 +979,10 @@ async function applyRecord($, record) {
   if (record.wave !== undefined) run.wave = record.wave
   run.batchIndex = record.batchIndex
   run.batchCount = record.batchCount
+  const spawns = []
   for (const s of Array.isArray(record.spawns) ? record.spawns : []) {
     if (!s || typeof s !== 'object' || !str(s.label)) continue
+    spawns.push({ label: s.label, title: str(s.title) || s.label, sha: str(s.promptSha256) })
     run.rows.set(s.label, {
       label: s.label,
       title: str(s.title) || s.label,
@@ -831,10 +990,13 @@ async function applyRecord($, record) {
       model: str(s.model),
       effort: str(s.effort),
       sha: str(s.promptSha256),
+      // The briefing the spawn names, read off the agent's own first read of it.
+      promptPath: str(s.promptPath),
       // Spawned by a step that dispatches a batch: a lane, planned or not.
       batch: BATCH_ACTIONS.has(record.action)
     })
   }
+  noteStep(record, relayId, spawns)
   takeBoard($, record)
   for (const banner of Array.isArray(record.banners) ? record.banners : []) {
     if (typeof banner !== 'string' || !banner) continue
@@ -979,9 +1141,14 @@ function rowForAgent(a) {
   return null
 }
 
-function laneForAgent(a) {
-  const r = rowForAgent(a)
-  return r ? r.label : null
+/**
+ * What an agent is called: its joined spawn's title, else `cli · <what it
+ * relayed>` for a driver-line agent, else `null`, which reads `unmatched agent`.
+ */
+function agentName(a) {
+  const row = rowForAgent(a)
+  if (row) return row.title
+  return a.relay ? `cli · ${a.relay}` : null
 }
 
 /**
@@ -1006,25 +1173,133 @@ function sessionLines(usage, failure) {
 }
 
 /**
- * `last activity <ISO>` or `last activity unknown`, then the quiet word while a
- * live run is quiet. The word is recomputed from the clock at each draw, so a
- * pane opened after the host stopped the interval still shows it (design D2, D5).
+ * `started <local date and time> · last activity <local time>` (the start left
+ * out when the launch read no time, `last activity unknown` when no stamp did),
+ * then the quiet word while a live run is quiet, as the line and the word
+ * apart. The word is recomputed from the clock at each draw, so a pane opened
+ * after the host stopped the interval still shows it (design D2, D5).
  */
 async function lastActivityText($) {
-  if (run.lastActivityAt === null) return 'last activity unknown'
-  const at = new Date(run.lastActivityAt).toISOString()
+  const started = run.launchedAt === null ? '' : `started ${stampText(run.launchedAt)} · `
+  if (run.lastActivityAt === null) return { line: `${started}last activity unknown`, word: null }
   const word = run.phase === 'live' ? quietWord(quietMs(run.lastActivityAt, await clockNow($))) : null
-  return `last activity ${at}${word ? ` · ${word}` : ''}`
+  return { line: `${started}last activity ${clockText(run.lastActivityAt)}`, word }
+}
+
+/** An agent id as a line shows it: its first eight characters. */
+const id8 = id => String(id).slice(0, 8)
+
+/** `1 request`, `N requests`. */
+const requestsText = a => (a.requests === 1 ? '1 request' : `${a.requests} requests`)
+
+/** An agent's turn: `running`, else the host's word and, once reported, how long the turn took. */
+const turnText = a =>
+  a.reason ? `${a.reason}${a.durationMs !== null ? ` ${durationText(a.durationMs)}` : ''}` : 'running'
+
+/** Whether the host ended the agent's turn without an answer. */
+const abnormal = a => Boolean(a.reason) && a.reason !== 'answer'
+
+/**
+ * An agent's first line, one wrapping text: its name, its id and models dim,
+ * then its turn word. A joined agent is named in the identity colour, a relay
+ * dim, an unmatched agent dim and italic. The turn word is the host's, coloured
+ * by what it means; a relay's running or answered turn stays dim, and only its
+ * abnormal end is coloured.
+ */
+function agentLine(Text, a, name, kind) {
+  const nameProps = kind === 'joined' ? NAME_PROPS : kind === 'relay' ? DIM : { dimColor: true, italic: true }
+  const quiet = kind === 'relay' && !abnormal(a)
+  return h(
+    Text,
+    { wrap: 'wrap' },
+    h(Text, nameProps, name),
+    h(Text, DIM, ` · ${id8(a.id)} · ${a.models.join(', ') || 'model not reported'}`),
+    ' · ',
+    h(Text, quiet ? DIM : turnProps(a.reason), turnText(a))
+  )
+}
+
+/**
+ * One timed line (layout probe P3): the local time in a fixed dim gutter,
+ * blank when no time was read, then the content in a column that wraps beside
+ * it, `depth` steps in. Each content line is one Text with its coloured words
+ * nested inside it, never a row of sibling Texts.
+ */
+function gutterRow(Box, Text, key, at, depth, ...content) {
+  return h(
+    Box,
+    { key, flexDirection: 'row' },
+    h(Box, { width: GUTTER_COLUMNS, flexShrink: 0 }, h(Text, DIM, clockText(at))),
+    h(Box, { flexGrow: 1, flexShrink: 1, flexDirection: 'column', paddingLeft: depth * INDENT }, ...content)
+  )
+}
+
+/**
+ * A step's line: its own words, then the agent whose Bash call printed it,
+ * dim, with its served models, its requests and, once its turn ended, how long
+ * it took; the relay's turn word only when the host ended it without an answer.
+ */
+function stepLine(Text, step) {
+  const spans = [stepText(step)]
+  if (step.relayId) {
+    const a = run.agents.get(step.relayId)
+    const figures = a ? ` · ${a.models.join(', ') || 'model not reported'} · ${requestsText(a)}` : ''
+    spans.push(h(Text, DIM, ` · cli ${id8(step.relayId)}${figures}`))
+    if (a && abnormal(a)) spans.push(' · ', h(Text, turnProps(a.reason), turnText(a)))
+    else if (a && a.durationMs !== null) spans.push(h(Text, DIM, ` · ${durationText(a.durationMs)}`))
+  }
+  return h(Text, { wrap: 'wrap' }, ...spans)
 }
 
-/** One spawn as a flat row, as the section drew every spawn before the board. */
-function flatRow(keyed, r) {
+/**
+ * The timeline section: `lib/meter-timeline.mjs`'s entries, each a gutter
+ * line. An agent a step spawned and an agent no step names keep the requests
+ * and tokens line beneath their own; a relay's figures ride its step's line or
+ * its own one line, and its token breakdown is the trajectory's.
+ */
+function drawTimeline($, e) {
+  const { Box, Text } = $.ui.resolve(e)
+  const entries = timeline({
+    steps: run.steps,
+    agents: [...run.agents.values()],
+    launch: { at: run.launchedAt, name: run.workflowName }
+  })
+  const figures = a => h(Text, { dimColor: true, wrap: 'wrap' }, `${requestsText(a)} · ${tokensText(a)}`)
+  const out = []
+  for (const entry of entries) {
+    const row = (...content) => gutterRow(Box, Text, entry.key, entry.at, entry.depth, ...content)
+    if (entry.kind === 'launch') out.push(row(h(Text, { wrap: 'wrap' }, `launch · ${entry.name || 'interlock:ship'}`)))
+    else if (entry.kind === 'step') out.push(row(stepLine(Text, entry.step)))
+    else if (entry.kind === 'spawn' && entry.agent) {
+      out.push(row(agentLine(Text, entry.agent, entry.spawn.title, 'joined'), figures(entry.agent)))
+    } else if (entry.kind === 'spawn') {
+      out.push(row(h(Text, { wrap: 'wrap' }, h(Text, NAME_PROPS, entry.spawn.title), ' · ', h(Text, DIM, 'waiting'))))
+    } else if (entry.kind === 'relay') out.push(row(agentLine(Text, entry.agent, `cli · ${entry.agent.relay}`, 'relay')))
+    else if (entry.kind === 'unmatched-head') out.push(h(Box, { key: entry.key }, h(Text, DIM, 'unmatched')))
+    else if (entry.kind === 'unmatched') out.push(row(agentLine(Text, entry.agent, UNMATCHED, 'unmatched'), figures(entry.agent)))
+  }
+  if (entries.some(entry => entry.kind === 'unmatched')) {
+    out.push(h(Box, { key: 'agents-unmatched', paddingLeft: INDENT }, h(Text, { dimColor: true, wrap: 'wrap' }, UNMATCHED_LINE)))
+  }
+  if (!run.steps.length) out.push(h(Box, { key: 'timeline-no-step' }, h(Text, DIM, NO_STEP_LINE)))
+  return out
+}
+
+/** One spawn as a flat row, as the section drew every spawn before the board: its title in the identity colour. */
+function flatRow($, e, r) {
+  const { Box, Text } = $.ui.resolve(e)
   const a = agentForSha(r.sha)
   const served = a && a.models.length ? a.models.join(', ') : '?'
   const state = a ? a.reason || 'running' : 'waiting'
-  return keyed(
-    `wave-row-${r.label}`,
-    `${r.title} · ${r.kind || 'agent'} · routed ${r.model || '?'} · served ${served} · effort ${r.effort || '?'} · ${state}`
+  return h(
+    Box,
+    { key: `wave-row-${r.label}` },
+    h(
+      Text,
+      null,
+      h(Text, NAME_PROPS, r.title),
+      ` · ${r.kind || 'agent'} · routed ${r.model || '?'} · served ${served} · effort ${r.effort || '?'} · ${state}`
+    )
   )
 }
 
@@ -1051,7 +1326,7 @@ function laneNotes() {
   for (const r of run.rows.values()) {
     const a = agentForSha(r.sha)
     const served = a && a.models.length ? a.models.join(', ') : '?'
-    notes[r.label] = `served ${served}${a ? ` · ${a.reason || 'running'}` : ''}`
+    notes[r.label] = `served ${served}${a ? ` · ${turnText(a)}` : ''}`
   }
   return notes
 }
@@ -1064,22 +1339,13 @@ function boardKey(key) {
   return `${kind === 'wave' ? 'wave-block' : `wave-${kind}`}-${rest.join('-')}`
 }
 
-/** Colour only a state word the board printed: hue for ok/failed/current, dim for the rest. */
-function stateProps(word) {
-  if (word === 'ok') return { color: 'green' }
-  if (word === 'failed') return { color: 'red' }
-  if (word === 'current') return { color: 'yellow' }
-  if (word === 'pending' || word === 'not reached' || word === 'not recorded' || word === 'per task') {
-    return { dimColor: true }
-  }
-  return null
-}
-
-/** The width a card and the renderer share: the body, capped at the published default. */
+/**
+ * The width a card and the renderer share: the section body (the pane's body
+ * less the body's indent beneath its heading), capped at the published default.
+ */
 function boardColumns(e) {
-  const body = e.props && isInt(e.props.bodyColumns) && e.props.bodyColumns > 0
-    ? e.props.bodyColumns
-    : LIMITS.waveBoardDefaultColumns
+  const pane = e.props && isInt(e.props.bodyColumns) && e.props.bodyColumns > 0 ? e.props.bodyColumns : null
+  const body = pane === null ? LIMITS.waveBoardDefaultColumns : Math.max(1, pane - INDENT)
   return body < LIMITS.waveBoardMinColumns ? body : Math.min(body, LIMITS.waveBoardDefaultColumns)
 }
 
@@ -1108,28 +1374,71 @@ function idSpans(Text, parts) {
 }
 
 /**
- * A lane in its card: the fixed cells as one Text, the gist wrapping beneath,
- * then the host's note, dim. The coloured words are spans nested in that one
- * Text, because a row of separate elements shrinks each into its own column
- * and breaks words apart once the line is wider than the card.
+ * A lane's label, model, tier and effort cells, space-joined as the board
+ * prints them, the label a span in the identity colour. The batch cell is the
+ * sub-header the lane sits under, so the lane does not repeat it.
+ */
+function headSpans(Text, parts) {
+  const after = [parts.model, parts.tier, parts.effort].filter(Boolean).join(' ')
+  if (!parts.label) return [after]
+  return [h(Text, NAME_PROPS, parts.label), ...(after ? [` ${after}`] : [])]
+}
+
+/** Whether a lane the board drew holds the cursor: its own state word, or a task's, is `current`. */
+const isCurrentLane = parts =>
+  Boolean(parts) &&
+  (parts.state === 'current' || (Array.isArray(parts.tasks) && parts.tasks.some(task => task && task.word === 'current')))
+
+/**
+ * A lane in its card, one step in beneath its batch's sub-header with a blank
+ * gutter: the fixed cells as one Text, the gist wrapping beneath, then the
+ * host's note, dim. The coloured words are spans nested in that one Text,
+ * because a row of separate elements shrinks each into its own column and
+ * breaks words apart once the line is wider than the card.
  */
 function drawLane($, e, row) {
   const { Box, Text } = $.ui.resolve(e)
   const key = boardKey(row.key)
   const parts = row.parts
   if (!parts) return h(Box, { key }, h(Text, { wrap: 'truncate-end' }, row.text))
-  const head = [parts.batch, parts.label, parts.model, parts.tier, parts.effort].filter(Boolean).join(' ')
   const line = [
-    ...(parts.state ? [`${head} `, h(Text, stateProps(parts.state), parts.state)] : [head]),
+    ...headSpans(Text, parts),
+    ...(parts.state ? [' ', h(Text, stateProps(parts.state), parts.state)] : []),
     ...idSpans(Text, parts),
     ...(Array.isArray(parts.after) && parts.after.length ? [` ←${parts.after.join(',')}`] : [])
   ]
   const kids = [
     h(Text, { wrap: 'wrap' }, ...line),
     parts.gist ? h(Box, { key: `${key}-gist` }, h(Text, { wrap: 'wrap' }, parts.gist)) : null,
-    parts.note ? h(Box, { key: `${key}-note` }, h(Text, { dimColor: true }, parts.note)) : null
+    parts.note ? h(Box, { key: `${key}-note` }, h(Text, { dimColor: true, wrap: 'wrap' }, parts.note)) : null
   ].filter(Boolean)
-  return h(Box, { key, flexDirection: 'column' }, ...kids)
+  return gutterRow(Box, Text, key, null, 1, ...kids)
+}
+
+/**
+ * A card's lanes, grouped by the batch the board printed for each: before each
+ * group a gutter line with the time that batch was first dispatched and how
+ * many lanes it runs side by side. It carries no state word: the cursor card's
+ * border already marks where the run is.
+ */
+function drawBatches($, e, index, lanes) {
+  const { Box, Text } = $.ui.resolve(e)
+  const groups = new Map()
+  for (const row of lanes) {
+    const batch = row.parts && typeof row.parts.batch === 'string' ? row.parts.batch : null
+    if (!groups.has(batch)) groups.set(batch, [])
+    groups.get(batch).push(row)
+  }
+  const out = []
+  for (const [batch, rows] of groups) {
+    const k = batch && /^b\d+$/.test(batch) ? batch.slice(1) : null
+    if (k !== null) {
+      const at = run.batchAt.has(`${index}:${k}`) ? run.batchAt.get(`${index}:${k}`) : null
+      out.push(gutterRow(Box, Text, `wave-batch-${index}-${k}`, at, 0, h(Text, { wrap: 'wrap' }, `${batch} · ${laneCountText(rows.length)}`)))
+    }
+    out.push(...rows.map(row => drawLane($, e, row)))
+  }
+  return out
 }
 
 function drawBoardCards($, e, board, width) {
@@ -1138,8 +1447,12 @@ function drawBoardCards($, e, board, width) {
   const out = []
   let index = null
   let kids = null
+  let lanes = null
+  // Whether the card being filled holds a lane at the cursor: its border is then the current colour.
+  let current = false
   const flush = () => {
     if (index === null) return
+    kids.push(...drawBatches($, e, index, lanes))
     out.push(
       h(
         Box,
@@ -1147,7 +1460,7 @@ function drawBoardCards($, e, board, width) {
           key: `wave-card-${index}`,
           flexDirection: 'column',
           borderStyle: 'single',
-          borderDimColor: true,
+          ...(current ? { borderColor: PALETTE.current } : { borderDimColor: true }),
           width,
           paddingLeft: 1,
           paddingRight: 1,
@@ -1158,6 +1471,8 @@ function drawBoardCards($, e, board, width) {
     )
     index = null
     kids = null
+    lanes = null
+    current = false
   }
   for (const row of board) {
     if (row.key.startsWith('wave:') && row.key.endsWith(':end')) continue
@@ -1165,12 +1480,14 @@ function drawBoardCards($, e, board, width) {
       flush()
       index = row.key.slice('wave:'.length)
       kids = [h(Box, { key: boardKey(row.key) }, h(Text, { bold: true }, waveTitleOf(row)))]
+      lanes = []
       continue
     }
     if (row.key.startsWith('lane:')) {
-      const lane = drawLane($, e, row)
-      if (kids) kids.push(lane)
-      else out.push(lane)
+      if (lanes) {
+        lanes.push(row)
+        if (isCurrentLane(row.parts)) current = true
+      } else out.push(drawLane($, e, row))
       continue
     }
     flush()
@@ -1197,7 +1514,7 @@ function drawWaves($, e) {
   if (!run.plan) {
     if (!rows.length) return [h(Text, { dimColor: true }, NO_LANES_LINE)]
     const dispatched = run.dispatched !== null || rows.some(r => r.batch)
-    return [...(dispatched ? [keyed('wave-board-unrelayed', UNRELAYED_LINE)] : []), ...rows.map(r => flatRow(keyed, r))]
+    return [...(dispatched ? [keyed('wave-board-unrelayed', UNRELAYED_LINE)] : []), ...rows.map(r => flatRow($, e, r))]
   }
   const width = boardColumns(e)
   let board
@@ -1205,49 +1522,50 @@ function drawWaves($, e) {
     board = drawPlanBoardRows(run.plan, { columns: width, state: boardOverlay(run.plan), notes: laneNotes() })
   } catch (err) {
     $.ui.log(`interlock meter: ${BOARD_FAILED_LINE}: ${messageOf(err)}`, { to: 'debug' })
-    return [keyed('wave-board-failed', BOARD_FAILED_LINE), ...rows.map(r => flatRow(keyed, r))]
+    return [keyed('wave-board-failed', BOARD_FAILED_LINE), ...rows.map(r => flatRow($, e, r))]
   }
   // Every board ends in its tail; the renderer's spoken line for a narrow body
   // is one row without one, and the lanes are then drawn flat beneath it.
   const drawn = board.length > 0 && board[board.length - 1].key === 'tail'
   const planned = new Set(drawn ? board.filter(row => row.key.startsWith('lane:')).map(row => row.key.slice('lane:'.length)) : [])
   const body = drawn ? drawBoardCards($, e, board, width) : board.map(row => line(boardKey(row.key), row.text))
-  return [...body, ...rows.filter(r => !planned.has(r.label)).map(r => flatRow(keyed, r))]
+  return [...body, ...rows.filter(r => !planned.has(r.label)).map(r => flatRow($, e, r))]
 }
 
 async function drawPane($, e) {
   const { Box, Text } = $.ui.resolve(e)
   const keyed = (key, text, props) => h(Box, { key }, h(Text, props || null, text))
-  const heading = text => h(Box, { marginTop: 1 }, h(Text, { bold: true }, text))
+  const heading = text => h(Box, { marginTop: 1 }, h(Text, HEADING_PROPS, text))
+  // Each section's body sits one indent in beneath its heading.
+  const body = (key, ...kids) => h(Box, { key, flexDirection: 'column', paddingLeft: INDENT }, ...kids)
+  // The launch-guard line, in the alarm colour only while its ruling refuses the next launch.
+  const guardLine = async () => {
+    const guard = await launchGuardText($)
+    return keyed('launch-guard', guard.text, guard.refused ? { color: PALETTE.alarm } : null)
+  }
   if (run.phase === 'idle' && !run.summary) {
     // The guard runs in every session, so its line stands here too (design D5).
-    return h(Box, { flexDirection: 'column' }, h(Text, { dimColor: true }, NO_RUN_LINE), keyed('launch-guard', await launchGuardText($)))
+    return h(Box, { flexDirection: 'column' }, h(Text, { dimColor: true }, NO_RUN_LINE), await guardLine())
   }
 
   const out = []
-  out.push(h(Text, { bold: true }, `${run.change || 'ship run'}${run.runId ? ` · run ${run.runId}` : ''}`))
+  out.push(h(Text, HEADING_PROPS, `${run.change || 'ship run'}${run.runId ? ` · run ${run.runId}` : ''}`))
   out.push(keyed('action', `action: ${run.action || 'starting'}${run.phase === 'closed' ? ' (closed)' : ''}`))
-  out.push(keyed('last-activity', await lastActivityText($)))
+  const activity = await lastActivityText($)
+  out.push(
+    h(
+      Box,
+      { key: 'last-activity' },
+      h(Text, null, activity.line, ...(activity.word ? [' · ', h(Text, { color: PALETTE.warn }, activity.word)] : []))
+    )
+  )
   out.push(h(Text, { dimColor: true }, RECORD_LINE))
 
   out.push(heading('waves'))
-  out.push(...drawWaves($, e))
-
-  out.push(heading('agents'))
-  if (!run.agents.size) out.push(h(Text, { dimColor: true }, 'no agent has reported a request yet'))
-  for (const a of run.agents.values()) {
-    const lane = laneForAgent(a)
-    const n = a.requests === 1 ? '1 request' : `${a.requests} requests`
-    const done = a.reason ? `${a.reason}${a.durationMs !== null ? ` ${(a.durationMs / 1000).toFixed(1)}s` : ''}` : 'running'
-    out.push(
-      h(
-        Box,
-        { key: `agent-${a.id}`, flexDirection: 'column' },
-        h(Box, null, h(Text, null, `${lane || 'lane unknown'} · ${a.id} · ${a.models.join(', ') || 'model not reported'} · ${done}`)),
-        h(Box, null, h(Text, { dimColor: true }, `${n} · ${tokensText(a)}`))
-      )
-    )
-  }
+  out.push(body('waves-body', ...drawWaves($, e)))
+
+  out.push(heading('timeline'))
+  out.push(body('timeline-body', ...drawTimeline($, e)))
 
   // One plain read feeds the session lines and the plan windows; a breakdown
   // is never asked for, because only the plain call is free (design D4).
@@ -1261,36 +1579,35 @@ async function drawPane($, e) {
   }
   const [contextLine, costLine] = sessionLines(usage, failure)
   out.push(heading('session'))
-  out.push(keyed('session-context', contextLine))
-  out.push(keyed('session-cost', costLine))
+  out.push(body('session-body', keyed('session-context', contextLine), keyed('session-cost', costLine)))
 
   out.push(heading('plan windows'))
   const windows = usage && Array.isArray(usage.rateLimits) ? usage.rateLimits : []
-  if (failure !== null) out.push(h(Text, { dimColor: true }, `plan windows unavailable: ${failure}`))
-  else if (!windows.length) out.push(h(Text, { dimColor: true }, 'none reported (off a subscription the session has none)'))
+  const planLines = []
+  if (failure !== null) planLines.push(h(Text, { dimColor: true }, `plan windows unavailable: ${failure}`))
+  else if (!windows.length) planLines.push(h(Text, { dimColor: true }, 'none reported (off a subscription the session has none)'))
   for (const w of windows) {
     if (!w || typeof w !== 'object') continue
     const kind = String(w.kind)
-    out.push(keyed(`plan-window-${kind}`, `${kind} ${w.percentUsed}% used${w.resetsAt ? ` · resets ${w.resetsAt}` : ''}`))
+    planLines.push(keyed(`plan-window-${kind}`, `${kind} ${w.percentUsed}% used${w.resetsAt ? ` · resets ${w.resetsAt}` : ''}`))
   }
+  out.push(body('plan-windows-body', ...planLines))
 
   out.push(heading('banners'))
   out.push(
-    h(
-      Box,
-      { key: 'banners', flexDirection: 'column' },
-      ...(run.banners.length ? run.banners.map(b => h(Text, null, b)) : [h(Text, { dimColor: true }, 'none so far')])
+    body(
+      'banners',
+      ...(run.banners.length ? run.banners.map(b => h(Text, { color: PALETTE.warn }, b)) : [h(Text, { dimColor: true }, 'none so far')])
     )
   )
 
   out.push(heading('refusals'))
   const denials = guardDenialLine(run.guardDenials)
-  if (denials) out.push(keyed('guard-denials', denials))
-  out.push(keyed('launch-guard', await launchGuardText($)))
+  out.push(body('refusals-body', ...(denials ? [keyed('guard-denials', denials, { color: PALETTE.alarm })] : []), await guardLine()))
 
   if (run.summary) {
     out.push(heading('close summary'))
-    out.push(h(Box, { key: 'summary', flexDirection: 'column' }, h(Text, null, run.summary)))
+    out.push(body('summary', h(Text, null, run.summary)))
   }
   return h(Box, { flexDirection: 'column' }, ...out)
 }
@@ -1305,7 +1622,7 @@ export function register(on) {
     try {
       await $.command.register({
         name: PANE,
-        description: 'Open the Interlock ship meter: the live run, its waves, agents, plan windows and banners',
+        description: 'Open the Interlock ship meter: the live run, its waves, step timeline, plan windows and banners',
         immediate: true
       })
     } catch (err) {
@@ -1422,6 +1739,7 @@ export function register(on) {
     run.workflowName = str(r.result.workflowName)
     run.transcriptDir = str(r.result.transcriptDir)
     run.lastActivityAt = now
+    run.launchedAt = now
     $.ui.invalidate('ui.render')
     const placed = await openPane($)
     if (!placed || placed.isPlaced !== true) $.ui.toast(UNPLACED_TOAST)
@@ -1444,6 +1762,12 @@ export function register(on) {
       return r
     }
     const held = run
+    // A run agent's command names it: a
+    // briefing it reads joins it to its lane, and a driver line names a relay.
+    if (run.phase === 'live' && str(e.agentId)) {
+      noteBriefing($, e.agentId, command)
+      if (driver) noteRelay($, e.agentId, command)
+    }
     const r = await next(e)
     // Any Bash call during the run is read for a guard's refusal (guard-commit); only a driver line for a step.
     if (held === run) speakRefusal($, r)
@@ -1451,7 +1775,7 @@ export function register(on) {
       try {
         const { record, problem } = readRecord(r.text)
         if (!record) $.ui.log(`interlock meter: ${command.slice(0, 80)}: not a step record (${problem})`, { to: 'debug' })
-        else if (held === run) await applyRecord($, record)
+        else if (held === run) await applyRecord($, record, str(e.agentId))
         else if (run.phase === 'idle' && !run.idleStepNamed) nameIdleStep($)
       } catch (err) {
         $.ui.log(`interlock meter: step read failed: ${(err && err.message) || err}`, { to: 'debug' })
@@ -1470,6 +1794,14 @@ export function register(on) {
     return r
   })
 
+  // A run agent's Read, observed for the briefing it names and passed on as it
+  // came: the Workflow host raises no spawn event, so a briefing read is how an
+  // agent is joined to its lane.
+  on('tool.call', { tool: 'Read' }, async ($, e, next) => {
+    if (session.interactive && run.phase === 'live' && e.agentId) noteBriefing($, e.agentId, e.file_path)
+    return next(e)
+  })
+
   // The tools the manifest's `Edit|Write` matcher names for guard-tests and guard-tasks (design D4).
   on('tool.call', { tool: 'Edit' }, editCall)
   on('tool.call', { tool: 'Write' }, editCall)
@@ -1477,7 +1809,9 @@ export function register(on) {
   on('turn.step', async function* ($, e, next) {
     if (!session.interactive || run.phase !== 'live' || !e.agentId) return yield* next(e)
     // A run agent's request starting, and its answer arriving, are each activity (design D1).
+    const held = run
     if (await stamp($)) redrawWord($)
+    if (held === run) firstRequest(agentOf(e.agentId))
     const result = yield* next(e)
     if (await stamp($)) redrawWord($)
     try {
@@ -1499,14 +1833,15 @@ export function register(on) {
       // (speak-lane-turn-ends-and-session-cost design D1-D3).
       if (a.reason && a.reason !== 'answer' && !a.endToasted) {
         a.endToasted = true
-        const row = rowForAgent(a)
         try {
-          $.ui.toast(`${row ? row.title : 'lane unknown'} · agent ${a.id} · turn ended: ${a.reason}`)
+          $.ui.toast(`${agentName(a) || UNMATCHED} · agent ${a.id} · turn ended: ${a.reason}`)
         } catch (err) {
           $.ui.log(`interlock meter: the turn-end toast for ${a.id} was refused: ${messageOf(err)}`, { to: 'debug' })
         }
       }
+      const held = run
       if (await stamp($)) redrawWord($)
+      if (held === run) a.endAt = run.stampedAt
       $.ui.invalidate('ui.render')
     }
     return next(e)

package/lib/draw-plan.mjs

@@ -16,7 +16,7 @@
 // `lib/limits.mjs` only (`test/spine/draw-plan.test.mjs` walks it). The widths
 // are `interlock limits`'s.
 
-import { TITLE_SEPARATOR, fitRow, laneEffort, laneLabel, laneModel, laneTier, laneTitle } from './lane.mjs'
+import { TITLE_SEPARATOR, fitRow, laneEffort, laneGist, laneLabel, laneModel, laneTier, laneTitle } from './lane.mjs'
 import { LIMITS } from './limits.mjs'
 
 /** The words a lane's state cell may read, each the state's own record. */
@@ -281,7 +281,6 @@ function lanesOf(positions, plan) {
       for (const lane of batch) {
         const label = laneLabel(lane)
         const title = laneTitle(lane)
-        const prefix = `${label}${TITLE_SEPARATOR}`
         const tier = laneTier(lane)
         out.push({
           lane,
@@ -289,7 +288,7 @@ function lanesOf(positions, plan) {
           batch: b,
           label,
           title,
-          gist: title.startsWith(prefix) ? title.slice(prefix.length) : '',
+          gist: laneGist(lane),
           model: laneModel(lane),
           tier: tier > 0 ? String(tier) : '?',
           effort: laneEffort(lane) ?? 'inherit',

package/lib/lane.mjs

@@ -53,8 +53,35 @@ export function titleGist(description) {
 }
 
 /**
- * The name a lane is SHOWN under — its label, then the first words of its first
- * task's description: `1.1+5 · Add the relaunch guard to…`.
+ * What a lane is called in words: `task 1.1` for a one-task lane, `tasks 1.1+2`
+ * for a lane of several. The role word names what the agent is doing for a
+ * reader of /workflows and the meter, where a bare `1.5` reads as an outline
+ * sub-number. Display only: the join key stays `laneLabel`.
+ */
+export function laneName(lane) {
+  return `${lane.length === 1 ? 'task' : 'tasks'} ${laneLabel(lane)}`
+}
+
+/**
+ * The words a lane's title adds after its name: the first words of its first
+ * task's description, cut so that label + separator + gist fits TITLE_MAX
+ * (ellipsis included); '' when the description says nothing. The role word does
+ * not count against the cap, so a gist is cut exactly where it always was.
+ */
+export function laneGist(lane) {
+  const gist = titleGist(lane[0] && lane[0].description)
+  if (!gist) return ''
+  const head = `${laneLabel(lane)}${TITLE_SEPARATOR}`
+  const full = `${head}${gist}`
+  const cut = full.length <= TITLE_MAX ? full : `${full.slice(0, TITLE_MAX - 1).trimEnd()}…`
+  return cut.slice(head.length)
+}
+
+/**
+ * The name a lane is SHOWN under — its role word and label, then the first words
+ * of its first task's description: `tasks 1.1+5 · Add the relaunch guard to…`.
+ * The role word names what the agent is doing for a reader of /workflows and the
+ * meter; the cap is on the label and gist, so a gist is cut where it always was.
  *
  * Display only. Everything that joins on a lane — its briefing file, worktree,
  * trajectory line, record-batch fold — keys on `laneLabel`, because a key built
@@ -62,11 +89,8 @@ export function titleGist(description) {
  * function of the lane, so a replay displays, and cache-hits, the same agent.
  */
 export function laneTitle(lane) {
-  const label = laneLabel(lane)
-  const gist = titleGist(lane[0] && lane[0].description)
-  if (!gist) return label
-  const full = `${label}${TITLE_SEPARATOR}${gist}`
-  return full.length <= TITLE_MAX ? full : `${full.slice(0, TITLE_MAX - 1).trimEnd()}…`
+  const gist = laneGist(lane)
+  return gist ? `${laneName(lane)}${TITLE_SEPARATOR}${gist}` : laneName(lane)
 }
 
 /**

package/lib/meter-palette.mjs

@@ -0,0 +1,51 @@
+// The ship meter's colours, as the theme keys the pane draws with.
+//
+// Each value is a key of the person's own theme, never a fixed hue: `Text` and
+// `Box` colour props resolve a theme key, so the pane follows the light, dark
+// or colour-blind theme the person chose (probed on Claude Code 2.1.295: the
+// keys below resolve, nested spans inside one `Text` keep their own, a
+// bordered `Box` takes one for its border, and an unknown key draws uncoloured
+// with no error). A colour names what a word means: a state the renderer
+// printed, a name, a heading, a word the host or the CLI sent. It is never a
+// threshold or a verdict of the meter's own, so a figure the engine reports
+// (the context, the cost, a plan window) carries none.
+//
+// Pure and Node-free: the hooks module runs in the engine with no Node, and
+// imports this file.
+
+export const PALETTE = Object.freeze({
+  // A state word the board printed: the recorded ok, the recorded failure, the cursor.
+  ok: 'success',
+  failed: 'error',
+  current: 'warning',
+  // A lane label and an agent's name.
+  identity: 'suggestion',
+  // The run header and the section headings.
+  accent: 'claude',
+  // A word the CLI or the host raised to be read: a banner, the quiet word, a running turn.
+  warn: 'warning',
+  // A refusal, and a turn the host ended without an answer.
+  alarm: 'error'
+})
+
+const DIM_WORDS = new Set(['pending', 'not reached', 'not recorded', 'per task'])
+
+/** The props a state word the board printed is drawn with: a hue for ok, failed and current, dim for the rest, else none. */
+export function stateProps(word) {
+  if (word === 'ok') return { color: PALETTE.ok }
+  if (word === 'failed') return { color: PALETTE.failed }
+  if (word === 'current') return { color: PALETTE.current }
+  if (DIM_WORDS.has(word)) return { dimColor: true }
+  return null
+}
+
+/**
+ * The props an agent's turn word is drawn with. No reason is a turn still
+ * running; `answer` is the host's ordinary end; any other word the host sends
+ * is a turn it ended without one. The caller shows the word itself verbatim.
+ */
+export function turnProps(reason) {
+  if (reason === null || reason === undefined) return { color: PALETTE.warn }
+  if (reason === 'answer') return { color: PALETTE.ok }
+  return { color: PALETTE.alarm }
+}

package/lib/meter-time.mjs

@@ -0,0 +1,43 @@
+// The ship meter's time words: the clock reading a line was stamped with, and
+// how long a turn took, as a person reads them.
+//
+// Each reading is the engine's own (`$.clock.now()` in the hooks module), so a
+// time is either a real reading or absent: absent draws as nothing, never as a
+// guessed time. The wall-clock words are the local time of the machine the
+// engine runs on, from `Date`'s own local fields. The duration bands are unit
+// conversions (seconds, minutes, hours), not thresholds: no band is a verdict
+// on the figure it formats.
+//
+// Pure and Node-free: the hooks module runs in the engine with no Node, and
+// imports this file.
+
+const isTime = ms => typeof ms === 'number' && Number.isFinite(ms)
+const pad = n => String(n).padStart(2, '0')
+
+/** The local wall-clock time of a reading, `HH:MM:SS`; `''` for no reading. */
+export function clockText(ms) {
+  if (!isTime(ms)) return ''
+  const d = new Date(ms)
+  return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`
+}
+
+/** The local date and time of a reading, `YYYY-MM-DD HH:MM:SS`; `''` for no reading. */
+export function stampText(ms) {
+  if (!isTime(ms)) return ''
+  const d = new Date(ms)
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${clockText(ms)}`
+}
+
+/**
+ * A duration in milliseconds as a person reads it: under a minute, seconds to
+ * one decimal, cut down (`41.2s`, `0.8s`, never `60.0s`); under an hour, whole
+ * minutes and seconds (`2m 14s`); else hours and minutes (`1h 03m`). `''` for
+ * no figure, a negative one or one that is not a finite number.
+ */
+export function durationText(ms) {
+  if (!isTime(ms) || ms < 0) return ''
+  if (ms < 60_000) return `${(Math.floor(ms / 100) / 10).toFixed(1)}s`
+  const seconds = Math.floor(ms / 1000)
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${pad(seconds % 60)}s`
+  return `${Math.floor(seconds / 3600)}h ${pad(Math.floor((seconds % 3600) / 60))}m`
+}

package/lib/meter-timeline.mjs

@@ -0,0 +1,161 @@
+// The ship meter's step timeline: what each step the CLI printed says, and the
+// order the pane lays the steps, the agents they spawned and the agents no
+// step names in.
+//
+// A step's words are its own fields, verbatim: the action, its position, how
+// many lanes a batch dispatched, a skipped verification's reason, a halt's
+// reason and the plan size a step relayed. No word here is a verdict, a cause
+// or a state the step did not carry.
+//
+// The order is pure data over plain inputs, so it is pinned under Node
+// (`test/spine/meter-timeline.test.mjs`) and the hooks module only draws it:
+//
+// - The top level is the launch, every step and every relay agent no step
+//   names, laid by time. An entry with a time sorts by it, ties keeping their
+//   input order (the launch, then the steps as they crossed, then the relays as
+//   first seen); an entry with no time follows every timed one, in input order.
+// - Beneath a step, at depth 1, the agents it spawned: a spawn is joined to an
+//   agent by its briefing hash, one agent per spawn in step order (an agent
+//   beyond the spawns that carry its hash stays with the last of them). The
+//   joined spawns are laid by their agent's first request time, by the same
+//   rule; the spawns no agent has joined yet follow, `waiting`, in the step's
+//   spawn order. A step's relay is drawn on the step's own line and nowhere
+//   else.
+// - Last, the agents nothing names, under one head, in first-seen order.
+//
+// Pure and Node-free: the hooks module runs in the engine with no Node, and
+// imports this file.
+
+/** The actions that dispatch a batch of lanes. */
+export const BATCH_ACTIONS = new Set(['run-batch', 'test-wave'])
+
+const isInt = v => Number.isInteger(v)
+const isTime = v => typeof v === 'number' && Number.isFinite(v)
+const str = v => (typeof v === 'string' && v ? v : null)
+const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`
+
+/** `batch <j>/<k>`, one-based, as the status line says it; `null` when the step carries no position. */
+export function batchText(batchIndex, batchCount) {
+  return isInt(batchIndex) && isInt(batchCount) ? `batch ${batchIndex + 1}/${batchCount}` : null
+}
+
+/** How many lanes run side by side: `N in parallel`, `1 lane`, or `null` for none. */
+export function laneCountText(n) {
+  if (!isInt(n) || n < 1) return null
+  return n === 1 ? '1 lane' : `${n} in parallel`
+}
+
+/** The waves a plan summary holds, its test wave counted; `null` for anything that is not a summary. */
+export function planWaveCount(plan) {
+  if (plan === null || typeof plan !== 'object' || !Array.isArray(plan.waves)) return null
+  return plan.waves.length + (plan.testWave ? 1 : 0)
+}
+
+/** A step's words, from its own fields only. */
+export function stepText(step) {
+  const s = step && typeof step === 'object' ? step : {}
+  const parts = [String(s.action)]
+  if (s.wave !== undefined && s.wave !== null) parts.push(`wave ${s.wave}`)
+  const batch = batchText(s.batchIndex, s.batchCount)
+  if (batch) parts.push(batch)
+  if (BATCH_ACTIONS.has(s.action)) {
+    const lanes = laneCountText(Array.isArray(s.spawns) ? s.spawns.length : 0)
+    if (lanes) parts.push(lanes)
+  }
+  if (s.action === 'verify' && s.skipped === true) parts.push(str(s.reason) ? `skipped: ${s.reason}` : 'skipped')
+  if (s.action === 'halt' && str(s.reason)) parts.push(s.reason)
+  if (isInt(s.planWaves)) parts.push(`plan: ${plural(s.planWaves, 'wave')}`)
+  return parts.join(' · ')
+}
+
+/** The entries with a time laid by it, ties in input order; then the entries with none, in input order. */
+function byTime(entries) {
+  const timed = entries.map((entry, i) => ({ entry, i })).filter(({ entry }) => isTime(entry.at))
+  timed.sort((a, b) => a.entry.at - b.entry.at || a.i - b.i)
+  return [...timed.map(({ entry }) => entry), ...entries.filter(entry => !isTime(entry.at))]
+}
+
+/**
+ * The timeline as ordered display entries, each `{ key, kind, at, depth, ... }`:
+ * `launch` (`name`), `step` (`step`), `spawn` (`step`, `spawn`, `agent` or
+ * `null` while it waits), `relay` (`agent`, a relay agent no step names),
+ * `unmatched-head`, and `unmatched` (`agent`). An agent's entry is keyed
+ * `agent-<id>`, a waiting spawn's `spawn-<n>-<label>`, a step's `step-<n>`.
+ *
+ * @param {{
+ *   steps?: {n: number, at: number|null, action: string, wave?: unknown, waveIndex?: unknown, batchIndex?: unknown,
+ *     batchCount?: unknown, skipped?: unknown, reason?: unknown, planWaves?: number|null, relayId?: string|null,
+ *     spawns: {label: string, title: string, sha: string|null}[]}[],
+ *   agents?: {id: string, sha?: string|null, relay?: string|null, firstAt?: number|null}[],
+ *   launch?: {at: number|null, name?: string|null}|null
+ * }} input
+ * @returns {object[]}
+ */
+export function timeline({ steps = [], agents = [], launch = null } = {}) {
+  const relays = new Set(steps.map(step => str(step.relayId)).filter(Boolean))
+
+  // Each spawn carrying a hash, in step order, and the agents carrying it, first seen first.
+  const slots = new Map()
+  const spawnsOf = step => (Array.isArray(step.spawns) ? step.spawns : [])
+  steps.forEach((step, i) =>
+    spawnsOf(step).forEach((spawn, j) => {
+      const sha = str(spawn.sha)
+      if (!sha) return
+      if (!slots.has(sha)) slots.set(sha, [])
+      slots.get(sha).push({ pos: `${i}:${j}`, agents: [] })
+    })
+  )
+  const placed = new Set()
+  const counts = new Map()
+  for (const agent of agents) {
+    const sha = str(agent.sha)
+    if (!sha || relays.has(agent.id) || !slots.has(sha)) continue
+    const held = slots.get(sha)
+    const at = counts.get(sha) || 0
+    held[Math.min(at, held.length - 1)].agents.push(agent)
+    counts.set(sha, at + 1)
+    placed.add(agent.id)
+  }
+  const joinedBy = new Map()
+  for (const held of slots.values()) for (const slot of held) joinedBy.set(slot.pos, slot.agents)
+
+  const top = []
+  if (launch && typeof launch === 'object') {
+    top.push({ key: 'launch', kind: 'launch', at: isTime(launch.at) ? launch.at : null, depth: 0, name: str(launch.name) })
+  }
+  for (const step of steps) top.push({ key: `step-${step.n}`, kind: 'step', at: isTime(step.at) ? step.at : null, depth: 0, step })
+  const orphans = agents.filter(agent => str(agent.relay) && !relays.has(agent.id) && !placed.has(agent.id))
+  for (const agent of orphans) {
+    top.push({ key: `agent-${agent.id}`, kind: 'relay', at: isTime(agent.firstAt) ? agent.firstAt : null, depth: 0, agent })
+    placed.add(agent.id)
+  }
+
+  const out = []
+  for (const entry of byTime(top)) {
+    out.push(entry)
+    if (entry.kind !== 'step') continue
+    const i = steps.indexOf(entry.step)
+    const joined = []
+    const waiting = []
+    for (const [j, spawn] of spawnsOf(entry.step).entries()) {
+      const held = joinedBy.get(`${i}:${j}`) || []
+      if (!held.length) {
+        waiting.push({ key: `spawn-${entry.step.n}-${spawn.label}`, kind: 'spawn', at: null, depth: 1, step: entry.step, spawn, agent: null })
+      }
+      for (const agent of held) {
+        const at = isTime(agent.firstAt) ? agent.firstAt : null
+        joined.push({ key: `agent-${agent.id}`, kind: 'spawn', at, depth: 1, step: entry.step, spawn, agent })
+      }
+    }
+    out.push(...byTime(joined), ...waiting)
+  }
+
+  const unmatched = agents.filter(agent => !relays.has(agent.id) && !placed.has(agent.id))
+  if (unmatched.length) {
+    out.push({ key: 'agents-unmatched-head', kind: 'unmatched-head', at: null, depth: 0 })
+    for (const agent of unmatched) {
+      out.push({ key: `agent-${agent.id}`, kind: 'unmatched', at: isTime(agent.firstAt) ? agent.firstAt : null, depth: 1, agent })
+    }
+  }
+  return out
+}

package/lib/waves.mjs

@@ -484,7 +484,7 @@ function capForTier(caps, tier) {
 // The lane rule — tier, label, title, model, effort — lives in `lib/lane.mjs`,
 // a module the engine can load (draw-wave-plan-and-handoff-graph-from-the-cli
 // design D3). Re-exported so every importer of it from here is unchanged.
-export { laneEffort, laneLabel, laneModel, laneTier, laneTitle, TITLE_SEPARATOR } from './lane.mjs'
+export { laneEffort, laneGist, laneLabel, laneModel, laneName, laneTier, laneTitle, TITLE_SEPARATOR } from './lane.mjs'
 
 /**
  * Group a group's tasks into lanes: connected components over canonical-path

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renzrollon/interlock",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "Autonomous spec-driven development orchestration for Claude Code, layered on OpenSpec",
   "type": "module",
   "engines": {