@renzrollon/interlock 1.1.1 → 1.2.1

package/lib/report.mjs

@@ -66,15 +66,31 @@
 // would depress the share for a planner's silence, and read as an implementer
 // going off-plan.
 //
+// THE CORPORA ARE READ FROM THE STATE HOME, NOT FROM THE ROOT (design D17). A
+// linked worktree's corpora live in its main checkout (`lib/state-home.mjs`), so
+// the trajectories, the outcome corpus, the review metrics and the interrupted
+// notes are all read from the home the CLI resolved — or that this module
+// resolves itself when none was passed — and the report names that home and the
+// surface of the root it ran in. The outcome-eval history is the exception, and
+// on purpose: it is a committed file under `evals/history/`, part of the working
+// tree rather than a corpus a run appends to, so it is read from the root.
+//
+// Trajectories recorded in OTHER linked worktrees are counted, never read: a
+// stat-only listing of each worktree git names, so a run recorded before the
+// state home existed is spoken about without being folded into any figure.
+//
 // Exposed to skills as `interlock report [--json] [--since <iso>] [--change <name>]`.
 
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
-import { join } from 'node:path'
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs'
+import { join, resolve } from 'node:path'
 import { LEARNING_DIR, OUTCOMES_FILE, readOutcomes } from './outcomes.mjs'
 import { METRICS_DIR, REVIEW_METRICS_SCHEMA } from './metrics.mjs'
-import { RUN_LOG_DIR, readRunLog, runLogDir } from './run-log.mjs'
+import { RUN_LOG_DIR, RUN_SURFACES, readRunLog, runLogDir } from './run-log.mjs'
 import { EVAL_HISTORY_DIR, SHIP_OUTCOMES_FILE, readShipOutcomes } from './eval-history.mjs'
 import { REPORT_CAPS } from './limits.mjs'
+import { readInterruptedNotes } from './interrupted.mjs'
+import { SURFACES, resolveStateHome } from './state-home.mjs'
 
 /** Bump when an indicator's definition changes, so two reports stay comparable. */
 export const REPORT_SCHEMA = 'interlock.report/1'
@@ -252,6 +268,10 @@ function digestTrajectories(root, { since, change, maxRuns }) {
       change: runChange,
       startedAt: firstTs || null,
       hasRunStart: Boolean(start),
+      // Recorded on `run-start` since design D14. Anything outside the
+      // vocabulary — an older trajectory, or no run-start at all — is `null`,
+      // and is counted unrecorded rather than guessed.
+      surface: start && RUN_SURFACES.includes(start.surface) ? start.surface : null,
       hasTerminal: records.some(r => r.type === 'run-complete' || r.type === 'run-halt'),
       hasReceipt: Boolean(receipt),
       // Receipt-derived, tri-state throughout: a receipt written by a run that
@@ -429,11 +449,208 @@ function digestOutcomes(root, { since, change }) {
   return { ...read, records: kept, filteredOut }
 }
 
+// ---------------------------------------------------------------------------
+// The state home, and what it cannot see
+// ---------------------------------------------------------------------------
+
+/** How long `git worktree list` may take before the count is reported as not made. */
+const WORKTREE_LIST_TIMEOUT_MS = 10_000
+
+/** How a home was arrived at — `lib/state-home.mjs`'s vocabulary. */
+const RESOLVED_FROM = Object.freeze(['explicit', 'git', 'lane', 'fallback'])
+
+/**
+ * The surface partition's buckets, keyed as `coverage.surfaces` keys them and
+ * labelled as every rendering prints them, in one order. Exported so the HTML
+ * surface reads the labels from here: two renderings naming one bucket two ways
+ * is how a reader comes to believe they are two facts.
+ */
+export const SURFACE_BUCKETS = Object.freeze([
+  Object.freeze({ key: 'main', label: 'main' }),
+  Object.freeze({ key: 'linkedWorktree', label: 'linked-worktree' }),
+  Object.freeze({ key: 'laneWorktree', label: 'lane-worktree' }),
+  Object.freeze({ key: 'unknown', label: 'unknown' }),
+  // A run whose `run-start` recorded no surface: written before the field
+  // existed, or with no `run-start` at all.
+  Object.freeze({ key: 'unrecorded', label: 'unrecorded' })
+])
+
+function defaultExec(file, args, { cwd } = {}) {
+  return execFileSync(file, args, {
+    cwd,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+    timeout: WORKTREE_LIST_TIMEOUT_MS
+  })
+}
+
+function nonEmptyString(value) {
+  return typeof value === 'string' && value.trim() !== ''
+}
+
+function realOrSelf(path) {
+  try {
+    return realpathSync(path)
+  } catch {
+    return resolve(path)
+  }
+}
+
+/**
+ * The home every corpus is read from, and what the root is.
+ *
+ * A resolution object the CLI computed is used as given — the CLI resolves once
+ * so every reader in one invocation agrees. A bare string is taken as an
+ * explicit home and resolved here, so a caller that passed the flag's value
+ * instead of a resolution still gets that home rather than silently losing it.
+ * Absent, the home is resolved here from `opts.env` (else the process
+ * environment) and git. `resolveStateHome` never throws; neither does this.
+ */
+function stateHomeFor(root, opts) {
+  const given = opts.stateHome
+  const exec = typeof opts.exec === 'function' ? opts.exec : undefined
+  if (isObject(given) && nonEmptyString(given.home)) {
+    const surface = SURFACES.includes(given.surface) ? given.surface : 'unknown'
+    let reason = nonEmptyString(given.reason) ? given.reason : null
+    if (surface !== given.surface) {
+      reason =
+        `the surface passed with the state home (${JSON.stringify(given.surface ?? null)}) is not one of ` +
+        `${SURFACES.join(', ')}` + (reason ? `; ${reason}` : '')
+    }
+    return {
+      home: given.home,
+      surface,
+      reason,
+      resolvedFrom: RESOLVED_FROM.includes(given.resolvedFrom) ? given.resolvedFrom : 'explicit'
+    }
+  }
+  try {
+    if (nonEmptyString(given)) return resolveStateHome(root, { explicit: given, env: opts.env, exec })
+    return resolveStateHome(root, { env: opts.env, exec })
+  } catch (err) {
+    // Unreachable by the resolver's own contract; held here because this
+    // module's is the same.
+    const abs = resolve(nonEmptyString(root) ? root : '.')
+    return { home: abs, surface: 'unknown', reason: `the state home could not be resolved: ${messageOf(err)}`, resolvedFrom: 'fallback' }
+  }
+}
+
+function describeWorktreeListFailure(err, home) {
+  if (err && err.code === 'ENOENT') return `git could not be run in ${home}: not found on PATH (ENOENT)`
+  if (err && (err.code === 'ETIMEDOUT' || err.signal === 'SIGTERM')) {
+    return `git worktree list timed out after ${WORKTREE_LIST_TIMEOUT_MS / 1000}s in ${home}`
+  }
+  const status = err && typeof err.status === 'number' ? err.status : null
+  if (status === 128) {
+    return `git worktree list failed in ${home} (exit 128): not a git repository, or one git refuses to read`
+  }
+  if (status !== null) return `git worktree list failed in ${home} (exit ${status})`
+  return `git worktree list failed in ${home}: ${messageOf(err)}`
+}
+
+/**
+ * Trajectories recorded in the home repository's OTHER worktrees, which this
+ * report does not read: the spoken form of every run recorded before the state
+ * home existed in a worktree that still exists.
+ *
+ * COUNTED, NEVER OPENED. Each worktree git lists, other than the home itself,
+ * has its run-log directory listed by name and entry type — `readdir` opens the
+ * directory, not a file in it — so no indicator can change on their account and
+ * an unreadable file is counted like any other. Any git failure, or a home that
+ * is not a repository, is a reason with null counts, never a zero: a scan that
+ * was not made is not a scan that found nothing.
+ */
+function unreadInLinkedWorktrees(home, exec) {
+  const notCounted = reason => ({ worktrees: null, runs: null, reason, unscannable: [] })
+  if (!existsSync(home)) return notCounted(`the state home ${home} does not exist, so it has no worktree list`)
+
+  let out
+  try {
+    out = exec('git', ['worktree', 'list', '--porcelain'], { cwd: home })
+  } catch (err) {
+    return notCounted(describeWorktreeListFailure(err, home))
+  }
+
+  const listed = String(out ?? '')
+    .split(/\r?\n/)
+    .filter(line => line.startsWith('worktree '))
+    .map(line => line.slice('worktree '.length))
+    .filter(Boolean)
+  if (!listed.length) return notCounted(`git worktree list in ${home} named no worktree`)
+
+  const self = realOrSelf(home)
+  let worktrees = 0
+  let runs = 0
+  const unscannable = []
+  for (const entry of listed) {
+    const path = resolve(home, entry)
+    if (realOrSelf(path) === self) continue
+    const dir = runLogDir(path)
+    let count
+    try {
+      count = readdirSync(dir, { withFileTypes: true }).filter(d => d.name.endsWith('.jsonl') && !d.isDirectory()).length
+    } catch (err) {
+      // No run-log directory — or a worktree git still lists after its
+      // directory was deleted — strands nothing.
+      if (err && (err.code === 'ENOENT' || err.code === 'ENOTDIR')) continue
+      unscannable.push({ worktree: path, reason: messageOf(err) })
+      continue
+    }
+    if (count) {
+      worktrees++
+      runs += count
+    }
+  }
+  return { worktrees, runs, reason: null, unscannable }
+}
+
+/** One count per scanned run, from the surface its `run-start` recorded. */
+function surfacesOf(runs) {
+  const counts = Object.fromEntries(SURFACE_BUCKETS.map(b => [b.key, 0]))
+  const keyOf = Object.fromEntries(SURFACE_BUCKETS.filter(b => b.key !== 'unrecorded').map(b => [b.label, b.key]))
+  for (const run of runs) counts[(run.surface && keyOf[run.surface]) || 'unrecorded']++
+  return counts
+}
+
 // ---------------------------------------------------------------------------
 // Indicators
 // ---------------------------------------------------------------------------
 
-function coverageOf(trajectories, outcomes, metrics, evalHistory) {
+/**
+ * Runs without a terminal event, split by whether an interrupted-run note names
+ * them (design D7). A note is what a session that ended mid-run leaves instead
+ * of a close, so a run it names is INTERRUPTED; one nobody explains is
+ * UNEXPLAINED — a different fact, and the one a reader should go and look at.
+ *
+ * A note is joined by run id to the scanned runs only. One that names no run in
+ * the listing at all is counted apart rather than joined to nothing; one whose
+ * run is on disk but outside the filter is outside the view, as its run is.
+ */
+function interruptedCoverage(root, trajectories, filter) {
+  const read = readInterruptedNotes(root)
+  const scanned = new Set(trajectories.runs.map(r => r.runId))
+  const listed = new Set(trajectories.listing.runIds || [])
+  const named = new Set()
+  let withoutTrajectory = 0
+  for (const note of read.notes) {
+    if (scanned.has(note.runId)) named.add(note.runId)
+    else if (!listed.has(note.runId)) {
+      // No trajectory to apply the filter to, so the note's own fields stand in.
+      if (filter.change && note.change !== filter.change) continue
+      if (filter.since && !(typeof note.at === 'string' && note.at >= filter.since)) continue
+      withoutTrajectory++
+    }
+  }
+  const open = trajectories.runs.filter(r => !r.hasTerminal)
+  const interrupted = open.filter(r => named.has(r.runId)).length
+  return {
+    withoutTerminal: { total: open.length, interrupted, unexplained: open.length - interrupted },
+    interruptedNotesWithoutTrajectory: withoutTrajectory,
+    interruptedNotesUnreadable: read.unreadable
+  }
+}
+
+function coverageOf(trajectories, outcomes, metrics, evalHistory, interrupted, unread) {
   const byMode = {}
   for (const record of outcomes.records) {
     const mode = typeof record.mode === 'string' ? record.mode : 'unknown'
@@ -448,11 +665,16 @@ function coverageOf(trajectories, outcomes, metrics, evalHistory) {
       filteredOut: trajectories.filteredOut,
       withRunStart: trajectories.runs.filter(r => r.hasRunStart).length,
       withTerminal: trajectories.runs.filter(r => r.hasTerminal).length,
+      ...interrupted,
       withReceipt: trajectories.runs.filter(r => r.hasReceipt).length,
       unreadable: trajectories.unreadable,
       skippedLines: trajectories.skippedLines,
       reason: trajectories.listing.reason
     },
+    // Over the scanned runs, like every trajectory figure above.
+    surfaces: surfacesOf(trajectories.runs),
+    // Counted, never read — see `unreadInLinkedWorktrees`.
+    unreadInLinkedWorktrees: unread,
     outcomes: {
       path: outcomes.path,
       exists: outcomes.exists,
@@ -862,10 +1084,21 @@ function shipOutcomeEvalOf(history) {
  * Compute every indicator the corpora support. Never throws, writes nothing,
  * and produces no verdict.
  *
- * @param {string} [root] repository root
- * @param {{since?: string, change?: string, maxRuns?: number}} [opts]
- *   `since` is an ISO 8601 instant; a run is in the window when its earliest
- *   record is at or after it. `maxRuns` overrides the published scan cap.
+ * @param {string} [root] the working tree the report runs in
+ * @param {object} [opts]
+ * @param {string} [opts.since] an ISO 8601 instant; a run is in the window when
+ *   its earliest record is at or after it
+ * @param {string} [opts.change] narrow to one change
+ * @param {number} [opts.maxRuns] overrides the published scan cap
+ * @param {{home: string, surface: string, reason: string|null, resolvedFrom: string}|string} [opts.stateHome]
+ *   the resolution the CLI computed (`resolveStateHome`); every corpus but the
+ *   committed eval history is read from its `home`. A string is an explicit
+ *   home, resolved here. Absent, the home is resolved here.
+ * @param {Record<string, string|undefined>} [opts.env] where `INTERLOCK_STATE_HOME`
+ *   is read when the home is resolved here; defaults to the process environment
+ * @param {(file: string, args: string[], opts: {cwd: string}) => string} [opts.exec]
+ *   runs git (the resolver's calls and the worktree list) and returns stdout;
+ *   throws on failure. Defaults to a bounded `execFileSync`.
  * @returns {object} report
  */
 export function buildReport(root = '.', opts = {}) {
@@ -878,19 +1111,32 @@ export function buildReport(root = '.', opts = {}) {
       : REPORT_CAPS.maxRunsScanned
 
   const filter = { since, change, maxRuns }
+  const stateHome = stateHomeFor(root, opts)
+  const home = stateHome.home
+  const exec = typeof opts.exec === 'function' ? opts.exec : defaultExec
 
   try {
-    const trajectories = digestTrajectories(root, filter)
-    const outcomes = digestOutcomes(root, filter)
-    const metrics = digestMetrics(root, filter)
+    const trajectories = digestTrajectories(home, filter)
+    const outcomes = digestOutcomes(home, filter)
+    const metrics = digestMetrics(home, filter)
+    // The committed eval history is part of the working tree, not a corpus a
+    // run appends to: it is read from the root. See the header.
     const evalHistory = digestEvalHistory(root, filter)
     const runs = trajectories.runs
 
     return {
       schema: REPORT_SCHEMA,
       root,
+      stateHome,
       filter,
-      coverage: coverageOf(trajectories, outcomes, metrics, evalHistory),
+      coverage: coverageOf(
+        trajectories,
+        outcomes,
+        metrics,
+        evalHistory,
+        interruptedCoverage(home, trajectories, filter),
+        unreadInLinkedWorktrees(home, exec)
+      ),
       indicators: {
         firstPassShip: firstPassShipOf(runs),
         rework: reworkOf(runs),
@@ -911,6 +1157,7 @@ export function buildReport(root = '.', opts = {}) {
     return {
       schema: REPORT_SCHEMA,
       root,
+      stateHome,
       filter,
       coverage: null,
       indicators: null,
@@ -937,10 +1184,31 @@ function plain(ind, unit = '') {
     (ind.notObserved ? `, ${ind.notObserved} not observed` : '')
 }
 
+/**
+ * Which home the corpora were read from and what the root is, and — when the
+ * home could not be resolved — that it could not, and why. Spoken, never
+ * implied: a report read from the wrong directory looks exactly like a report
+ * of a quiet project.
+ */
+function stateHomeLines(h) {
+  if (!h) return []
+  const out = [
+    `  state home: ${h.home} (${h.surface})` +
+      (h.resolvedFrom === 'explicit' ? ' — set by --state-home or INTERLOCK_STATE_HOME' : '')
+  ]
+  if (h.resolvedFrom === 'fallback') {
+    out.push(`  STATE HOME UNRESOLVED: ${h.reason || 'no reason was given'} — every corpus was read from the root`)
+  } else if (h.reason) {
+    out.push(`  surface unknown: ${h.reason}`)
+  }
+  return out
+}
+
 /** Human-readable report. Coverage first, per design.md D3. */
 export function formatReport(report) {
   const lines = []
   lines.push('INTERLOCK REPORT — indicators over the recorded corpora. Gates nothing (§4.15a).')
+  lines.push(...stateHomeLines(report.stateHome))
 
   if (report.filter && (report.filter.since || report.filter.change)) {
     const bits = []
@@ -964,11 +1232,44 @@ export function formatReport(report) {
       (t.filteredOut ? `  (${t.filteredOut} outside the filter)` : '')
   )
   lines.push(`    with run-start  ${t.withRunStart}`)
+  const surfaces = report.coverage.surfaces
+  if (surfaces) {
+    lines.push(
+      `    surfaces        ${SURFACE_BUCKETS.map(b => `${b.label} ${surfaces[b.key] ?? 0}`).join(', ')}` +
+        ` — over ${t.scanned} scanned, as each run-start recorded it`
+    )
+  }
   lines.push(`    with terminal   ${t.withTerminal}   (run-complete or run-halt)`)
+  if (t.withoutTerminal) {
+    const w = t.withoutTerminal
+    lines.push(
+      `    without terminal ${w.total} — interrupted ${w.interrupted} (a SessionEnd note names the run), ` +
+        `unexplained ${w.unexplained}`
+    )
+  }
+  if (t.interruptedNotesWithoutTrajectory) {
+    const n = t.interruptedNotesWithoutTrajectory
+    lines.push(`    ${n} interrupted-run note${n === 1 ? '' : 's'} name${n === 1 ? 's' : ''} no scanned trajectory`)
+  }
+  for (const u of t.interruptedNotesUnreadable || []) {
+    lines.push(`    interrupted-run note unreadable  ${u.file}: ${u.reason}`)
+  }
   lines.push(`    with receipt    ${t.withReceipt}   — every receipt-derived indicator below rests on this`)
   if (t.skippedLines) lines.push(`    torn lines      ${t.skippedLines} skipped`)
   for (const u of t.unreadable) lines.push(`    unreadable      ${u.runId}: ${u.reason}`)
   if (t.reason) lines.push(`    directory       ${t.reason}`)
+  const u = report.coverage.unreadInLinkedWorktrees
+  if (u) {
+    if (u.runs === null || u.worktrees === null) {
+      lines.push(`    trajectories recorded in other linked worktrees could not be counted: ${u.reason || 'no reason was given'}`)
+    } else {
+      lines.push(
+        `    trajectories recorded in other linked worktrees and not read: ${u.runs} across ${u.worktrees} ` +
+          `worktree${u.worktrees === 1 ? '' : 's'} — counted, never opened, in no figure below`
+      )
+    }
+    for (const w of u.unscannable || []) lines.push(`    worktree not counted  ${w.worktree}: ${w.reason}`)
+  }
 
   lines.push(
     `  outcome corpus    ${o.exists ? `${o.records} record(s)` : 'absent'}` +

package/lib/resume-card.mjs

@@ -86,6 +86,28 @@ function rows(list, { whole }) {
   }
 }
 
+// A label or an outcome printed inside a backticked span on one list row: a
+// backtick or a newline from a plan or a host would break the row apart.
+function inline(value, max) {
+  return clamp(typeof value === 'string' ? value.replace(/[`\r\n]+/g, ' ') : '', max)
+}
+
+// A session id is pasted into a shell command, so it is printed only when it is
+// a plain identifier: no whitespace, no shell syntax, and no leading `-` that
+// `claude` would read as a flag. The host's ids are UUIDs.
+function isResumableId(value) {
+  return typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(value)
+}
+
+// Whether the state home names the directory the close ran in. Text only —
+// trailing separators ignored, nothing read from disk — so a home reached
+// through a symlink prints a line naming a real path rather than losing one.
+function samePath(a, b) {
+  if (typeof a !== 'string' || typeof b !== 'string') return false
+  const trim = p => (p.length > 1 ? p.replace(/[\\/]+$/, '') || p.slice(0, 1) : p)
+  return trim(a) === trim(b)
+}
+
 /**
  * Where this change's card lives, relative to the repo root.
  *
@@ -109,7 +131,14 @@ export function resumeCardPath({ change, runId } = {}) {
  * happens at the next `run start`, against artifacts that may change in
  * between, and a card that guessed would be wrong exactly when it mattered.
  *
+ * `cwd` is the directory the close ran in and `stateHome` the directory its
+ * corpora went to (design D14); the two differ for a run in a linked worktree,
+ * where this card is written under the main checkout. `laneSessions` is every
+ * lane for which the host recorded a session id, with that lane's outcome.
+ *
  * @param {object} input
+ * @param {Array<{label?: string, sessionId?: string, outcome?: string}>} [input.laneSessions]
+ * @param {string|null} [input.stateHome]
  * @returns {string} the markdown body
  */
 export function formatResumeCard({
@@ -120,13 +149,16 @@ export function formatResumeCard({
   plan = null,
   planStored = false,
   waves = [],
+  laneSessions = [],
   degradations = [],
   projectSlug = null,
-  cwd = null
+  cwd = null,
+  stateHome = null
 } = {}) {
   const name = typeof change === 'string' && change.trim() ? change.trim() : 'unnamed'
   const reason = clamp(halted, MAX_REASON_CHARS) || 'the run halted without recording a reason'
   const hasRun = typeof runId === 'string' && runId.length > 0
+  const elsewhere = typeof stateHome === 'string' && stateHome.length > 0 && !samePath(stateHome, cwd)
   const lines = []
 
   lines.push(`<!-- ${RESUME_CARD_SCHEMA} change=${name} run=${hasRun ? runId : NO_RUN_ID} -->`)
@@ -151,8 +183,20 @@ export function formatResumeCard({
   )
   if (projectSlug) lines.push(`- project: \`${projectSlug}\``)
   if (cwd) lines.push(`- cwd: \`${cwd}\``)
+  // Only when it differs, so a main-checkout card is byte-identical to one
+  // written before the state home existed. When it does differ, the corpora are
+  // not in the tree the run worked on, and a reader in either tree needs to be
+  // told which relative paths mean which.
+  if (elsewhere) {
+    lines.push(
+      `- state home: \`${stateHome}\` — the trajectory, the outcome line and this card were written ` +
+        'here; the other relative paths in this card are relative to the cwd above'
+    )
+  }
   if (hasRun) {
-    lines.push(`- trajectory: \`.claude/ship/runs/${runId}.jsonl\``)
+    lines.push(
+      `- trajectory: \`${elsewhere ? join(stateHome, '.claude', 'ship', 'runs', `${runId}.jsonl`) : `.claude/ship/runs/${runId}.jsonl`}\``
+    )
     lines.push('')
     lines.push('Read the whole walk that led here rather than re-deriving it:')
     lines.push('')
@@ -249,6 +293,50 @@ export function formatResumeCard({
   }
   lines.push('')
 
+  lines.push('## Lanes with a host session')
+  lines.push('')
+  // Only a lane whose host recorded a session id is listed, and only an id that
+  // is safe to paste gets a command: a command a reader cannot run is worse
+  // than its absence. An id that was recorded but is not a plain identifier is
+  // said, not dropped. The Workflow host records no lane session, so a run
+  // there always lands on the absence sentence.
+  const recorded = (Array.isArray(laneSessions) ? laneSessions : []).filter(
+    lane => lane && typeof lane === 'object' && typeof lane.sessionId === 'string' && lane.sessionId.length > 0
+  )
+  const laneRows = rows(
+    recorded.map(lane => {
+      const label = inline(lane.label, 120) || 'unlabelled lane'
+      const outcome = inline(lane.outcome, 200) || 'outcome not recorded'
+      return isResumableId(lane.sessionId)
+        ? `- \`${label}\` (${outcome}): \`claude --resume ${lane.sessionId} --fork-session\``
+        : `- \`${label}\` (${outcome}): the recorded session id is not a safe identifier, so no resume command is printed for it`
+    }),
+    {
+      whole: hasRun
+        ? `\`interlock run-log query --run ${runId} --type agent-result\``
+        : 'the run manifest, `.claude/ship/run.json`'
+    }
+  )
+  if (!laneRows.shown.length) {
+    lines.push('No lane recorded a host session, so there is no session to resume.')
+  } else {
+    for (const row of laneRows.shown) lines.push(row)
+    if (laneRows.note) {
+      lines.push('')
+      lines.push(laneRows.note)
+    }
+    if (recorded.some(lane => isResumableId(lane.sessionId))) {
+      lines.push('')
+      lines.push(
+        'Each command works only if the session still exists: the host deletes transcripts after ' +
+          'its retention period, and a session deleted in the desktop app is gone with its ' +
+          'transcript. `--fork-session` resumes into a new session, so the recorded one is left as ' +
+          'it was.'
+      )
+    }
+  }
+  lines.push('')
+
   lines.push('## Degraded before the halt')
   lines.push('')
   const bannerRows = rows(