@renzrollon/interlock 1.3.0 → 1.4.0

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "interlock",
   "displayName": "Interlock",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "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",
@@ -9,7 +9,6 @@
   },
   "homepage": "https://github.com/renzrollon/interlock",
   "repository": "https://github.com/renzrollon/interlock",
-  "icon": ".claude-plugin/icon.png",
   "license": "MIT",
   "keywords": [
     "openspec",

package/CHANGELOG.md

@@ -5,7 +5,32 @@ 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.
 
-## [Unreleased]
+## 1.4.0 — 2026-10-09
+
+### Changed
+
+- **A lane's worker is shown as `task 1.1 · <gist>`.** `/workflows`, `interlock-run`'s log, the meter's rows and toasts and the Mermaid plan all name a lane by `laneTitle`, which read `1.1 · Add the relaunch guard`. A bare `1.1` among `plan-waves`, `cli-3 · run next` and `verify` looked like an outline number rather than a worker. The title now opens with what the agent is doing: `task 1.1 · …` for a one-task lane and `tasks 1.1+2 · …` for a lane of several. The 48-character cap still applies to the label and gist, so a gist is cut where it was and `interlock waves --format board` prints byte-for-byte what it printed before. The label (`1.1`, `1.1+2`) is unchanged and still names the briefing file, the worktree, the trajectory line and `run record-batch`. Non-lane spawns keep their labels as titles. The workflow runtime caches an agent by its label, so resuming a run from `/workflows` that started before this upgrade re-runs its lane agents.
+- **The ship meter names every agent on the Workflow host.** On that host every agent row and turn-end toast read `lane unknown`. The meter joined an agent to its lane only through `agent.spawn`, which the host never raises for a workflow agent, so the board's lane notes never left `served ?` either. Every run agent's first act is to read its own briefing, so the meter now joins on that read. A `Read` whose path names a dispatched spawn's briefing, or a Bash command that names it (a worker that `cat`s it), matches the agent to that spawn's row by the same briefing hash. A new `tool.call` observer on `Read` makes that join and passes the call on unchanged. An agent is named by its spawn's title (`task 1.1 · …`, `plan-waves`, `verify`). A relay ping is named by its own `interlock` line (`cli · run next`). An agent seen doing neither reads `unmatched agent`, and one line beneath the rows says why. The pane and the toast now use one name; before, the pane printed the label and the toast the title.
+- **The meter pane draws in your theme's colours.** Every colour is a theme key, so the pane follows a light, dark or colour-blind theme. A probe on 2.1.295 showed theme keys resolve in a module's pane and an unknown key renders uncoloured.
+  - State words: `success`, `error` and `warning` for `ok`, `failed` and `current`, replacing raw green, red and yellow.
+  - Names: lane labels and agent names in `suggestion`, bold.
+  - Headings: the run header and section headings in `claude`.
+  - Cards: the card of the wave holding a `current` lane is bordered in `warning`; every other card stays dim.
+  - Agent rows: an agent's turn word in `warning` while running, `success` for `answer` and `error` for any other host word, with relay pings dim.
+  - Warnings: the quiet word and banners in `warning`.
+  - Refusals: the guard-denial line, and the launch-guard line when it refuses, in `error`.
+  - Uncoloured, as before: the context, cost and plan-window lines (colour there would read as a threshold) and a `RED` marker in a wave title. The rules are `lib/meter-palette.mjs`'s, a Node-free module pinned by `test/spine/meter-palette.test.mjs`.
+
+## 1.3.1 — 2026-10-08
+
+### Changed
+
+- **The ship meter draws each wave as a card, and colours only the state word.** The 1.3.0 pane stretched every wave rule to the pane's width and cut each lane's title with `…`. Each wave is now one bordered card, as wide as the pane up to the board's published default width. A lane is its fixed cells, then its title wrapping beneath them, then, once its agent has spawned, what the host reported serving it, dim. The state word is the only coloured text: `ok` green, `failed` red, `current` yellow, the rest dim, and a lane whose tasks disagree colours each task's own word beside its id. The fixed cells are one text with the coloured words inside it, so in a narrow docked pane the line wraps instead of breaking words apart. `interlock waves --format board` prints exactly what it printed before.
+  - **The renderer's rows carry their fields.** `drawPlanBoardRows` gives a wave-header row `parts.title` and a lane row `parts`: batch, label, model, tier, effort, state word, gist, note, task ids, ordered-after ids and each task's own word. A drawer colours a word without searching the cut line. The lines form and the Mermaid output are byte-identical to 1.3.0.
+  - **A hook parameter renamed from `$` is pinned.** The meter's spawn, session-start and command hooks name their parameters for a reader. The allow-list scan reads only `$.`, so `test/spine/mod-pins.test.mjs` now fails when a renamed engine handle is read through, or a renamed forward is called with anything but the hook's own input.
+- **The listing image moved out of the manifest folder.** It sat in `.claude-plugin/`, where the plugin layout keeps only the manifest. It now ships from the plugin's assets folder, `package.json` lists that folder in `files`, and `plugin.json` no longer names the image.
+
+## 1.3.0 — 2026-10-08
 
 ### Added
 

package/hooks/mod.mjs

@@ -64,10 +64,20 @@
 // drawn from one source: the plan summary the adoption and replan steps carry,
 // with an overlay built from the steps alone (the cursor, the ids each recorded
 // batch names, the skipped verifications, the halt). No file is read for it.
-// The layout, the state words and the cut are the renderer's; the module keys
-// its rows, appends what the host observed of a lane, and speaks every
-// fallback: a CLI that relays no plan, a pane narrower than the board, a
-// renderer that throws.
+// The module lays those rows as one bordered card per wave, wraps the gist,
+// and colours the state word the renderer chose and the lane's label. It keys the lanes,
+// appends what the host observed of a lane, and speaks every fallback: a CLI
+// that relays no plan, a pane narrower than the board, a renderer that throws.
+//
+// THE AGENTS' NAMES AND THE PALETTE. The
+// Workflow host raises no `agent.spawn` for a Workflow agent, so the spawn
+// event's join never fires there. Every run agent's first act is to read its
+// own briefing, and that Read or Bash call names the spawn's briefing path:
+// the module joins the agent to the spawn's row by it, through the same
+// briefing hash. A driver line from an agent no row names marks a relay; any
+// other agent reads `unmatched agent`, said once beneath the rows. Every colour
+// is a theme key from `lib/meter-palette.mjs` and names a meaning, never a
+// threshold: the engine's own figures carry none.
 //
 // THE SESSION START (show-preflight-and-interrupted-runs-at-session-start
 // design D5-D8). Outside a run the module draws two things, both from the
@@ -101,6 +111,7 @@
 import { drawPlanBoardRows } from '../lib/draw-plan.mjs'
 import { decideLaunch, emptyRecord, isAcceptedLaunch, isShipLaunch, withLaunch, withPrompt } from '../lib/launch-rule.mjs'
 import { LIMITS } from '../lib/limits.mjs'
+import { PALETTE, stateProps, turnProps } from '../lib/meter-palette.mjs'
 import { TICK_MS, quietMs, quietWord } from '../lib/meter-quiet.mjs'
 import { guardDenialLine, guardOf, guardReason, launchGuardLine } from '../lib/meter-refusals.mjs'
 import {
@@ -166,6 +177,17 @@ const GUARD = 'interlock guard'
 const DRIVER_LINE = /^interlock\s/
 // The bootstrap line a lane's spawn prompt carries (as `lib/agent-usage.mjs` reads it).
 const BRIEFING_SHA = /Expected sha256: ([0-9a-f]{64})/g
+// What an agent row and a turn-end toast read for an agent no row and no driver line names.
+const UNMATCHED = 'unmatched agent'
+const UNMATCHED_LINE = 'unmatched: no briefing read or interlock line seen from this agent yet'
+// The characters a briefing path may stand behind in a Read path or a command,
+// and the ones that would make it part of a longer file name after it.
+const PATH_BEFORE = /[\s\/'"=]/
+const PATH_AFTER = /[\w.+-]/
+/** The props a name is drawn with: a lane label, a spawn's title, a joined agent's name. */
+const NAME_PROPS = { bold: true, color: PALETTE.identity }
+/** The props the run header and each section heading are drawn with. */
+const HEADING_PROPS = { bold: true, color: PALETTE.accent }
 const TOKEN_FIELDS = ['input_tokens', 'output_tokens', 'cache_read_input_tokens', 'cache_creation_input_tokens']
 // The classic session-start sources that start the session over, as the person
 // typed them (design D4). `startup` and `compact` are not among them.
@@ -595,6 +617,117 @@ async function fileWrite($, path) {
   }
 }
 
+/** What an `agent.spawn` chain returned, read for the meter and handed back unchanged. */
+async function noteSpawn($, input, spawned) {
+  if (session.interactive && run.phase === 'live') {
+    if (spawned && str(spawned.agentId) && input && typeof input.prompt === 'string') {
+      const found = [...input.prompt.matchAll(BRIEFING_SHA)]
+      if (found.length) agentOf(spawned.agentId).sha = found[found.length - 1][1]
+    }
+    if (await stamp($)) redrawWord($)
+  }
+  // An Explore investigator the chain let through (observe-the-spec-run-live design D5).
+  if (specWatching() && input && input.subagentType === 'Explore' && spawned && typeof spawned.model === 'string') {
+    await countInvestigator($)
+  }
+  return spawned
+}
+
+/** Whether `text` names `path` whole: behind its start or a separator, and not followed by more of a file name. */
+function namesPath(text, path) {
+  for (let at = text.indexOf(path); at !== -1; at = text.indexOf(path, at + 1)) {
+    const before = at === 0 ? '' : text[at - 1]
+    const after = text[at + path.length] ?? ''
+    if ((before === '' || PATH_BEFORE.test(before)) && (after === '' || !PATH_AFTER.test(after))) return true
+  }
+  return false
+}
+
+/**
+ * The Workflow host's join: it raises no
+ * `agent.spawn` for a Workflow agent, but every run agent's first act is to
+ * read its own briefing. A Read path or a Bash command that names a
+ * dispatched spawn's briefing path joins the agent to that spawn's row,
+ * through the same briefing hash the spawn event joins on. The first briefing
+ * an agent reads wins; an agent that names none is left as it was, and no
+ * agent record is made for it. Never throws.
+ */
+function noteBriefing($, agentId, text) {
+  try {
+    const id = str(agentId)
+    if (!id || typeof text !== 'string') return
+    const known = run.agents.get(id)
+    if (known && known.sha) return
+    const said = text.split('\\').join('/')
+    for (const r of run.rows.values()) {
+      if (!r.sha || !r.promptPath) continue
+      if (!namesPath(said, r.promptPath.split('\\').join('/'))) continue
+      agentOf(id).sha = r.sha
+      $.ui.invalidate('ui.render')
+      return
+    }
+  } catch (err) {
+    $.ui.log(`interlock meter: a briefing read was not joined to its lane: ${messageOf(err)}`, { to: 'debug' })
+  }
+}
+
+/**
+ * `run next` for `interlock run next --results … --json`: the subcommand a
+ * driver line relays, as `workflows/ship.js` names its relay (`argv.slice(0, 2)`),
+ * the second word dropped when it is a flag or a shell operator.
+ */
+function relayOf(command) {
+  const words = command.trim().split(/\s+/).slice(1, 3)
+  if (!words.length || !words[0]) return null
+  const second = words[1]
+  return second && !/^(--|[;&|<>])/.test(second) ? `${words[0]} ${second}` : words[0]
+}
+
+/** An agent that ran a driver line before any briefing named it is a relay, shown by what it relayed. Never throws. */
+function noteRelay($, agentId, command) {
+  try {
+    const id = str(agentId)
+    if (!id) return
+    const known = run.agents.get(id)
+    if (known && known.sha) return
+    const relay = relayOf(command)
+    if (!relay || (known && known.relay === relay)) return
+    agentOf(id).relay = relay
+    $.ui.invalidate('ui.render')
+  } catch (err) {
+    $.ui.log(`interlock meter: a driver line was not read for its agent: ${messageOf(err)}`, { to: 'debug' })
+  }
+}
+
+/**
+ * A clear, resume or fork ends the run the meter holds, before the chain
+ * beneath runs. Any other source, and a non-interactive session, changes
+ * nothing. Never throws.
+ */
+function endRunAtBoundary($, input) {
+  if (!session.interactive) return
+  try {
+    const boundary = BOUNDARIES.get(input.source)
+    if (!boundary) return
+    const ended = run
+    stopTick()
+    run = freshRun()
+    start = freshStart()
+    spec = freshSpec({ afterBoundary: true })
+    setStatus($)
+    $.ui.invalidate('ui.render')
+    const what = ended.phase === 'idle' ? 'no run was held' : `run ${ended.runId || '(no id)'} is no longer drawn`
+    $.ui.log(`interlock meter: ${boundary} started the session over; ${what}`, { to: 'debug' })
+  } catch (err) {
+    $.ui.log(`interlock meter: the session boundary was not applied: ${messageOf(err)}`, { to: 'debug' })
+  }
+}
+
+/** Once the chain beneath has run: the preflight's report, read for every source. */
+async function readPreflightAfterStart($, input) {
+  if (session.interactive) await readPreflight($, str(input.cwd) || session.cwd)
+}
+
 /** One Explore investigator the chain let through (design D5). Never throws. */
 async function countInvestigator($) {
   try {
@@ -613,11 +746,14 @@ function drawSpecPane($, e) {
   return h(Box, { flexDirection: 'column' }, ...specPaneLines(spec).map(l => h(Box, { key: l.key }, h(Text, props(l), l.text))))
 }
 
-/** The launch guard's ruling now, over the record its branch would read, in the rule's words (design D5). */
+/**
+ * The launch guard's ruling now, over the record its branch would read, in the
+ * rule's words (design D5), and whether that ruling refuses the next launch.
+ */
 async function launchGuardText($) {
   const { record, now } = await guardFacts($)
   const ruling = decideLaunch(record, now)
-  return launchGuardLine(ruling, now)
+  return { text: launchGuardLine(ruling, now), refused: now !== null && ruling.decision !== 'allow' && Boolean(ruling.reason) }
 }
 
 /** Names, once per run record, a step that crossed with no live run (design D4). */
@@ -674,6 +810,8 @@ function agentOf(id) {
       reason: null,
       durationMs: null,
       sha: null,
+      // The two words after `interlock` in the first driver line it ran while no row named it.
+      relay: null,
       // Whether its turn end has been spoken: once per agent per run (speak-lane-turn-ends design D1).
       endToasted: false
     }
@@ -786,6 +924,8 @@ async function applyRecord($, record) {
       model: str(s.model),
       effort: str(s.effort),
       sha: str(s.promptSha256),
+      // The briefing the spawn names, read off the agent's own first read of it.
+      promptPath: str(s.promptPath),
       // Spawned by a step that dispatches a batch: a lane, planned or not.
       batch: BATCH_ACTIONS.has(record.action)
     })
@@ -934,9 +1074,14 @@ function rowForAgent(a) {
   return null
 }
 
-function laneForAgent(a) {
-  const r = rowForAgent(a)
-  return r ? r.label : null
+/**
+ * What an agent is called: its joined spawn's title, else `cli · <what it
+ * relayed>` for a driver-line agent, else `null`, which reads `unmatched agent`.
+ */
+function agentName(a) {
+  const row = rowForAgent(a)
+  if (row) return row.title
+  return a.relay ? `cli · ${a.relay}` : null
 }
 
 /**
@@ -962,24 +1107,53 @@ function sessionLines(usage, failure) {
 
 /**
  * `last activity <ISO>` or `last activity unknown`, then the quiet word while a
- * live run is quiet. The word is recomputed from the clock at each draw, so a
- * pane opened after the host stopped the interval still shows it (design D2, D5).
+ * live run is quiet, as the line and the word apart. The word is recomputed
+ * from the clock at each draw, so a pane opened after the host stopped the
+ * interval still shows it (design D2, D5).
  */
 async function lastActivityText($) {
-  if (run.lastActivityAt === null) return 'last activity unknown'
+  if (run.lastActivityAt === null) return { line: 'last activity unknown', word: null }
   const at = new Date(run.lastActivityAt).toISOString()
   const word = run.phase === 'live' ? quietWord(quietMs(run.lastActivityAt, await clockNow($))) : null
-  return `last activity ${at}${word ? ` · ${word}` : ''}`
+  return { line: `last activity ${at}`, word }
 }
 
-/** One spawn as a flat row, as the section drew every spawn before the board. */
-function flatRow(keyed, r) {
+/**
+ * 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.
+ */
+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'}`),
+    ' · ',
+    h(Text, quiet ? { dimColor: true } : turnProps(a.reason), done)
+  )
+}
+
+/** One spawn as a flat row, as the section drew every spawn before the board: its title in the identity colour. */
+function flatRow($, e, r) {
+  const { Box, Text } = $.ui.resolve(e)
   const a = agentForSha(r.sha)
   const served = a && a.models.length ? a.models.join(', ') : '?'
   const state = a ? a.reason || 'running' : 'waiting'
-  return keyed(
-    `wave-row-${r.label}`,
-    `${r.title} · ${r.kind || 'agent'} · routed ${r.model || '?'} · served ${served} · effort ${r.effort || '?'} · ${state}`
+  return h(
+    Box,
+    { key: `wave-row-${r.label}` },
+    h(
+      Text,
+      null,
+      h(Text, NAME_PROPS, r.title),
+      ` · ${r.kind || 'agent'} · routed ${r.model || '?'} · served ${served} · effort ${r.effort || '?'} · ${state}`
+    )
   )
 }
 
@@ -1019,9 +1193,136 @@ 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. */
+function boardColumns(e) {
+  const body = e.props && isInt(e.props.bodyColumns) && e.props.bodyColumns > 0
+    ? e.props.bodyColumns
+    : LIMITS.waveBoardDefaultColumns
+  return body < LIMITS.waveBoardMinColumns ? body : Math.min(body, LIMITS.waveBoardDefaultColumns)
+}
+
+function waveTitleOf(row) {
+  if (row.parts && typeof row.parts.title === 'string' && row.parts.title) return row.parts.title
+  const text = row.text || ''
+  if (!text.startsWith('┌─ ')) return text
+  const rest = text.slice(3)
+  const cut = rest.search(/ ─/)
+  return (cut === -1 ? rest : rest.slice(0, cut)).trimEnd()
+}
+
+/** A lane's ids cell, as spans: each task's own state word coloured when its tasks disagree. */
+function idSpans(Text, parts) {
+  if (parts.state === 'per task' && Array.isArray(parts.tasks) && parts.tasks.length) {
+    const spans = [' [']
+    parts.tasks.forEach((task, i) => {
+      if (i) spans.push(', ')
+      if (!task.word) return spans.push(task.id)
+      spans.push(`${task.id} `, h(Text, stateProps(task.word), task.word))
+    })
+    spans.push(']')
+    return spans
+  }
+  return parts.ids ? [` [${parts.ids}]`] : []
+}
+
+/**
+ * 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.
+ */
+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 !== '')
+}
+
+/** Whether a lane the board drew holds the cursor: its own state word, or a task's, is `current`. */
+const isCurrentLane = parts =>
+  Boolean(parts) &&
+  (parts.state === 'current' || (Array.isArray(parts.tasks) && parts.tasks.some(task => task && task.word === 'current')))
+
+/**
+ * A lane in its card: the fixed cells as one Text, the gist wrapping beneath,
+ * then the host's note, dim. The coloured words are spans nested in that one
+ * Text, because a row of separate elements shrinks each into its own column
+ * and breaks words apart once the line is wider than the card.
+ */
+function drawLane($, e, row) {
+  const { Box, Text } = $.ui.resolve(e)
+  const key = boardKey(row.key)
+  const parts = row.parts
+  if (!parts) return h(Box, { key }, h(Text, { wrap: 'truncate-end' }, row.text))
+  const line = [
+    ...headSpans(Text, parts),
+    ...(parts.state ? [' ', h(Text, stateProps(parts.state), parts.state)] : []),
+    ...idSpans(Text, parts),
+    ...(Array.isArray(parts.after) && parts.after.length ? [` ←${parts.after.join(',')}`] : [])
+  ]
+  const kids = [
+    h(Text, { wrap: 'wrap' }, ...line),
+    parts.gist ? h(Box, { key: `${key}-gist` }, h(Text, { wrap: 'wrap' }, parts.gist)) : null,
+    parts.note ? h(Box, { key: `${key}-note` }, h(Text, { dimColor: true }, parts.note)) : null
+  ].filter(Boolean)
+  return h(Box, { key, flexDirection: 'column' }, ...kids)
+}
+
+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 out = []
+  let index = null
+  let kids = 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
+    out.push(
+      h(
+        Box,
+        {
+          key: `wave-card-${index}`,
+          flexDirection: 'column',
+          borderStyle: 'single',
+          ...(current ? { borderColor: PALETTE.current } : { borderDimColor: true }),
+          width,
+          paddingLeft: 1,
+          paddingRight: 1,
+          marginBottom: 1
+        },
+        ...kids
+      )
+    )
+    index = null
+    kids = null
+    current = false
+  }
+  for (const row of board) {
+    if (row.key.startsWith('wave:') && row.key.endsWith(':end')) continue
+    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)))]
+      continue
+    }
+    if (row.key.startsWith('lane:')) {
+      const lane = drawLane($, e, row)
+      if (kids) {
+        kids.push(lane)
+        if (isCurrentLane(row.parts)) current = true
+      } else out.push(lane)
+      continue
+    }
+    flush()
+    out.push(keyed(boardKey(row.key), row.text, row.key === 'header' || row.key === 'tail' ? null : { wrap: 'truncate-end' }))
+  }
+  flush()
+  return out
+}
+
 /**
  * The waves section (design D7, D8): the board once a plan summary has
- * crossed, at the pane's own width, one truncating text per row; then a flat
+ * crossed, one bordered card per wave at the body width capped at the board's
+ * default, the rows between cards one truncating text each; then a flat
  * row for each spawn no planned lane carries. Before a summary, the flat rows,
  * beneath a spoken line once a batch was dispatched. Below the board's minimum
  * the renderer's spoken line stands in for it, and a renderer that throws is
@@ -1035,57 +1336,69 @@ function drawWaves($, e) {
   if (!run.plan) {
     if (!rows.length) return [h(Text, { dimColor: true }, NO_LANES_LINE)]
     const dispatched = run.dispatched !== null || rows.some(r => r.batch)
-    return [...(dispatched ? [keyed('wave-board-unrelayed', UNRELAYED_LINE)] : []), ...rows.map(r => flatRow(keyed, r))]
+    return [...(dispatched ? [keyed('wave-board-unrelayed', UNRELAYED_LINE)] : []), ...rows.map(r => flatRow($, e, r))]
   }
-  const props = e.props || {}
-  const width = isInt(props.bodyColumns) && props.bodyColumns > 0 ? props.bodyColumns : LIMITS.waveBoardDefaultColumns
+  const width = boardColumns(e)
   let board
   try {
     board = drawPlanBoardRows(run.plan, { columns: width, state: boardOverlay(run.plan), notes: laneNotes() })
   } catch (err) {
     $.ui.log(`interlock meter: ${BOARD_FAILED_LINE}: ${messageOf(err)}`, { to: 'debug' })
-    return [keyed('wave-board-failed', BOARD_FAILED_LINE), ...rows.map(r => flatRow(keyed, r))]
+    return [keyed('wave-board-failed', BOARD_FAILED_LINE), ...rows.map(r => flatRow($, e, r))]
   }
   // Every board ends in its tail; the renderer's spoken line for a narrow body
   // is one row without one, and the lanes are then drawn flat beneath it.
   const drawn = board.length > 0 && board[board.length - 1].key === 'tail'
   const planned = new Set(drawn ? board.filter(row => row.key.startsWith('lane:')).map(row => row.key.slice('lane:'.length)) : [])
-  return [
-    ...board.map(row => line(boardKey(row.key), row.text)),
-    ...rows.filter(r => !planned.has(r.label)).map(r => flatRow(keyed, r))
-  ]
+  const body = drawn ? drawBoardCards($, e, board, width) : board.map(row => line(boardKey(row.key), row.text))
+  return [...body, ...rows.filter(r => !planned.has(r.label)).map(r => flatRow($, e, r))]
 }
 
 async function drawPane($, e) {
   const { Box, Text } = $.ui.resolve(e)
   const keyed = (key, text, props) => h(Box, { key }, h(Text, props || null, text))
+  const heading = text => h(Box, { marginTop: 1 }, h(Text, HEADING_PROPS, text))
+  // The launch-guard line, in the alarm colour only while its ruling refuses the next launch.
+  const guardLine = async () => {
+    const guard = await launchGuardText($)
+    return keyed('launch-guard', guard.text, guard.refused ? { color: PALETTE.alarm } : null)
+  }
   if (run.phase === 'idle' && !run.summary) {
     // The guard runs in every session, so its line stands here too (design D5).
-    return h(Box, { flexDirection: 'column' }, h(Text, { dimColor: true }, NO_RUN_LINE), keyed('launch-guard', await launchGuardText($)))
+    return h(Box, { flexDirection: 'column' }, h(Text, { dimColor: true }, NO_RUN_LINE), await guardLine())
   }
 
   const out = []
-  out.push(h(Text, { bold: true }, `${run.change || 'ship run'}${run.runId ? ` · run ${run.runId}` : ''}`))
+  out.push(h(Text, HEADING_PROPS, `${run.change || 'ship run'}${run.runId ? ` · run ${run.runId}` : ''}`))
   out.push(keyed('action', `action: ${run.action || 'starting'}${run.phase === 'closed' ? ' (closed)' : ''}`))
-  out.push(keyed('last-activity', await lastActivityText($)))
+  const activity = await lastActivityText($)
+  out.push(
+    h(
+      Box,
+      { key: 'last-activity' },
+      h(Text, null, activity.line, ...(activity.word ? [' · ', h(Text, { color: PALETTE.warn }, activity.word)] : []))
+    )
+  )
   out.push(h(Text, { dimColor: true }, RECORD_LINE))
 
-  out.push(h(Text, { bold: true }, 'waves'))
+  out.push(heading('waves'))
   out.push(...drawWaves($, e))
 
-  out.push(h(Text, { bold: true }, 'agents'))
+  out.push(heading('agents'))
   if (!run.agents.size) out.push(h(Text, { dimColor: true }, 'no agent has reported a request yet'))
   for (const a of run.agents.values()) {
-    const lane = laneForAgent(a)
     const n = a.requests === 1 ? '1 request' : `${a.requests} requests`
     const done = a.reason ? `${a.reason}${a.durationMs !== null ? ` ${(a.durationMs / 1000).toFixed(1)}s` : ''}` : 'running'
     out.push(
-      keyed(
-        `agent-${a.id}`,
-        `${lane || 'lane unknown'} · ${a.id} · ${a.models.join(', ') || 'model not reported'} · ${n} · ${tokensText(a)} · ${done}`
+      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 }))
 
   // 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).
@@ -1098,11 +1411,11 @@ async function drawPane($, e) {
     failure = messageOf(err)
   }
   const [contextLine, costLine] = sessionLines(usage, failure)
-  out.push(h(Text, { bold: true }, 'session'))
+  out.push(heading('session'))
   out.push(keyed('session-context', contextLine))
   out.push(keyed('session-cost', costLine))
 
-  out.push(h(Text, { bold: true }, 'plan windows'))
+  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)'))
@@ -1112,22 +1425,22 @@ async function drawPane($, e) {
     out.push(keyed(`plan-window-${kind}`, `${kind} ${w.percentUsed}% used${w.resetsAt ? ` · resets ${w.resetsAt}` : ''}`))
   }
 
-  out.push(h(Text, { bold: true }, 'banners'))
+  out.push(heading('banners'))
   out.push(
     h(
       Box,
       { key: 'banners', flexDirection: 'column' },
-      ...(run.banners.length ? run.banners.map(b => h(Text, null, b)) : [h(Text, { dimColor: true }, 'none so far')])
+      ...(run.banners.length ? run.banners.map(b => h(Text, { color: PALETTE.warn }, b)) : [h(Text, { dimColor: true }, 'none so far')])
     )
   )
 
-  out.push(h(Text, { bold: true }, 'refusals'))
+  out.push(heading('refusals'))
   const denials = guardDenialLine(run.guardDenials)
-  if (denials) out.push(keyed('guard-denials', denials))
-  out.push(keyed('launch-guard', await launchGuardText($)))
+  if (denials) out.push(keyed('guard-denials', denials, { color: PALETTE.alarm }))
+  out.push(await guardLine())
 
   if (run.summary) {
-    out.push(h(Text, { bold: true }, 'close summary'))
+    out.push(heading('close summary'))
     out.push(h(Box, { key: 'summary', flexDirection: 'column' }, h(Text, null, run.summary)))
   }
   return h(Box, { flexDirection: 'column' }, ...out)
@@ -1282,6 +1595,12 @@ export function register(on) {
       return r
     }
     const held = run
+    // A run agent's command names it: a
+    // briefing it reads joins it to its lane, and a driver line names a relay.
+    if (run.phase === 'live' && str(e.agentId)) {
+      noteBriefing($, e.agentId, command)
+      if (driver) noteRelay($, e.agentId, command)
+    }
     const r = await next(e)
     // Any Bash call during the run is read for a guard's refusal (guard-commit); only a driver line for a step.
     if (held === run) speakRefusal($, r)
@@ -1308,6 +1627,14 @@ export function register(on) {
     return r
   })
 
+  // A run agent's Read, observed for the briefing it names and passed on as it
+  // came: the Workflow host raises no spawn event, so a briefing read is how an
+  // agent is joined to its lane.
+  on('tool.call', { tool: 'Read' }, async ($, e, next) => {
+    if (session.interactive && run.phase === 'live' && e.agentId) noteBriefing($, e.agentId, e.file_path)
+    return next(e)
+  })
+
   // The tools the manifest's `Edit|Write` matcher names for guard-tests and guard-tasks (design D4).
   on('tool.call', { tool: 'Edit' }, editCall)
   on('tool.call', { tool: 'Write' }, editCall)
@@ -1337,9 +1664,8 @@ export function register(on) {
       // (speak-lane-turn-ends-and-session-cost design D1-D3).
       if (a.reason && a.reason !== 'answer' && !a.endToasted) {
         a.endToasted = true
-        const row = rowForAgent(a)
         try {
-          $.ui.toast(`${row ? row.title : 'lane unknown'} · agent ${a.id} · turn ended: ${a.reason}`)
+          $.ui.toast(`${agentName(a) || UNMATCHED} · agent ${a.id} · turn ended: ${a.reason}`)
         } catch (err) {
           $.ui.log(`interlock meter: the turn-end toast for ${a.id} was refused: ${messageOf(err)}`, { to: 'debug' })
         }
@@ -1350,18 +1676,12 @@ export function register(on) {
     return next(e)
   })
 
-  on('agent.spawn', async ($, e, next) => {
-    const r = await next(e)
-    if (session.interactive && run.phase === 'live') {
-      if (r && str(r.agentId) && typeof e.prompt === 'string') {
-        const found = [...e.prompt.matchAll(BRIEFING_SHA)]
-        if (found.length) agentOf(r.agentId).sha = found[found.length - 1][1]
-      }
-      if (await stamp($)) redrawWord($)
-    }
-    // An Explore investigator the chain let through, counted for the spec run (observe-the-spec-run-live design D5).
-    if (specWatching() && e.subagentType === 'Explore' && r && typeof r.model === 'string') await countInvestigator($)
-    return r
+  // Pass the spawn on unchanged. The three parameter names are plain identifiers
+  // and are not bound anywhere else in this file, so the value given to the
+  // next handler is the event parameter. permissionMode is left as the parent
+  // set it. The meter reads the chain's result and returns that same result.
+  on('agent.spawn', async (meterSpawnApi, meterSpawnInput, meterSpawnForward) => {
+    return meterSpawnForward(meterSpawnInput).then(spawned => noteSpawn(meterSpawnApi, meterSpawnInput, spawned))
   })
 
   // The session boundary (design D4). /clear, /resume and /branch start the
@@ -1374,27 +1694,15 @@ export function register(on) {
   // source (show-preflight-and-interrupted-runs-at-session-start design D5).
   // The kit raises this event; Claude Code 2.1.291 raises no classic event to
   // a module, so there the prompt hook above reads the report instead.
-  on('classic.SessionStart', async ($, e, next) => {
-    if (!session.interactive) return next(e)
-    try {
-      const boundary = BOUNDARIES.get(e.source)
-      if (boundary) {
-        const ended = run
-        stopTick()
-        run = freshRun()
-        start = freshStart()
-        spec = freshSpec({ afterBoundary: true })
-        setStatus($)
-        $.ui.invalidate('ui.render')
-        const what = ended.phase === 'idle' ? 'no run was held' : `run ${ended.runId || '(no id)'} is no longer drawn`
-        $.ui.log(`interlock meter: ${boundary} started the session over; ${what}`, { to: 'debug' })
-      }
-    } catch (err) {
-      $.ui.log(`interlock meter: the session boundary was not applied: ${messageOf(err)}`, { to: 'debug' })
-    }
-    const r = await next(e)
-    await readPreflight($, str(e.cwd) || session.cwd)
-    return r
+  //
+  // Pass the event on unchanged. The value this hook returns is the forward
+  // itself: no first message, no permission decision. The meter's reset runs
+  // before that chain and the preflight read after it; neither becomes the return.
+  on('classic.SessionStart', async (meterSessionApi, meterSessionInput, meterSessionForward) => {
+    endRunAtBoundary(meterSessionApi, meterSessionInput)
+    const sessionForwarded = meterSessionForward(meterSessionInput)
+    await sessionForwarded.then(() => readPreflightAfterStart(meterSessionApi, meterSessionInput))
+    return sessionForwarded
   })
 
   on('ui.render', { component: 'Spinner' }, ($, e, next) => {
@@ -1413,27 +1721,27 @@ export function register(on) {
 
   on('ui.render', { component: 'Pane', requestId: SPEC_PANE }, async ($, e) => drawSpecPane($, e))
 
-  on('command.run', { command: PANE }, async $ => {
-    await openPane($)
+  on('command.run', { command: PANE }, async paneHost => {
+    await openPane(paneHost)
     return {}
   })
 
   // Typed before any prompt, the command reads the report itself, so it never
   // opens on a report no prompt has fetched yet (design D5).
-  on('command.run', { command: PREFLIGHT_PANE }, async $ => {
-    if (session.interactive) await readPreflight($, session.cwd)
-    await openPane($, PREFLIGHT_PANE, 'Interlock preflight')
+  on('command.run', { command: PREFLIGHT_PANE }, async preflightHost => {
+    if (session.interactive) await readPreflight(preflightHost, session.cwd)
+    await openPane(preflightHost, PREFLIGHT_PANE, 'Interlock preflight')
     return {}
   })
 
-  on('command.run', { command: HANDOFF_PANE }, async $ => {
-    if (session.interactive) await readPreflight($, session.cwd)
-    await openPane($, HANDOFF_PANE, 'Interlock handoff')
+  on('command.run', { command: HANDOFF_PANE }, async handoffHost => {
+    if (session.interactive) await readPreflight(handoffHost, session.cwd)
+    await openPane(handoffHost, HANDOFF_PANE, 'Interlock handoff')
     return {}
   })
 
-  on('command.run', { command: SPEC_PANE }, async $ => {
-    await openPane($, SPEC_PANE, SPEC_TITLE)
+  on('command.run', { command: SPEC_PANE }, async specCmdHost => {
+    await openPane(specCmdHost, SPEC_PANE, SPEC_TITLE)
     return {}
   })
 }

package/lib/draw-plan.mjs

@@ -16,7 +16,7 @@
 // `lib/limits.mjs` only (`test/spine/draw-plan.test.mjs` walks it). The widths
 // are `interlock limits`'s.
 
-import { TITLE_SEPARATOR, fitRow, laneEffort, laneLabel, laneModel, laneTier, laneTitle } from './lane.mjs'
+import { TITLE_SEPARATOR, fitRow, laneEffort, laneGist, laneLabel, laneModel, laneTier, laneTitle } from './lane.mjs'
 import { LIMITS } from './limits.mjs'
 
 /** The words a lane's state cell may read, each the state's own record. */
@@ -145,12 +145,13 @@ function taskWord(overlay, id, position, batch) {
 /** A lane's state cell and ids cell: one word when its tasks agree, else per task. */
 function laneCells(overlay, lane, position, batch) {
   const ids = lane.map(task => task.id)
-  if (!overlay) return { word: null, ids: ids.length > 1 ? ids.join(', ') : null }
+  if (!overlay) return { word: null, ids: ids.length > 1 ? ids.join(', ') : null, tasks: null }
   const words = lane.map(task => taskWord(overlay, task.id, position, batch))
+  const tasks = ids.map((id, i) => ({ id, word: words[i] }))
   if (words.every(word => word === words[0])) {
-    return { word: words[0], ids: ids.length > 1 ? ids.join(', ') : null }
+    return { word: words[0], ids: ids.length > 1 ? ids.join(', ') : null, tasks }
   }
-  return { word: PER_TASK, ids: ids.map((id, i) => (words[i] ? `${id} ${words[i]}` : id)).join(', ') }
+  return { word: PER_TASK, ids: ids.map((id, i) => (words[i] ? `${id} ${words[i]}` : id)).join(', '), tasks }
 }
 
 /**
@@ -280,7 +281,6 @@ function lanesOf(positions, plan) {
       for (const lane of batch) {
         const label = laneLabel(lane)
         const title = laneTitle(lane)
-        const prefix = `${label}${TITLE_SEPARATOR}`
         const tier = laneTier(lane)
         out.push({
           lane,
@@ -288,7 +288,7 @@ function lanesOf(positions, plan) {
           batch: b,
           label,
           title,
-          gist: title.startsWith(prefix) ? title.slice(prefix.length) : '',
+          gist: laneGist(lane),
           model: laneModel(lane),
           tier: tier > 0 ? String(tier) : '?',
           effort: laneEffort(lane) ?? 'inherit',
@@ -309,7 +309,9 @@ function topRule(text, width) {
 
 /**
  * The plan as rows of `{ key, text }`: `header`, `wave:<i>`, `lane:<label>`,
- * `wave:<i>:end`, `verify:<i>`, `unplaced:<n>`, `tail`.
+ * `wave:<i>:end`, `verify:<i>`, `unplaced:<n>`, `tail`. Lane and wave-header
+ * rows also carry `parts`, so a drawer can colour a state word without
+ * searching the cut line; `text` is still the CLI line.
  */
 function boardRows(plan, opts) {
   const width = boardWidth(opts.columns)
@@ -323,7 +325,11 @@ function boardRows(plan, opts) {
   const notes = new Map(Object.entries(isObject(opts.notes) ? opts.notes : {}).filter(([, text]) => isText(text)))
   const mode = overlayHeader(overlay, positions, opts.stateNote)
   const rows = []
-  const push = (key, text) => rows.push({ key, text: fitRow(text, width) })
+  const push = (key, text, parts) => {
+    const row = { key, text: fitRow(text, width) }
+    if (parts) row.parts = parts
+    rows.push(row)
+  }
 
   push(
     'header',
@@ -340,9 +346,10 @@ function boardRows(plan, opts) {
       const i = position.index - 1
       push(`verify:${i}`, [`  verify after idx ${i}`, ...texts[i]].join(' · '))
     }
-    push(`wave:${position.index}`, topRule(waveTitle(position), width))
+    const title = waveTitle(position)
+    push(`wave:${position.index}`, topRule(title, width), { title })
     for (const l of lanes.filter(l => l.position === position.index)) {
-      const { word, ids } = laneCells(overlay, l.lane, l.position, l.batch)
+      const { word, ids, tasks } = laneCells(overlay, l.lane, l.position, l.batch)
       const cells = [
         '│',
         `b${l.batch}`.padEnd(batchCell),
@@ -359,7 +366,19 @@ function boardRows(plan, opts) {
       if (ids) cells.push(`[${ids}]`)
       if (l.after.length) cells.push(`←${l.after.join(',')}`)
       const head = cells.join(' ')
-      push(`lane:${l.label}`, l.gist ? `${head}${TITLE_SEPARATOR}${l.gist}` : head.trimEnd())
+      push(`lane:${l.label}`, l.gist ? `${head}${TITLE_SEPARATOR}${l.gist}` : head.trimEnd(), {
+        batch: `b${l.batch}`,
+        label: l.label,
+        model: l.model,
+        tier: `T${l.tier}`,
+        effort: l.effort,
+        state: word,
+        gist: l.gist,
+        note: note || '',
+        ids: ids || '',
+        after: l.after,
+        tasks
+      })
     }
     push(`wave:${position.index}:end`, `└${'─'.repeat(width - 1)}`)
   }
@@ -385,7 +404,7 @@ function boardRows(plan, opts) {
  *
  * @param {unknown} plan what `planWaves` emits, or a plan summary; any value draws
  * @param {{columns?: number, state?: object|null, stateNote?: string, notes?: Record<string, string>}} [opts]
- * @returns {{key: string, text: string}[]}
+ * @returns {{key: string, text: string, parts?: object}[]}
  */
 export function drawPlanBoardRows(plan, opts = {}) {
   return boardRows(plan, isObject(opts) ? opts : {})

package/lib/lane.mjs

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

package/lib/meter-palette.mjs

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

package/lib/waves.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renzrollon/interlock",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Autonomous spec-driven development orchestration for Claude Code, layered on OpenSpec",
   "type": "module",
   "engines": {
@@ -22,7 +22,7 @@
     "agents",
     "shared",
     ".claude-plugin/plugin.json",
-    ".claude-plugin/icon.png",
+    "assets",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"