@renzrollon/interlock 1.3.0 → 1.3.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "interlock",
   "displayName": "Interlock",
-  "version": "1.3.0",
+  "version": "1.3.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",
@@ -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,16 @@ 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.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,10 @@
 // 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 only the state word the renderer chose. 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 SESSION START (show-preflight-and-interrupted-runs-at-session-start
 // design D5-D8). Outside a run the module draws two things, both from the
@@ -595,6 +595,51 @@ 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
+}
+
+/**
+ * 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 {
@@ -1019,9 +1064,126 @@ function boardKey(key) {
   return `${kind === 'wave' ? 'wave-block' : `wave-${kind}`}-${rest.join('-')}`
 }
 
+/** Colour only a state word the board printed: hue for ok/failed/current, dim for the rest. */
+function stateProps(word) {
+  if (word === 'ok') return { color: 'green' }
+  if (word === 'failed') return { color: 'red' }
+  if (word === 'current') return { color: 'yellow' }
+  if (word === 'pending' || word === 'not reached' || word === 'not recorded' || word === 'per task') {
+    return { dimColor: true }
+  }
+  return null
+}
+
+/** The width a card and the renderer share: the body, capped at the published default. */
+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 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 head = [parts.batch, parts.label, parts.model, parts.tier, parts.effort].filter(Boolean).join(' ')
+  const line = [
+    ...(parts.state ? [`${head} `, h(Text, stateProps(parts.state), parts.state)] : [head]),
+    ...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
+  const flush = () => {
+    if (index === null) return
+    out.push(
+      h(
+        Box,
+        {
+          key: `wave-card-${index}`,
+          flexDirection: 'column',
+          borderStyle: 'single',
+          borderDimColor: true,
+          width,
+          paddingLeft: 1,
+          paddingRight: 1,
+          marginBottom: 1
+        },
+        ...kids
+      )
+    )
+    index = null
+    kids = null
+  }
+  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)
+      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
@@ -1037,8 +1199,7 @@ function drawWaves($, e) {
     const dispatched = run.dispatched !== null || rows.some(r => r.batch)
     return [...(dispatched ? [keyed('wave-board-unrelayed', UNRELAYED_LINE)] : []), ...rows.map(r => flatRow(keyed, 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() })
@@ -1050,15 +1211,14 @@ function drawWaves($, e) {
   // 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(keyed, r))]
 }
 
 async function drawPane($, e) {
   const { Box, Text } = $.ui.resolve(e)
   const keyed = (key, text, props) => h(Box, { key }, h(Text, props || null, text))
+  const heading = text => h(Box, { marginTop: 1 }, h(Text, { bold: true }, text))
   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($)))
@@ -1070,19 +1230,21 @@ async function drawPane($, e) {
   out.push(keyed('last-activity', await lastActivityText($)))
   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, h(Text, null, `${lane || 'lane unknown'} · ${a.id} · ${a.models.join(', ') || 'model not reported'} · ${done}`)),
+        h(Box, null, h(Text, { dimColor: true }, `${n} · ${tokensText(a)}`))
       )
     )
   }
@@ -1098,11 +1260,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,7 +1274,7 @@ 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,
@@ -1121,13 +1283,13 @@ async function drawPane($, e) {
     )
   )
 
-  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 (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)
@@ -1350,18 +1512,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 +1530,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 +1557,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

@@ -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 }
 }
 
 /**
@@ -309,7 +310,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 +326,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 +347,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 +367,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 +405,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renzrollon/interlock",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "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"