spexcode 0.5.4 → 0.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spexcode",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "type": "module",
   "description": "SpexCode — a spec-driven, self-developing dev tool. The `spex` CLI + spec server reads the .spec tree and its git history, and serves the dashboard.",
   "license": "MIT",

package/spec-cli/hooks/dispatch.sh

@@ -43,6 +43,16 @@ proj="${CLAUDE_PROJECT_DIR:-$PWD}"
 rt="$(cd "$proj" 2>/dev/null && hp_runtime_dir)" || rt=""
 slot="$(cd "$proj" 2>/dev/null && hp_tree_dir)" || slot=""
 
+# A project transport can outlive the tree that installed it. The current tree's last successful materialize
+# is the authority for whether its events are active. Before the v1 marker, an absent allowlist is the legacy
+# shape; afterwards absence means this tree never successfully selected a harness and dispatch stays inert.
+allowed="$slot/harnesses"
+if [ -f "$allowed" ]; then
+  grep -Fxq "$harness" "$allowed" || exit 0
+elif [ -f "$rt/harness-selection-v1" ]; then
+  exit 0
+fi
+
 # --- dispatch ---------------------------------------------------------------------------------------------
 if [ -n "${SPEX_HOOK_MANIFEST:-}" ]; then
   manifest="$SPEX_HOOK_MANIFEST"

package/spec-cli/src/cli.ts

@@ -1130,10 +1130,11 @@ if (cmd === 'serve') {
     const ok = mark(() => s.markState(st, { proposal: flag('propose') as any, note: flag('note'), sessionId: sess }))
     console.log(ok.ok ? `state -> ${st}${noteEcho(flag('note'))}` : ok.reason ?? noRecord())
   } else if (sub === 'session-fail') {
-    // the StopFailure hook marks its session (--session from the payload) as error (turn died on an API error)
-    const { s, sess, mark, noRecord } = await stateKit()
-    const failed = mark(() => s.markError(sess))
-    console.log(failed.ok ? 'marked error' : failed.reason ?? noRecord())
+    // StopFailure is one native source for the shared active-only turn-failure CAS. A declaration or explicit
+    // stop that landed first is authoritative, just as it is for Codex notifications and headless exits.
+    const { s, sess, mark } = await stateKit()
+    const failed = mark(() => s.markTurnFailure(sess, 'claude turn failed'))
+    console.log(failed.ok ? 'marked error' : failed.reason ?? 'noop (session is not live active)')
   } else if (sub === 'session-turn-fail') {
     // Headless adapters report an ephemeral turn's non-zero exit through this one shared CAS. A declaration
     // that landed before teardown wins, so a late child close can never erase an agent-authored state.
@@ -1143,7 +1144,7 @@ if (cmd === 'serve') {
       process.exit(2)
     }
     const { markHeadlessTurnFailure } = await import('./sessions.js')
-    console.log(markHeadlessTurnFailure(sessionId, harness, exitCode) ? `marked error (${harness} ${exitCode})` : 'noop (no active session record)')
+    console.log(markHeadlessTurnFailure(sessionId, harness, exitCode) ? `marked error (${harness} ${exitCode})` : 'noop (session is not live active)')
   } else if (sub === 'session-idle') {
     // the Notification(idle_prompt) hook marks its session (--session from the payload) idle when claude waits
     // at its prompt. INFERRED, so guarded active-only: it no-ops unless the current status is exactly `active`,

package/spec-cli/src/contract-filter.ts

@@ -1,8 +1,9 @@
-import { mkdirSync, readFileSync, rmSync, writeFileSync, chmodSync } from 'node:fs'
+import { mkdirSync, readFileSync, rmSync, writeFileSync, chmodSync, existsSync } from 'node:fs'
 import { join, relative } from 'node:path'
 import { execFileSync } from 'node:child_process'
 import { git } from './git.js'
 import { writeManagedBlock, removeManagedBlock } from './harness.js'
+import { encodeProject, runtimeRoot, treeSlotDir } from './layout.js'
 
 // @@@ contract-filter ([[content-filter]]) - the answer for a MIXED-CONTENT contract file: a
 // CLAUDE.md/AGENTS.md the HOST TRACKS — or has begun writing its OWN prose into — where "generate + ignore"
@@ -34,30 +35,54 @@ function commonDirOf(proj: string): string {
 const filterDir = (common: string) => join(common, 'spexcode')
 const shimPath = (common: string) => join(filterDir(common), 'contract-filter.sh')
 const blockPath = (common: string) => join(filterDir(common), 'contract-block.md')
+const rootPath = (common: string) => join(filterDir(common), 'contract-filter-root')
+const bindingsPath = (common: string) => join(filterDir(common), 'contract-filter-bindings')
+const treeFilterDir = (proj: string) => join(treeSlotDir(proj), 'contract-filter')
 const attributesPath = (common: string) => join(common, 'info', 'attributes')
 
-// the per-clone shim both filter directions run through. Pure shell/awk (no node boot on git's hot path),
-// mirroring writeManagedBlock/removeManagedBlock's normalization exactly so the two writers agree:
+const registeredSlots = (proj: string) => git(['-C', proj, 'worktree', 'list', '--porcelain', '-z']).split('\0')
+  .filter((row) => row.startsWith('worktree ')).map((row) =>
+    join(runtimeRoot(proj), 'trees', encodeProject(row.slice('worktree '.length))))
+const legacyFilterTree = (proj: string) => registeredSlots(proj)
+  .some((slot) => existsSync(join(slot, 'content-hash')) && !existsSync(join(slot, 'contract-filter-v2')))
+
+export type ContractFilterPayload = { file: string; content: string }
+export type ContractFilterBinding = { file: string; start: string; end: string; legacy?: boolean }
+
+// The common shim both filter directions run through. Pure shell/awk (no node boot on git's hot path), it
+// resolves the invoking checkout to that tree's payload before mirroring managed-block normalization:
 //   clean : drop the sentinel block (+ the blank line smudge printed before it) → the pristine host prose.
-//   smudge: clean first (defensive — a block already in the index can never double-inject), then append one
-//           blank line + START + the contract-block file's content + END.
+//   smudge: clean first (a block already in the index can never double-inject), then append the tree payload.
 // Byte-exactness holds for text ending in exactly one newline (git's own well-formed-text shape); a pristine
 // file ending in zero or 2+ newlines is normalized to one on the first round-trip and stable after.
 const SHIM = `#!/usr/bin/env bash
-# spexcode contract filter (generated by spex materialize; see [[content-filter]]).
-# clean(smudge(x)) == x: the repo keeps the pristine host prose, the working tree carries prose + block.
+# spexcode managed-text filter (generated by spex materialize; see [[content-filter]]).
+# One common driver selects the payload belonging to the Git checkout that invoked it.
 set -u
-mode="\${1:?usage: contract-filter.sh smudge|clean}"
+mode="\${1:?usage: contract-filter.sh smudge|clean <path>}"
+path="\${2:?usage: contract-filter.sh smudge|clean <path>}"
 here="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
-block="$here/contract-block.md"
+binding="$(awk -F '\t' -v p="$path" '$1 == p { print $2 "\t" $3 "\t" $4; exit }' "$here/contract-filter-bindings" 2>/dev/null)"
+[ -n "$binding" ] || { cat; exit 0; }
+start="\${binding%%$'\t'*}"; rest="\${binding#*$'\t'}"
+end="\${rest%%$'\t'*}"; legacy="\${rest#*$'\t'}"
+top="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+root="$(cat "$here/contract-filter-root" 2>/dev/null || true)"
+key="$(printf '%s' "$top" | sed 's#[/.]#-#g')"
+manifest="$root/trees/$key/contract-filter/manifest"
+payload="$(awk -F '\t' -v p="$path" '$1 == p { print $2; exit }' "$manifest" 2>/dev/null)"
+# A pre-v2 tree has only the old common payload. Once that tree materializes, its marker makes a missing
+# per-file payload mean identity (for example, AGENTS.md in a Claude-only tree), never global fallback.
+marker="$root/trees/$key/contract-filter-v2"
+if [ ! -r "$payload" ] && [ ! -f "$marker" ] && [ "$legacy" = 1 ] && [ -r "$here/contract-block.md" ]; then payload="$here/contract-block.md"; fi
 strip() {
-  awk 'BEGIN { n = 0 }
+  awk -v sline="$start" -v eline="$end" 'BEGIN { n = 0 }
     { lines[n++] = $0 }
     END {
       s = -1; e = -1
       for (i = 0; i < n; i++) {
-        if (lines[i] == "<!-- spexcode:start -->" && s < 0) s = i
-        if (lines[i] == "<!-- spexcode:end -->" && s >= 0 && e < 0) e = i
+        if (lines[i] == sline && s < 0) s = i
+        if (lines[i] == eline && s >= 0 && e < 0) e = i
       }
       if (s >= 0 && e >= s) {
         a = s; while (a > 0 && lines[a-1] == "") a--
@@ -66,24 +91,22 @@ strip() {
         for (i = 0; i < n; i++) if (i < a || i > b) lines[j++] = lines[i]
         n = j
       }
-      # NO leading-blank strip: dropping a..b (block + its surrounding blanks) can never CREATE a leading
-      # blank, and a host file that BEGINS with blank lines must keep them — clean(smudge(x)) == x.
       for (i = 0; i < n; i++) print lines[i]
     }'
 }
 case "$mode" in
   clean) strip ;;
   smudge)
-    if [ ! -r "$block" ]; then cat; exit 0; fi          # no block content → identity (graceful, never fatal)
-    strip | awk -v b="$block" 'BEGIN { n = 0 }
+    if [ ! -r "$payload" ]; then strip; exit 0; fi
+    strip | awk -v b="$payload" -v sline="$start" -v eline="$end" 'BEGIN { n = 0 }
       { lines[n++] = $0 }
       END {
-        while (n > 0 && lines[n-1] == "") n--           # trim trailing blanks (writeManagedBlock parity)
+        while (n > 0 && lines[n-1] == "") n--
         for (i = 0; i < n; i++) print lines[i]
         if (n > 0) print ""
-        print "<!-- spexcode:start -->"
+        print sline
         while ((getline l < b) > 0) print l
-        print "<!-- spexcode:end -->"
+        print eline
       }' ;;
   *) echo "contract-filter.sh: unknown mode $mode" >&2; exit 1 ;;
 esac
@@ -92,25 +115,37 @@ esac
 // edge ①: the command git runs is a tolerant wrapper — the shim path is an ARGUMENT ($0), and a missing/
 // unreadable shim degrades to `cat` (identity) instead of a per-operation fatal.
 const filterCmd = (shim: string, mode: 'smudge' | 'clean') =>
-  `sh -c 'test -r "$0" && exec bash "$0" ${mode} || exec cat' '${shim.replace(/'/g, `'\\''`)}'`
+  `sh -c 'test -r "$0" && exec bash "$0" ${mode} "$1" || exec cat' '${shim.replace(/'/g, `'\\''`)}' %f`
 
 // plant (or refresh) the filter for the given contract files (tracked, or untracked-with-host-content —
 // pre-armed): the shim + the block content it smudges, the per-clone git config, and the attribute lines
 // binding each file to the filter. Idempotent — every write is a full replace. `contract` is the assembled
 // block body (guide + surface:system). settleIndexStat skips untracked entries (no index blob) by design.
-export function plantContractFilter(proj: string, trackedFiles: string[], contract: string): void {
+export function plantContractFilter(proj: string, payloads: ContractFilterPayload[], bindings: ContractFilterBinding[]): void {
   const common = commonDirOf(proj)
   mkdirSync(filterDir(common), { recursive: true })
-  writeFileSync(blockPath(common), contract.endsWith('\n') ? contract : `${contract}\n`)   // edge ②: the shim's smudge source, refreshed with the materialize
   writeFileSync(shimPath(common), SHIM)
   chmodSync(shimPath(common), 0o755)
   git(['-C', proj, 'config', 'filter.spexcode.smudge', filterCmd(shimPath(common), 'smudge')])
   git(['-C', proj, 'config', 'filter.spexcode.clean', filterCmd(shimPath(common), 'clean')])
-  // attribute patterns are checkout-relative, so one line serves the main checkout and every worktree.
-  const entries = trackedFiles.map((f) => `/${relative(proj, f)} filter=spexcode`).sort().join('\n')
+  writeFileSync(bindingsPath(common), bindings.map((b) => `${b.file}\t${b.start}\t${b.end}\t${b.legacy ? 1 : 0}`).join('\n') + '\n')
+  const dir = treeFilterDir(proj)
+  rmSync(dir, { recursive: true, force: true }); mkdirSync(dir, { recursive: true })
+  const manifest: string[] = []
+  for (const [i, payload] of payloads.entries()) {
+    const target = join(dir, String(i))
+    writeFileSync(target, payload.content.endsWith('\n') ? payload.content : `${payload.content}\n`)
+    manifest.push(`${payload.file}\t${target}`)
+  }
+  const manifestPath = join(dir, 'manifest')
+  writeFileSync(manifestPath, manifest.join('\n') + (manifest.length ? '\n' : ''))
+  writeFileSync(rootPath(common), `${runtimeRoot(proj)}\n`)
+  // Attribute patterns are checkout-relative; the stable binding set is safe in the common git dir because
+  // the driver selects a payload from the invoking checkout's tree slot.
+  const entries = bindings.map((b) => `/${b.file} filter=spexcode`).sort().join('\n')
   mkdirSync(join(common, 'info'), { recursive: true })
   writeManagedBlock(attributesPath(common), entries, ['# ', ''])
-  settleIndexStat(proj, trackedFiles)
+  settleIndexStat(proj, payloads.map((p) => join(proj, p.file)))
 }
 
 // settle the index STAT for each file — the famous filtered-path phantom-`M`: git cannot verify a
@@ -139,15 +174,24 @@ export function settleIndexStat(proj: string, files: string[]): void {
 // the full inverse (edge ③ — call AFTER the managed blocks left the working files): attribute lines out,
 // config keys unset, shim + block content removed. `<common>/spexcode/` may host other spexcode data
 // (evidence blobs), so only OUR two files go, never the dir.
-export function removeContractFilter(proj: string): void {
+export function removeContractFilter(proj: string, files: string[] = [], final = false): void {
   let common: string
   try { common = commonDirOf(proj) } catch { return }   // not a git repo → nothing was ever planted
+  try { rmSync(treeFilterDir(proj), { recursive: true, force: true }) } catch { /* inaccessible tree */ }
+  settleIndexStat(proj, files)
+  const anotherPayload = registeredSlots(proj).some((slot) => existsSync(join(slot, 'contract-filter', 'manifest')))
+  const legacyTree = legacyFilterTree(proj)
+  if (!legacyTree) rmSync(blockPath(common), { force: true })
+  if (!final && (anotherPayload || legacyTree)) return
   removeManagedBlock(attributesPath(common), ['# ', ''], true)
   for (const key of ['filter.spexcode.smudge', 'filter.spexcode.clean']) {
-    try { git(['-C', proj, 'config', '--unset', key]) } catch { /* not set — already clean */ }
+    try { git(['-C', proj, 'config', '--unset-all', key]) } catch { /* not set — already clean */ }
   }
-  rmSync(shimPath(common), { force: true })
-  rmSync(blockPath(common), { force: true })
+  for (const path of [shimPath(common), blockPath(common), rootPath(common), bindingsPath(common)]) rmSync(path, { force: true })
+}
+
+export function retireLegacyContractBlock(proj: string): void {
+  if (!legacyFilterTree(proj)) rmSync(blockPath(commonDirOf(proj)), { force: true })
 }
 
 // is the filter currently planted? (the assert-side probe tests use; cheap: one config read)

package/spec-cli/src/git.ts

@@ -360,9 +360,36 @@ type EventStreamRequest = {
 }
 
 type EventPathMemo = EventCacheLocation & {
-  common: string; shallowPath: string; grafts: string; shallow: string; replacements: string
+  common: string; shallowPath: string; grafts: string; shallow: string
+  replacementStorage: string; replacements: string
 }
 const eventPathMemo = new Map<string, EventPathMemo>()
+function replacementStorageIdentity(common: string): string {
+  const hash = createHash('sha256')
+  const addTree = (root: string, rel: string) => {
+    if (!existsSync(root)) return
+    const stack = [{ dir: root, rel }]
+    while (stack.length) {
+      const current = stack.pop()!
+      const entries = readdirSync(current.dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))
+      for (const entry of entries) {
+        const path = join(current.dir, entry.name)
+        const name = `${current.rel}/${entry.name}`
+        if (entry.isDirectory()) stack.push({ dir: path, rel: name })
+        else hash.update(`\0${name}\0`).update(readFileSync(path))
+      }
+    }
+  }
+  addTree(join(common, 'refs', 'replace'), 'refs/replace')
+  for (const name of ['packed-refs']) {
+    const path = join(common, name)
+    if (existsSync(path)) hash.update(`\0${name}\0`).update(readFileSync(path))
+  }
+  // Reftable is opaque here by design: its bytes are only an invalidation signal. Git remains the one
+  // parser and supplies the canonical refs/replace targets when those bytes change.
+  addTree(join(common, 'reftable'), 'reftable')
+  return hash.digest('hex')
+}
 function eventCacheLocation(root: string): EventCacheLocation {
   const rootId = rootKey(root), old = eventPathMemo.get(rootId)
   const common = old?.common ?? git(['-C', root, 'rev-parse', '--path-format=absolute', '--git-common-dir']).trim()
@@ -370,7 +397,10 @@ function eventCacheLocation(root: string): EventCacheLocation {
   const shallow = existsSync(shallowPath) ? readFileSync(shallowPath, 'utf8') : 'unshallow'
   const graftsPath = join(common, 'info', 'grafts')
   const grafts = existsSync(graftsPath) ? readFileSync(graftsPath, 'utf8') : ''
-  const replacements = git(['-C', root, 'for-each-ref', 'refs/replace', '--format=%(refname) %(objectname)'])
+  const replacementStorage = replacementStorageIdentity(common)
+  const replacements = old?.replacementStorage === replacementStorage
+    ? old.replacements
+    : git(['-C', root, 'for-each-ref', 'refs/replace', '--format=%(refname) %(objectname)'])
   const objectFormat = gitObjectFormat(root)
   if (old && old.shallow === shallow && old.grafts === grafts && old.replacements === replacements && old.objectFormat === objectFormat)
     return { path: old.path, identity: old.identity, objectFormat }
@@ -382,7 +412,7 @@ function eventCacheLocation(root: string): EventCacheLocation {
   const gitDir = gitDirOf(root)
   const storeIdentity = gitDir === root && common === root ? join(common, '.git') : common
   const path = join(projectRuntimeRoot(storeIdentity), `${EVENT_CACHE_SCHEMA}-${identity}.ndjson`)
-  eventPathMemo.set(rootId, { common, shallowPath, grafts, shallow, replacements, path, identity, objectFormat })
+  eventPathMemo.set(rootId, { common, shallowPath, grafts, shallow, replacementStorage, replacements, path, identity, objectFormat })
   return { path, identity, objectFormat }
 }
 function emptyEventCache(): EventCache {
@@ -1002,38 +1032,45 @@ function canonicalPathProjector(
 }
 
 type SharedIndexInputs = {
-  allPathsOut: string
-  topologyOut: string
+  allPaths: Set<string>
+  specPaths: Set<string>
+  topology: TopologyProjection
   historyOut: string
   driftOut: string
   mergeIndex: MergeHistoryEvents
 }
 
+type TopologyProjection = {
+  order: Map<string, number>
+  parents: Map<string, string[]>
+  reachable: Set<string>
+}
+
 async function buildIndex(root: string, tip: string, transient: boolean, useCache = true, shared?: SharedIndexInputs): Promise<HistoryIndex> {
   const versions = new Map<string, Version[]>()
   const stats = new Map<string, Map<string, DiffStat>>()
   const mergeVersions = new Set<string>()
   const commitVersions = new Map<string, Version>()
   const commitOrder = new Map<string, number>()
-  const [tipPathsOut, topologyOut] = shared
-    ? [shared.allPathsOut, shared.topologyOut]
-    : await Promise.all([
+  const rawVersions = new Map<string, Version[]>()
+  const rawStats = new Map<string, Map<string, DiffStat>>()
+  let currentPaths: Set<string>
+  let topology: TopologyProjection
+  if (shared) {
+    currentPaths = shared.specPaths
+    topology = shared.topology
+  } else {
+    const [tipPathsOut, topologyOut] = await Promise.all([
       strictEventGit(['-C', root, '-c', 'core.quotePath=false', 'ls-tree', '-r', '-z', '--name-only', tip, '--', '.spec']),
       strictEventGit(['-C', root, 'rev-list', '--parents', tip]),
     ])
-  const rawVersions = new Map<string, Version[]>()
-  const rawStats = new Map<string, Map<string, DiffStat>>()
-  const currentPaths = new Set(tipPathsOut.split('\0').filter((path) => path.startsWith('.spec/')))
-  const renamesByFrom = new Map<string, { hash: string; to: string }[]>()
-  const topologyOrd = new Map<string, number>(), topologyParents = new Map<string, string[]>()
-  let topologyPosition = 0
-  for (const line of topologyOut.trim().split('\n')) {
-    if (!line) continue
-    const [hash, ...parents] = line.split(' ')
-    topologyOrd.set(hash, topologyPosition++)
-    topologyParents.set(hash, parents)
+    currentPaths = new Set(tipPathsOut.split('\0').filter((path) => path.startsWith('.spec/')))
+    topology = topologyProjection(topologyOut)
   }
-  const topologyReachable = new Set(topologyOrd.keys())
+  const renamesByFrom = new Map<string, { hash: string; to: string }[]>()
+  const topologyOrd = topology.order
+  const topologyParents = topology.parents
+  const topologyReachable = topology.reachable
   const out = shared?.historyOut ?? await eventStream(root, tip,
     indexEventRequests(root, tip, topologyOrd, topologyReachable).numstat, !transient, useCache)
   if (!out) return { versions, stats, mergeVersions }
@@ -1363,23 +1400,22 @@ async function buildDriftIndex(root: string, tip: string, transient: boolean, us
   const acks = new Map<string, Set<string>>(), selfAcks = new Map<string, Set<string>>(), specNodes = new Map<string, Set<string>>()
   const ackCandidates = new Map<string, Set<string>>(), trees = new Map<string, string>()
   const idx: DriftIndex = { tip, ord, parents, fileEvents, lineageEvents, lineageKeys: (path) => [path], resolutionEvents: new Map(), acks, selfAcks, specNodes, anc: new Map() }
-  const [tipPathsOut, topology] = shared
-    ? [shared.allPathsOut, shared.topologyOut]
-    : await Promise.all([
-      strictEventGit(['-C', root, '-c', 'core.quotePath=false', 'ls-tree', '-r', '-z', '--name-only', tip]),
+  let currentPaths: Set<string>
+  let topology: TopologyProjection
+  if (shared) {
+    currentPaths = shared.allPaths
+    topology = shared.topology
+  } else {
+    const [tipPathsOut, topologyOut] = await Promise.all([
+      strictEventGit(['-C', root, 'ls-tree', '-r', '-z', '--name-only', tip]),
       strictEventGit(['-C', root, 'rev-list', '--parents', tip]),
     ])
-  const currentPaths = new Set(tipPathsOut.split('\0').filter(Boolean))
-  const topologyOrder = new Map<string, number>(), topologyParents = new Map<string, string[]>(), topologyReachable = new Set<string>()
-  let topologyPosition = 0
-  for (const line of topology.trim().split('\n')) {
-    const [hash, ...parentList] = line.split(' ')
-    if (hash) {
-      topologyOrder.set(hash, topologyPosition++)
-      topologyParents.set(hash, parentList)
-      topologyReachable.add(hash)
-    }
+    currentPaths = new Set(tipPathsOut.split('\0').filter(Boolean))
+    topology = topologyProjection(topologyOut)
   }
+  const topologyOrder = topology.order
+  const topologyParents = topology.parents
+  const topologyReachable = topology.reachable
   // Numstat is the immutable identity event: unlike a name-only stream it records both sides of a rename,
   // allowing the same event-scoped projection used by spec history to follow forks and reject path reuse.
   const out = shared?.driftOut ?? await eventStream(root, tip,
@@ -1507,16 +1543,17 @@ export function driftIndex(root: string, tip = 'HEAD'): Promise<DriftIndex> {
   return p
 }
 
-function topologyProjection(out: string): { order: Map<string, number>; reachable: Set<string> } {
-  const order = new Map<string, number>(), reachable = new Set<string>()
+function topologyProjection(out: string): TopologyProjection {
+  const order = new Map<string, number>(), parents = new Map<string, string[]>(), reachable = new Set<string>()
   let position = 0
   for (const line of out.trim().split('\n')) {
-    const hash = line.split(' ', 1)[0]
+    const [hash, ...parentList] = line.split(' ')
     if (!hash) continue
     order.set(hash, position++)
+    parents.set(hash, parentList)
     reachable.add(hash)
   }
-  return { order, reachable }
+  return { order, parents, reachable }
 }
 
 async function buildIndexPair(root: string, tip: string, transient: boolean, useCache = true): Promise<[HistoryIndex, DriftIndex]> {
@@ -1525,11 +1562,14 @@ async function buildIndexPair(root: string, tip: string, transient: boolean, use
     strictEventGit(['-C', root, 'rev-list', '--parents', tip]),
   ])
   const topology = topologyProjection(topologyOut)
+  const allPaths = new Set(allPathsOut.split('\0').filter(Boolean))
+  const specPaths = new Set([...allPaths].filter((path) => path.startsWith('.spec/')))
   const requests = indexEventRequests(root, tip, topology.order, topology.reachable)
   const streams = await deriveEventStreams(root, tip, EVENT_STREAM_KINDS.map((kind) => requests[kind]), !transient, useCache)
   const shared: SharedIndexInputs = {
-    allPathsOut,
-    topologyOut,
+    allPaths,
+    specPaths,
+    topology,
     historyOut: streams.get('numstat') ?? '',
     driftOut: streams.get('drift-numstat') ?? '',
     mergeIndex: parseMergeHistoryEvents(streams.get('merge') ?? ''),