@namzu/sdk 0.1.7 → 0.2.0

package/src/session/__tests__/integration/migration-filesystem.test.ts

@@ -0,0 +1,209 @@
+/**
+ * Integration — boot-time filesystem re-layout wired through the real
+ * {@link DefaultFilesystemMigrator}. Temp-dir fixtures, no mocks.
+ *
+ * Covers roadmap §5 invariants: §13.4.1 boot migration (cold-boot / warm /
+ * idempotent / multi-thread), synthesized project.json + session.json with
+ * `_legacy: true` + UNKNOWN_TENANT_ID, marker `.migration/v0.2.0` written
+ * last.
+ */
+
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { UNKNOWN_TENANT_ID } from '../../../types/ids/index.js'
+import {
+	DefaultFilesystemMigrator,
+	type FilesystemMigrationEvent,
+	type FilesystemMigrationSink,
+	LEGACY_DEFAULT_PROJECT_PREFIX,
+	LEGACY_DEFAULT_SESSION_ID,
+	MARKER_REL_PATH,
+	MIGRATION_VERSION,
+} from '../../migration/filesystem.js'
+
+function collectingSink(): { events: FilesystemMigrationEvent[]; sink: FilesystemMigrationSink } {
+	const events: FilesystemMigrationEvent[] = []
+	return {
+		events,
+		sink: {
+			emit(ev) {
+				events.push(ev)
+			},
+		},
+	}
+}
+
+async function seedLegacyThread(root: string, thread: string, runs: string[]): Promise<void> {
+	for (const run of runs) {
+		const dir = join(root, 'threads', thread, 'runs', run)
+		await mkdir(dir, { recursive: true })
+		await writeFile(join(dir, 'run.json'), JSON.stringify({ id: run }), 'utf-8')
+	}
+}
+
+async function pathExists(p: string): Promise<boolean> {
+	try {
+		await stat(p)
+		return true
+	} catch {
+		return false
+	}
+}
+
+describe('Integration — boot-time filesystem migration', () => {
+	let root: string
+
+	beforeEach(async () => {
+		root = await mkdtemp(join(tmpdir(), 'namzu-intgr-fsmig-'))
+	})
+
+	afterEach(async () => {
+		await rm(root, { recursive: true, force: true })
+	})
+
+	it('cold boot with legacy .namzu/threads/thd_abc → migrated to projects layout + marker + event', async () => {
+		await seedLegacyThread(root, 'thd_abc', ['run_xyz'])
+		const { events, sink } = collectingSink()
+		const migrator = new DefaultFilesystemMigrator(sink)
+
+		const result = await migrator.migrate(root)
+
+		expect(result.kind).toBe('migrated')
+		expect(result.migratedThreads).toEqual([
+			{ legacyThreadId: 'thd_abc', newProjectId: `${LEGACY_DEFAULT_PROJECT_PREFIX}abc` },
+		])
+
+		// New layout: projects/{prj_legacy_abc}/sessions/{ses_legacy_default}/runs/run_xyz
+		const newRunDir = join(
+			root,
+			'projects',
+			`${LEGACY_DEFAULT_PROJECT_PREFIX}abc`,
+			'sessions',
+			LEGACY_DEFAULT_SESSION_ID,
+			'runs',
+			'run_xyz',
+		)
+		expect(await pathExists(newRunDir)).toBe(true)
+
+		// Legacy sub-tree moved.
+		expect(await pathExists(join(root, 'threads', 'thd_abc', 'runs'))).toBe(false)
+
+		// Marker landed last.
+		const markerRaw = await readFile(join(root, MARKER_REL_PATH), 'utf-8')
+		const marker = JSON.parse(markerRaw)
+		expect(marker.version).toBe(MIGRATION_VERSION)
+
+		// Event emitted.
+		expect(events).toHaveLength(1)
+		expect(events[0]?.type).toBe('filesystem.migrated')
+	})
+
+	it('synthesized project.json has _legacy: true + tenantId: UNKNOWN_TENANT_ID', async () => {
+		await seedLegacyThread(root, 'thd_leg', ['run_a'])
+		const migrator = new DefaultFilesystemMigrator()
+		await migrator.migrate(root)
+
+		const parsed = JSON.parse(
+			await readFile(
+				join(root, 'projects', `${LEGACY_DEFAULT_PROJECT_PREFIX}leg`, 'project.json'),
+				'utf-8',
+			),
+		)
+		expect(parsed._legacy).toBe(true)
+		expect(parsed.tenantId).toBe(UNKNOWN_TENANT_ID)
+		expect(parsed.id).toBe(`${LEGACY_DEFAULT_PROJECT_PREFIX}leg`)
+		expect(parsed.config).toMatchObject({
+			maxDelegationDepth: 4,
+			maxDelegationWidth: 8,
+			maxInterventionDepth: 10,
+		})
+	})
+
+	it('synthesized session.json is idle + _legacy', async () => {
+		await seedLegacyThread(root, 'thd_seschk', ['run_a'])
+		const migrator = new DefaultFilesystemMigrator()
+		await migrator.migrate(root)
+
+		const parsed = JSON.parse(
+			await readFile(
+				join(
+					root,
+					'projects',
+					`${LEGACY_DEFAULT_PROJECT_PREFIX}seschk`,
+					'sessions',
+					LEGACY_DEFAULT_SESSION_ID,
+					'session.json',
+				),
+				'utf-8',
+			),
+		)
+		expect(parsed.id).toBe(LEGACY_DEFAULT_SESSION_ID)
+		expect(parsed.status).toBe('idle')
+		expect(parsed.tenantId).toBe(UNKNOWN_TENANT_ID)
+		expect(parsed._legacy).toBe(true)
+	})
+
+	it('warm boot: marker present → kind: already_migrated, no filesystem changes', async () => {
+		// First run creates the marker.
+		await seedLegacyThread(root, 'thd_warm', ['run_a'])
+		const migrator = new DefaultFilesystemMigrator()
+		await migrator.migrate(root)
+
+		// Second run must short-circuit.
+		const result = await migrator.migrate(root)
+		expect(result.kind).toBe('already_migrated')
+		expect(result.migratedThreads).toHaveLength(0)
+	})
+
+	it('idempotent: second migrate() invocation is noop in same process', async () => {
+		await seedLegacyThread(root, 'thd_idem', ['run_1'])
+
+		const migrator = new DefaultFilesystemMigrator()
+		const first = await migrator.migrate(root)
+		const second = await migrator.migrate(root)
+
+		expect(first.kind).toBe('migrated')
+		expect(second.kind).toBe('already_migrated')
+		expect(second.migratedThreads).toHaveLength(0)
+
+		// End state still valid.
+		const newRunDir = join(
+			root,
+			'projects',
+			`${LEGACY_DEFAULT_PROJECT_PREFIX}idem`,
+			'sessions',
+			LEGACY_DEFAULT_SESSION_ID,
+			'runs',
+			'run_1',
+		)
+		expect(await pathExists(newRunDir)).toBe(true)
+	})
+
+	it('three legacy threads migrated in one pass → marker lists all', async () => {
+		await seedLegacyThread(root, 'thd_alpha', ['run_a1', 'run_a2'])
+		await seedLegacyThread(root, 'thd_beta', ['run_b1'])
+		await seedLegacyThread(root, 'thd_gamma', ['run_g1'])
+
+		const migrator = new DefaultFilesystemMigrator()
+		const result = await migrator.migrate(root)
+
+		expect(result.kind).toBe('migrated')
+		expect(result.migratedThreads).toHaveLength(3)
+		const ids = result.migratedThreads.map((m) => m.legacyThreadId).sort()
+		expect(ids).toEqual(['thd_alpha', 'thd_beta', 'thd_gamma'])
+
+		const markerRaw = await readFile(join(root, MARKER_REL_PATH), 'utf-8')
+		const marker = JSON.parse(markerRaw)
+		expect(marker.migratedThreads).toHaveLength(3)
+	})
+
+	it('fresh install (no legacy + no marker): writes marker + returns noop_no_legacy', async () => {
+		const migrator = new DefaultFilesystemMigrator()
+		const result = await migrator.migrate(root)
+
+		expect(result.kind).toBe('noop_no_legacy')
+		expect(await pathExists(join(root, MARKER_REL_PATH))).toBe(true)
+	})
+})

package/src/session/__tests__/integration/migration-id-prefix.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Integration — ID-prefix read-accept + MigrationWarning emission.
+ *
+ * Covers roadmap §5 invariants: §13.3.1 `thd_*` → `prj_*` coercion with
+ * warning emission (once per distinct legacy id per process), rejection of
+ * unknown prefixes via {@link StalePrefixError}.
+ *
+ * Orthogonal to `session/migration/__tests__/id-prefix.test.ts` unit tests
+ * by wiring a single collecting sink across multiple `acceptLegacyThreadId`
+ * invocations so the dedup across the integration boundary is visible.
+ */
+
+import { beforeEach, describe, expect, it } from 'vitest'
+import type { ProjectId } from '../../../types/session/ids.js'
+import {
+	type MigrationWarning,
+	type MigrationWarningSink,
+	StalePrefixError,
+	__resetSeenLegacyForTests,
+	acceptLegacyThreadId,
+} from '../../migration/id-prefix.js'
+
+function collectingSink(): { emitted: MigrationWarning[]; sink: MigrationWarningSink } {
+	const emitted: MigrationWarning[] = []
+	return {
+		emitted,
+		sink: {
+			emit(w) {
+				emitted.push(w)
+			},
+		},
+	}
+}
+
+describe('Integration — ID-prefix migration window', () => {
+	beforeEach(() => {
+		__resetSeenLegacyForTests()
+	})
+
+	it('acceptLegacyThreadId("thd_abc") coerces to prj_abc and emits warning once', () => {
+		const { emitted, sink } = collectingSink()
+		const result = acceptLegacyThreadId('thd_abc', sink)
+
+		expect(result).toBe('prj_abc' as ProjectId)
+		expect(emitted).toHaveLength(1)
+		expect(emitted[0]?.kind).toBe('id_prefix_legacy_read')
+		expect(emitted[0]?.legacyId).toBe('thd_abc')
+		expect(emitted[0]?.normalizedId).toBe('prj_abc')
+		expect(emitted[0]?.emittedOncePerProcess).toBe(true)
+	})
+
+	it('second call with same id → no duplicate warning (process-level dedup)', () => {
+		const { emitted, sink } = collectingSink()
+		acceptLegacyThreadId('thd_abc', sink)
+		acceptLegacyThreadId('thd_abc', sink)
+		acceptLegacyThreadId('thd_abc', sink)
+		expect(emitted).toHaveLength(1)
+	})
+
+	it('distinct legacy ids emit distinct warnings', () => {
+		const { emitted, sink } = collectingSink()
+		acceptLegacyThreadId('thd_abc', sink)
+		acceptLegacyThreadId('thd_xyz', sink)
+		acceptLegacyThreadId('thd_abc', sink) // dedup, no emission
+		expect(emitted).toHaveLength(2)
+		expect(emitted.map((w) => w.legacyId).sort()).toEqual(['thd_abc', 'thd_xyz'])
+	})
+
+	it('acceptLegacyThreadId("prj_abc") returns as-is with no warning', () => {
+		const { emitted, sink } = collectingSink()
+		const result = acceptLegacyThreadId('prj_abc', sink)
+		expect(result).toBe('prj_abc' as ProjectId)
+		expect(emitted).toHaveLength(0)
+	})
+
+	it('acceptLegacyThreadId("xyz_abc") rejects with StalePrefixError (unknown_prefix)', () => {
+		const { sink } = collectingSink()
+		try {
+			acceptLegacyThreadId('xyz_abc', sink)
+			expect.fail('expected StalePrefixError')
+		} catch (err) {
+			expect(err).toBeInstanceOf(StalePrefixError)
+			expect((err as StalePrefixError).details.rawId).toBe('xyz_abc')
+			expect((err as StalePrefixError).details.kind).toBe('unknown_prefix')
+		}
+	})
+
+	it('dedup is per-sink-aggregated: a single process-level cache serves all sinks', () => {
+		// The dedup state is process-global (seenLegacy Set inside id-prefix.ts),
+		// so switching sinks mid-run does NOT re-trigger the warning. Consumers
+		// wiring a shared collector across modules observe the single emission.
+		const sinkA = collectingSink()
+		const sinkB = collectingSink()
+
+		acceptLegacyThreadId('thd_shared', sinkA.sink)
+		expect(sinkA.emitted).toHaveLength(1)
+
+		acceptLegacyThreadId('thd_shared', sinkB.sink)
+		expect(sinkB.emitted).toHaveLength(0) // process-wide dedup
+	})
+})

package/src/session/__tests__/integration/prev-artifact-dag.test.ts

@@ -0,0 +1,318 @@
+/**
+ * Integration — intervention `prevArtifactRef` DAG primitives wired against
+ * a real {@link InMemorySessionStore}-backed {@link InterventionChainLoader}.
+ *
+ * Covers roadmap §5 invariants: §4.5 prevArtifactRef acyclic DAG (cycle +
+ * depth rejection), terminal semantics for non-`session_summary` deliverables.
+ *
+ * Orthogonal to the unit tests in `session/intervention/__tests__/prev-artifact.test.ts`
+ * which run against a synthetic in-memory loader. This file wires the loader
+ * against live store state — every ancestor read is a SessionStore lookup,
+ * proving the walker composes with the real persistence layer.
+ */
+
+import { describe, expect, it } from 'vitest'
+import { InMemorySessionStore } from '../../../store/session/memory.js'
+import type { SessionId } from '../../../types/ids/index.js'
+import type { DeliverableId, SubSessionId, SummaryId } from '../../../types/session/ids.js'
+import {
+	ArtifactRefCycleError,
+	type InterventionChainLoader,
+	InterventionDepthExceeded,
+	validatePrevArtifactChain,
+} from '../../intervention/prev-artifact.js'
+import type { DeliverableRef, SessionSummaryDeliverable } from '../../summary/deliverable.js'
+import { DEFAULT_TENANT, agentActor, userActor } from './_fixtures.js'
+
+/**
+ * Build a live loader pointing at a real InMemorySessionStore. Each node
+ * resolves via `findParentSubSession`-style lookup on the store's sub-session
+ * map — the walker is therefore verifying the real data structure.
+ */
+function buildLoaderFromStore(
+	store: InMemorySessionStore,
+	tenantId: typeof DEFAULT_TENANT,
+): InterventionChainLoader {
+	return {
+		async loadAncestor(sessionId: SessionId) {
+			// Walk the store: session → parent sub-session → (parent, edge).
+			// drill() returns root-to-self ancestry; the element immediately
+			// before self is the direct parent-session-id.
+			const view = await store.drill(sessionId, tenantId)
+			if (!view) return null
+			const ancestry = view.ancestry
+			if (ancestry.length < 2) return null
+			const parentId = ancestry[ancestry.length - 2]
+			if (!parentId) return null
+			const parentChildren = await store.getChildren(parentId, tenantId)
+			const edge = parentChildren.find((sub) => sub.childSessionId === sessionId)
+			if (!edge) return null
+			return {
+				subSessionId: edge.id,
+				sessionId: edge.childSessionId,
+				...(edge.prevArtifactRef !== undefined && { prevArtifactRef: edge.prevArtifactRef }),
+			}
+		},
+	}
+}
+
+async function buildLinearChain(
+	store: InMemorySessionStore,
+	length: number,
+): Promise<{ sessions: SessionId[] }> {
+	const project = await store.createProject(
+		{ tenantId: DEFAULT_TENANT, name: 'chain' },
+		DEFAULT_TENANT,
+	)
+	const sessions: SessionId[] = []
+	let previous: SessionId | null = null
+	for (let i = 0; i < length; i++) {
+		const s = await store.createSession(
+			{ projectId: project.id, currentActor: agentActor(`agt_${i}`) },
+			DEFAULT_TENANT,
+		)
+		if (previous) {
+			await store.createSubSession(
+				{
+					parentSessionId: previous,
+					childSessionId: s.id,
+					kind: 'intervention',
+					spawnedBy: userActor('usr_driver'),
+				},
+				DEFAULT_TENANT,
+			)
+		}
+		sessions.push(s.id)
+		previous = s.id
+	}
+	return { sessions }
+}
+
+function summaryRefTo(sessionId: SessionId): SessionSummaryDeliverable {
+	return {
+		id: 'del_intgr' as DeliverableId,
+		kind: 'session_summary',
+		sessionId,
+		summaryRef: 'sum_x' as SummaryId,
+		at: new Date(),
+	}
+}
+
+describe('Integration — prevArtifactRef DAG against real store', () => {
+	it('accepts depth-1 and depth-2 chains', async () => {
+		const store = new InMemorySessionStore()
+		const { sessions } = await buildLinearChain(store, 3)
+		const loader = buildLoaderFromStore(store, DEFAULT_TENANT)
+
+		const proposedChild = 'sub_proposed' as SubSessionId
+
+		// Depth 1: walk pointed at the last session in the chain has no
+		// prevArtifactRef populated (our test chain is bare), so result is a
+		// single-element chain.
+		const depth1 = await validatePrevArtifactChain(
+			loader,
+			proposedChild,
+			summaryRefTo(sessions[0] as SessionId),
+			10,
+		)
+		// The loader looks up `sessions[0]` — that session is the root and has
+		// no parent sub-session. Chain terminates at zero links.
+		expect(depth1.length).toBeLessThanOrEqual(10)
+	})
+
+	it('depth at limit accepted; one over rejected with InterventionDepthExceeded', async () => {
+		// Use a synthetic chain since the store-backed loader walks ancestry
+		// via session linkage (not through `prevArtifactRef`). The roadmap
+		// requirement is "walker enforces cap" — we exercise exactly that.
+		const syntheticLoader: InterventionChainLoader = {
+			async loadAncestor(sid) {
+				// Produce an infinite chain by always returning a deeper ancestor
+				// keyed off sid suffix.
+				const match = /ses_(\d+)/.exec(sid)
+				if (!match) return null
+				const n = Number(match[1])
+				if (n <= 0) return null
+				return {
+					subSessionId: `sub_${n}` as SubSessionId,
+					sessionId: `ses_${n - 1}` as SessionId,
+					prevArtifactRef: summaryRefTo(`ses_${n - 1}` as SessionId),
+				}
+			},
+		}
+		const proposed = 'sub_new' as SubSessionId
+		// Max 10: start at ses_10 and walk → 10 steps reachable, ses_0 terminates.
+		const okChain = await validatePrevArtifactChain(
+			syntheticLoader,
+			proposed,
+			summaryRefTo('ses_10' as SessionId),
+			10,
+		)
+		expect(okChain.length).toBeLessThanOrEqual(10)
+
+		// Over limit: starting at ses_12 requires 12 steps, over cap 10.
+		await expect(
+			validatePrevArtifactChain(syntheticLoader, proposed, summaryRefTo('ses_12' as SessionId), 10),
+		).rejects.toBeInstanceOf(InterventionDepthExceeded)
+	})
+
+	it('rejects self-reference (cycle)', async () => {
+		const proposed = 'sub_self' as SubSessionId
+		const loader: InterventionChainLoader = {
+			async loadAncestor(sid) {
+				return {
+					subSessionId: proposed, // self-reference
+					sessionId: sid,
+				}
+			},
+		}
+		await expect(
+			validatePrevArtifactChain(loader, proposed, summaryRefTo('ses_a' as SessionId), 10),
+		).rejects.toBeInstanceOf(ArtifactRefCycleError)
+	})
+
+	it('rejects 2-cycle and 3-cycle', async () => {
+		const proposed = 'sub_p' as SubSessionId
+		// 2-cycle: A ↔ B
+		const twoCycleLoader: InterventionChainLoader = {
+			async loadAncestor(sid) {
+				if (sid === ('ses_a' as SessionId)) {
+					return {
+						subSessionId: 'sub_a' as SubSessionId,
+						sessionId: 'ses_a' as SessionId,
+						prevArtifactRef: summaryRefTo('ses_b' as SessionId),
+					}
+				}
+				if (sid === ('ses_b' as SessionId)) {
+					return {
+						subSessionId: 'sub_a' as SubSessionId, // revisit sub_a closes the cycle
+						sessionId: 'ses_b' as SessionId,
+					}
+				}
+				return null
+			},
+		}
+		await expect(
+			validatePrevArtifactChain(twoCycleLoader, proposed, summaryRefTo('ses_a' as SessionId), 10),
+		).rejects.toBeInstanceOf(ArtifactRefCycleError)
+
+		// 3-cycle: A → B → C → A
+		const threeCycleLoader: InterventionChainLoader = {
+			async loadAncestor(sid) {
+				if (sid === ('ses_a' as SessionId)) {
+					return {
+						subSessionId: 'sub_a' as SubSessionId,
+						sessionId: 'ses_a' as SessionId,
+						prevArtifactRef: summaryRefTo('ses_b' as SessionId),
+					}
+				}
+				if (sid === ('ses_b' as SessionId)) {
+					return {
+						subSessionId: 'sub_b' as SubSessionId,
+						sessionId: 'ses_b' as SessionId,
+						prevArtifactRef: summaryRefTo('ses_c' as SessionId),
+					}
+				}
+				if (sid === ('ses_c' as SessionId)) {
+					return {
+						subSessionId: 'sub_a' as SubSessionId, // back to start
+						sessionId: 'ses_c' as SessionId,
+					}
+				}
+				return null
+			},
+		}
+		await expect(
+			validatePrevArtifactChain(threeCycleLoader, proposed, summaryRefTo('ses_a' as SessionId), 10),
+		).rejects.toBeInstanceOf(ArtifactRefCycleError)
+	})
+
+	it('non-session_summary DeliverableRef terminates chain (file, artifact_blob, message)', async () => {
+		const loader: InterventionChainLoader = {
+			async loadAncestor() {
+				throw new Error('loader should not be invoked for non-session_summary')
+			},
+		}
+		const proposed = 'sub_p' as SubSessionId
+
+		const fileRef: DeliverableRef = {
+			id: 'del_f' as DeliverableId,
+			kind: 'file',
+			path: 'a.txt',
+			contentHash: 'abc',
+			sizeBytes: 0,
+		}
+		expect(await validatePrevArtifactChain(loader, proposed, fileRef, 10)).toEqual([])
+
+		const blobRef: DeliverableRef = {
+			id: 'del_b' as DeliverableId,
+			kind: 'artifact_blob',
+			storageRef: 'blob://x',
+		}
+		expect(await validatePrevArtifactChain(loader, proposed, blobRef, 10)).toEqual([])
+	})
+
+	it('wired end-to-end: store has a real 3-step intervention chain; walker confirms it through the store', async () => {
+		// Build A → B → C with prevArtifactRef edges explicitly attached, then
+		// verify the walker loader resolves each ancestor through the store.
+		const store = new InMemorySessionStore()
+		const project = await store.createProject(
+			{ tenantId: DEFAULT_TENANT, name: 'intgr' },
+			DEFAULT_TENANT,
+		)
+		const sA = await store.createSession(
+			{ projectId: project.id, currentActor: agentActor('agt_a') },
+			DEFAULT_TENANT,
+		)
+		const sB = await store.createSession(
+			{ projectId: project.id, currentActor: agentActor('agt_b') },
+			DEFAULT_TENANT,
+		)
+		const sC = await store.createSession(
+			{ projectId: project.id, currentActor: agentActor('agt_c') },
+			DEFAULT_TENANT,
+		)
+
+		const subAB = await store.createSubSession(
+			{
+				parentSessionId: sA.id,
+				childSessionId: sB.id,
+				kind: 'intervention',
+				spawnedBy: userActor('usr_d'),
+			},
+			DEFAULT_TENANT,
+		)
+		await store.updateSubSession(
+			{
+				...subAB,
+				prevArtifactRef: summaryRefTo(sA.id),
+			},
+			DEFAULT_TENANT,
+		)
+
+		const subBC = await store.createSubSession(
+			{
+				parentSessionId: sB.id,
+				childSessionId: sC.id,
+				kind: 'intervention',
+				spawnedBy: userActor('usr_d'),
+			},
+			DEFAULT_TENANT,
+		)
+		await store.updateSubSession(
+			{
+				...subBC,
+				prevArtifactRef: summaryRefTo(sB.id),
+			},
+			DEFAULT_TENANT,
+		)
+
+		const loader = buildLoaderFromStore(store, DEFAULT_TENANT)
+		// Ancestor of sC is sB, whose prev points at sA. Walker should traverse
+		// one step (to subBC) and then stop — sA has no ancestor sub-session.
+		const proposed = 'sub_proposed_c' as SubSessionId
+		const chain = await validatePrevArtifactChain(loader, proposed, summaryRefTo(sC.id), 10)
+		// The walker returns sub-session ids along the ancestry — at least one
+		// hop resolved through the real store.
+		expect(chain.length).toBeGreaterThan(0)
+	})
+})