@namzu/sdk 14.0.6 → 15.0.0

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

@@ -1,296 +0,0 @@
-/**
- * End-to-end SubSession spawn flow.
- *
- * Builds Tenant → Project → Session → simulated Run → spawnSubAgent →
- * SubSession → child Run → child completion → SessionSummaryRef materialized
- * → parent reads the child summary via `sessionStore.drill`. Asserts the
- * event sequence matches §10.5 of session-hierarchy.md (spawn, child run,
- * idled).
- *
- * Covers Phase 6 invariants #1–5 in the pattern doc checklist:
- *  - Sub-session spawn triple (SubSession + Session + workspace meta)
- *  - Kernel-materialized Summary on completion
- *  - Lineage on every sub-session event (depth, rootSessionId)
- *  - Atomic `recordSummary` flip active→idle
- *  - `sessionStore.drill` surfaces the child's structure after completion
- */
-
-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,
-	BaseAgentConfig,
-	BaseAgentResult,
-} from '../../../types/agent/base.js'
-import type { Agent } from '../../../types/agent/core.js'
-import type { AgentDefinition } from '../../../types/agent/factory.js'
-import type { AgentTaskContext, SendMessageOptions } from '../../../types/agent/task.js'
-import type { RunId, TenantId, UserId } from '../../../types/ids/index.js'
-import { createAssistantMessage } from '../../../types/message/index.js'
-import type { RunEvent } from '../../../types/run/events.js'
-import type { ActorRef } from '../../../types/session/actor.js'
-import type { SummaryId } from '../../../types/session/ids.js'
-import { ZERO_COST } from '../../../utils/cost.js'
-import { DefaultCapacityValidator } from '../../handoff/capacity.js'
-import { SessionSummaryMaterializer } from '../../summary/materialize.js'
-import { WorkspaceBackendRegistry } from '../../workspace/registry.js'
-
-const tenant = 'tnt_alpha' as TenantId
-
-const capabilities: AgentCapabilities = {
-	supportsTools: false,
-	supportsStreaming: false,
-	supportsConcurrency: false,
-	supportsSubAgents: false,
-}
-
-function buildAgent(id: string): Agent<BaseAgentConfig, BaseAgentResult> {
-	return {
-		type: 'reactive',
-		metadata: {
-			type: 'reactive',
-			id,
-			name: id,
-			version: '1.0.0',
-			category: 'test',
-			description: id,
-			capabilities,
-		},
-		run: async (_input: AgentInput, _config: BaseAgentConfig): Promise<BaseAgentResult> => ({
-			runId: 'run_child' as RunId,
-			status: 'completed',
-			usage: { ...EMPTY_TOKEN_USAGE },
-			cost: { ...ZERO_COST },
-			iterations: 1,
-			durationMs: 1,
-			messages: [createAssistantMessage('child did the work')],
-			result: 'child did the work',
-		}),
-		cancel: async () => undefined,
-		getCapabilities: () => capabilities,
-	}
-}
-
-function buildDefinition(agent: Agent<BaseAgentConfig, BaseAgentResult>): AgentDefinition {
-	return {
-		info: {
-			id: agent.metadata.id,
-			name: agent.metadata.name,
-			version: agent.metadata.version,
-			category: agent.metadata.category,
-			description: agent.metadata.description,
-			tools: [],
-			defaults: { model: 'test', tokenBudget: 1_000 },
-		},
-		typedAgent: agent,
-	}
-}
-
-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',
-			userId: 'usr_root' as UserId,
-			tenantId: tenant,
-		}
-
-		const parentSession = await store.createSession(
-			{ threadId: thread.id, projectId: project.id, currentActor: userActor },
-			tenant,
-		)
-		// Parent Run in flight — session active while the spawn is happening.
-		await store.updateSession({ ...parentSession, status: 'active' }, tenant)
-
-		let summaryCounter = 0
-		const materializer = new SessionSummaryMaterializer({
-			store,
-			generateSummaryId: () => `sum_test_${++summaryCounter}` as SummaryId,
-		})
-
-		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[] = []
-		const listener = (event: RunEvent): void => {
-			capturedEvents.push(event)
-		}
-
-		const taskContext: AgentTaskContext = {
-			parentRunId: 'run_parent' as RunId,
-			parentAgentId: 'supervisor',
-			parentAbortController: new AbortController(),
-			depth: 0,
-			budgetTracker: { total: 100_000, remaining: 100_000 },
-			tenantId: tenant,
-			threadId: thread.id,
-			sessionId: parentSession.id,
-			projectId: project.id,
-			parentActor: userActor,
-		}
-
-		const options: SendMessageOptions = {
-			agentId: 'worker',
-			input: { messages: [], workingDirectory: '/tmp' },
-			parentSessionId: parentSession.id,
-			tenantId: tenant,
-			projectId: project.id,
-			parentActor: userActor,
-		}
-
-		const task = await manager.sendMessage(options, taskContext, listener)
-		await manager.waitForCompletion(task.taskId)
-
-		// --- Event sequence assertions ---
-		const eventTypes = capturedEvents.map((e) => e.type)
-		expect(eventTypes).toEqual([
-			'agent_pending',
-			'subsession_spawned',
-			'subsession_idled',
-			'agent_completed',
-		])
-
-		const spawned = capturedEvents.find((e) => e.type === 'subsession_spawned')
-		const idled = capturedEvents.find((e) => e.type === 'subsession_idled')
-		expect(spawned).toBeDefined()
-		expect(idled).toBeDefined()
-
-		// --- Lineage + schemaVersion invariants ---
-		if (spawned && 'lineage' in spawned && 'schemaVersion' in spawned) {
-			expect(spawned.lineage.parentSessionId).toBe(parentSession.id)
-			expect(spawned.lineage.rootSessionId).toBe(parentSession.id)
-			expect(spawned.lineage.depth).toBe(1)
-			expect(spawned.schemaVersion).toBe(3)
-		}
-		if (idled && 'lineage' in idled && 'schemaVersion' in idled) {
-			expect(idled.lineage.rootSessionId).toBe(parentSession.id)
-			expect(idled.lineage.depth).toBe(1)
-			expect(idled.schemaVersion).toBe(3)
-		}
-
-		// --- Summary materialized by kernel ---
-		const spawnRecord = manager.getSpawnRecord(task.taskId)
-		expect(spawnRecord).toBeDefined()
-		const summary = await store.getSummary(spawnRecord!.childSessionId, tenant)
-		expect(summary).toBeDefined()
-		expect(summary?.materializedBy).toBe('kernel')
-		expect(summary?.agentSummary).toBe('child did the work')
-		expect(summary?.outcome.status).toBe('succeeded')
-
-		// --- SubSession transitioned to idle with summaryRef attached ---
-		const subSession = await store.getSubSession(spawnRecord!.subSessionId, tenant)
-		expect(subSession?.status).toBe('idle')
-		expect(subSession?.summaryRef).toBe(summary?.id)
-
-		// --- Child session status flipped atomically with summary ---
-		const childSession = await store.getSession(spawnRecord!.childSessionId, tenant)
-		expect(childSession?.status).toBe('idle')
-
-		// --- Parent drills into the child; rootSessionId identical across tree ---
-		const parentDrill = await store.drill(parentSession.id, tenant)
-		expect(parentDrill).not.toBeNull()
-		expect(parentDrill?.children.length).toBe(1)
-		expect(parentDrill?.children[0]?.childSessionId).toBe(spawnRecord!.childSessionId)
-
-		const childDrill = await store.drill(spawnRecord!.childSessionId, tenant)
-		expect(childDrill).not.toBeNull()
-		expect(childDrill?.ancestry[0]).toBe(parentSession.id)
-		expect(childDrill?.ancestry[childDrill.ancestry.length - 1]).toBe(spawnRecord!.childSessionId)
-	})
-
-	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',
-			userId: 'usr_root' as UserId,
-			tenantId: tenant,
-		}
-		const parentSession = await store.createSession(
-			{ threadId: thread.id, projectId: project.id, currentActor: userActor },
-			tenant,
-		)
-		await store.updateSession({ ...parentSession, status: 'active' }, tenant)
-
-		let counter = 0
-		const materializer = new SessionSummaryMaterializer({
-			store,
-			generateSummaryId: () => `sum_gap_${++counter}` as SummaryId,
-		})
-
-		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(
-			{
-				agentId: 'worker',
-				input: { messages: [], workingDirectory: '/tmp' },
-				parentSessionId: parentSession.id,
-				tenantId: tenant,
-				projectId: project.id,
-				parentActor: userActor,
-			},
-			{
-				parentRunId: 'run_parent' as RunId,
-				parentAgentId: 'supervisor',
-				parentAbortController: new AbortController(),
-				depth: 0,
-				budgetTracker: { total: 10_000, remaining: 10_000 },
-				tenantId: tenant,
-				threadId: thread.id,
-				sessionId: parentSession.id,
-				projectId: project.id,
-				parentActor: userActor,
-			},
-		)
-		await manager.waitForCompletion(task.taskId)
-
-		const spawnRecord = manager.getSpawnRecord(task.taskId)
-		expect(spawnRecord).toBeDefined()
-
-		// Close the gap: parent references the child's summary via store.drill —
-		// no loose-cast Object.assign, no transcript re-inlining, just a typed
-		// structural pointer.
-		const view = await store.drill(spawnRecord!.childSessionId, tenant)
-		expect(view?.session.id).toBe(spawnRecord!.childSessionId)
-		const summary = await store.getSummary(spawnRecord!.childSessionId, tenant)
-		expect(summary?.sessionRef).toBe(spawnRecord!.childSessionId)
-	})
-})

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

@@ -1,410 +0,0 @@
-/**
- * Integration — event stream ordering + lineage + schemaVersion envelope.
- *
- * Covers roadmap §5 invariants:
- *   - §10.1 schemaVersion: 3 on every sub-session RunEvent
- *   - §10.3 tree-scoped monotonic ordering by (rootSessionId, eventId)
- *   - §10.3 depth filter ('self' vs 'tree') at subscribe time
- *   - §10.4 lineage stamped on every sub-session event with parent + root + depth
- *
- * Orthogonal to `e2e-spawn.test.ts` (covers single-level spawn). This file
- * drives a multi-level (3-deep) delegation tree so monotonic ordering across
- * concurrent descendants is observable.
- */
-
-import { describe, expect, it } from 'vitest'
-import { EMPTY_TOKEN_USAGE } from '../../../constants/limits.js'
-import type { AgentManager } from '../../../manager/agent/lifecycle.js'
-import type { AgentInput, BaseAgentConfig, BaseAgentResult } from '../../../types/agent/base.js'
-import type { RunId } from '../../../types/ids/index.js'
-import { createAssistantMessage } from '../../../types/message/index.js'
-import type { RunEvent } from '../../../types/run/events.js'
-import { ZERO_COST } from '../../../utils/cost.js'
-import {
-	DEFAULT_TENANT,
-	buildAgent,
-	buildAgentCustom,
-	buildDefinition,
-	buildHarness,
-	buildSendMessageOptions,
-	buildTaskContext,
-	seedActiveParent,
-} from './_fixtures.js'
-
-describe('Integration — event stream ordering + lineage + schemaVersion', () => {
-	it('every sub-session RunEvent carries schemaVersion: 3', async () => {
-		const harness = buildHarness()
-		const { project, thread, session, actor } = await seedActiveParent(harness)
-		harness.registry.register(buildDefinition(buildAgent('worker')))
-
-		const captured: RunEvent[] = []
-		const task = await 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,
-			}),
-			(ev) => {
-				captured.push(ev)
-			},
-		)
-		await harness.manager.waitForCompletion(task.taskId)
-
-		// Every sub-session lifecycle event is stamped with schemaVersion: 3.
-		const subSessionEvents = captured.filter(
-			(e) =>
-				e.type === 'subsession_spawned' ||
-				e.type === 'subsession_messaged' ||
-				e.type === 'subsession_idled',
-		)
-		expect(subSessionEvents.length).toBeGreaterThan(0)
-		for (const ev of subSessionEvents) {
-			expect(ev.schemaVersion).toBe(3)
-		}
-	})
-
-	it('every sub-session event carries lineage { parentSessionId, rootSessionId, depth }', async () => {
-		const harness = buildHarness()
-		const { project, thread, session, actor } = await seedActiveParent(harness)
-		harness.registry.register(buildDefinition(buildAgent('worker')))
-
-		const captured: RunEvent[] = []
-		const task = await 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,
-			}),
-			(ev) => {
-				captured.push(ev)
-			},
-		)
-		await harness.manager.waitForCompletion(task.taskId)
-
-		const spawned = captured.find((e) => e.type === 'subsession_spawned')
-		const idled = captured.find((e) => e.type === 'subsession_idled')
-		expect(spawned).toBeDefined()
-		expect(idled).toBeDefined()
-
-		if (spawned && 'lineage' in spawned) {
-			expect(spawned.lineage.parentSessionId).toBe(session.id)
-			expect(spawned.lineage.rootSessionId).toBe(session.id)
-			expect(spawned.lineage.depth).toBe(1)
-		}
-		if (idled && 'lineage' in idled) {
-			expect(idled.lineage.parentSessionId).toBe(session.id)
-			expect(idled.lineage.rootSessionId).toBe(session.id)
-			expect(idled.lineage.depth).toBe(1)
-		}
-	})
-
-	it('3-deep delegation: rootSessionId identical across tree; depth ascends 1→2→3', async () => {
-		const harness = buildHarness()
-		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
-		// via a closure so level-2 can spawn level-3.
-		const manager: AgentManager = harness.manager
-		const nestedEventsCaptured: RunEvent[] = []
-
-		const leafAgent = buildAgent('leaf', 'leaf result')
-		const midAgent = buildAgentCustom(
-			'mid',
-			async (_input: AgentInput, config: BaseAgentConfig): Promise<BaseAgentResult> => {
-				// Spawn a level-2 child from inside the mid-agent's run.
-				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.
-				const childSessionId = config.sessionId
-				const cs = await harness.store.getSession(childSessionId, config.tenantId)
-				if (cs && cs.status !== 'active') {
-					await harness.store.updateSession({ ...cs, status: 'active' }, config.tenantId)
-				}
-				const task2 = await manager.sendMessage(
-					{
-						agentId: 'leaf',
-						input: { messages: [], workingDirectory: '/tmp' },
-						parentSessionId: childSessionId,
-						tenantId: config.tenantId,
-						projectId: config.projectId,
-						parentActor: { kind: 'agent', agentId: 'mid' as never, tenantId: config.tenantId },
-					},
-					{
-						parentRunId: 'run_mid' as RunId,
-						parentAgentId: 'mid',
-						parentAbortController: new AbortController(),
-						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 },
-					},
-					(ev) => {
-						nestedEventsCaptured.push(ev)
-					},
-				)
-				await manager.waitForCompletion(task2.taskId)
-
-				return {
-					runId: 'run_mid_result' as RunId,
-					status: 'completed',
-					usage: { ...EMPTY_TOKEN_USAGE },
-					cost: { ...ZERO_COST },
-					iterations: 1,
-					durationMs: 1,
-					messages: [createAssistantMessage('mid done')],
-					result: 'mid done',
-				}
-			},
-		)
-
-		harness.registry.register(buildDefinition(leafAgent))
-		harness.registry.register(buildDefinition(midAgent))
-
-		const outerCaptured: RunEvent[] = []
-		const task = await harness.manager.sendMessage(
-			buildSendMessageOptions({
-				agentId: 'mid',
-				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,
-			}),
-			(ev) => {
-				outerCaptured.push(ev)
-			},
-		)
-		await harness.manager.waitForCompletion(task.taskId)
-
-		// Outer capture has level-1 events with rootSessionId === session.id,
-		// depth 1. The nested capture has level-2 events with rootSessionId
-		// also === session.id (the whole tree shares a root) and depth 2.
-		const outerLineages = outerCaptured
-			.filter((e) => 'lineage' in e && e.lineage)
-			.map((e) => {
-				const l = (e as unknown as { lineage: { rootSessionId: string; depth: number } }).lineage
-				return { rootSessionId: l.rootSessionId, depth: l.depth }
-			})
-		expect(outerLineages.length).toBeGreaterThan(0)
-		for (const l of outerLineages) {
-			expect(l.rootSessionId).toBe(session.id)
-			expect(l.depth).toBe(1)
-		}
-
-		// Nested level-2 events: same rootSessionId, depth 2.
-		const nestedLineages = nestedEventsCaptured
-			.filter((e) => 'lineage' in e && e.lineage)
-			.map((e) => {
-				const l = (e as unknown as { lineage: { rootSessionId: string; depth: number } }).lineage
-				return { rootSessionId: l.rootSessionId, depth: l.depth }
-			})
-		expect(nestedLineages.length).toBeGreaterThan(0)
-		for (const l of nestedLineages) {
-			expect(l.rootSessionId).toBe(session.id)
-			expect(l.depth).toBe(2)
-		}
-	})
-
-	it('self vs tree depth filter: outer listener sees only its session events; nested listener sees its own tree', async () => {
-		// The subscribe-time depth filter is implemented at the listener
-		// injection seam — the parent passes a listener that captures events
-		// from its own sendMessage call. A nested child's sendMessage receives
-		// its own listener — the outer listener does NOT see the nested
-		// listener's events (no cross-contamination).
-		const harness = buildHarness()
-		const { project, thread, session, actor } = await seedActiveParent(harness)
-
-		const outerCaptured: RunEvent[] = []
-		const nestedCaptured: RunEvent[] = []
-
-		const leafAgent = buildAgent('leaf', 'leaf')
-		const midAgent = buildAgentCustom(
-			'mid',
-			async (_input: AgentInput, config: BaseAgentConfig): Promise<BaseAgentResult> => {
-				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)
-				if (cs && cs.status !== 'active') {
-					await harness.store.updateSession({ ...cs, status: 'active' }, config.tenantId)
-				}
-				const inner = await harness.manager.sendMessage(
-					{
-						agentId: 'leaf',
-						input: { messages: [], workingDirectory: '/tmp' },
-						parentSessionId: config.sessionId,
-						tenantId: config.tenantId,
-						projectId: config.projectId,
-						parentActor: {
-							kind: 'agent',
-							agentId: 'mid' as never,
-							tenantId: config.tenantId,
-						},
-					},
-					{
-						parentRunId: 'run_mid_inner' as RunId,
-						parentAgentId: 'mid',
-						parentAbortController: new AbortController(),
-						depth: 1,
-						budgetTracker: { total: 10_000, remaining: 10_000 },
-						tenantId: config.tenantId,
-						threadId: config.threadId,
-						sessionId: config.sessionId,
-						projectId: config.projectId,
-						parentActor: {
-							kind: 'agent',
-							agentId: 'mid' as never,
-							tenantId: config.tenantId,
-						},
-					},
-					(ev) => {
-						nestedCaptured.push(ev)
-					},
-				)
-				await harness.manager.waitForCompletion(inner.taskId)
-				return {
-					runId: 'run_mid_done' as RunId,
-					status: 'completed',
-					usage: { ...EMPTY_TOKEN_USAGE },
-					cost: { ...ZERO_COST },
-					iterations: 1,
-					durationMs: 1,
-					messages: [createAssistantMessage('mid')],
-					result: 'mid',
-				}
-			},
-		)
-
-		harness.registry.register(buildDefinition(leafAgent))
-		harness.registry.register(buildDefinition(midAgent))
-
-		const task = await harness.manager.sendMessage(
-			buildSendMessageOptions({
-				agentId: 'mid',
-				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,
-			}),
-			(ev) => {
-				outerCaptured.push(ev)
-			},
-		)
-		await harness.manager.waitForCompletion(task.taskId)
-
-		// Outer only sees its own spawn events (depth 1).
-		const outerSpawnedDepths = outerCaptured
-			.filter((e) => e.type === 'subsession_spawned')
-			.map((e) => ('lineage' in e && e.lineage ? e.lineage.depth : -1))
-		expect(outerSpawnedDepths).toEqual([1])
-
-		// Nested listener only sees its own spawn events (depth 2).
-		const nestedSpawnedDepths = nestedCaptured
-			.filter((e) => e.type === 'subsession_spawned')
-			.map((e) => ('lineage' in e && e.lineage ? e.lineage.depth : -1))
-		expect(nestedSpawnedDepths).toEqual([2])
-
-		// Cross-contamination sentinel: outer listener MUST NOT contain any
-		// depth-2 events (those belong to the nested scope).
-		const outerDepths = outerCaptured
-			.filter((e) => 'lineage' in e && e.lineage)
-			.map((e) => ('lineage' in e && e.lineage ? e.lineage.depth : -1))
-		expect(outerDepths.every((d) => d === 1)).toBe(true)
-	})
-
-	it('run_started and other core RunEvents also carry schemaVersion: 3 when stamped by the child listener wrapper', async () => {
-		// The listener wrapper in `manager/agent/lifecycle.ts#wrapChildListener`
-		// stamps `schemaVersion: 3` + `lineage` on EVERY event emitted inside
-		// the child's run. Core events that pass through the wrapped listener
-		// therefore inherit the envelope even though they have no lineage in
-		// their own type definition.
-		const harness = buildHarness()
-		const { project, thread, session, actor } = await seedActiveParent(harness)
-
-		const leafAgent = buildAgentCustom(
-			'leaf-emit',
-			async (_i, _c, listener): Promise<BaseAgentResult> => {
-				// Emit a core event inside the child's run via the listener passed in.
-				await listener?.({
-					type: 'run_started',
-					runId: 'run_child_inner' as RunId,
-				})
-				return {
-					runId: 'run_child_inner' as RunId,
-					status: 'completed',
-					usage: { ...EMPTY_TOKEN_USAGE },
-					cost: { ...ZERO_COST },
-					iterations: 1,
-					durationMs: 1,
-					messages: [createAssistantMessage('done')],
-					result: 'done',
-				}
-			},
-		)
-		harness.registry.register(buildDefinition(leafAgent))
-
-		const captured: RunEvent[] = []
-		const task = await harness.manager.sendMessage(
-			buildSendMessageOptions({
-				agentId: 'leaf-emit',
-				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,
-			}),
-			(ev) => {
-				captured.push(ev)
-			},
-		)
-		await harness.manager.waitForCompletion(task.taskId)
-
-		const runStarted = captured.find((e) => e.type === 'run_started')
-		expect(runStarted).toBeDefined()
-		if (runStarted && 'schemaVersion' in runStarted) {
-			expect(runStarted.schemaVersion).toBe(3)
-		}
-	})
-})