@namzu/sdk 0.2.0 → 0.3.0

package/src/session/__tests__/integration/handoff-single-e2e.test.ts

@@ -13,7 +13,9 @@
  */
 
 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 { TenantId } from '../../../types/ids/index.js'
 import { generateHandoffId } from '../../../utils/id.js'
 import { TenantIsolationError } from '../../errors.js'
@@ -26,7 +28,10 @@ import { GitWorktreeDriver } from '../../workspace/git-worktree.js'
 import { WorkspaceBackendRegistry } from '../../workspace/registry.js'
 import { DEFAULT_TENANT, OTHER_TENANT, okExec, stubLogger, userActor } from './_fixtures.js'
 
-function buildHandoffDeps(store: InMemorySessionStore): {
+function buildHandoffDeps(
+	store: InMemorySessionStore,
+	threadStore: InMemoryThreadStore,
+): {
 	deps: SingleHandoffDeps
 	updateCalls: Array<{ status?: string; ownerVersion?: number }>
 } {
@@ -52,12 +57,14 @@ function buildHandoffDeps(store: InMemorySessionStore): {
 		return originalUpdate(session, tenantId)
 	}
 
+	const threadManager = new ThreadManager({ threadStore, sessionStore: store })
 	return {
 		deps: {
 			store,
 			workspaceRegistry,
 			capacity: new DefaultCapacityValidator(store),
 			events: sink,
+			threadManager,
 		},
 		updateCalls,
 	}
@@ -66,23 +73,29 @@ function buildHandoffDeps(store: InMemorySessionStore): {
 describe('Integration — single-recipient handoff E2E', () => {
 	it('idle → locked → commit: source previousActors grew + ownerVersion bumped atomically', async () => {
 		const store = new InMemorySessionStore()
+		const threadStore = new InMemoryThreadStore()
 		const project = await store.createProject(
 			{ tenantId: DEFAULT_TENANT, name: 'ho' },
 			DEFAULT_TENANT,
 		)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'ho' },
+			DEFAULT_TENANT,
+		)
 		const sourceActor = userActor('usr_source')
 		const recipientActor = userActor('usr_target')
 		const session = await store.createSession(
-			{ projectId: project.id, currentActor: sourceActor },
+			{ threadId: thread.id, projectId: project.id, currentActor: sourceActor },
 			DEFAULT_TENANT,
 		)
 
-		const { deps, updateCalls } = buildHandoffDeps(store)
+		const { deps, updateCalls } = buildHandoffDeps(store, threadStore)
 		const assignment: HandoffAssignment = {
 			id: generateHandoffId(),
 			mode: 'single',
 			sourceSessionId: session.id,
 			tenantId: DEFAULT_TENANT,
+			threadId: thread.id,
 			projectId: project.id,
 			sourceActor,
 			recipientActor,
@@ -115,21 +128,27 @@ describe('Integration — single-recipient handoff E2E', () => {
 
 	it('cross-tenant assignment rejects at entry (TenantIsolationError)', async () => {
 		const store = new InMemorySessionStore()
+		const threadStore = new InMemoryThreadStore()
 		const project = await store.createProject(
 			{ tenantId: DEFAULT_TENANT, name: 'ct' },
 			DEFAULT_TENANT,
 		)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'ct' },
+			DEFAULT_TENANT,
+		)
 		const session = await store.createSession(
-			{ projectId: project.id, currentActor: userActor('usr_source') },
+			{ threadId: thread.id, projectId: project.id, currentActor: userActor('usr_source') },
 			DEFAULT_TENANT,
 		)
 
-		const { deps } = buildHandoffDeps(store)
+		const { deps } = buildHandoffDeps(store, threadStore)
 		const assignment: HandoffAssignment = {
 			id: generateHandoffId(),
 			mode: 'single',
 			sourceSessionId: session.id,
 			tenantId: OTHER_TENANT,
+			threadId: thread.id,
 			projectId: project.id,
 			sourceActor: userActor('usr_source', OTHER_TENANT),
 			recipientActor: userActor('usr_target', OTHER_TENANT),
@@ -144,21 +163,27 @@ describe('Integration — single-recipient handoff E2E', () => {
 
 	it('source-owned workspace provisioned for recipient', async () => {
 		const store = new InMemorySessionStore()
+		const threadStore = new InMemoryThreadStore()
 		const project = await store.createProject(
 			{ tenantId: DEFAULT_TENANT, name: 'wsp' },
 			DEFAULT_TENANT,
 		)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'wsp' },
+			DEFAULT_TENANT,
+		)
 		const source = await store.createSession(
-			{ projectId: project.id, currentActor: userActor('usr_source') },
+			{ threadId: thread.id, projectId: project.id, currentActor: userActor('usr_source') },
 			DEFAULT_TENANT,
 		)
 
-		const { deps } = buildHandoffDeps(store)
+		const { deps } = buildHandoffDeps(store, threadStore)
 		const assignment: HandoffAssignment = {
 			id: generateHandoffId(),
 			mode: 'single',
 			sourceSessionId: source.id,
 			tenantId: DEFAULT_TENANT,
+			threadId: thread.id,
 			projectId: project.id,
 			sourceActor: userActor('usr_source'),
 			recipientActor: userActor('usr_target'),
@@ -190,21 +215,27 @@ describe('Integration — single-recipient handoff E2E', () => {
 	it('denormalized tenantId stamped on Session + SubSession records', async () => {
 		const _tenantType: TenantId = DEFAULT_TENANT
 		const store = new InMemorySessionStore()
+		const threadStore = new InMemoryThreadStore()
 		const project = await store.createProject(
 			{ tenantId: DEFAULT_TENANT, name: 'denorm' },
 			DEFAULT_TENANT,
 		)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'denorm' },
+			DEFAULT_TENANT,
+		)
 		const source = await store.createSession(
-			{ projectId: project.id, currentActor: userActor('usr_source') },
+			{ threadId: thread.id, projectId: project.id, currentActor: userActor('usr_source') },
 			DEFAULT_TENANT,
 		)
-		const { deps } = buildHandoffDeps(store)
+		const { deps } = buildHandoffDeps(store, threadStore)
 
 		const assignment: HandoffAssignment = {
 			id: generateHandoffId(),
 			mode: 'single',
 			sourceSessionId: source.id,
 			tenantId: DEFAULT_TENANT,
+			threadId: thread.id,
 			projectId: project.id,
 			sourceActor: userActor('usr_source'),
 			recipientActor: userActor('usr_target'),

package/src/session/__tests__/integration/hierarchy-lifecycle.test.ts

@@ -10,9 +10,12 @@
  */
 
 import { describe, expect, it } from 'vitest'
+import type { ThreadId } from '../../../types/session/ids.js'
 import { TenantIsolationError } from '../../errors.js'
 import { DEFAULT_TENANT, agentActor, buildHarness, userActor } from './_fixtures.js'
 
+const TEST_THREAD_ID = 'thd_test' as ThreadId
+
 describe('Integration — hierarchy lifecycle', () => {
 	it('creates Tenant → Project → Session → SubSession with properly branded IDs', async () => {
 		const { store } = buildHarness()
@@ -23,7 +26,7 @@ describe('Integration — hierarchy lifecycle', () => {
 		expect(project.tenantId.startsWith('tnt_')).toBe(true)
 
 		const session = await store.createSession(
-			{ projectId: project.id, currentActor: userActor('usr_a') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userActor('usr_a') },
 			tenant,
 		)
 		expect(session.id.startsWith('ses_')).toBe(true)
@@ -34,7 +37,7 @@ describe('Integration — hierarchy lifecycle', () => {
 		expect(session.previousActors).toEqual([])
 
 		const childSession = await store.createSession(
-			{ projectId: project.id, currentActor: agentActor('agt_worker') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_worker') },
 			tenant,
 		)
 		const subSession = await store.createSubSession(
@@ -59,15 +62,15 @@ describe('Integration — hierarchy lifecycle', () => {
 
 		const project = await store.createProject({ tenantId: tenant, name: 'drill' }, tenant)
 		const parent = await store.createSession(
-			{ projectId: project.id, currentActor: userActor('usr_root') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userActor('usr_root') },
 			tenant,
 		)
 		const childA = await store.createSession(
-			{ projectId: project.id, currentActor: agentActor('agt_a') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_a') },
 			tenant,
 		)
 		const childB = await store.createSession(
-			{ projectId: project.id, currentActor: agentActor('agt_b') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_b') },
 			tenant,
 		)
 		await store.createSubSession(
@@ -120,7 +123,7 @@ describe('Integration — hierarchy lifecycle', () => {
 		const userC = userActor('usr_c')
 
 		const session = await store.createSession(
-			{ projectId: project.id, currentActor: userA },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userA },
 			tenant,
 		)
 
@@ -154,11 +157,11 @@ describe('Integration — hierarchy lifecycle', () => {
 
 		const project = await store.createProject({ tenantId: tenant, name: 'cycle' }, tenant)
 		const sA = await store.createSession(
-			{ projectId: project.id, currentActor: userActor('usr_a') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userActor('usr_a') },
 			tenant,
 		)
 		const sB = await store.createSession(
-			{ projectId: project.id, currentActor: userActor('usr_b') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userActor('usr_b') },
 			tenant,
 		)
 
@@ -195,11 +198,11 @@ describe('Integration — hierarchy lifecycle', () => {
 
 		const project = await store.createProject({ tenantId: tenant, name: 'lifecycle' }, tenant)
 		const parent = await store.createSession(
-			{ projectId: project.id, currentActor: userActor('usr_a') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userActor('usr_a') },
 			tenant,
 		)
 		const child = await store.createSession(
-			{ projectId: project.id, currentActor: agentActor('agt_a') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_a') },
 			tenant,
 		)
 		const sub = await store.createSubSession(

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

@@ -14,7 +14,12 @@
 import { describe, expect, it } from 'vitest'
 import { InMemorySessionStore } from '../../../store/session/memory.js'
 import type { SessionId } from '../../../types/ids/index.js'
-import type { DeliverableId, SubSessionId, SummaryId } from '../../../types/session/ids.js'
+import type {
+	DeliverableId,
+	SubSessionId,
+	SummaryId,
+	ThreadId,
+} from '../../../types/session/ids.js'
 import {
 	ArtifactRefCycleError,
 	type InterventionChainLoader,
@@ -24,6 +29,8 @@ import {
 import type { DeliverableRef, SessionSummaryDeliverable } from '../../summary/deliverable.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
@@ -68,7 +75,7 @@ async function buildLinearChain(
 	let previous: SessionId | null = null
 	for (let i = 0; i < length; i++) {
 		const s = await store.createSession(
-			{ projectId: project.id, currentActor: agentActor(`agt_${i}`) },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(`agt_${i}`) },
 			DEFAULT_TENANT,
 		)
 		if (previous) {
@@ -260,15 +267,15 @@ describe('Integration — prevArtifactRef DAG against real store', () => {
 			DEFAULT_TENANT,
 		)
 		const sA = await store.createSession(
-			{ projectId: project.id, currentActor: agentActor('agt_a') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_a') },
 			DEFAULT_TENANT,
 		)
 		const sB = await store.createSession(
-			{ projectId: project.id, currentActor: agentActor('agt_b') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_b') },
 			DEFAULT_TENANT,
 		)
 		const sC = await store.createSession(
-			{ projectId: project.id, currentActor: agentActor('agt_c') },
+			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_c') },
 			DEFAULT_TENANT,
 		)
 

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

@@ -15,24 +15,26 @@ import { join } from 'node:path'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { InMemorySessionStore } from '../../../store/session/memory.js'
 import { createUserMessage } from '../../../types/message/index.js'
-import type { WorkspaceId } from '../../../types/session/ids.js'
+import type { ThreadId, WorkspaceId } from '../../../types/session/ids.js'
 import { ArchivalManager, ArchiveNotConfiguredError } from '../../retention/archive.js'
 import { DiskArchiveBackend } from '../../retention/disk-backend.js'
 import type { WorkspaceRef } from '../../workspace/ref.js'
 import { WorkspaceBackendRegistry } from '../../workspace/registry.js'
 import { DEFAULT_TENANT, agentActor, userActor } from './_fixtures.js'
 
+const TEST_THREAD_ID = 'thd_test' as ThreadId
+
 async function seedIdleSubSession(store: InMemorySessionStore) {
 	const project = await store.createProject(
 		{ tenantId: DEFAULT_TENANT, name: 'archive' },
 		DEFAULT_TENANT,
 	)
 	const parent = await store.createSession(
-		{ projectId: project.id, currentActor: userActor('usr_a') },
+		{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userActor('usr_a') },
 		DEFAULT_TENANT,
 	)
 	const child = await store.createSession(
-		{ projectId: project.id, currentActor: agentActor('agt_w') },
+		{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_w') },
 		DEFAULT_TENANT,
 	)
 	const sub = await store.createSubSession(

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

@@ -0,0 +1,313 @@
+/**
+ * Integration — AgentManager.provisionSpawn compensating rollback.
+ *
+ * Covers Codex SPAWN-ROLLBACK critique (ses_001-hierarchy-redesign Phase 2
+ * adversarial review, 2026-04-18). Without the try/catch wrapper around the
+ * createSession → updateSession → createSubSession → workspace.create
+ * mutation block, a failure after createSession leaves an `active` child
+ * session with no subsession edge — invisible to the parent, but counted
+ * against `maxDelegationWidth` and visible to SessionStore.listSessions
+ * consumers (archive/delete flows in ThreadManager).
+ *
+ * Failure modes exercised:
+ *   A. Workspace driver throws on create. Subsession exists; must flip to
+ *      'failed' for audit. Child session must be hard-deleted.
+ *   B. Subsession insert fails (store injection). No subsession recorded.
+ *      Child session must be hard-deleted.
+ *
+ * Assertions in both cases:
+ *   - sendMessage rejects with the underlying error.
+ *   - SessionStore.listSessions(threadId) returns no row with the child id.
+ *   - Parent session remains untouched (status, currentActor).
+ *   - Fan-out cap reclaims the slot (next spawn succeeds up to the same
+ *     width).
+ */
+
+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 { SummaryId } from '../../../types/session/ids.js'
+import { ZERO_COST } from '../../../utils/cost.js'
+import { DefaultCapacityValidator } from '../../handoff/capacity.js'
+import type { ActorRef } from '../../hierarchy/actor.js'
+import { SessionSummaryMaterializer } from '../../summary/materialize.js'
+import type {
+	BranchWorkspaceParams,
+	CreateWorkspaceParams,
+	WorkspaceBackendDriver,
+	WorkspaceInspection,
+} from '../../workspace/driver.js'
+import type { WorkspaceRef } from '../../workspace/ref.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,
+	}
+}
+
+class FailingWorkspaceDriver implements WorkspaceBackendDriver {
+	readonly kind = 'git-worktree' as const
+	createCalls = 0
+
+	async create(_params: CreateWorkspaceParams): Promise<WorkspaceRef> {
+		this.createCalls += 1
+		throw new Error('synthetic workspace backend failure')
+	}
+
+	async branch(_source: WorkspaceRef, _params: BranchWorkspaceParams): Promise<WorkspaceRef> {
+		throw new Error('unused in this test')
+	}
+
+	async dispose(_ref: WorkspaceRef): Promise<void> {
+		/* no-op */
+	}
+
+	async inspect(_ref: WorkspaceRef): Promise<WorkspaceInspection> {
+		throw new Error('unused in this test')
+	}
+}
+
+describe('provisionSpawn compensating rollback', () => {
+	it('workspace driver failure — deletes child session, marks subsession failed, leaves no orphan', async () => {
+		const store = new InMemorySessionStore()
+		const threadStore = new InMemoryThreadStore()
+		const project = await store.createProject(
+			{ tenantId: tenant, name: 'rollback-project' },
+			tenant,
+		)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'rollback-topic' },
+			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 summaryCounter = 0
+		const materializer = new SessionSummaryMaterializer({
+			store,
+			generateSummaryId: () => `sum_test_${++summaryCounter}` as SummaryId,
+		})
+
+		const registry = new AgentRegistry()
+		registry.register(buildDefinition(buildAgent('worker')))
+
+		const workspaceRegistry = new WorkspaceBackendRegistry()
+		const failingDriver = new FailingWorkspaceDriver()
+		workspaceRegistry.register(failingDriver)
+
+		const threadManager = new ThreadManager({ threadStore, sessionStore: store })
+		const manager = new AgentManager(registry, undefined, {
+			sessionStore: store,
+			summaryMaterializer: materializer,
+			workspaceRegistry,
+			capacity: new DefaultCapacityValidator(store),
+			threadManager,
+		})
+
+		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,
+			workspaceBackend: 'git-worktree',
+		}
+
+		await expect(manager.sendMessage(options, taskContext)).rejects.toThrow(
+			'synthetic workspace backend failure',
+		)
+		expect(failingDriver.createCalls).toBe(1)
+
+		// Child session is gone — archive/delete flows and fan-out caps see
+		// zero child attached to the thread beyond the parent.
+		const sessionsOnThread = await store.listSessions(thread.id, tenant)
+		expect(sessionsOnThread.map((s) => s.id)).toEqual([parentSession.id])
+
+		// Parent session is untouched.
+		const refetchedParent = await store.getSession(parentSession.id, tenant)
+		expect(refetchedParent?.status).toBe('active')
+		expect(refetchedParent?.currentActor).toEqual(userActor)
+
+		// No subsession breadcrumb — `subsession_spawned` never fired
+		// (provisionSpawn aborted before buildSpawnRecord), so nothing is
+		// expecting an audit row. Leaving a `status: 'failed'` record would
+		// dangle with no corresponding emission.
+		const subsessions = await store.getChildren(parentSession.id, tenant)
+		expect(subsessions).toHaveLength(0)
+	})
+
+	it('repeated rollback does not accumulate orphan sessions or subsessions', async () => {
+		const store = new InMemorySessionStore()
+		const threadStore = new InMemoryThreadStore()
+		const project = await store.createProject(
+			{
+				tenantId: tenant,
+				name: 'rollback-repeat-project',
+			},
+			tenant,
+		)
+		const thread = await threadStore.createThread(
+			{ projectId: project.id, title: 'rollback-width-topic' },
+			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 summaryCounter = 0
+		const materializer = new SessionSummaryMaterializer({
+			store,
+			generateSummaryId: () => `sum_test_${++summaryCounter}` as SummaryId,
+		})
+
+		const registry = new AgentRegistry()
+		registry.register(buildDefinition(buildAgent('worker')))
+
+		const workspaceRegistry = new WorkspaceBackendRegistry()
+		workspaceRegistry.register(new FailingWorkspaceDriver())
+
+		const threadManager = new ThreadManager({ threadStore, sessionStore: store })
+		const manager = new AgentManager(registry, undefined, {
+			sessionStore: store,
+			summaryMaterializer: materializer,
+			workspaceRegistry,
+			capacity: new DefaultCapacityValidator(store),
+			threadManager,
+		})
+
+		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,
+			workspaceBackend: 'git-worktree',
+		}
+
+		// Two consecutive failing spawns. Without rollback, two orphan
+		// `active` child sessions would accumulate; with rollback, each
+		// attempt cleans up after itself and the store stays at { parent }.
+		await expect(manager.sendMessage(options, taskContext)).rejects.toThrow(
+			'synthetic workspace backend failure',
+		)
+		await expect(manager.sendMessage(options, taskContext)).rejects.toThrow(
+			'synthetic workspace backend failure',
+		)
+
+		// Still no child session under the thread.
+		const sessionsOnThread = await store.listSessions(thread.id, tenant)
+		expect(sessionsOnThread.map((s) => s.id)).toEqual([parentSession.id])
+
+		// No lingering subsession rows — both attempts rolled back cleanly.
+		const subsessions = await store.getChildren(parentSession.id, tenant)
+		expect(subsessions).toHaveLength(0)
+	})
+})

package/src/session/__tests__/integration/summary-materialization-e2e.test.ts

@@ -18,18 +18,20 @@
 import { describe, expect, it } from 'vitest'
 import { InMemorySessionStore } from '../../../store/session/memory.js'
 import type { SessionId } from '../../../types/ids/index.js'
-import type { SummaryId } from '../../../types/session/ids.js'
+import type { SummaryId, ThreadId } from '../../../types/session/ids.js'
 import { SessionSummaryMaterializer } from '../../summary/materialize.js'
 import { SessionAlreadySummarizedError } from '../../summary/ref.js'
 import { DEFAULT_TENANT, agentActor } from './_fixtures.js'
 
+const TEST_THREAD_ID = 'thd_test' as ThreadId
+
 async function seedActive(store: InMemorySessionStore) {
 	const project = await store.createProject(
 		{ tenantId: DEFAULT_TENANT, name: 'summary' },
 		DEFAULT_TENANT,
 	)
 	const session = await store.createSession(
-		{ projectId: project.id, currentActor: agentActor('agt_worker') },
+		{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor('agt_worker') },
 		DEFAULT_TENANT,
 	)
 	await store.updateSession({ ...session, status: 'active' }, DEFAULT_TENANT)