@namzu/sdk 14.0.7 → 15.0.0

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

@@ -1,209 +0,0 @@
-/**
- * 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

@@ -1,101 +0,0 @@
-/**
- * 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

@@ -1,328 +0,0 @@
-/**
- * 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,
-	ThreadId,
-} from '../../../types/session/ids.js'
-import type {
-	DeliverableRef,
-	SessionSummaryDeliverable,
-} from '../../../types/summary/deliverable.js'
-import {
-	ArtifactRefCycleError,
-	type InterventionChainLoader,
-	InterventionDepthExceeded,
-	validatePrevArtifactChain,
-} from '../../intervention/prev-artifact.js'
-import { DEFAULT_TENANT, agentActor, userActor } from './_fixtures.js'
-
-const TEST_THREAD_ID = 'thd_test' as ThreadId
-
-/**
- * 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(
-			{ threadId: TEST_THREAD_ID, 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(
-			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_a') },
-			DEFAULT_TENANT,
-		)
-		const sB = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_b') },
-			DEFAULT_TENANT,
-		)
-		const sC = await store.createSession(
-			{ threadId: TEST_THREAD_ID, 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)
-	})
-})