@namzu/sdk 14.0.7 → 15.0.0

package/src/session/handoff/__tests__/single.test.ts

@@ -1,333 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { ThreadManager } from '../../../manager/thread/lifecycle.js'
-import { TenantIsolationError } from '../../../session/errors.js'
-import {
-	type ExecFile,
-	type ExecFileResult,
-	GitWorktreeDriver,
-} from '../../../session/workspace/git-worktree.js'
-import { WorkspaceBackendRegistry } from '../../../session/workspace/registry.js'
-import { InMemorySessionStore } from '../../../store/session/memory.js'
-import { InMemoryThreadStore } from '../../../store/thread/memory.js'
-import type { AgentId, SessionId, TenantId, UserId } from '../../../types/ids/index.js'
-import type { ActorRef } from '../../../types/session/actor.js'
-import { generateHandoffId } from '../../../utils/id.js'
-import type { HandoffAssignment } from '../assignment.js'
-import { DefaultCapacityValidator } from '../capacity.js'
-import { DelegationCapacityExceeded } from '../capacity.js'
-import type {
-	HandoffBroadcastRollbackEvent,
-	HandoffCommittedEvent,
-	HandoffEventSink,
-	HandoffLockedEvent,
-	HandoffUnlockedEvent,
-} from '../events.js'
-import { type RunStatusResolver, type SingleHandoffDeps, executeSingleHandoff } from '../single.js'
-import { HandoffLockRejected, HandoffVersionConflict } from '../version.js'
-
-const tenant = 'tnt_alpha' as TenantId
-const otherTenant = 'tnt_beta' as TenantId
-
-function stubLogger() {
-	return {
-		debug: vi.fn(),
-		info: vi.fn(),
-		warn: vi.fn(),
-		error: vi.fn(),
-		child() {
-			return stubLogger()
-		},
-	}
-}
-
-function okExec(stdout = '', stderr = ''): ExecFileResult {
-	return { stdout, stderr }
-}
-
-function user(kind = 'usr_a'): ActorRef {
-	return { kind: 'user', userId: kind as UserId, tenantId: tenant }
-}
-
-function agent(): ActorRef {
-	return { kind: 'agent', agentId: 'agt_a' as AgentId, tenantId: tenant }
-}
-
-interface MockedHandoffEventSink extends HandoffEventSink {
-	onLocked: ReturnType<typeof vi.fn<(ev: HandoffLockedEvent) => void>>
-	onUnlocked: ReturnType<typeof vi.fn<(ev: HandoffUnlockedEvent) => void>>
-	onCommitted: ReturnType<typeof vi.fn<(ev: HandoffCommittedEvent) => void>>
-	onBroadcastRollback: ReturnType<typeof vi.fn<(ev: HandoffBroadcastRollbackEvent) => void>>
-}
-
-function buildDeps(
-	store: InMemorySessionStore,
-	threadStore: InMemoryThreadStore,
-	execOverride?: ExecFile,
-	runResolver?: RunStatusResolver,
-): { deps: SingleHandoffDeps; events: MockedHandoffEventSink; execCalls: string[] } {
-	const execCalls: string[] = []
-	const exec: ExecFile = execOverride
-		? execOverride
-		: async (_file, args) => {
-				execCalls.push(args.join(' '))
-				return okExec()
-			}
-	const driver = new GitWorktreeDriver({
-		repoRoot: '/repo',
-		logger: stubLogger(),
-		execFile: exec,
-	})
-	const registry = new WorkspaceBackendRegistry()
-	registry.register(driver)
-
-	const events: MockedHandoffEventSink = {
-		onLocked: vi.fn<(ev: HandoffLockedEvent) => void>(),
-		onUnlocked: vi.fn<(ev: HandoffUnlockedEvent) => void>(),
-		onCommitted: vi.fn<(ev: HandoffCommittedEvent) => void>(),
-		onBroadcastRollback: vi.fn<(ev: HandoffBroadcastRollbackEvent) => void>(),
-	}
-
-	const threadManager = new ThreadManager({ threadStore, sessionStore: store })
-	const deps: SingleHandoffDeps = {
-		store,
-		workspaceRegistry: registry,
-		capacity: new DefaultCapacityValidator(store),
-		events,
-		threadManager,
-		...(runResolver !== undefined && { runStatus: runResolver }),
-	}
-
-	return { deps, events, execCalls }
-}
-
-async function seedIdle(store: InMemorySessionStore, threadStore: InMemoryThreadStore) {
-	const project = await store.createProject({ tenantId: tenant, name: 'p' }, tenant)
-	const thread = await threadStore.createThread(
-		{ projectId: project.id, title: 'handoff-single-test' },
-		tenant,
-	)
-	const session = await store.createSession(
-		{ threadId: thread.id, projectId: project.id, currentActor: user('usr_source') },
-		tenant,
-	)
-	return { project, thread, session }
-}
-
-function buildAssignment(
-	sourceSessionId: SessionId,
-	projectId: Awaited<ReturnType<InMemorySessionStore['createProject']>>['id'],
-	threadId: Awaited<ReturnType<InMemoryThreadStore['createThread']>>['id'],
-	expectedOwnerVersion: number,
-	recipient: ActorRef = user('usr_target'),
-): HandoffAssignment {
-	return {
-		id: generateHandoffId(),
-		mode: 'single',
-		sourceSessionId,
-		tenantId: tenant,
-		threadId,
-		projectId,
-		sourceActor: user('usr_source'),
-		recipientActor: recipient,
-		expectedOwnerVersion,
-		createdAt: new Date('2026-02-01'),
-	}
-}
-
-describe('executeSingleHandoff', () => {
-	let store: InMemorySessionStore
-	let threadStore: InMemoryThreadStore
-
-	beforeEach(() => {
-		store = new InMemorySessionStore()
-		threadStore = new InMemoryThreadStore()
-	})
-
-	it('happy path: idle source → lock → commit → outcome populated + source mutated', async () => {
-		const { project, thread, session } = await seedIdle(store, threadStore)
-		const { deps, events } = buildDeps(store, threadStore)
-
-		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
-		const outcome = await executeSingleHandoff(deps, assignment, tenant)
-
-		expect(outcome.assignmentId).toBe(assignment.id)
-		expect(outcome.workspaceId.startsWith('wsp_')).toBe(true)
-		expect(outcome.newSessionId.startsWith('ses_')).toBe(true)
-		expect(outcome.committedOwnerVersion).toBe(1)
-
-		const reloaded = await store.getSession(session.id, tenant)
-		expect(reloaded?.status).toBe('idle')
-		expect(reloaded?.ownerVersion).toBe(1)
-		expect(reloaded?.previousActors).toHaveLength(1)
-		expect(reloaded?.currentActor).toEqual(assignment.recipientActor)
-
-		// Events fire in order: locked then committed.
-		expect(events.onLocked).toHaveBeenCalledTimes(1)
-		expect(events.onCommitted).toHaveBeenCalledTimes(1)
-		expect(events.onUnlocked).not.toHaveBeenCalled()
-	})
-
-	it('rejects when source session is non-idle (active → HandoffLockRejected with active_run)', async () => {
-		const { project, thread, session } = await seedIdle(store, threadStore)
-		await store.updateSession({ ...session, status: 'active' }, tenant)
-
-		const { deps } = buildDeps(store, threadStore)
-		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
-
-		try {
-			await executeSingleHandoff(deps, assignment, tenant)
-			expect.fail('expected HandoffLockRejected')
-		} catch (err) {
-			expect(err).toBeInstanceOf(HandoffLockRejected)
-			expect((err as HandoffLockRejected).details.reason).toBe('active_run')
-		}
-	})
-
-	it('rejects when Run resolver reports pending_hitl', async () => {
-		const { project, thread, session } = await seedIdle(store, threadStore)
-		const resolver: RunStatusResolver = {
-			async blockingRun() {
-				return { reason: 'pending_hitl' }
-			},
-		}
-		const { deps } = buildDeps(store, threadStore, undefined, resolver)
-		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
-
-		try {
-			await executeSingleHandoff(deps, assignment, tenant)
-			expect.fail('expected HandoffLockRejected')
-		} catch (err) {
-			expect(err).toBeInstanceOf(HandoffLockRejected)
-			expect((err as HandoffLockRejected).details.reason).toBe('pending_hitl')
-		}
-	})
-
-	it('rejects on tenant mismatch (TenantIsolationError)', async () => {
-		const { project, thread, session } = await seedIdle(store, threadStore)
-		const { deps } = buildDeps(store, threadStore)
-		// Assignment tenant differs from the call-site tenant.
-		const assignment: HandoffAssignment = {
-			...buildAssignment(session.id, project.id, thread.id, 0),
-			tenantId: otherTenant,
-		}
-		await expect(executeSingleHandoff(deps, assignment, otherTenant)).rejects.toBeInstanceOf(
-			TenantIsolationError,
-		)
-	})
-
-	it('rejects on CAS mismatch (HandoffVersionConflict)', async () => {
-		const { project, thread, session } = await seedIdle(store, threadStore)
-		const { deps } = buildDeps(store, threadStore)
-
-		// Simulate a concurrent bump: move ownerVersion to 1 before the assignment
-		// with expectedOwnerVersion=0 is executed.
-		await store.updateSession({ ...session, ownerVersion: 1 }, tenant)
-		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
-
-		try {
-			await executeSingleHandoff(deps, assignment, tenant)
-			expect.fail('expected HandoffVersionConflict')
-		} catch (err) {
-			expect(err).toBeInstanceOf(HandoffVersionConflict)
-			expect((err as HandoffVersionConflict).details.expected).toBe(0)
-			expect((err as HandoffVersionConflict).details.actual).toBe(1)
-		}
-	})
-
-	it('depth cap enforcement rejects with DelegationCapacityExceeded (dimension=depth)', async () => {
-		// Build a chain so the handoff source already sits at max depth.
-		const project = await store.createProject({ tenantId: tenant, name: 'p' }, tenant)
-		const thread = await threadStore.createThread(
-			{ projectId: project.id, title: 'depth-cap' },
-			tenant,
-		)
-		// Set a tight limit on the project via a second createProject? — no, the
-		// store hardcodes defaults {4,8,10}. Build a depth-4 chain then attempt
-		// handoff on depth-4 node (ancestry length 5 > 4).
-		const root = await store.createSession(
-			{ threadId: thread.id, projectId: project.id, currentActor: user('usr_source') },
-			tenant,
-		)
-		let parent = root.id
-		let tail: SessionId = root.id
-		for (let i = 0; i < 4; i++) {
-			const child = await store.createSession(
-				{ threadId: thread.id, projectId: project.id, currentActor: user(`usr_${i}`) },
-				tenant,
-			)
-			await store.createSubSession(
-				{
-					parentSessionId: parent,
-					childSessionId: child.id,
-					kind: 'agent_spawn',
-					spawnedBy: agent(),
-				},
-				tenant,
-			)
-			parent = child.id
-			tail = child.id
-		}
-
-		// Source is `tail` at ancestry length 5 → depth-capacity with limit 4 rejects.
-		const { deps } = buildDeps(store, threadStore)
-		const assignment = buildAssignment(tail, project.id, thread.id, 0)
-		await expect(executeSingleHandoff(deps, assignment, tenant)).rejects.toBeInstanceOf(
-			DelegationCapacityExceeded,
-		)
-	})
-
-	it('compensating revert: workspace provisioning failure reverts source to idle, version unchanged, onUnlocked fires', async () => {
-		const { project, thread, session } = await seedIdle(store, threadStore)
-
-		// Fail only on `worktree add` but pass for everything else. Here we fail
-		// the single worktree add.
-		const exec: ExecFile = async (_file, args) => {
-			if (args.includes('add')) {
-				throw new Error('simulated git worktree add failure')
-			}
-			return okExec()
-		}
-		const { deps, events } = buildDeps(store, threadStore, exec)
-		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
-
-		await expect(executeSingleHandoff(deps, assignment, tenant)).rejects.toThrow(
-			/Workspace backend git-worktree failed on create/,
-		)
-
-		// Source is back to idle, ownerVersion unchanged.
-		const reloaded = await store.getSession(session.id, tenant)
-		expect(reloaded?.status).toBe('idle')
-		expect(reloaded?.ownerVersion).toBe(0)
-		expect(reloaded?.previousActors).toHaveLength(0)
-
-		// onLocked fired, then onUnlocked, no onCommitted.
-		expect(events.onLocked).toHaveBeenCalledTimes(1)
-		expect(events.onUnlocked).toHaveBeenCalledTimes(1)
-		expect(events.onCommitted).not.toHaveBeenCalled()
-	})
-
-	it('compensating revert: store.createSubSession failure still reverts + archives partial recipient', async () => {
-		const { project, thread, session } = await seedIdle(store, threadStore)
-
-		// Monkey-patch createSubSession on the store to throw.
-		const original = store.createSubSession.bind(store)
-		store.createSubSession = async () => {
-			throw new Error('simulated createSubSession failure')
-		}
-
-		const { deps, events } = buildDeps(store, threadStore)
-		const assignment = buildAssignment(session.id, project.id, thread.id, 0)
-
-		await expect(executeSingleHandoff(deps, assignment, tenant)).rejects.toThrow(
-			/createSubSession failure/,
-		)
-
-		// Restore for subsequent tests (though beforeEach makes this moot).
-		store.createSubSession = original
-
-		const reloaded = await store.getSession(session.id, tenant)
-		expect(reloaded?.status).toBe('idle')
-		expect(reloaded?.ownerVersion).toBe(0)
-		expect(events.onUnlocked).toHaveBeenCalledTimes(1)
-	})
-})

package/src/session/intervention/__tests__/prev-artifact.test.ts

@@ -1,237 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { SessionId } from '../../../types/ids/index.js'
-import type { DeliverableId, SubSessionId, SummaryId } from '../../../types/session/ids.js'
-import type {
-	DeliverableRef,
-	SessionSummaryDeliverable,
-} from '../../../types/summary/deliverable.js'
-import {
-	ArtifactRefCycleError,
-	type InterventionChainLoader,
-	InterventionDepthExceeded,
-	type PrevArtifactNode,
-	validatePrevArtifactChain,
-} from '../prev-artifact.js'
-
-// Helpers -------------------------------------------------------------------
-
-function sessionId(n: number): SessionId {
-	return `ses_${n}` as SessionId
-}
-
-function subId(n: number): SubSessionId {
-	return `sub_${n}` as SubSessionId
-}
-
-function summaryDeliverable(targetSession: SessionId): SessionSummaryDeliverable {
-	return {
-		id: 'del_test' as DeliverableId,
-		kind: 'session_summary',
-		sessionId: targetSession,
-		summaryRef: 'sum_test' as SummaryId,
-		at: new Date('2026-04-17T00:00:00Z'),
-	}
-}
-
-/**
- * Build a loader that walks a pre-configured chain. `chain[i]` is the node
- * returned for the i'th step (keyed by the session id the previous step
- * targeted). `nodesBySession` keys the loader by `sessionId`.
- */
-function buildLoader(
-	nodes: Array<PrevArtifactNode & { bySession: SessionId }>,
-): InterventionChainLoader {
-	const map = new Map<SessionId, PrevArtifactNode>()
-	for (const n of nodes) {
-		map.set(n.bySession, {
-			subSessionId: n.subSessionId,
-			sessionId: n.sessionId,
-			...(n.prevArtifactRef !== undefined && { prevArtifactRef: n.prevArtifactRef }),
-		})
-	}
-	return {
-		loadAncestor: async (sid) => map.get(sid) ?? null,
-	}
-}
-
-describe('validatePrevArtifactChain', () => {
-	it('accepts a depth-1 chain (direct parent only)', async () => {
-		const loader = buildLoader([
-			{
-				bySession: sessionId(1),
-				subSessionId: subId(1),
-				sessionId: sessionId(1),
-				// No prevArtifactRef — chain terminates here.
-			},
-		])
-		const chain = await validatePrevArtifactChain(
-			loader,
-			subId(100),
-			summaryDeliverable(sessionId(1)),
-			10,
-		)
-		expect(chain).toEqual([subId(1)])
-	})
-
-	it('accepts a depth-2 chain', async () => {
-		const loader = buildLoader([
-			{
-				bySession: sessionId(1),
-				subSessionId: subId(1),
-				sessionId: sessionId(1),
-				prevArtifactRef: summaryDeliverable(sessionId(2)),
-			},
-			{
-				bySession: sessionId(2),
-				subSessionId: subId(2),
-				sessionId: sessionId(2),
-			},
-		])
-		const chain = await validatePrevArtifactChain(
-			loader,
-			subId(100),
-			summaryDeliverable(sessionId(1)),
-			10,
-		)
-		expect(chain).toEqual([subId(1), subId(2)])
-	})
-
-	it('accepts a chain exactly at the depth limit', async () => {
-		// 10-deep chain with maxDepth = 10.
-		const nodes: Array<PrevArtifactNode & { bySession: SessionId }> = []
-		for (let i = 1; i <= 10; i++) {
-			nodes.push({
-				bySession: sessionId(i),
-				subSessionId: subId(i),
-				sessionId: sessionId(i),
-				...(i < 10 && { prevArtifactRef: summaryDeliverable(sessionId(i + 1)) }),
-			})
-		}
-		const loader = buildLoader(nodes)
-		const chain = await validatePrevArtifactChain(
-			loader,
-			subId(100),
-			summaryDeliverable(sessionId(1)),
-			10,
-		)
-		expect(chain).toHaveLength(10)
-	})
-
-	it('rejects a chain that would exceed the depth limit', async () => {
-		// 11-deep chain with maxDepth = 10.
-		const nodes: Array<PrevArtifactNode & { bySession: SessionId }> = []
-		for (let i = 1; i <= 11; i++) {
-			nodes.push({
-				bySession: sessionId(i),
-				subSessionId: subId(i),
-				sessionId: sessionId(i),
-				...(i < 11 && { prevArtifactRef: summaryDeliverable(sessionId(i + 1)) }),
-			})
-		}
-		const loader = buildLoader(nodes)
-		await expect(
-			validatePrevArtifactChain(loader, subId(100), summaryDeliverable(sessionId(1)), 10),
-		).rejects.toBeInstanceOf(InterventionDepthExceeded)
-	})
-
-	it('rejects self-reference as a cycle', async () => {
-		// proposedChild's prev points at a node whose subSessionId == proposedChild.
-		const loader = buildLoader([
-			{
-				bySession: sessionId(1),
-				subSessionId: subId(100), // SAME id as proposedChild
-				sessionId: sessionId(1),
-			},
-		])
-		await expect(
-			validatePrevArtifactChain(loader, subId(100), summaryDeliverable(sessionId(1)), 10),
-		).rejects.toBeInstanceOf(ArtifactRefCycleError)
-	})
-
-	it('rejects a 2-cycle (A -> B -> A)', async () => {
-		const loader = buildLoader([
-			{
-				bySession: sessionId(1),
-				subSessionId: subId(1),
-				sessionId: sessionId(1),
-				prevArtifactRef: summaryDeliverable(sessionId(2)),
-			},
-			{
-				bySession: sessionId(2),
-				subSessionId: subId(2),
-				sessionId: sessionId(2),
-				prevArtifactRef: summaryDeliverable(sessionId(1)),
-			},
-		])
-		await expect(
-			validatePrevArtifactChain(loader, subId(100), summaryDeliverable(sessionId(1)), 10),
-		).rejects.toBeInstanceOf(ArtifactRefCycleError)
-	})
-
-	it('rejects a 3-cycle (A -> B -> C -> A)', async () => {
-		const loader = buildLoader([
-			{
-				bySession: sessionId(1),
-				subSessionId: subId(1),
-				sessionId: sessionId(1),
-				prevArtifactRef: summaryDeliverable(sessionId(2)),
-			},
-			{
-				bySession: sessionId(2),
-				subSessionId: subId(2),
-				sessionId: sessionId(2),
-				prevArtifactRef: summaryDeliverable(sessionId(3)),
-			},
-			{
-				bySession: sessionId(3),
-				subSessionId: subId(3),
-				sessionId: sessionId(3),
-				prevArtifactRef: summaryDeliverable(sessionId(1)),
-			},
-		])
-		await expect(
-			validatePrevArtifactChain(loader, subId(100), summaryDeliverable(sessionId(1)), 10),
-		).rejects.toBeInstanceOf(ArtifactRefCycleError)
-	})
-
-	it('returns an empty chain for a non-session_summary deliverable', async () => {
-		const fileRef: DeliverableRef = {
-			id: 'del_file' as DeliverableId,
-			kind: 'file',
-			path: 'a.txt',
-			contentHash: 'abc',
-			sizeBytes: 0,
-		}
-		const loader: InterventionChainLoader = {
-			loadAncestor: async () => null,
-		}
-		const chain = await validatePrevArtifactChain(loader, subId(100), fileRef, 10)
-		expect(chain).toEqual([])
-	})
-
-	it('terminates cleanly on unknown ancestor (archived/tombstoned)', async () => {
-		const loader = buildLoader([
-			// no matching node — loadAncestor returns null for any id
-		])
-		const chain = await validatePrevArtifactChain(
-			loader,
-			subId(100),
-			summaryDeliverable(sessionId(42)),
-			10,
-		)
-		expect(chain).toEqual([])
-	})
-
-	it('rejects zero/negative maxDepth as depth-exceeded up front', async () => {
-		const loader = buildLoader([
-			{
-				bySession: sessionId(1),
-				subSessionId: subId(1),
-				sessionId: sessionId(1),
-			},
-		])
-		await expect(
-			validatePrevArtifactChain(loader, subId(100), summaryDeliverable(sessionId(1)), 0),
-		).rejects.toBeInstanceOf(InterventionDepthExceeded)
-	})
-})

package/src/session/migration/__tests__/a-migrated-project-id-is-an-id.test.ts

@@ -1,92 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import { ProjectIdSchema } from '../../../contracts/schemas.js'
-import { FilesystemMigrationError } from '../errors.js'
-import { DefaultFilesystemMigrator, NOOP_FILESYSTEM_MIGRATION_SINK } from '../filesystem.js'
-
-/**
- * The v0.2.0 migration is the only place a `ProjectId` is built from data
- * instead of generated: it takes a legacy `thd_*` folder name off disk and
- * mints `prj_legacy_<that name>`. The only check the name had passed was
- * `startsWith('thd_')`, so a folder named `thd_Not An Id` produced a project
- * id that satisfies the TypeScript type, is written into the new layout as a
- * directory name, and is rejected by the SDK's own `ProjectIdSchema`.
- *
- * It refuses such a folder rather than skipping it. Skipping would leave that
- * thread's runs on disk and unaddressable, write the completion marker anyway,
- * and return `kind: 'migrated'` with the thread missing from the list — the
- * failure shape this codebase keeps meeting, where the run did not fail, it
- * succeeded while quietly not doing what it said.
- */
-
-const dirs: string[] = []
-afterEach(async () => {
-	await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })))
-	dirs.length = 0
-})
-
-async function seed(root: string, folder: string): Promise<void> {
-	const dir = join(root, 'threads', folder, 'runs', 'run_seed')
-	await mkdir(dir, { recursive: true })
-	await writeFile(join(dir, 'run.json'), JSON.stringify({ id: 'run_seed' }), 'utf-8')
-}
-
-async function newRoot(tag: string): Promise<string> {
-	const root = await mkdtemp(join(tmpdir(), `namzu-mig-${tag}-`))
-	dirs.push(root)
-	return root
-}
-
-describe('the migration only mints project ids that are project ids', () => {
-	it('refuses a legacy folder whose name is not a thread id, and names it', async () => {
-		const root = await newRoot('badname')
-		await seed(root, 'thd_Not An Id')
-
-		const error = await new DefaultFilesystemMigrator(NOOP_FILESYSTEM_MIGRATION_SINK)
-			.migrate(root)
-			.then(
-				() => null,
-				(e: unknown) => e,
-			)
-
-		expect(error).toBeInstanceOf(FilesystemMigrationError)
-		const details = (error as FilesystemMigrationError).details
-		expect(details.op).toBe('validate_thread_id')
-		// An operator has to be able to go and look at the folder.
-		expect(details.path).toContain('thd_Not An Id')
-	})
-
-	it('refuses rather than reporting a migration that left a thread behind', async () => {
-		// The seductive alternative is `continue`. This pins why it is wrong:
-		// the good thread would migrate, the result would say `migrated`, and
-		// the bad one would be absent from `migratedThreads` with no error.
-		const root = await newRoot('partial')
-		await seed(root, 'thd_a1b2c3d4e5f6')
-		await seed(root, 'thd_UPPER')
-
-		await expect(
-			new DefaultFilesystemMigrator(NOOP_FILESYSTEM_MIGRATION_SINK).migrate(root),
-		).rejects.toBeInstanceOf(FilesystemMigrationError)
-	})
-
-	it('still migrates a folder whose name is a thread id, and the id it mints validates', async () => {
-		// The guard must refuse only what is not an id. A guard that refuses
-		// everything passes the two cases above and breaks migration entirely.
-		const root = await newRoot('good')
-		await seed(root, 'thd_a1b2c3d4e5f6')
-
-		const result = await new DefaultFilesystemMigrator(NOOP_FILESYSTEM_MIGRATION_SINK).migrate(root)
-
-		expect(result.kind).toBe('migrated')
-		expect(result.migratedThreads.map((m) => m.legacyThreadId)).toEqual(['thd_a1b2c3d4e5f6'])
-		for (const { newProjectId } of result.migratedThreads) {
-			expect({ newProjectId, ok: ProjectIdSchema.safeParse(newProjectId).success }).toEqual({
-				newProjectId,
-				ok: true,
-			})
-		}
-	})
-})