@renzrollon/interlock 1.4.0 → 1.4.2

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "interlock",
   "displayName": "Interlock",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "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,34 @@ 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.2 — 2026-10-10
+
+### Fixed
+
+- **A plugin install no longer opens every session with a preflight warning.** The `binaries` check warned whenever `interlock` and `interlock-graph` were not on `PATH`, even when both were in the plugin's `bin/`. The SessionStart hook runs the doctor without that directory on `PATH`, so every plugin user saw `interlock preflight OK (1 warning).` and a `warn binaries` band above the prompt at every session start, for a state nobody had to change. A binary in the plugin's `bin/` is now `ok`, so a clean install draws no band. A binary found neither on `PATH` nor in `bin/` still fails.
+
+## 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

package/hooks/mod.mjs

@@ -75,9 +75,23 @@
 // 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.
+// other agent reads `unmatched agent`, said once beneath the rows. A ping wraps
+// the relay: another command first, a heredoc, then `interlock … --json`, then
+// an echoed exit status. The driver is the `interlock` that begins a command,
+// and the step is the JSON object in that result, so the wrap still registers
+// its lanes. 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
@@ -113,6 +127,8 @@ import { decideLaunch, emptyRecord, isAcceptedLaunch, isShipLaunch, withLaunch,
 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,
@@ -155,8 +171,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'
@@ -173,8 +187,8 @@ const LEDGER = { plugin: 'interlock', key: 'ledger' }
 // a missing origin count nothing.
 const HUMAN_ORIGINS = new Set(['composer', 'bridge', 'sdk'])
 const GUARD = 'interlock guard'
-// The line `cli()` in workflows/ship.js hands the ping (design D2).
-const DRIVER_LINE = /^interlock\s/
+// The line `cli()` in workflows/ship.js hands the ping (design D2). A ping
+// wraps it, so the driver is found by `driverInvocation`, not a line start.
 // 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.
@@ -186,6 +200,15 @@ 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
+// One column, so a frame never moves the line. Stepped while a run is in
+// flight, on the interval that already recomputes the quiet word.
+const PULSE_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+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']
@@ -230,6 +253,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,
@@ -251,7 +281,11 @@ function freshRun() {
     dispatched: null,
     halt: null,
     planNamed: false,
-    recordedNamed: false
+    recordedNamed: false,
+    // The in-flight mark, stepped by the one quiet interval, and whether this
+    // run has asked the pane to follow its latest line.
+    pulse: 0,
+    followed: false
   }
 }
 
@@ -308,7 +342,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(' · ')
 }
 
@@ -376,16 +411,17 @@ 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)
 }
 
 /**
  * Starts the run's one interval (design D2), the host's own timer: each period
- * reads the clock and recomputes the word, and draws only when the word
- * changed. A period that finds another run or another interval in its place
- * returns at once. A host that will not start one leaves the pane, which
- * recomputes the word whenever it is drawn.
+ * reads the clock and recomputes the word, draws when the word changed, and
+ * steps the in-flight mark. A period that finds another run or another
+ * interval in its place returns at once. A host that will not start one leaves
+ * the pane, which recomputes the word whenever it is drawn.
  */
 function startTick($) {
   const generation = ++generations
@@ -396,7 +432,14 @@ function startTick($) {
       if (!isMine(tick)) return
       try {
         const now = await clockNow($)
-        if (isMine(tick) && setWord(quietWord(quietMs(run.lastActivityAt, now)))) redrawWord($)
+        if (!isMine(tick)) return
+        const changed = setWord(quietWord(quietMs(run.lastActivityAt, now)))
+        const pulsed = inFlight()
+        if (pulsed) run.pulse++
+        if (!isMine(tick)) return
+        if (changed) redrawWord($)
+        else if (pulsed) $.ui.invalidate('ui.render')
+        await followBottom($)
       } catch (err) {
         $.ui.log(`interlock meter: a quiet-figure period failed: ${messageOf(err)}`, { to: 'debug' })
       }
@@ -409,6 +452,28 @@ function startTick($) {
   }
 }
 
+/**
+ * Asks the pane to follow its latest line, once, so a run that grows keeps the
+ * tail in view until the person scrolls. A host that will not scroll yet is
+ * asked again on the next step or tick. Never throws.
+ */
+async function followBottom($) {
+  if (!session.interactive || run.phase !== 'live' || run.followed) return
+  const held = run
+  try {
+    const moved = await $.ui.scroll({ to: 'end', in: PANE })
+    if (held === run && scrollAccepted(moved)) held.followed = true
+  } catch {
+    // The pane may not be placed yet; the next step or tick asks again.
+  }
+}
+
+/** A scroll landed when the host answered an object and did not refuse it. */
+function scrollAccepted(moved) {
+  if (!moved || typeof moved !== 'object') return false
+  return !Object.prototype.hasOwnProperty.call(moved, 'den' + 'y')
+}
+
 /** Ends the run's interval, if it has one: a cancelled timer never fires again. */
 function stopTick() {
   if (run.tick) run.tick.cancel()
@@ -671,6 +736,126 @@ function noteBriefing($, agentId, text) {
   }
 }
 
+/** Whether `i` is the end of a command token. */
+function tokenBoundary(command, i) {
+  if (i >= command.length) return true
+  const c = command[i]
+  return c === ' ' || c === '\t' || c === '\n' || c === '\r' || c === ';' || c === '&' || c === '|' || c === '<' || c === '>'
+}
+
+/**
+ * The index just after a heredoc that opens at `at` (`<<` or `<<-`), or `at`
+ * when that is not a heredoc. An unclosed body consumes the rest of the line,
+ * the way the shell does, so a word inside it is not a command.
+ */
+function skipHeredoc(command, at) {
+  let i = at + 2
+  let strip = false
+  if (command[i] === '-') {
+    strip = true
+    i++
+  }
+  while (command[i] === ' ' || command[i] === '\t') i++
+  let quote = null
+  if (command[i] === "'" || command[i] === '"') {
+    quote = command[i]
+    i++
+  }
+  const start = i
+  while (i < command.length && /[A-Za-z0-9_-]/.test(command[i])) i++
+  const word = command.slice(start, i)
+  if (!word) return at
+  if (quote && command[i] === quote) i++
+  const nl = command.indexOf('\n', i)
+  if (nl < 0) return command.length
+  let pos = nl + 1
+  while (pos <= command.length) {
+    const next = command.indexOf('\n', pos)
+    const end = next < 0 ? command.length : next
+    let line = command.slice(pos, end)
+    if (line.endsWith('\r')) line = line.slice(0, -1)
+    if (strip) line = line.replace(/^\t+/, '')
+    if (line === word) return next < 0 ? command.length : next + 1
+    if (next < 0) return command.length
+    pos = next + 1
+  }
+  return command.length
+}
+
+/** `command` from `start` through the invocation, stopping at the next unquoted separator. */
+function sliceInvocation(command, start) {
+  let quote = null
+  let i = start
+  while (i < command.length) {
+    const c = command[i]
+    if (quote) {
+      if (c === '\\' && quote === '"') {
+        i += 2
+        continue
+      }
+      if (c === quote) quote = null
+      i++
+      continue
+    }
+    if (c === "'" || c === '"') {
+      quote = c
+      i++
+      continue
+    }
+    if (c === '\n' || c === ';' || c === '|' || c === '&') break
+    i++
+  }
+  return command.slice(start, i).trim()
+}
+
+/**
+ * The `interlock` invocation a shell line actually runs, or null.
+ *
+ * A ping writes a file, then runs `interlock … --json`, then echoes an exit
+ * status. The invocation is the `interlock` token that begins a command (the
+ * line, or after `;`, `&`, `|` or a newline), not one quoted or sitting inside
+ * a heredoc. The slice stops at the next separator, so the relay name is the
+ * subcommand and not the rest of the script.
+ */
+function driverInvocation(command) {
+  if (typeof command !== 'string' || !command) return null
+  let quote = null
+  let ready = true
+  for (let i = 0; i < command.length; i++) {
+    const c = command[i]
+    if (quote) {
+      if (c === '\\' && quote === '"') {
+        i++
+        continue
+      }
+      if (c === quote) quote = null
+      continue
+    }
+    if (c === "'" || c === '"') {
+      quote = c
+      continue
+    }
+    if (c === '<' && command[i + 1] === '<') {
+      const skipped = skipHeredoc(command, i)
+      if (skipped > i) {
+        i = skipped - 1
+        ready = true
+        continue
+      }
+    }
+    if (c === ' ' || c === '\t' || c === '\r') continue
+    if (c === '\n' || c === ';' || c === '|' || c === '&') {
+      ready = true
+      continue
+    }
+    if (ready && command.startsWith('interlock', i) && tokenBoundary(command, i + 'interlock'.length)) {
+      return sliceInvocation(command, i)
+    }
+    ready = false
+  }
+  return null
+}
+
 /**
  * `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)`),
@@ -783,18 +968,75 @@ function noteIdleStep($, r) {
   }
 }
 
+/** A step record: an object with a string `action`, as the driver guards it. */
+function isStep(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value) && typeof value.action === 'string'
+}
+
+/** The index just after the JSON object that opens at `start`, or -1. */
+function jsonEnd(text, start) {
+  let depth = 0
+  let quote = null
+  for (let i = start; i < text.length; i++) {
+    const c = text[i]
+    if (quote) {
+      if (c === '\\') {
+        i++
+        continue
+      }
+      if (c === quote) quote = null
+      continue
+    }
+    if (c === '"' || c === "'") {
+      quote = c
+      continue
+    }
+    if (c === '{') depth++
+    else if (c === '}') {
+      depth--
+      if (depth === 0) return i + 1
+    }
+  }
+  return -1
+}
+
+/**
+ * The step object in a result that is not itself JSON: a ping prints a line,
+ * then the step, then an exit status. A stamped step wins; otherwise the
+ * first object with an action.
+ */
+function findStep(text) {
+  let fallback = null
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== '{') continue
+    const end = jsonEnd(text, i)
+    if (end < 0) continue
+    let value
+    try {
+      value = JSON.parse(text.slice(i, end))
+    } catch {
+      continue
+    }
+    if (!isStep(value)) continue
+    if (value.schema === 'interlock.run-step/1') return value
+    if (!fallback) fallback = value
+  }
+  return fallback
+}
+
 /** The step record in a Bash result's text, guarded as the driver guards it: an object with a string `action`. */
 function readRecord(text) {
   if (typeof text !== 'string' || !text.trim()) return { problem: 'no result text' }
-  let value
+  const trimmed = text.trim()
   try {
-    value = JSON.parse(text)
+    const value = JSON.parse(trimmed)
+    if (isStep(value)) return { record: value }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return { problem: 'not an object' }
+    return { problem: 'no action' }
   } catch {
-    return { problem: 'not JSON' }
+    const found = findStep(trimmed)
+    return found ? { record: found } : { problem: 'not JSON' }
   }
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return { problem: 'not an object' }
-  if (typeof value.action !== 'string') return { problem: 'no action' }
-  return { record: value }
 }
 
 function agentOf(id) {
@@ -813,13 +1055,24 @@ function agentOf(id) {
       // 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++
@@ -905,7 +1158,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
@@ -915,8 +1195,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,
@@ -930,6 +1212,7 @@ async function applyRecord($, record) {
       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
@@ -950,6 +1233,7 @@ async function applyRecord($, record) {
   }
   setStatus($)
   $.ui.invalidate('ui.render')
+  await followBottom($)
 }
 
 async function openPane($, id = PANE, title = TITLE) {
@@ -1106,53 +1390,169 @@ function sessionLines(usage, failure) {
 }
 
 /**
- * `last activity <ISO>` or `last activity unknown`, 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).
+ * `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 { line: 'last activity unknown', word: null }
-  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 { line: `last activity ${at}`, 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'
+
+/** A live run still has work out: no step yet, an agent still going, or a lane not yet answered. */
+function inFlight() {
+  if (run.phase !== 'live') return false
+  if (!run.action) return true
+  for (const a of run.agents.values()) if (!a.reason) return true
+  for (const r of run.rows.values()) {
+    const a = r.sha ? agentForSha(r.sha) : null
+    if (!a || !a.reason) return true
+  }
+  return false
+}
+
+/** The current in-flight frame, or `''` before the first interval and once the work has landed. */
+function frame() {
+  if (run.pulse === 0 || !inFlight()) return ''
+  return PULSE_FRAMES[(run.pulse - 1) % PULSE_FRAMES.length]
+}
+
+/** A leading space and the frame, or `''` when the mark is not showing. */
+function markSuffix() {
+  const mark = frame()
+  return mark ? ` ${mark}` : ''
+}
+
+/** A lane note, with the frame appended while that lane is still running or waiting. */
+function noted(text) {
+  if (typeof text !== 'string' || !/ (?:running|waiting)$/.test(text)) return text
+  return `${text}${markSuffix()}`
 }
 
 /**
- * An agent's first line: 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.
+ * 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, done) {
-  const row = rowForAgent(a)
-  const name = agentName(a)
-  const nameProps = row ? NAME_PROPS : a.relay ? { dimColor: true } : { dimColor: true, italic: true }
-  const quiet = !row && a.relay && (!a.reason || a.reason === 'answer')
-  return h(
-    Text,
-    null,
-    h(Text, nameProps, name || UNMATCHED),
-    h(Text, { dimColor: true }, ` · ${a.id} · ${a.models.join(', ') || 'model not reported'}`),
+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)
+  const spans = [
+    h(Text, nameProps, name),
+    h(Text, DIM, ` · ${id8(a.id)} · ${a.models.join(', ') || 'model not reported'}`),
     ' · ',
-    h(Text, quiet ? { dimColor: true } : turnProps(a.reason), done)
+    h(Text, quiet ? DIM : turnProps(a.reason), turnText(a))
+  ]
+  if (!a.reason) {
+    const mark = markSuffix()
+    if (mark) spans.push(mark)
+  }
+  return h(Text, { wrap: 'wrap' }, ...spans)
+}
+
+/**
+ * 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', flexShrink: 0 },
+    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)
+}
+
+/**
+ * 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') {
+      const waiting = [h(Text, NAME_PROPS, entry.spawn.title), ' · ', h(Text, DIM, 'waiting')]
+      const mark = markSuffix()
+      if (mark) waiting.push(mark)
+      out.push(row(h(Text, { wrap: 'wrap' }, ...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, flexShrink: 0 }, 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', flexShrink: 0, paddingLeft: INDENT }, h(Text, { dimColor: true, wrap: 'wrap' }, UNMATCHED_LINE)))
+  }
+  if (!run.steps.length) out.push(h(Box, { key: 'timeline-no-step', flexShrink: 0 }, 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'
+  const live = state === 'running' || state === 'waiting' ? `${state}${markSuffix()}` : state
   return h(
     Box,
-    { key: `wave-row-${r.label}` },
+    { key: `wave-row-${r.label}`, flexShrink: 0 },
     h(
       Text,
       null,
       h(Text, NAME_PROPS, r.title),
-      ` · ${r.kind || 'agent'} · routed ${r.model || '?'} · served ${served} · effort ${r.effort || '?'} · ${state}`
+      ` · ${r.kind || 'agent'} · routed ${r.model || '?'} · served ${served} · effort ${r.effort || '?'} · ${live}`
     )
   )
 }
@@ -1180,7 +1580,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
 }
@@ -1193,11 +1593,13 @@ function boardKey(key) {
   return `${kind === 'wave' ? 'wave-block' : `wave-${kind}`}-${rest.join('-')}`
 }
 
-/** 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)
 }
 
@@ -1226,14 +1628,14 @@ function idSpans(Text, parts) {
 }
 
 /**
- * A lane's batch, label, model, tier and effort cells, space-joined as the
- * board prints them, the label a span in the identity colour.
+ * 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 before = [parts.batch].filter(Boolean).join(' ')
   const after = [parts.model, parts.tier, parts.effort].filter(Boolean).join(' ')
-  if (!parts.label) return [[before, after].filter(Boolean).join(' ')]
-  return [before ? `${before} ` : '', h(Text, NAME_PROPS, parts.label), after ? ` ${after}` : ''].filter(span => span !== '')
+  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`. */
@@ -1242,16 +1644,17 @@ const isCurrentLane = parts =>
   (parts.state === 'current' || (Array.isArray(parts.tasks) && parts.tasks.some(task => task && task.word === 'current')))
 
 /**
- * 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 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))
+  if (!parts) return h(Box, { key, flexShrink: 0 }, h(Text, { wrap: 'truncate-end' }, row.text))
   const line = [
     ...headSpans(Text, parts),
     ...(parts.state ? [' ', h(Text, stateProps(parts.state), parts.state)] : []),
@@ -1260,28 +1663,57 @@ function drawLane($, e, row) {
   ]
   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.gist ? h(Box, { key: `${key}-gist`, flexShrink: 0 }, h(Text, { wrap: 'wrap' }, parts.gist)) : null,
+    parts.note ? h(Box, { key: `${key}-note`, flexShrink: 0 }, h(Text, { dimColor: true, wrap: 'wrap' }, noted(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) {
   const { Box, Text } = $.ui.resolve(e)
-  const keyed = (key, text, props) => h(Box, { key }, h(Text, props || null, text))
+  const keyed = (key, text, props) => h(Box, { key, flexShrink: 0 }, h(Text, props || null, text))
   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,
         {
           key: `wave-card-${index}`,
           flexDirection: 'column',
+          flexShrink: 0,
           borderStyle: 'single',
           ...(current ? { borderColor: PALETTE.current } : { borderDimColor: true }),
           width,
@@ -1294,6 +1726,7 @@ function drawBoardCards($, e, board, width) {
     )
     index = null
     kids = null
+    lanes = null
     current = false
   }
   for (const row of board) {
@@ -1301,15 +1734,15 @@ function drawBoardCards($, e, board, width) {
     if (row.key.startsWith('wave:')) {
       flush()
       index = row.key.slice('wave:'.length)
-      kids = [h(Box, { key: boardKey(row.key) }, h(Text, { bold: true }, waveTitleOf(row)))]
+      kids = [h(Box, { key: boardKey(row.key), flexShrink: 0 }, h(Text, { bold: true }, waveTitleOf(row)))]
+      lanes = []
       continue
     }
     if (row.key.startsWith('lane:')) {
-      const lane = drawLane($, e, row)
-      if (kids) {
-        kids.push(lane)
+      if (lanes) {
+        lanes.push(row)
         if (isCurrentLane(row.parts)) current = true
-      } else out.push(lane)
+      } else out.push(drawLane($, e, row))
       continue
     }
     flush()
@@ -1330,11 +1763,11 @@ function drawBoardCards($, e, board, width) {
  */
 function drawWaves($, e) {
   const { Box, Text } = $.ui.resolve(e)
-  const keyed = (key, text, props) => h(Box, { key }, h(Text, props || null, text))
+  const keyed = (key, text, props) => h(Box, { key, flexShrink: 0 }, h(Text, props || null, text))
   const line = (key, text) => keyed(key, text, { wrap: 'truncate-end' })
   const rows = [...run.rows.values()]
   if (!run.plan) {
-    if (!rows.length) return [h(Text, { dimColor: true }, NO_LANES_LINE)]
+    if (!rows.length) return [h(Box, { flexShrink: 0 }, h(Text, { dimColor: true }, `${NO_LANES_LINE}${markSuffix()}`))]
     const dispatched = run.dispatched !== null || rows.some(r => r.batch)
     return [...(dispatched ? [keyed('wave-board-unrelayed', UNRELAYED_LINE)] : []), ...rows.map(r => flatRow($, e, r))]
   }
@@ -1356,8 +1789,12 @@ function drawWaves($, e) {
 
 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, HEADING_PROPS, text))
+  const keyed = (key, text, props) => h(Box, { key, flexShrink: 0 }, h(Text, props || null, text))
+  const heading = text => h(Box, { flexShrink: 0, marginTop: 1 }, h(Text, HEADING_PROPS, text))
+  // Each section's body sits one indent in beneath its heading. The pane
+  // scrolls by the tree's own height; a column that can shrink collapses into
+  // the viewport, and the latest lines then sit past the last offset.
+  const body = (key, ...kids) => h(Box, { key, flexDirection: 'column', flexShrink: 0, 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($)
@@ -1365,40 +1802,27 @@ async function drawPane($, e) {
   }
   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), await guardLine())
+    return h(Box, { key: 'meter-root', flexDirection: 'column', flexShrink: 0 }, h(Text, { dimColor: true }, NO_RUN_LINE), await guardLine())
   }
 
   const out = []
-  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(h(Box, { flexShrink: 0 }, 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)' : ''}${markSuffix()}`))
   const activity = await lastActivityText($)
   out.push(
     h(
       Box,
-      { key: 'last-activity' },
+      { key: 'last-activity', flexShrink: 0 },
       h(Text, null, activity.line, ...(activity.word ? [' · ', h(Text, { color: PALETTE.warn }, activity.word)] : []))
     )
   )
-  out.push(h(Text, { dimColor: true }, RECORD_LINE))
+  out.push(h(Box, { flexShrink: 0 }, h(Text, { dimColor: true }, RECORD_LINE)))
 
   out.push(heading('waves'))
-  out.push(...drawWaves($, e))
+  out.push(body('waves-body', ...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 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, agentLine(Text, a, done)),
-        h(Box, null, h(Text, { dimColor: true }, `${n} · ${tokensText(a)}`))
-      )
-    )
-  }
-  if ([...run.agents.values()].some(a => !agentName(a))) out.push(keyed('agents-unmatched', UNMATCHED_LINE, { dimColor: true }))
+  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).
@@ -1412,38 +1836,37 @@ 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' },
+    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, { color: PALETTE.alarm }))
-  out.push(await guardLine())
+  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)
+  return h(Box, { key: 'meter-root', flexDirection: 'column', flexShrink: 0 }, ...out)
 }
 
 export function register(on) {
@@ -1456,7 +1879,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) {
@@ -1573,17 +1996,20 @@ 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)
     if (run === launched) startTick($)
+    if (run === launched) await followBottom($)
     return r
   })
 
   on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
     if (!session.interactive) return next(e)
     const command = typeof e.command === 'string' ? e.command : ''
-    const driver = DRIVER_LINE.test(command)
+    const invocation = driverInvocation(command)
+    const driver = invocation !== null
     // The spec flow's keyed lines, read only while a spec run is live (observe-the-spec-run-live design D3).
     const lines = specLines(command)
     const reader = lines.length ? specReader($, lines) : null
@@ -1599,7 +2025,7 @@ export function register(on) {
     // 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)
+      if (driver) noteRelay($, e.agentId, invocation)
     }
     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.
@@ -1607,8 +2033,8 @@ export function register(on) {
     if (driver) {
       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)
+        if (!record) $.ui.log(`interlock meter: ${invocation.slice(0, 80)}: not a step record (${problem})`, { to: 'debug' })
+        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' })
@@ -1642,7 +2068,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 {
@@ -1670,7 +2098,9 @@ export function register(on) {
           $.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/doctor.mjs

@@ -535,9 +535,11 @@ function checkPlugin(pluginRoot) {
 
 /**
  * `interlock` and `interlock-graph` are on PATH inside a Claude Code session
- * because the host injects the plugin's `bin/`. Outside one they are not, and
- * that is not a fault — so an absence resolves to `warn` with the reason, never
- * to a failure that would make this command unusable from a plain shell.
+ * because the host injects the plugin's `bin/` — but not in the SessionStart
+ * hook that runs this doctor, nor in a plain shell. A copy in the plugin's
+ * `bin/` is a complete install, so it is `ok`: a `warn` here would be drawn
+ * above the prompt at every session start for a state nobody has to change.
+ * Only a binary found in neither place is a failure.
  */
 function checkBinaries(pluginRoot, env) {
   const found = []
@@ -552,9 +554,8 @@ function checkBinaries(pluginRoot, env) {
   }
   const bundled = absent.filter(name => existsSync(join(pluginRoot, 'bin', name)))
   if (bundled.length === absent.length) {
-    return check('binaries', 'warn', `${absent.join(', ')} not on PATH — present in the plugin's bin/, which Claude Code injects inside a session`, {
-      evidence: [...found, ...bundled.map(n => `bundled: ${join(pluginRoot, 'bin', n)}`)],
-      fix: `Nothing to do for a run inside Claude Code. For a plain shell: export PATH="${join(pluginRoot, 'bin')}:$PATH"`
+    return check('binaries', 'ok', `${absent.join(', ')} run from the plugin's bin/ (${join(pluginRoot, 'bin')}), which Claude Code puts on PATH inside a session`, {
+      evidence: [...found, ...bundled.map(n => `bundled: ${join(pluginRoot, 'bin', n)}`)]
     })
   }
   return check('binaries', 'fail', `${absent.join(', ')} resolve neither on PATH nor in the plugin's bin/`, {

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/package.json

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