@namzu/sdk 14.0.6 → 15.0.0

package/src/advisory/executor.test.ts

@@ -1,301 +0,0 @@
-/**
- * Current-code invariants asserted (2026-04-21, ses_006 Phase 6):
- *
- *   - `AdvisoryExecutor.consult(advisor, request, callCtx)`:
- *     - Builds a system prompt (see buildSystemPrompt tests).
- *     - Builds a context message block (see buildContext tests).
- *     - Concatenates `[system, ...context, user(question)]` and calls
- *       `advisor.provider.chat(...)` with `toolChoice: 'none'`.
- *     - Parses the response with `parseAdvisoryResponse`, lifting any
- *       `<warnings>` / `<decisions>` blocks out of the prose.
- *     - Returns `{result, usage, cost, durationMs}`. `cost` is computed
- *       from `advisor.pricing` when present, and zero-valued when the
- *       advisor carries none.
- *
- *   - `buildSystemPrompt` priority:
- *     1. `advisor.systemPrompt`.
- *     2. `advisor.persona` (via `assembleSystemPrompt`).
- *     3. Fallback: "You are <name>, an advisory agent." + optional
- *        domains line + "Provide concise, actionable advice..."
- *     Every branch is followed by the response contract, so an advisor
- *     with its own prompt is still told how its answer is read back.
- *
- *   - `buildContext`:
- *     - Returns [] when `request.includeContext === false`.
- *     - Includes workingStateSummary when present.
- *     - Includes a runtime tool summary when a toolCatalog is present
- *       + non-empty; executable schemas remain runtime-owned.
- *     - Includes truncated conversation context (most-recent-first
- *       walk, bounded by `advisor.maxContextTokens * CHARS_PER_TOKEN`).
- *     - Returns [] when no context parts were assembled.
- *
- *   - `truncateMessages(msgs, maxTokens)` walks right-to-left and
- *     includes messages until the char budget is exhausted (in token
- *     terms). Returns the included subset preserving original order.
- *     No limit when `maxTokens` is undefined.
- */
-
-import { describe, expect, it, vi } from 'vitest'
-
-import type { AdvisorDefinition } from '../types/advisory/config.js'
-import type { AdvisoryRequest } from '../types/advisory/result.js'
-import type { Message } from '../types/message/index.js'
-import type {
-	ChatCompletionParams,
-	ChatCompletionResponse,
-	LLMProvider,
-	StreamChunk,
-} from '../types/provider/index.js'
-
-import { type AdvisoryCallContext, AdvisoryExecutor } from './executor.js'
-import { ADVISORY_RESPONSE_CONTRACT } from './parse.js'
-
-/**
- * Builds a minimal mock provider for advisory tests. Phase 2 of
- * ses_001-tool-stream-events removed `chat()` from `LLMProvider`, so
- * the test stubs `chatStream` and `AdvisoryExecutor` consumes via
- * `collect()`. The mock returns a single chunk with the legacy text +
- * usage so the aggregated response shape matches what `chat()` would
- * have returned.
- */
-function mockProvider(response: Partial<ChatCompletionResponse> = {}): LLMProvider {
-	const merged: ChatCompletionResponse = {
-		id: 'resp_1',
-		model: 'm',
-		message: { role: 'assistant', content: 'advice text' },
-		usage: {
-			promptTokens: 100,
-			completionTokens: 50,
-			totalTokens: 150,
-			cachedTokens: 0,
-			cacheWriteTokens: 0,
-		},
-		finishReason: 'stop',
-		...response,
-	}
-	const chatStream = vi.fn<(p: ChatCompletionParams) => AsyncIterable<StreamChunk>>(() => {
-		const chunks: StreamChunk[] = [
-			{ id: merged.id, delta: { content: merged.message.content ?? '' } },
-			{
-				id: merged.id,
-				delta: {},
-				finishReason: merged.finishReason,
-				usage: merged.usage,
-			},
-		]
-		return (async function* () {
-			for (const c of chunks) yield c
-		})()
-	})
-	return {
-		id: 'mock',
-		name: 'Mock',
-		chatStream,
-	}
-}
-
-function advisor(overrides: Partial<AdvisorDefinition> = {}): AdvisorDefinition {
-	return {
-		id: 'adv',
-		name: 'Adv',
-		provider: mockProvider(),
-		model: 'm',
-		...overrides,
-	}
-}
-
-function ctx(overrides: Partial<AdvisoryCallContext> = {}): AdvisoryCallContext {
-	return {
-		messages: [],
-		iteration: 1,
-		...overrides,
-	}
-}
-
-const req: AdvisoryRequest = { question: 'what next?' }
-
-describe('AdvisoryExecutor — consult happy path', () => {
-	it('calls provider.chat with system + question, toolChoice none', async () => {
-		const provider = mockProvider()
-		const e = new AdvisoryExecutor()
-		const a = advisor({ provider, systemPrompt: 'You are Adv.' })
-		await e.consult(a, req, ctx())
-		const call = vi.mocked(provider.chatStream).mock.calls[0]?.[0] as ChatCompletionParams
-		expect(call.model).toBe('m')
-		expect(call.toolChoice).toBe('none')
-		const roles = call.messages.map((m) => m.role)
-		expect(roles[0]).toBe('system')
-		expect(roles.at(-1)).toBe('user')
-	})
-
-	it('returns {result, usage, cost, durationMs}; cost is zero-valued', async () => {
-		const e = new AdvisoryExecutor()
-		const out = await e.consult(advisor(), req, ctx())
-		expect(out.result.advice).toBe('advice text')
-		expect(out.usage.totalTokens).toBe(150)
-		expect(out.cost).toEqual({
-			inputCostPer1M: 0,
-			outputCostPer1M: 0,
-			totalCost: 0,
-			cacheDiscount: 0,
-		})
-		expect(typeof out.durationMs).toBe('number')
-	})
-
-	it('parseResult is currently a passthrough — advice = content verbatim', async () => {
-		const provider = mockProvider({
-			message: { role: 'assistant', content: 'Raw text with **markdown**' },
-		})
-		const e = new AdvisoryExecutor()
-		const out = await e.consult(advisor({ provider }), req, ctx())
-		expect(out.result.advice).toBe('Raw text with **markdown**')
-	})
-
-	it('handles null provider content as empty string', async () => {
-		const provider = mockProvider({
-			message: { role: 'assistant', content: null },
-		})
-		const e = new AdvisoryExecutor()
-		const out = await e.consult(advisor({ provider }), req, ctx())
-		expect(out.result.advice).toBe('')
-	})
-})
-
-describe('AdvisoryExecutor — buildSystemPrompt', () => {
-	it('keeps advisor.systemPrompt and appends the response contract', async () => {
-		const provider = mockProvider()
-		const e = new AdvisoryExecutor()
-		await e.consult(advisor({ provider, systemPrompt: 'FIXED PROMPT' }), req, ctx())
-		const call = vi.mocked(provider.chatStream).mock.calls[0]?.[0] as ChatCompletionParams
-		expect(call.messages[0]?.content).toContain('FIXED PROMPT')
-		expect(call.messages[0]?.content).toContain(ADVISORY_RESPONSE_CONTRACT)
-	})
-
-	it('falls back to name + domains + boilerplate when no systemPrompt or persona', async () => {
-		const provider = mockProvider()
-		const e = new AdvisoryExecutor()
-		await e.consult(
-			advisor({ provider, name: 'Architect', domains: ['security', 'performance'] }),
-			req,
-			ctx(),
-		)
-		const call = vi.mocked(provider.chatStream).mock.calls[0]?.[0] as ChatCompletionParams
-		const systemContent = call.messages[0]?.content ?? ''
-		expect(systemContent).toContain('Architect')
-		expect(systemContent).toContain('security, performance')
-		expect(systemContent).toContain('concise, actionable advice')
-	})
-
-	it('fallback without domains omits the domains line', async () => {
-		const provider = mockProvider()
-		const e = new AdvisoryExecutor()
-		await e.consult(advisor({ provider, name: 'Adv' }), req, ctx())
-		const call = vi.mocked(provider.chatStream).mock.calls[0]?.[0] as ChatCompletionParams
-		const systemContent = call.messages[0]?.content ?? ''
-		expect(systemContent).not.toContain('domains of expertise')
-	})
-})
-
-describe('AdvisoryExecutor — buildContext', () => {
-	it('returns no context message when request.includeContext is false', async () => {
-		const provider = mockProvider()
-		const e = new AdvisoryExecutor()
-		await e.consult(
-			advisor({ provider }),
-			{ question: 'q', includeContext: false },
-			ctx({ workingStateSummary: 'should be ignored' }),
-		)
-		const call = vi.mocked(provider.chatStream).mock.calls[0]?.[0] as ChatCompletionParams
-		// Only system + user(question)
-		expect(call.messages).toHaveLength(2)
-	})
-
-	it('includes workingStateSummary + runtime tool summary when present', async () => {
-		const provider = mockProvider()
-		const e = new AdvisoryExecutor()
-		await e.consult(advisor({ provider }), req, {
-			messages: [],
-			iteration: 1,
-			workingStateSummary: 'state summary here',
-			toolCatalog: [
-				{
-					type: 'function',
-					function: { name: 'read_file', description: 'read', parameters: {} },
-				},
-				{
-					type: 'function',
-					function: { name: 'write_file', description: 'write', parameters: {} },
-				},
-			],
-		})
-		const call = vi.mocked(provider.chatStream).mock.calls[0]?.[0] as ChatCompletionParams
-		const contextMsg = call.messages[1]?.content ?? ''
-		expect(contextMsg).toContain('Working State')
-		expect(contextMsg).toContain('state summary here')
-		expect(contextMsg).toContain('Runtime Tool Summary')
-		expect(contextMsg).toContain('executable schemas remain owned by the runtime tool catalogue')
-		expect(contextMsg).toContain('- read_file: read')
-		expect(contextMsg).toContain('- write_file: write')
-	})
-
-	it('includes conversation context (no truncation when no maxContextTokens)', async () => {
-		const provider = mockProvider()
-		const messages: Message[] = [
-			{ role: 'user', content: 'hi' },
-			{ role: 'assistant', content: 'hello' },
-		]
-		const e = new AdvisoryExecutor()
-		await e.consult(advisor({ provider }), req, ctx({ messages }))
-		const call = vi.mocked(provider.chatStream).mock.calls[0]?.[0] as ChatCompletionParams
-		const contextMsg = call.messages[1]?.content ?? ''
-		expect(contextMsg).toContain('Conversation Context')
-		expect(contextMsg).toContain('[user]: hi')
-		expect(contextMsg).toContain('[assistant]: hello')
-	})
-
-	it('truncates conversation from the back when maxContextTokens is set', async () => {
-		const provider = mockProvider()
-		const messages: Message[] = [
-			{ role: 'user', content: 'a'.repeat(100) }, // oldest — should be dropped
-			{ role: 'user', content: 'recent' },
-		]
-		const e = new AdvisoryExecutor()
-		// maxContextTokens=5 → 5*4=20 char budget; only 'recent' (6 chars) fits.
-		await e.consult(advisor({ provider, maxContextTokens: 5 }), req, ctx({ messages }))
-		const call = vi.mocked(provider.chatStream).mock.calls[0]?.[0] as ChatCompletionParams
-		const contextMsg = call.messages[1]?.content ?? ''
-		expect(contextMsg).toContain('recent')
-		expect(contextMsg).not.toContain('a'.repeat(100))
-	})
-
-	it('omits the context message entirely when there are no context parts', async () => {
-		const provider = mockProvider()
-		const e = new AdvisoryExecutor()
-		await e.consult(advisor({ provider }), req, ctx())
-		const call = vi.mocked(provider.chatStream).mock.calls[0]?.[0] as ChatCompletionParams
-		expect(call.messages).toHaveLength(2)
-	})
-})
-
-describe('AdvisoryExecutor — tool calls in context', () => {
-	it('represents assistant messages with tool calls as "(tool calls)" stub', async () => {
-		const provider = mockProvider()
-		const e = new AdvisoryExecutor()
-		await e.consult(
-			advisor({ provider }),
-			req,
-			ctx({
-				messages: [
-					{
-						role: 'assistant',
-						content: null,
-						toolCalls: [{ id: 't1', type: 'function', function: { name: 'x', arguments: '{}' } }],
-					},
-				],
-			}),
-		)
-		const call = vi.mocked(provider.chatStream).mock.calls[0]?.[0] as ChatCompletionParams
-		const contextMsg = call.messages[1]?.content ?? ''
-		expect(contextMsg).toContain('[assistant]: (tool calls)')
-	})
-})

package/src/advisory/registry.test.ts

@@ -1,75 +0,0 @@
-/**
- * Current-code invariants asserted (2026-04-21, ses_006 Phase 6):
- *
- *   - `AdvisorRegistry` extends the plain `Registry<AdvisorDefinition>`
- *     (NOT `ManagedRegistry` — no warn-log, direct register via `Map.set`).
- *   - Constructor registers every advisor immediately.
- *   - `resolve(advisorId?, domain?)` resolution priority:
- *     1. Explicit `advisorId` (even if unknown — returns undefined).
- *     2. Domain match — first advisor whose `domains[]` includes the domain.
- *     3. Explicit `defaultId`.
- *     4. First registered advisor.
- *     5. Undefined when nothing is registered.
- *   - `listAll()` returns everything in insertion order.
- */
-
-import { describe, expect, it } from 'vitest'
-
-import type { AdvisorDefinition } from '../types/advisory/index.js'
-import type { LLMProvider } from '../types/provider/index.js'
-
-import { AdvisorRegistry } from './registry.js'
-
-const provider = {} as LLMProvider
-
-function makeAdvisor(id: string, domains?: string[]): AdvisorDefinition {
-	return {
-		id,
-		name: id,
-		provider,
-		model: 'opus',
-		domains,
-	}
-}
-
-describe('AdvisorRegistry', () => {
-	it('registers every advisor from the constructor array', () => {
-		const r = new AdvisorRegistry([makeAdvisor('a'), makeAdvisor('b')])
-		expect(r.listAll().map((a) => a.id)).toEqual(['a', 'b'])
-	})
-
-	describe('resolve priority', () => {
-		it('returns the advisor for an explicit advisorId', () => {
-			const r = new AdvisorRegistry([makeAdvisor('a'), makeAdvisor('b')])
-			expect(r.resolve('b')?.id).toBe('b')
-		})
-
-		it('returns undefined for an explicit unknown advisorId (does NOT fall through)', () => {
-			const r = new AdvisorRegistry([makeAdvisor('a')])
-			expect(r.resolve('unknown')).toBeUndefined()
-		})
-
-		it('matches first advisor with a matching domain when no advisorId', () => {
-			const r = new AdvisorRegistry([
-				makeAdvisor('sec', ['security']),
-				makeAdvisor('perf', ['performance']),
-			])
-			expect(r.resolve(undefined, 'performance')?.id).toBe('perf')
-		})
-
-		it('falls back to defaultId when no advisorId and no matching domain', () => {
-			const r = new AdvisorRegistry([makeAdvisor('a'), makeAdvisor('b')], 'b')
-			expect(r.resolve(undefined, 'nope')?.id).toBe('b')
-		})
-
-		it('falls back to first registered advisor when no default', () => {
-			const r = new AdvisorRegistry([makeAdvisor('first'), makeAdvisor('second')])
-			expect(r.resolve(undefined, 'nope')?.id).toBe('first')
-		})
-
-		it('returns undefined on an empty registry with no context', () => {
-			const r = new AdvisorRegistry([])
-			expect(r.resolve()).toBeUndefined()
-		})
-	})
-})

package/src/agents/__tests__/a-policy-nobody-can-select.test.ts

@@ -1,202 +0,0 @@
-import { mkdtemp } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-import { MockLLMProvider, registerMock } from '../../provider/index.js'
-import { ToolRegistry } from '../../registry/index.js'
-import type { Agent } from '../../types/agent/core.js'
-import type { SiblingFailurePolicy } from '../../types/agent/gateway.js'
-import type { AgentManagerContract } from '../../types/agent/manager.js'
-import type {
-	AgentTask,
-	AgentTaskContext,
-	AgentTaskState,
-	SendMessageOptions,
-} from '../../types/agent/task.js'
-import type { RunId, TaskId } from '../../types/ids/index.js'
-import { SupervisorAgent } from '../SupervisorAgent.js'
-
-/**
- * `'cancel-siblings'` was unreachable from every entry point.
- *
- * `LocalTaskGateway` has honoured the policy since it was written and the
- * cancellation machinery behind it is complete — but the policy was the fifth
- * constructor argument of a gateway the supervisor builds itself, and the
- * supervisor passed four. So every host in existence ran `'continue'`, and the
- * only way to reach the other value was to construct the gateway by hand and
- * hand it in through `config.gateway`. A policy nobody can select is not a
- * policy, and the tests it had all constructed the gateway directly, so they
- * passed while nothing upstream could turn it on.
- *
- * The assertion is deliberately the cancellation itself. Asserting that the run
- * completed would pass with the forwarding deleted — a fan-out under
- * `'continue'` completes too — and prove nothing.
- */
-
-registerMock()
-
-const FAILING = 'doomed' as const
-const SLOW = 'patient' as const
-
-/**
- * A manager whose slow child only settles when someone cancels it — which is
- * what an abort actually does, and what lets this run terminate at all.
- */
-class FanOutManager implements AgentManagerContract {
-	readonly cancelled: TaskId[] = []
-	private readonly tasks = new Map<TaskId, AgentTask>()
-	private releaseSlow?: () => void
-	private readonly slowSettled = new Promise<void>((resolve) => {
-		this.releaseSlow = resolve
-	})
-	private markLaunched?: () => void
-	/**
-	 * The doomed child does not settle until BOTH have launched.
-	 *
-	 * Without this the test is a race it usually wins: the sibling policy only
-	 * cancels tasks the gateway is already tracking, so if the failure lands
-	 * before the slow child finishes registering, nothing is cancelled, nothing
-	 * releases the slow child, and the run hangs until the delegation timeout.
-	 * That happened once here. A fan-out where one leg dies while another is
-	 * genuinely in flight is the scenario being tested, so the harness states
-	 * it instead of hoping for it.
-	 */
-	private readonly bothLaunched = new Promise<void>((resolve) => {
-		this.markLaunched = resolve
-	})
-
-	async sendMessage(options: SendMessageOptions): Promise<AgentTask> {
-		const failing = options.agentId === FAILING
-		const taskId = (failing ? 'task_doomed' : 'task_patient') as TaskId
-		const task = {
-			taskId,
-			agentId: options.agentId,
-			agent: {} as Agent<never, never>,
-			childAbortController: new AbortController(),
-			context: {} as AgentTaskContext,
-			// The failing child is `completed` at the gateway layer and
-			// `failed` in its own result — the two-authority split that makes
-			// this worth checking at all.
-			state: (failing ? 'completed' : 'running') as AgentTaskState,
-			pendingMessages: [],
-			createdAt: 1,
-			...(failing
-				? { result: { runId: 'run_child' as RunId, status: 'failed', result: 'it broke' } }
-				: {}),
-		} as AgentTask
-
-		this.tasks.set(taskId, task)
-		if (this.tasks.size === 2) this.markLaunched?.()
-		return task
-	}
-
-	cancel(taskId: TaskId): void {
-		this.cancelled.push(taskId)
-		const task = this.tasks.get(taskId)
-		if (task) task.state = 'failed' as AgentTaskState
-		this.releaseSlow?.()
-	}
-
-	async waitForCompletion(taskId: TaskId): Promise<void> {
-		if (taskId === ('task_patient' as TaskId)) await this.slowSettled
-		// The doomed child fails only once its sibling is actually in flight —
-		// see `bothLaunched`. Registration happens inside `createTask` right
-		// after `sendMessage` returns, so waiting a further microtask turn is
-		// what puts this after it rather than racing it.
-		else {
-			await this.bothLaunched.then(() => undefined)
-			// Safety valve, and it is what makes a REGRESSION legible. If the
-			// policy never reaches the gateway, nothing cancels the slow child
-			// and this run hangs until the delegation timeout — so the test
-			// would report "timed out after 60s" instead of "the sibling was
-			// not cancelled". Releasing it here means the assertion below is
-			// what fails, and it fails in a second.
-			setTimeout(() => this.releaseSlow?.(), 250).unref?.()
-		}
-	}
-
-	getInstance(taskId: TaskId): AgentTask | undefined {
-		return this.tasks.get(taskId)
-	}
-
-	cancelAll(): void {}
-	async continueTask(): Promise<void> {}
-	queueMessage(): void {}
-	drainMessages() {
-		return []
-	}
-	listByParent(): AgentTask[] {
-		return []
-	}
-	listActive(): AgentTask[] {
-		return []
-	}
-	getState(): AgentTaskState | undefined {
-		return undefined
-	}
-	on(): void {}
-	off(): void {}
-	cleanup(): void {}
-	dispose(): void {}
-}
-
-async function fanOut(policy?: SiblingFailurePolicy): Promise<FanOutManager> {
-	const agentManager = new FanOutManager()
-	const agent = new SupervisorAgent({
-		id: 'sup_policy',
-		name: 'Supervisor',
-		version: '1',
-		category: 'test',
-		description: 'coordinates workers',
-	})
-
-	await agent.run(
-		{
-			messages: [{ role: 'user', content: 'go', timestamp: 1 }],
-			workingDirectory: await mkdtemp(join(tmpdir(), 'namzu-sibling-policy-')),
-		} as never,
-		{
-			provider: new MockLLMProvider({
-				turns: [
-					{
-						toolCalls: [
-							{
-								name: 'create_task',
-								args: { agent_id: SLOW, prompt: 'long work', description: 'the patient one' },
-							},
-							{
-								name: 'create_task',
-								args: { agent_id: FAILING, prompt: 'doomed work', description: 'the doomed one' },
-							},
-						],
-					},
-					{ text: 'done' },
-				],
-			}),
-			agentIds: [SLOW, FAILING],
-			agentManager,
-			tools: new ToolRegistry(),
-			systemPrompt: 'You coordinate.',
-			model: 'mock-model',
-			tokenBudget: 100_000,
-			timeoutMs: 30_000,
-			maxIterations: 3,
-			sessionId: 'ses_policy',
-			threadId: 'thd_policy',
-			projectId: 'prj_policy',
-			tenantId: 'tnt_policy',
-			...(policy ? { siblingFailurePolicy: policy } : {}),
-		} as never,
-	)
-
-	return agentManager
-}
-
-describe('a supervisor can say what a failed child means for its siblings', () => {
-	it('reaches the gateway, so cancel-siblings actually stops the rest', async () => {
-		const manager = await fanOut('cancel-siblings')
-
-		expect(manager.cancelled).toContain('task_patient' as TaskId)
-	}, 60_000)
-})