@namzu/sdk 14.0.7 → 15.1.0

package/src/session/summary/__tests__/materialize.test.ts

@@ -1,340 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { TenantIsolationError } from '../../../session/errors.js'
-import { InMemorySessionStore } from '../../../store/session/memory.js'
-import type { AgentId, SessionId, TenantId, UserId } from '../../../types/ids/index.js'
-import type { ActorRef } from '../../../types/session/actor.js'
-import type { SummaryId, ThreadId } from '../../../types/session/ids.js'
-import type { DeliverableRef } from '../../../types/summary/deliverable.js'
-import { AGENT_SUMMARY_MAX_CHARS } from '../../../types/summary/ref.js'
-import { AgentSummaryTooLongError, SessionAlreadySummarizedError } from '../errors.js'
-import { SessionSummaryMaterializer } from '../materialize.js'
-
-const TEST_THREAD_ID = 'thd_test' as ThreadId
-
-const tenantA = 'tnt_alpha' as TenantId
-const tenantB = 'tnt_beta' as TenantId
-
-function userActor(tenantId: TenantId): ActorRef {
-	return { kind: 'user', userId: 'usr_a' as UserId, tenantId }
-}
-
-function agentActor(tenantId: TenantId): ActorRef {
-	return { kind: 'agent', agentId: 'agt_a' as AgentId, tenantId }
-}
-
-function makeSummaryIdGenerator(): () => SummaryId {
-	let n = 0
-	return (): SummaryId => `sum_test_${++n}` as SummaryId
-}
-
-async function seedActiveSession(store: InMemorySessionStore, tenantId: TenantId) {
-	const project = await store.createProject({ tenantId, name: 'p1' }, tenantId)
-	const session = await store.createSession(
-		{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantId) },
-		tenantId,
-	)
-	// Put the session into `active` so the materializer's status-flip behavior
-	// is observable.
-	await store.updateSession({ ...session, status: 'active' }, tenantId)
-	return { project, session: { ...session, status: 'active' as const } }
-}
-
-function buildMaterializer(store: InMemorySessionStore) {
-	return new SessionSummaryMaterializer({
-		store,
-		generateSummaryId: makeSummaryIdGenerator(),
-		now: () => new Date('2026-04-17T00:00:00Z'),
-	})
-}
-
-describe('SessionSummaryMaterializer.materialize', () => {
-	it('materializes on an active session and flips status to idle', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seedActiveSession(store, tenantA)
-		const materializer = buildMaterializer(store)
-
-		const summary = await materializer.materialize({
-			sessionId: session.id,
-			tenantId: tenantA,
-			finalOutcome: { status: 'succeeded', verdict: 'done' },
-			agentSummary: 'Completed task X.',
-			declaredDeliverables: [],
-			keyDecisions: [],
-		})
-
-		expect(summary.id).toBe('sum_test_1')
-		expect(summary.sessionRef).toBe(session.id)
-		expect(summary.materializedBy).toBe('kernel')
-
-		const stored = await store.getSummary(session.id, tenantA)
-		expect(stored?.id).toBe(summary.id)
-
-		const reloaded = await store.getSession(session.id, tenantA)
-		expect(reloaded?.status).toBe('idle')
-	})
-
-	it('rejects an agentSummary exceeding AGENT_SUMMARY_MAX_CHARS', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seedActiveSession(store, tenantA)
-		const materializer = buildMaterializer(store)
-
-		await expect(
-			materializer.materialize({
-				sessionId: session.id,
-				tenantId: tenantA,
-				finalOutcome: { status: 'succeeded' },
-				agentSummary: 'x'.repeat(AGENT_SUMMARY_MAX_CHARS + 1),
-				declaredDeliverables: [],
-				keyDecisions: [],
-			}),
-		).rejects.toBeInstanceOf(AgentSummaryTooLongError)
-	})
-
-	it('rejects re-materialization when a summary already exists', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seedActiveSession(store, tenantA)
-		const materializer = buildMaterializer(store)
-
-		await materializer.materialize({
-			sessionId: session.id,
-			tenantId: tenantA,
-			finalOutcome: { status: 'succeeded' },
-			agentSummary: 'first',
-			declaredDeliverables: [],
-			keyDecisions: [],
-		})
-
-		await expect(
-			materializer.materialize({
-				sessionId: session.id,
-				tenantId: tenantA,
-				finalOutcome: { status: 'succeeded' },
-				agentSummary: 'second',
-				declaredDeliverables: [],
-				keyDecisions: [],
-			}),
-		).rejects.toBeInstanceOf(SessionAlreadySummarizedError)
-	})
-
-	it('rejects cross-tenant materialize with TenantIsolationError', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seedActiveSession(store, tenantA)
-		const materializer = buildMaterializer(store)
-
-		await expect(
-			materializer.materialize({
-				sessionId: session.id,
-				tenantId: tenantB,
-				finalOutcome: { status: 'succeeded' },
-				agentSummary: 'x',
-				declaredDeliverables: [],
-				keyDecisions: [],
-			}),
-		).rejects.toBeInstanceOf(TenantIsolationError)
-	})
-
-	it('preserves declaredDeliverables verbatim in the emitted ref', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seedActiveSession(store, tenantA)
-		const materializer = buildMaterializer(store)
-
-		const deliverables: DeliverableRef[] = [
-			{
-				id: 'del_a' as DeliverableRef['id'],
-				kind: 'file',
-				path: 'src/foo.ts',
-				contentHash: 'abc123',
-				sizeBytes: 42,
-			},
-			{
-				id: 'del_b' as DeliverableRef['id'],
-				kind: 'artifact_blob',
-				storageRef: 'blob://x',
-				mediaType: 'application/json',
-			},
-		]
-
-		const summary = await materializer.materialize({
-			sessionId: session.id,
-			tenantId: tenantA,
-			finalOutcome: { status: 'partial' },
-			agentSummary: '',
-			declaredDeliverables: deliverables,
-			keyDecisions: [],
-		})
-
-		expect(summary.deliverables).toEqual(deliverables)
-	})
-
-	it('preserves keyDecisions verbatim in the emitted ref', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seedActiveSession(store, tenantA)
-		const materializer = buildMaterializer(store)
-
-		const decisions = [
-			{ at: new Date('2026-04-17T01:00:00Z'), summary: 'plan approved' },
-			{ at: new Date('2026-04-17T02:00:00Z'), summary: 'hitl granted' },
-		]
-
-		const summary = await materializer.materialize({
-			sessionId: session.id,
-			tenantId: tenantA,
-			finalOutcome: { status: 'succeeded' },
-			agentSummary: '',
-			declaredDeliverables: [],
-			keyDecisions: decisions,
-		})
-
-		expect(summary.keyDecisions).toEqual(decisions)
-	})
-
-	it('constructs SummaryId via the injected generator', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seedActiveSession(store, tenantA)
-
-		const gen = makeSummaryIdGenerator()
-		const materializer = new SessionSummaryMaterializer({
-			store,
-			generateSummaryId: gen,
-		})
-
-		const summary = await materializer.materialize({
-			sessionId: session.id,
-			tenantId: tenantA,
-			finalOutcome: { status: 'succeeded' },
-			agentSummary: '',
-			declaredDeliverables: [],
-			keyDecisions: [],
-		})
-
-		expect(summary.id).toBe('sum_test_1')
-	})
-
-	it('always sets materializedBy to "kernel"', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seedActiveSession(store, tenantA)
-		const materializer = buildMaterializer(store)
-
-		const summary = await materializer.materialize({
-			sessionId: session.id,
-			tenantId: tenantA,
-			finalOutcome: { status: 'succeeded' },
-			agentSummary: '',
-			declaredDeliverables: [],
-			keyDecisions: [],
-		})
-
-		expect(summary.materializedBy).toBe('kernel')
-	})
-
-	it('leaves already-idle sessions in idle (no spurious flip)', async () => {
-		const store = new InMemorySessionStore()
-		const project = await store.createProject({ tenantId: tenantA, name: 'p1' }, tenantA)
-		const session = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: userActor(tenantA) },
-			tenantA,
-		)
-		// session.status defaults to 'idle'
-		const materializer = buildMaterializer(store)
-
-		await materializer.materialize({
-			sessionId: session.id,
-			tenantId: tenantA,
-			finalOutcome: { status: 'succeeded' },
-			agentSummary: '',
-			declaredDeliverables: [],
-			keyDecisions: [],
-		})
-
-		const reloaded = await store.getSession(session.id, tenantA)
-		expect(reloaded?.status).toBe('idle')
-	})
-
-	it('leaves failed sessions in failed (materialize does not resurrect)', async () => {
-		const store = new InMemorySessionStore()
-		const project = await store.createProject({ tenantId: tenantA, name: 'p1' }, tenantA)
-		const session = await store.createSession(
-			{ threadId: TEST_THREAD_ID, projectId: project.id, currentActor: agentActor(tenantA) },
-			tenantA,
-		)
-		await store.updateSession({ ...session, status: 'failed' }, tenantA)
-		const materializer = buildMaterializer(store)
-
-		await materializer.materialize({
-			sessionId: session.id,
-			tenantId: tenantA,
-			finalOutcome: { status: 'failed', verdict: 'gave up' },
-			agentSummary: '',
-			declaredDeliverables: [],
-			keyDecisions: [],
-		})
-
-		const reloaded = await store.getSession(session.id, tenantA)
-		expect(reloaded?.status).toBe('failed')
-	})
-})
-
-describe('SessionSummaryMaterializer.recover', () => {
-	it('returns null when no summary file exists (no side effect)', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seedActiveSession(store, tenantA)
-		const materializer = buildMaterializer(store)
-
-		const recovered = await materializer.recover(session.id, tenantA)
-		expect(recovered).toBeNull()
-
-		const reloaded = await store.getSession(session.id, tenantA)
-		// No side effect — still active.
-		expect(reloaded?.status).toBe('active')
-	})
-
-	it('flips dangling session status idempotently when summary is present', async () => {
-		const store = new InMemorySessionStore()
-		const { session } = await seedActiveSession(store, tenantA)
-		const materializer = buildMaterializer(store)
-
-		// Simulate mid-crash: write summary directly, then force session back to
-		// active (mimicking a process death between the two atomic writes).
-		await materializer.materialize({
-			sessionId: session.id,
-			tenantId: tenantA,
-			finalOutcome: { status: 'succeeded' },
-			agentSummary: '',
-			declaredDeliverables: [],
-			keyDecisions: [],
-		})
-		const mid = await store.getSession(session.id, tenantA)
-		if (!mid) throw new Error('seed mid session missing')
-		await store.updateSession({ ...mid, status: 'active' }, tenantA)
-
-		const recovered = await materializer.recover(session.id, tenantA)
-		expect(recovered).not.toBeNull()
-
-		const reloaded = await store.getSession(session.id, tenantA)
-		expect(reloaded?.status).toBe('idle')
-
-		// Idempotent: calling recover again with session already idle is a no-op.
-		const recovered2 = await materializer.recover(session.id, tenantA)
-		expect(recovered2?.id).toBe(recovered?.id)
-		const reloaded2 = await store.getSession(session.id, tenantA)
-		expect(reloaded2?.status).toBe('idle')
-	})
-})
-
-describe('SessionSummaryMaterializer missing session', () => {
-	it('throws when the session does not exist', async () => {
-		const store = new InMemorySessionStore()
-		const materializer = buildMaterializer(store)
-
-		await expect(
-			materializer.materialize({
-				sessionId: 'ses_missing' as SessionId,
-				tenantId: tenantA,
-				finalOutcome: { status: 'succeeded' },
-				agentSummary: '',
-				declaredDeliverables: [],
-				keyDecisions: [],
-			}),
-		).rejects.toThrow(/not found/)
-	})
-})

package/src/session/workspace/__tests__/git-worktree.test.ts

@@ -1,262 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { posix } from '../../../test-support/paths.js'
-import type { WorkspaceRef } from '../../../types/workspace/ref.js'
-import { WorkspaceBackendError } from '../../errors.js'
-import {
-	type ExecFile,
-	type ExecFileResult,
-	GitWorktreeDriver,
-	parseWorktreeList,
-} from '../git-worktree.js'
-
-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 }
-}
-
-describe('GitWorktreeDriver', () => {
-	it('create: invokes `git worktree add` with argv array (no shell interpolation)', async () => {
-		const calls: Array<{ file: string; args: readonly string[] }> = []
-		const exec: ExecFile = async (file, args) => {
-			calls.push({ file, args: [...args] })
-			return okExec()
-		}
-		const driver = new GitWorktreeDriver({
-			repoRoot: '/repo',
-			logger: stubLogger(),
-			execFile: exec,
-		})
-		const ref = await driver.create({ label: 'foo', baseRef: 'main' })
-
-		expect(ref.id.startsWith('wsp_')).toBe(true)
-		expect(ref.meta.backend).toBe('git-worktree')
-		expect(ref.meta.branch).toBe('namzu/foo')
-		expect(calls).toHaveLength(1)
-		const call = calls[0]
-		if (!call) throw new Error('missing call')
-		expect(call.file).toBe('git')
-		// `posix()` per element: the worktree path is built with `path.join`,
-		// so it is backslash-separated on Windows. The assertion is about
-		// argv shape and ordering, not separator style.
-		expect(call.args.map(posix)).toEqual([
-			'-C',
-			'/repo',
-			'worktree',
-			'add',
-			'-b',
-			'namzu/foo',
-			'/repo/.namzu/worktrees/foo',
-			'main',
-		])
-	})
-
-	it('create: omits baseRef argv slot when not supplied', async () => {
-		const calls: Array<{ file: string; args: readonly string[] }> = []
-		const exec: ExecFile = async (file, args) => {
-			calls.push({ file, args: [...args] })
-			return okExec()
-		}
-		const driver = new GitWorktreeDriver({
-			repoRoot: '/repo',
-			logger: stubLogger(),
-			execFile: exec,
-		})
-		await driver.create({ label: 'bar' })
-		const call = calls[0]
-		if (!call) throw new Error('missing call')
-		expect(posix(call.args.at(-1))).toBe('/repo/.namzu/worktrees/bar')
-	})
-
-	it('create: wraps failures in WorkspaceBackendError', async () => {
-		const exec: ExecFile = async () => {
-			throw new Error('invalid baseRef')
-		}
-		const driver = new GitWorktreeDriver({
-			repoRoot: '/repo',
-			logger: stubLogger(),
-			execFile: exec,
-		})
-		await expect(driver.create({ baseRef: 'does-not-exist' })).rejects.toBeInstanceOf(
-			WorkspaceBackendError,
-		)
-	})
-
-	it('dispose: removes worktree with --force', async () => {
-		const calls: Array<readonly string[]> = []
-		const exec: ExecFile = async (_file, args) => {
-			calls.push(args)
-			return okExec()
-		}
-		const driver = new GitWorktreeDriver({
-			repoRoot: '/repo',
-			logger: stubLogger(),
-			execFile: exec,
-		})
-		const ref: WorkspaceRef = {
-			id: 'wsp_x' as unknown as WorkspaceRef['id'],
-			meta: {
-				backend: 'git-worktree',
-				repoRoot: '/repo',
-				branch: 'namzu/x',
-				worktreePath: '/repo/.namzu/worktrees/x',
-			},
-			createdAt: new Date(),
-		}
-		await driver.dispose(ref)
-		expect(calls[0]).toEqual([
-			'-C',
-			'/repo',
-			'worktree',
-			'remove',
-			'/repo/.namzu/worktrees/x',
-			'--force',
-		])
-	})
-
-	it('dispose: tolerates missing worktree ("not a working tree")', async () => {
-		const exec: ExecFile = async () => {
-			throw new Error("'/tmp/gone' is not a working tree")
-		}
-		const driver = new GitWorktreeDriver({
-			repoRoot: '/repo',
-			logger: stubLogger(),
-			execFile: exec,
-		})
-		const ref: WorkspaceRef = {
-			id: 'wsp_x' as unknown as WorkspaceRef['id'],
-			meta: {
-				backend: 'git-worktree',
-				repoRoot: '/repo',
-				branch: 'namzu/x',
-				worktreePath: '/tmp/gone',
-			},
-			createdAt: new Date(),
-		}
-		// Must NOT throw — roadmap Risk #3 mitigation.
-		await expect(driver.dispose(ref)).resolves.toBeUndefined()
-	})
-
-	it('dispose: surfaces unexpected failures as WorkspaceBackendError', async () => {
-		const exec: ExecFile = async () => {
-			throw new Error('fatal: permission denied')
-		}
-		const driver = new GitWorktreeDriver({
-			repoRoot: '/repo',
-			logger: stubLogger(),
-			execFile: exec,
-		})
-		const ref: WorkspaceRef = {
-			id: 'wsp_x' as unknown as WorkspaceRef['id'],
-			meta: {
-				backend: 'git-worktree',
-				repoRoot: '/repo',
-				branch: 'namzu/x',
-				worktreePath: '/repo/.namzu/worktrees/x',
-			},
-			createdAt: new Date(),
-		}
-		await expect(driver.dispose(ref)).rejects.toBeInstanceOf(WorkspaceBackendError)
-	})
-
-	it('inspect: parses list output and detects clean tree', async () => {
-		const listStdout = [
-			'worktree /repo/.namzu/worktrees/x',
-			'HEAD abc123',
-			'branch refs/heads/namzu/x',
-			'',
-		].join('\n')
-		let callIndex = 0
-		const exec: ExecFile = async (_file, args) => {
-			callIndex++
-			if (args.includes('list')) return okExec(listStdout)
-			if (args.includes('status')) return okExec('')
-			throw new Error(`unexpected call ${callIndex}`)
-		}
-		const driver = new GitWorktreeDriver({
-			repoRoot: '/repo',
-			logger: stubLogger(),
-			execFile: exec,
-		})
-		const ref: WorkspaceRef = {
-			id: 'wsp_x' as unknown as WorkspaceRef['id'],
-			meta: {
-				backend: 'git-worktree',
-				repoRoot: '/repo',
-				branch: 'namzu/x',
-				worktreePath: '/repo/.namzu/worktrees/x',
-			},
-			createdAt: new Date(),
-		}
-		const inspection = await driver.inspect(ref)
-		expect(inspection.exists).toBe(true)
-		expect(inspection.isDirty).toBe(false)
-	})
-
-	it('inspect: reports dirty when status --porcelain has output', async () => {
-		const listStdout = [
-			'worktree /repo/.namzu/worktrees/x',
-			'HEAD abc123',
-			'branch refs/heads/namzu/x',
-			'',
-		].join('\n')
-		const exec: ExecFile = async (_file, args) => {
-			if (args.includes('list')) return okExec(listStdout)
-			if (args.includes('status')) return okExec(' M path/to/file\n')
-			throw new Error('unexpected')
-		}
-		const driver = new GitWorktreeDriver({
-			repoRoot: '/repo',
-			logger: stubLogger(),
-			execFile: exec,
-		})
-		const ref: WorkspaceRef = {
-			id: 'wsp_x' as unknown as WorkspaceRef['id'],
-			meta: {
-				backend: 'git-worktree',
-				repoRoot: '/repo',
-				branch: 'namzu/x',
-				worktreePath: '/repo/.namzu/worktrees/x',
-			},
-			createdAt: new Date(),
-		}
-		const inspection = await driver.inspect(ref)
-		expect(inspection.isDirty).toBe(true)
-	})
-})
-
-describe('parseWorktreeList', () => {
-	it('returns null when the target path is absent', () => {
-		const stdout = ['worktree /other', 'HEAD abc', 'branch refs/heads/main', ''].join('\n')
-		expect(parseWorktreeList(stdout, '/missing')).toBeNull()
-	})
-
-	it('extracts head + branch for the matching entry', () => {
-		const stdout = [
-			'worktree /repo/.namzu/worktrees/x',
-			'HEAD deadbeef',
-			'branch refs/heads/namzu/x',
-			'',
-			'worktree /other',
-			'HEAD abc',
-			'bare',
-			'',
-		].join('\n')
-		const entry = parseWorktreeList(stdout, '/repo/.namzu/worktrees/x')
-		expect(entry).toEqual({
-			path: '/repo/.namzu/worktrees/x',
-			head: 'deadbeef',
-			branch: 'refs/heads/namzu/x',
-		})
-	})
-})

package/src/session/workspace/__tests__/path-builder.test.ts

@@ -1,51 +0,0 @@
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import type { ProjectId, RunId, SessionId } from '../../../types/ids/index.js'
-import type { SubSessionId } from '../../../types/session/ids.js'
-import { DefaultPathBuilder } from '../path-builder.js'
-
-const projectId = 'prj_abc' as ProjectId
-const sessionId = 'ses_xyz' as SessionId
-const subSessionId = 'sub_qqq' as SubSessionId
-const runId = 'run_rrr' as RunId
-
-describe('DefaultPathBuilder', () => {
-	it('rootDir returns the injected root verbatim', () => {
-		const pb = new DefaultPathBuilder('/tmp/ns')
-		expect(pb.rootDir()).toBe('/tmp/ns')
-	})
-
-	it('projectDir resolves to {root}/projects/{projectId}', () => {
-		const pb = new DefaultPathBuilder('/tmp/ns')
-		expect(pb.projectDir(projectId)).toBe(join('/tmp/ns', 'projects', projectId))
-	})
-
-	it('sessionDir resolves to {root}/projects/{projectId}/sessions/{sessionId}', () => {
-		const pb = new DefaultPathBuilder('/tmp/ns')
-		expect(pb.sessionDir(projectId, sessionId)).toBe(
-			join('/tmp/ns', 'projects', projectId, 'sessions', sessionId),
-		)
-	})
-
-	it('subSessionDir nests under session/subsessions/{subSessionId}', () => {
-		const pb = new DefaultPathBuilder('/tmp/ns')
-		expect(pb.subSessionDir(projectId, sessionId, subSessionId)).toBe(
-			join('/tmp/ns', 'projects', projectId, 'sessions', sessionId, 'subsessions', subSessionId),
-		)
-	})
-
-	it('runDir nests under session/runs/{runId}', () => {
-		const pb = new DefaultPathBuilder('/tmp/ns')
-		expect(pb.runDir(projectId, sessionId, runId)).toBe(
-			join('/tmp/ns', 'projects', projectId, 'sessions', sessionId, 'runs', runId),
-		)
-	})
-
-	it('root injection is per-instance (does not mutate global state)', () => {
-		const a = new DefaultPathBuilder('/tmp/a')
-		const b = new DefaultPathBuilder('/tmp/b')
-		expect(a.rootDir()).toBe('/tmp/a')
-		expect(b.rootDir()).toBe('/tmp/b')
-		expect(a.projectDir(projectId)).not.toBe(b.projectDir(projectId))
-	})
-})