@namzu/sdk 0.2.0 → 0.4.0

package/src/session/__tests__/integration/archive-gate.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Integration — Thread archive gate enforced at session-creation ingress
+ * sites (Phase 2.6).
+ *
+ * The Phase 2.5 commit flagged this as a known gap:
+ *   > spawn and handoff paths do not yet invoke `ThreadManager.requireOpen`
+ *   > before creating a child session. Until they do, the archive invariant
+ *   > is best-effort.
+ *
+ * Phase 2.6 wires `requireOpen` into `AgentManager.provisionSpawn` + both
+ * handoff flows. These tests drive the archived-thread-then-attempt-creation
+ * scenarios end-to-end against the real stack.
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+import { ThreadManager } from '../../../manager/thread/lifecycle.js'
+import { InMemorySessionStore } from '../../../store/session/memory.js'
+import { InMemoryThreadStore } from '../../../store/thread/memory.js'
+import type { AgentId, RunId, UserId } from '../../../types/ids/index.js'
+import { generateHandoffId } from '../../../utils/id.js'
+import { ThreadClosedError } from '../../errors.js'
+import type { HandoffAssignment } from '../../handoff/assignment.js'
+import { type BroadcastHandoffDeps, executeBroadcastHandoff } from '../../handoff/broadcast.js'
+import { DefaultCapacityValidator } from '../../handoff/capacity.js'
+import type { HandoffEventSink } from '../../handoff/events.js'
+import { type SingleHandoffDeps, executeSingleHandoff } from '../../handoff/single.js'
+import type { ActorRef } from '../../hierarchy/actor.js'
+import { GitWorktreeDriver } from '../../workspace/git-worktree.js'
+import { WorkspaceBackendRegistry } from '../../workspace/registry.js'
+import {
+	DEFAULT_TENANT,
+	buildAgent,
+	buildDefinition,
+	buildHarness,
+	buildSendMessageOptions,
+	buildTaskContext,
+	okExec,
+	seedActiveParent,
+	stubLogger,
+	userActor,
+} from './_fixtures.js'
+
+describe('Integration — archive gate (Phase 2.6)', () => {
+	it('AgentManager spawn: rejects with ThreadClosedError when parent thread is archived', async () => {
+		const harness = buildHarness()
+		const { project, thread, session, actor } = await seedActiveParent(harness)
+
+		// Archive the thread via the manager so the invariant is enforced — no
+		// in-flight sessions under this thread, so archive succeeds.
+		await harness.store.updateSession({ ...session, status: 'idle' }, DEFAULT_TENANT)
+		await harness.threadManager.archive(thread.id, DEFAULT_TENANT)
+		// Flip session back to active so the spawn's capacity path reaches
+		// provisionSpawn (the archive gate should still reject).
+		await harness.store.updateSession({ ...session, status: 'active' }, DEFAULT_TENANT)
+
+		harness.registry.register(buildDefinition(buildAgent('worker')))
+
+		await expect(
+			harness.manager.sendMessage(
+				buildSendMessageOptions({
+					agentId: 'worker',
+					parentSessionId: session.id,
+					projectId: project.id,
+					tenantId: DEFAULT_TENANT,
+					parentActor: actor,
+				}),
+				buildTaskContext({
+					sessionId: session.id,
+					projectId: project.id,
+					threadId: thread.id,
+					tenantId: DEFAULT_TENANT,
+					parentActor: actor,
+				}),
+			),
+		).rejects.toBeInstanceOf(ThreadClosedError)
+
+		// Archive invariant held: no new child sessions under the archived thread.
+		const underThread = await harness.store.listSessions(thread.id, DEFAULT_TENANT)
+		expect(underThread).toHaveLength(1)
+		expect(underThread[0]?.id).toBe(session.id)
+	})
+
+	it('Single handoff: rejects with ThreadClosedError when thread is archived (before CAS lock)', async () => {
+		const store = new InMemorySessionStore()
+		const threadStore = new InMemoryThreadStore()
+		const project = await store.createProject(
+			{ tenantId: DEFAULT_TENANT, name: 'archive-single' },
+			DEFAULT_TENANT,
+		)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'archive-single' },
+			DEFAULT_TENANT,
+		)
+		const sourceActor: ActorRef = {
+			kind: 'user',
+			userId: 'usr_source' as UserId,
+			tenantId: DEFAULT_TENANT,
+		}
+		const session = await store.createSession(
+			{ threadId: thread.id, projectId: project.id, currentActor: sourceActor },
+			DEFAULT_TENANT,
+		)
+
+		// Archive the thread directly — session is idle, so archive precondition
+		// holds via listSessions.
+		const threadManager = new ThreadManager({ threadStore, sessionStore: store })
+		await threadManager.archive(thread.id, DEFAULT_TENANT)
+
+		const driver = new GitWorktreeDriver({
+			repoRoot: '/repo',
+			logger: stubLogger(),
+			execFile: async () => okExec(),
+		})
+		const workspaceRegistry = new WorkspaceBackendRegistry()
+		workspaceRegistry.register(driver)
+
+		const events: HandoffEventSink = {
+			onLocked: vi.fn(),
+			onUnlocked: vi.fn(),
+			onCommitted: vi.fn(),
+			onBroadcastRollback: vi.fn(),
+		}
+		const deps: SingleHandoffDeps = {
+			store,
+			workspaceRegistry,
+			capacity: new DefaultCapacityValidator(store),
+			events,
+			threadManager,
+		}
+
+		const assignment: HandoffAssignment = {
+			id: generateHandoffId(),
+			mode: 'single',
+			sourceSessionId: session.id,
+			tenantId: DEFAULT_TENANT,
+			threadId: thread.id,
+			projectId: project.id,
+			sourceActor,
+			recipientActor: userActor('usr_target'),
+			expectedOwnerVersion: 0,
+			createdAt: new Date('2026-04-19'),
+		}
+
+		await expect(executeSingleHandoff(deps, assignment, DEFAULT_TENANT)).rejects.toBeInstanceOf(
+			ThreadClosedError,
+		)
+
+		// Critical: source session must still be idle (lock never acquired).
+		const reloaded = await store.getSession(session.id, DEFAULT_TENANT)
+		expect(reloaded?.status).toBe('idle')
+		expect(reloaded?.ownerVersion).toBe(0)
+		expect(events.onLocked).not.toHaveBeenCalled()
+	})
+
+	it('Broadcast handoff: rejects with ThreadClosedError when thread is archived (no CAS, no worktrees)', async () => {
+		const store = new InMemorySessionStore()
+		const threadStore = new InMemoryThreadStore()
+		const project = await store.createProject(
+			{ tenantId: DEFAULT_TENANT, name: 'archive-bc' },
+			DEFAULT_TENANT,
+		)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'archive-bc' },
+			DEFAULT_TENANT,
+		)
+		const source = await store.createSession(
+			{ threadId: thread.id, projectId: project.id, currentActor: userActor('usr_source') },
+			DEFAULT_TENANT,
+		)
+
+		const threadManager = new ThreadManager({ threadStore, sessionStore: store })
+		await threadManager.archive(thread.id, DEFAULT_TENANT)
+
+		let worktreeAdds = 0
+		const driver = new GitWorktreeDriver({
+			repoRoot: '/repo',
+			logger: stubLogger(),
+			execFile: async (_file, args) => {
+				if (args.includes('add')) worktreeAdds += 1
+				return okExec()
+			},
+		})
+		const workspaceRegistry = new WorkspaceBackendRegistry()
+		workspaceRegistry.register(driver)
+
+		const events: HandoffEventSink = {
+			onLocked: vi.fn(),
+			onUnlocked: vi.fn(),
+			onCommitted: vi.fn(),
+			onBroadcastRollback: vi.fn(),
+		}
+		const deps: BroadcastHandoffDeps = {
+			store,
+			workspaceRegistry,
+			capacity: new DefaultCapacityValidator(store),
+			events,
+			threadManager,
+		}
+
+		const assignments: HandoffAssignment[] = [userActor('usr_b'), userActor('usr_c')].map(
+			(recipientActor) => ({
+				id: generateHandoffId(),
+				mode: 'broadcast' as const,
+				sourceSessionId: source.id,
+				tenantId: DEFAULT_TENANT,
+				threadId: thread.id,
+				projectId: project.id,
+				sourceActor: userActor('usr_source'),
+				recipientActor,
+				expectedOwnerVersion: 0,
+				broadcastId: 'bc_archive',
+				createdAt: new Date('2026-04-19'),
+			}),
+		)
+
+		await expect(executeBroadcastHandoff(deps, assignments, DEFAULT_TENANT)).rejects.toBeInstanceOf(
+			ThreadClosedError,
+		)
+
+		// Source never locked, no worktrees provisioned, no rollback event —
+		// the archive gate short-circuited before any side-effect landed.
+		const reloaded = await store.getSession(source.id, DEFAULT_TENANT)
+		expect(reloaded?.status).toBe('idle')
+		expect(reloaded?.ownerVersion).toBe(0)
+		expect(events.onLocked).not.toHaveBeenCalled()
+		expect(events.onBroadcastRollback).not.toHaveBeenCalled()
+		expect(worktreeAdds).toBe(0)
+	})
+
+	it('Phase 2.6 closure: post-archive spawn via AgentManager rejects (kernel ingress path gated)', async () => {
+		// End-to-end proof that the production ingress path honors the
+		// archive status. Direct `SessionStore.createSession` / `updateSession`
+		// remain ungated at the store layer (by design — the store has no
+		// cross-store awareness), so this test exercises the manager path,
+		// not the store boundary.
+		const harness = buildHarness()
+		const { project, thread, session } = await seedActiveParent(harness)
+
+		await harness.store.updateSession({ ...session, status: 'idle' }, DEFAULT_TENANT)
+		await harness.threadManager.archive(thread.id, DEFAULT_TENANT)
+
+		// Attempt to spawn directly via context threading (bypass the fixture
+		// builder to prove the gate trips from AgentManager, not from the
+		// fixture).
+		harness.registry.register(buildDefinition(buildAgent('leaker')))
+
+		const childActor: ActorRef = {
+			kind: 'agent',
+			agentId: 'leaker' as AgentId,
+			tenantId: DEFAULT_TENANT,
+		}
+
+		// Flip session to active again so capacity checks pass and the
+		// archive-gate is what fails — not an earlier guard.
+		await harness.store.updateSession({ ...session, status: 'active' }, DEFAULT_TENANT)
+
+		await expect(
+			harness.manager.sendMessage(
+				{
+					agentId: 'leaker',
+					input: { messages: [], workingDirectory: '/tmp' },
+					parentSessionId: session.id,
+					tenantId: DEFAULT_TENANT,
+					projectId: project.id,
+					parentActor: childActor,
+				},
+				{
+					parentRunId: 'run_post_archive' as RunId,
+					parentAgentId: 'supervisor',
+					parentAbortController: new AbortController(),
+					depth: 0,
+					budgetTracker: { total: 10_000, remaining: 10_000 },
+					tenantId: DEFAULT_TENANT,
+					threadId: thread.id,
+					sessionId: session.id,
+					projectId: project.id,
+					parentActor: childActor,
+				},
+			),
+		).rejects.toBeInstanceOf(ThreadClosedError)
+
+		// The gate tripped before any observable side effect — listSessions
+		// still shows only the original seeded session, not a smuggled child.
+		const underThread = await harness.store.listSessions(thread.id, DEFAULT_TENANT)
+		expect(underThread).toHaveLength(1)
+		expect(underThread[0]?.id).toBe(session.id)
+	})
+})

package/src/session/__tests__/integration/capacity-caps.test.ts

@@ -28,14 +28,18 @@ import {
 describe('Integration — capacity caps at spawn sites', () => {
 	it('spawn at depth 4 accepted; depth 5 rejected (default maxDelegationDepth=4)', async () => {
 		const harness = buildHarness()
-		const { project } = await seedActiveParent(harness)
+		const { project, thread } = await seedActiveParent(harness)
 
 		// Build a depth-4 ancestry chain under the project. Each layer flips to
 		// `active` so it is a legal spawn parent via the real AgentManager.
 		const chainActors: ActorRef[] = [userActor('usr_root')]
 		let parentSessionId = (
 			await harness.store.createSession(
-				{ projectId: project.id, currentActor: chainActors[0] ?? userActor('usr_root') },
+				{
+					threadId: thread.id,
+					projectId: project.id,
+					currentActor: chainActors[0] ?? userActor('usr_root'),
+				},
 				DEFAULT_TENANT,
 			)
 		).id
@@ -44,7 +48,7 @@ describe('Integration — capacity caps at spawn sites', () => {
 
 		for (let i = 0; i < 4; i++) {
 			const child = await harness.store.createSession(
-				{ projectId: project.id, currentActor: agentActor(`agt_${i}`) },
+				{ threadId: thread.id, projectId: project.id, currentActor: agentActor(`agt_${i}`) },
 				DEFAULT_TENANT,
 			)
 			await harness.store.createSubSession(
@@ -68,6 +72,7 @@ describe('Integration — capacity caps at spawn sites', () => {
 		const context = buildTaskContext({
 			sessionId: tail,
 			projectId: project.id,
+			threadId: thread.id,
 			tenantId: DEFAULT_TENANT,
 			parentActor: userActor('usr_root'),
 		})
@@ -86,12 +91,12 @@ describe('Integration — capacity caps at spawn sites', () => {
 
 	it('spawn at width 8 accepted; 9th sibling rejected (default maxDelegationWidth=8)', async () => {
 		const harness = buildHarness()
-		const { project, session, actor } = await seedActiveParent(harness)
+		const { project, thread, session, actor } = await seedActiveParent(harness)
 
 		// Seed 8 existing children directly through the store.
 		for (let i = 0; i < 8; i++) {
 			const child = await harness.store.createSession(
-				{ projectId: project.id, currentActor: agentActor(`agt_${i}`) },
+				{ threadId: thread.id, projectId: project.id, currentActor: agentActor(`agt_${i}`) },
 				DEFAULT_TENANT,
 			)
 			await harness.store.createSubSession(
@@ -110,6 +115,7 @@ describe('Integration — capacity caps at spawn sites', () => {
 		const context = buildTaskContext({
 			sessionId: session.id,
 			projectId: project.id,
+			threadId: thread.id,
 			tenantId: DEFAULT_TENANT,
 			parentActor: actor,
 		})
@@ -133,7 +139,7 @@ describe('Integration — capacity caps at spawn sites', () => {
 		// DefaultCapacityValidator(store) so it walks the actual persisted
 		// parent chain — confirms the wiring rather than a direct unit call.
 		const harness = buildHarness()
-		const { project, session, actor } = await seedActiveParent(harness)
+		const { project, thread, session, actor } = await seedActiveParent(harness)
 
 		harness.registry.register(buildDefinition(buildAgent('worker')))
 
@@ -142,6 +148,7 @@ describe('Integration — capacity caps at spawn sites', () => {
 		const context = buildTaskContext({
 			sessionId: session.id,
 			projectId: project.id,
+			threadId: thread.id,
 			tenantId: DEFAULT_TENANT,
 			parentActor: actor,
 		})

package/src/session/__tests__/integration/e2e-spawn.test.ts

@@ -18,8 +18,10 @@
 import { describe, expect, it } from 'vitest'
 import { EMPTY_TOKEN_USAGE } from '../../../constants/limits.js'
 import { AgentManager } from '../../../manager/agent/lifecycle.js'
+import { ThreadManager } from '../../../manager/thread/lifecycle.js'
 import { AgentRegistry } from '../../../registry/agent/definitions.js'
 import { InMemorySessionStore } from '../../../store/session/memory.js'
+import { InMemoryThreadStore } from '../../../store/thread/memory.js'
 import type {
 	AgentCapabilities,
 	AgentInput,
@@ -93,7 +95,12 @@ function buildDefinition(agent: Agent<BaseAgentConfig, BaseAgentResult>): AgentD
 describe('E2E — SubSession spawn → kernel summary → parent drill', () => {
 	it('emits the §10.5 event sequence with lineage + schemaVersion stamping', async () => {
 		const store = new InMemorySessionStore()
+		const threadStore = new InMemoryThreadStore()
 		const project = await store.createProject({ tenantId: tenant, name: 'e2e-project' }, tenant)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'e2e-spawn' },
+			tenant,
+		)
 
 		const userActor: ActorRef = {
 			kind: 'user',
@@ -102,7 +109,7 @@ describe('E2E — SubSession spawn → kernel summary → parent drill', () => {
 		}
 
 		const parentSession = await store.createSession(
-			{ projectId: project.id, currentActor: userActor },
+			{ threadId: thread.id, projectId: project.id, currentActor: userActor },
 			tenant,
 		)
 		// Parent Run in flight — session active while the spawn is happening.
@@ -117,11 +124,13 @@ describe('E2E — SubSession spawn → kernel summary → parent drill', () => {
 		const registry = new AgentRegistry()
 		registry.register(buildDefinition(buildAgent('worker')))
 
+		const threadManager = new ThreadManager({ threadStore, sessionStore: store })
 		const manager = new AgentManager(registry, undefined, {
 			sessionStore: store,
 			summaryMaterializer: materializer,
 			workspaceRegistry: new WorkspaceBackendRegistry(),
 			capacity: new DefaultCapacityValidator(store),
+			threadManager,
 		})
 
 		const capturedEvents: RunEvent[] = []
@@ -136,6 +145,7 @@ describe('E2E — SubSession spawn → kernel summary → parent drill', () => {
 			depth: 0,
 			budgetTracker: { total: 100_000, remaining: 100_000 },
 			tenantId: tenant,
+			threadId: thread.id,
 			sessionId: parentSession.id,
 			projectId: project.id,
 			parentActor: userActor,
@@ -212,7 +222,12 @@ describe('E2E — SubSession spawn → kernel summary → parent drill', () => {
 
 	it('closes the parent→child message gap: parent can re-ingest child content via drill + summary', async () => {
 		const store = new InMemorySessionStore()
+		const threadStore = new InMemoryThreadStore()
 		const project = await store.createProject({ tenantId: tenant, name: 'e2e-gap' }, tenant)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'e2e-gap' },
+			tenant,
+		)
 
 		const userActor: ActorRef = {
 			kind: 'user',
@@ -220,7 +235,7 @@ describe('E2E — SubSession spawn → kernel summary → parent drill', () => {
 			tenantId: tenant,
 		}
 		const parentSession = await store.createSession(
-			{ projectId: project.id, currentActor: userActor },
+			{ threadId: thread.id, projectId: project.id, currentActor: userActor },
 			tenant,
 		)
 		await store.updateSession({ ...parentSession, status: 'active' }, tenant)
@@ -234,11 +249,13 @@ describe('E2E — SubSession spawn → kernel summary → parent drill', () => {
 		const registry = new AgentRegistry()
 		registry.register(buildDefinition(buildAgent('worker')))
 
+		const threadManager = new ThreadManager({ threadStore, sessionStore: store })
 		const manager = new AgentManager(registry, undefined, {
 			sessionStore: store,
 			summaryMaterializer: materializer,
 			workspaceRegistry: new WorkspaceBackendRegistry(),
 			capacity: new DefaultCapacityValidator(store),
+			threadManager,
 		})
 
 		const task = await manager.sendMessage(
@@ -257,6 +274,7 @@ describe('E2E — SubSession spawn → kernel summary → parent drill', () => {
 				depth: 0,
 				budgetTracker: { total: 10_000, remaining: 10_000 },
 				tenantId: tenant,
+				threadId: thread.id,
 				sessionId: parentSession.id,
 				projectId: project.id,
 				parentActor: userActor,

package/src/session/__tests__/integration/event-stream-ordering.test.ts

@@ -34,7 +34,7 @@ import {
 describe('Integration — event stream ordering + lineage + schemaVersion', () => {
 	it('every sub-session RunEvent carries schemaVersion: 2', async () => {
 		const harness = buildHarness()
-		const { project, session, actor } = await seedActiveParent(harness)
+		const { project, thread, session, actor } = await seedActiveParent(harness)
 		harness.registry.register(buildDefinition(buildAgent('worker')))
 
 		const captured: RunEvent[] = []
@@ -49,6 +49,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 			buildTaskContext({
 				sessionId: session.id,
 				projectId: project.id,
+				threadId: thread.id,
 				tenantId: DEFAULT_TENANT,
 				parentActor: actor,
 			}),
@@ -73,7 +74,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 
 	it('every sub-session event carries lineage { parentSessionId, rootSessionId, depth }', async () => {
 		const harness = buildHarness()
-		const { project, session, actor } = await seedActiveParent(harness)
+		const { project, thread, session, actor } = await seedActiveParent(harness)
 		harness.registry.register(buildDefinition(buildAgent('worker')))
 
 		const captured: RunEvent[] = []
@@ -88,6 +89,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 			buildTaskContext({
 				sessionId: session.id,
 				projectId: project.id,
+				threadId: thread.id,
 				tenantId: DEFAULT_TENANT,
 				parentActor: actor,
 			}),
@@ -116,7 +118,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 
 	it('3-deep delegation: rootSessionId identical across tree; depth ascends 1→2→3', async () => {
 		const harness = buildHarness()
-		const { project, session, actor } = await seedActiveParent(harness)
+		const { project, thread, session, actor } = await seedActiveParent(harness)
 
 		// Wire a cascading agent: level-1 child spawns level-2 via its own
 		// sendMessage. We hand a reference to the manager into the child agent
@@ -129,7 +131,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 			'mid',
 			async (_input: AgentInput, config: BaseAgentConfig): Promise<BaseAgentResult> => {
 				// Spawn a level-2 child from inside the mid-agent's run.
-				if (!config.sessionId || !config.projectId || !config.tenantId) {
+				if (!config.sessionId || !config.threadId || !config.projectId || !config.tenantId) {
 					throw new Error('mid agent missing session scoping')
 				}
 				// Flip child session to active so it is a legal spawn parent.
@@ -154,6 +156,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 						depth: 1,
 						budgetTracker: { total: 10_000, remaining: 10_000 },
 						tenantId: config.tenantId,
+						threadId: config.threadId,
 						sessionId: childSessionId,
 						projectId: config.projectId,
 						parentActor: { kind: 'agent', agentId: 'mid' as never, tenantId: config.tenantId },
@@ -192,6 +195,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 			buildTaskContext({
 				sessionId: session.id,
 				projectId: project.id,
+				threadId: thread.id,
 				tenantId: DEFAULT_TENANT,
 				parentActor: actor,
 			}),
@@ -237,7 +241,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 		// its own listener — the outer listener does NOT see the nested
 		// listener's events (no cross-contamination).
 		const harness = buildHarness()
-		const { project, session, actor } = await seedActiveParent(harness)
+		const { project, thread, session, actor } = await seedActiveParent(harness)
 
 		const outerCaptured: RunEvent[] = []
 		const nestedCaptured: RunEvent[] = []
@@ -246,7 +250,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 		const midAgent = buildAgentCustom(
 			'mid',
 			async (_input: AgentInput, config: BaseAgentConfig): Promise<BaseAgentResult> => {
-				if (!config.sessionId || !config.projectId || !config.tenantId) {
+				if (!config.sessionId || !config.threadId || !config.projectId || !config.tenantId) {
 					throw new Error('mid missing scope')
 				}
 				const cs = await harness.store.getSession(config.sessionId, config.tenantId)
@@ -273,6 +277,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 						depth: 1,
 						budgetTracker: { total: 10_000, remaining: 10_000 },
 						tenantId: config.tenantId,
+						threadId: config.threadId,
 						sessionId: config.sessionId,
 						projectId: config.projectId,
 						parentActor: {
@@ -313,6 +318,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 			buildTaskContext({
 				sessionId: session.id,
 				projectId: project.id,
+				threadId: thread.id,
 				tenantId: DEFAULT_TENANT,
 				parentActor: actor,
 			}),
@@ -349,7 +355,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 		// therefore inherit the envelope even though they have no lineage in
 		// their own type definition.
 		const harness = buildHarness()
-		const { project, session, actor } = await seedActiveParent(harness)
+		const { project, thread, session, actor } = await seedActiveParent(harness)
 
 		const leafAgent = buildAgentCustom(
 			'leaf-emit',
@@ -385,6 +391,7 @@ describe('Integration — event stream ordering + lineage + schemaVersion', () =
 			buildTaskContext({
 				sessionId: session.id,
 				projectId: project.id,
+				threadId: thread.id,
 				tenantId: DEFAULT_TENANT,
 				parentActor: actor,
 			}),