@renzrollon/interlock 1.4.0 → 1.4.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "interlock",
   "displayName": "Interlock",
-  "version": "1.4.0",
+  "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,28 @@ 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

package/hooks/mod.mjs

@@ -79,6 +79,17 @@
 // 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
@@ -113,6 +124,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 +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'
@@ -186,6 +197,12 @@ 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']
@@ -230,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,
@@ -308,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(' · ')
 }
 
@@ -376,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)
 }
@@ -813,13 +839,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 +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
@@ -915,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,
@@ -930,6 +996,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
@@ -1106,39 +1173,118 @@ 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'
+
 /**
- * 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')
+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,
-    null,
-    h(Text, nameProps, name || UNMATCHED),
-    h(Text, { dimColor: true }, ` · ${a.id} · ${a.models.join(', ') || 'model not reported'}`),
+    { wrap: 'wrap' },
+    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))
   )
 }
 
+/**
+ * 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)
+}
+
+/**
+ * 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)
@@ -1180,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
 }
@@ -1193,11 +1339,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 +1374,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,10 +1390,11 @@ 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)
@@ -1261,9 +1410,35 @@ 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.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) {
@@ -1272,10 +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,
@@ -1294,6 +1471,7 @@ function drawBoardCards($, e, board, width) {
     )
     index = null
     kids = null
+    lanes = null
     current = false
   }
   for (const row of board) {
@@ -1302,14 +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)
+      if (lanes) {
+        lanes.push(row)
         if (isCurrentLane(row.parts)) current = true
-      } else out.push(lane)
+      } else out.push(drawLane($, e, row))
       continue
     }
     flush()
@@ -1358,6 +1536,8 @@ 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))
+  // 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($)
@@ -1382,23 +1562,10 @@ async function drawPane($, e) {
   out.push(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,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' },
+    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)
 }
@@ -1456,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) {
@@ -1573,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)
@@ -1608,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' })
@@ -1642,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 {
@@ -1670,7 +1839,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/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.1",
   "description": "Autonomous spec-driven development orchestration for Claude Code, layered on OpenSpec",
   "type": "module",
   "engines": {