@namzu/sdk 14.0.7 → 15.0.0

package/src/tools/builtins/__tests__/write-file.test.ts

@@ -1,177 +0,0 @@
-import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import type { FileReadTracker, ToolContext } from '../../../types/tool/index.js'
-import { WriteFileTool } from '../write-file.js'
-
-function makeTracker(): FileReadTracker & { keys(): string[] } {
-	const set = new Set<string>()
-	return {
-		recordRead: (k) => {
-			set.add(k)
-		},
-		hasRead: (k) => set.has(k),
-		keys: () => Array.from(set),
-	}
-}
-
-function makeContext(workingDirectory: string, tracker?: FileReadTracker): ToolContext {
-	return {
-		runId: 'run_test' as ToolContext['runId'],
-		workingDirectory,
-		abortSignal: new AbortController().signal,
-		env: {},
-		log: () => {},
-		fileReadTracker: tracker,
-	}
-}
-
-/**
- * The published contract, pinned exactly.
- *
- * This was dropped when the tool gained `newStr`, and dropping it is what let
- * the two contracts drift apart silently. They are deliberately NOT the same
- * contract, and that is the thing worth recording: a host driving `execute`
- * directly may pass `newStr`, and a model may not — because a model given two
- * names for the body has to choose, and choosing is what produces the
- * half-filled calls the closed model schema exists to prevent. Nothing said
- * that out loud once the test asserting it was rewritten to assert the
- * opposite.
- */
-describe('WriteFileTool — the published contract', () => {
-	it('publishes one closed path + content shape to the model', () => {
-		expect(WriteFileTool.modelInputSchema).toEqual({
-			type: 'object',
-			properties: {
-				path: {
-					type: 'string',
-					description: 'Relative path to the file to write. Must not be empty.',
-				},
-				content: {
-					type: 'string',
-					description:
-						'Complete file body. Use "" only for an intentionally empty file. Keep under 12000 characters.',
-				},
-			},
-			required: ['path', 'content'],
-			additionalProperties: false,
-		})
-		expect(WriteFileTool.enforceModelInput).toBe(true)
-	})
-
-	it('keeps newStr off the model surface while accepting it from a host', () => {
-		const modelProperties = WriteFileTool.modelInputSchema?.properties as Record<string, unknown>
-		expect(Object.keys(modelProperties)).not.toContain('newStr')
-
-		// The execution schema is the wider one, on purpose.
-		expect(WriteFileTool.inputSchema.safeParse({ path: 'doc.md', newStr: 'body' }).success).toBe(
-			true,
-		)
-	})
-
-	it('requires a body under one name or the other', () => {
-		expect(WriteFileTool.inputSchema.safeParse({ path: 'doc.md' }).success).toBe(false)
-		// An empty string is a body — an intentionally empty file is legal.
-		expect(WriteFileTool.inputSchema.safeParse({ path: 'doc.md', content: '' }).success).toBe(true)
-	})
-
-	it('refuses a whitespace-only path but not a path with edge whitespace', async () => {
-		expect(WriteFileTool.inputSchema.safeParse({ path: '   ', content: 'body' }).success).toBe(
-			false,
-		)
-
-		// The refusal above must not over-reach: ' fresh.txt ' is a legal name
-		// on every filesystem this runs on, and trimming it would write to a
-		// different file than the caller asked for.
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
-		const result = await WriteFileTool.execute(
-			{ path: ' fresh.txt ', content: 'hello' },
-			makeContext(dir),
-		)
-
-		expect(result.success).toBe(true)
-		expect(readFileSync(join(dir, ' fresh.txt '), 'utf-8')).toBe('hello')
-	})
-
-	it('rejects an undeclared field even when execute is called directly', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
-
-		const result = await WriteFileTool.execute(
-			{ path: 'fresh.txt', content: 'hello', append: true } as never,
-			makeContext(dir),
-		)
-
-		expect(result.success).toBe(false)
-		expect(result.error).toContain('Invalid write input')
-	})
-})
-
-describe('WriteFileTool — read-before-overwrite invariant', () => {
-	it('writes a new file without requiring a prior read', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
-		const tracker = makeTracker()
-		const ctx = makeContext(dir, tracker)
-
-		const result = await WriteFileTool.execute({ path: 'fresh.txt', content: 'hello' }, ctx)
-
-		expect(result.success).toBe(true)
-		expect(readFileSync(join(dir, 'fresh.txt'), 'utf-8')).toBe('hello')
-		expect(tracker.hasRead(join(dir, 'fresh.txt'))).toBe(true)
-	})
-
-	it('accepts newStr as the canonical create/write content alias', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
-		const tracker = makeTracker()
-		const ctx = makeContext(dir, tracker)
-
-		const result = await WriteFileTool.execute({ path: 'fresh.txt', newStr: 'hello' }, ctx)
-
-		expect(result.success).toBe(true)
-		expect(readFileSync(join(dir, 'fresh.txt'), 'utf-8')).toBe('hello')
-	})
-
-	it('refuses to overwrite an existing file the agent has not read', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
-		writeFileSync(join(dir, 'pre-existing.txt'), 'original')
-		const tracker = makeTracker()
-		const ctx = makeContext(dir, tracker)
-
-		const result = await WriteFileTool.execute(
-			{ path: 'pre-existing.txt', content: 'replaced' },
-			ctx,
-		)
-
-		expect(result.success).toBe(false)
-		expect(result.error).toMatch(/already exists.*read/i)
-		expect(readFileSync(join(dir, 'pre-existing.txt'), 'utf-8')).toBe('original')
-	})
-
-	it('allows overwrite once the file has been read in the same context', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
-		const filePath = join(dir, 'pre-existing.txt')
-		writeFileSync(filePath, 'original')
-		const tracker = makeTracker()
-		tracker.recordRead(filePath)
-		const ctx = makeContext(dir, tracker)
-
-		const result = await WriteFileTool.execute(
-			{ path: 'pre-existing.txt', content: 'replaced' },
-			ctx,
-		)
-
-		expect(result.success).toBe(true)
-		expect(readFileSync(filePath, 'utf-8')).toBe('replaced')
-	})
-
-	it('falls back to legacy behaviour when no fileReadTracker is provided (back-compat)', async () => {
-		const dir = mkdtempSync(join(tmpdir(), 'namzu-write-'))
-		writeFileSync(join(dir, 'legacy.txt'), 'before')
-		const ctx = makeContext(dir)
-
-		const result = await WriteFileTool.execute({ path: 'legacy.txt', content: 'after' }, ctx)
-
-		expect(result.success).toBe(true)
-		expect(readFileSync(join(dir, 'legacy.txt'), 'utf-8')).toBe('after')
-	})
-})

package/src/tools/coordinator/__tests__/a-failed-worker-is-not-an-answer.test.ts

@@ -1,133 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { TaskGateway, TaskHandle } from '../../../types/agent/gateway.js'
-import type { TaskId } from '../../../types/ids/index.js'
-import type { ToolDefinition } from '../../../types/tool/index.js'
-import { buildCoordinatorTools } from '../index.js'
-import { failureLabel, taskSucceeded } from '../outcome.js'
-
-/**
- * A worker that ran and failed was reported to the model as an answer.
- *
- * Two layers can disagree. `finalizeChild` always calls `markCompleted`, so the
- * gateway's `state` is `'completed'` for a child whose run returned
- * `status: 'failed'` — and `create_task` asked only that layer. The model then
- * read the failure text as a result, the tool result carried `isError: false`,
- * and the plan task was written closed as though the work had been done.
- *
- * The correct predicate existed twenty lines away in the canonical `Agent`
- * tool, put there because a review caught it on that site. Nothing carried the
- * answer to the other one. So this file tests the shared predicate, and the
- * predicate is shared so there is no longer a second place to forget.
- */
-
-const handle = (
-	state: TaskHandle['state'],
-	status?: string,
-): Pick<TaskHandle, 'state' | 'result'> =>
-	({ state, result: status === undefined ? undefined : { status } }) as Pick<
-		TaskHandle,
-		'state' | 'result'
-	>
-
-describe('success needs both authorities to agree', () => {
-	it('refuses a child the gateway called complete but whose run failed', () => {
-		// The exact shape the kernel produces: markCompleted was called, and
-		// the run underneath it did not succeed.
-		expect(taskSucceeded(handle('completed', 'failed'))).toBe(false)
-	})
-
-	it('accepts a child both layers agree on', () => {
-		expect(taskSucceeded(handle('completed', 'completed'))).toBe(true)
-	})
-
-	it('accepts a gateway that reports no run status at all', () => {
-		// A host gateway need not surface a run status. Treating its absence as
-		// failure would break every such gateway, so absence means "this layer
-		// has no opinion" rather than "it went wrong".
-		expect(taskSucceeded(handle('completed'))).toBe(true)
-	})
-
-	it('refuses a child that never reached a completed state', () => {
-		expect(taskSucceeded(handle('failed', 'completed'))).toBe(false)
-		expect(taskSucceeded(handle('canceled'))).toBe(false)
-	})
-})
-
-describe('the failure is named by whichever layer reported it', () => {
-	it('uses the task state when the task itself did not complete', () => {
-		// "failed" would lose the distinction a reader needs: a cancelled task
-		// and a task whose run errored call for different next moves.
-		expect(failureLabel(handle('canceled', 'completed'))).toBe('canceled')
-	})
-
-	it('uses the run status when the task completed but the run did not', () => {
-		expect(failureLabel(handle('completed', 'failed'))).toBe('failed')
-	})
-
-	it('falls back to a plain word when neither layer said anything useful', () => {
-		expect(failureLabel(handle('completed'))).toBe('failed')
-	})
-})
-
-describe('create_task itself reaches the predicate', () => {
-	/**
-	 * The unit tests above prove the predicate is right. They would all pass
-	 * with `create_task` still asking only the gateway — which is exactly the
-	 * state that shipped, with the correct version sitting twenty lines away in
-	 * a sibling tool.
-	 *
-	 * So this drives the tool.
-	 */
-	function toolFor(handle: TaskHandle): ToolDefinition {
-		const gateway = {
-			createTask: async () => ({ ...handle, state: 'running' }),
-			waitForTask: async () => handle,
-			getTask: () => handle,
-			listTasks: () => [handle],
-			cancelTask: () => undefined,
-			continueTask: async () => undefined,
-			onTaskCompleted: () => () => undefined,
-		} as unknown as TaskGateway
-
-		const tools = buildCoordinatorTools({
-			gateway,
-			workingDirectory: '/tmp/test',
-			allowedAgentIds: ['reviewer'],
-		})
-		const createTask = tools.find((t) => t.name === 'create_task')
-		if (!createTask) throw new Error('create_task was not built')
-		return createTask
-	}
-
-	const settled = (status: string): TaskHandle =>
-		({
-			taskId: 'tsk_1' as TaskId,
-			agentId: 'reviewer',
-			// The kernel's own shape: markCompleted ran regardless of the run.
-			state: 'completed',
-			createdAt: 1_000,
-			completedAt: 2_000,
-			result: { status, result: 'the worker text', lastError: 'it blew up' },
-		}) as unknown as TaskHandle
-
-	it('reports a failed run as a failure', async () => {
-		const tool = toolFor(settled('failed'))
-		const result = await tool.execute(
-			{ agent_id: 'reviewer', prompt: 'go', description: 'a task' },
-			{ toolUseId: 'call_1' } as never,
-		)
-
-		expect(result.success, 'a failed worker was reported as an answer').toBe(false)
-	})
-
-	it('still reports a successful run as a success', async () => {
-		const tool = toolFor(settled('completed'))
-		const result = await tool.execute(
-			{ agent_id: 'reviewer', prompt: 'go', description: 'a task' },
-			{ toolUseId: 'call_1' } as never,
-		)
-
-		expect(result.success).toBe(true)
-	})
-})

package/src/tools/coordinator/__tests__/a-listing-is-not-a-back-door.test.ts

@@ -1,171 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import type { TaskGateway, TaskHandle } from '../../../types/agent/gateway.js'
-import type { TaskId } from '../../../types/ids/index.js'
-import type { ToolContext } from '../../../types/tool/index.js'
-import { buildCoordinatorTools } from '../index.js'
-
-/**
- * A supervisor could read a sibling run's worker output by listing.
- *
- * `SupervisorAgentConfig.gateway` exists so a host can hand the SAME gateway to
- * several runs, which makes `listTasks()` gateway-wide by design.
- * `agent_task_list` handed that straight to the model — including each task's
- * `result`, the worker's actual output — and `wait_for_task` had the same reach
- * through `getTask`.
- *
- * `CompletionInbox` closed exactly this on the push side, because
- * `onTaskCompleted` is a broadcast and a shared gateway would otherwise hand
- * each supervisor the other's completions. The pull side kept no such record
- * and asked the gateway directly, so the same leak stayed open through a
- * different door.
- */
-
-const AGENTS = ['reviewer', 'researcher']
-
-function makeContext(): ToolContext {
-	return {
-		runId: 'run_scope' as never,
-		workingDirectory: '/tmp/test',
-		abortSignal: new AbortController().signal,
-		env: {},
-		log: () => {},
-	}
-}
-
-/** One gateway, as a host sharing it between two supervisors would have. */
-function sharedGateway() {
-	const handles = new Map<string, TaskHandle>()
-	let seq = 0
-
-	const gateway = {
-		createTask: async (opts: { agentId: string }) => {
-			seq += 1
-			const taskId = `tsk_${seq}` as TaskId
-			const handle: TaskHandle = {
-				taskId,
-				agentId: opts.agentId,
-				state: 'completed',
-				createdAt: 1_000,
-				completedAt: 2_000,
-				result: {
-					status: 'completed',
-					result: `output of ${opts.agentId} on ${taskId}`,
-				} as TaskHandle['result'],
-			}
-			handles.set(taskId, handle)
-			return handle
-		},
-		waitForTask: async (taskId: TaskId) => handles.get(taskId) as TaskHandle,
-		getTask: (taskId: TaskId) => handles.get(taskId),
-		listTasks: () => [...handles.values()],
-		cancelTask: () => undefined,
-		continueTask: async () => undefined,
-		onTaskCompleted: () => () => {},
-	} as unknown as TaskGateway
-
-	return gateway
-}
-
-/** A run's own coordinator surface over a gateway it may be sharing. */
-function runOver(gateway: TaskGateway) {
-	const tools = buildCoordinatorTools({
-		gateway,
-		workingDirectory: '/tmp/test',
-		allowedAgentIds: AGENTS,
-	})
-	const named = (name: string) => {
-		const t = tools.find((tool) => tool.name === name)
-		if (!t) throw new Error(`${name} missing from coordinator builder`)
-		return t
-	}
-	return {
-		launch: (agentId: string) =>
-			named('create_task').execute(
-				{ agent_id: agentId, prompt: 'work', description: `${agentId} work` },
-				makeContext(),
-			),
-		list: () => named('agent_task_list').execute({}, makeContext()),
-		waitFor: (taskId: string) => named('wait_for_task').execute({ task_id: taskId }, makeContext()),
-	}
-}
-
-describe('one run cannot read another run through the listing', () => {
-	it('lists only the tasks this run launched', async () => {
-		const gateway = sharedGateway()
-		const first = runOver(gateway)
-		const second = runOver(gateway)
-
-		await first.launch('reviewer')
-		await second.launch('researcher')
-
-		const listed = await second.list()
-
-		// Its own, yes.
-		expect(listed.output).toContain('tsk_2')
-		// The sibling's task, and — the part that matters — the sibling's
-		// worker output, which the listing renders inline.
-		expect(listed.output).not.toContain('tsk_1')
-		expect(listed.output).not.toContain('output of reviewer')
-	})
-
-	it('counts only its own in the summary', async () => {
-		// The summary is what a supervisor reads to decide "done vs not done".
-		// A total that includes a sibling's tasks is a wrong answer to that
-		// question even when no output leaks with it.
-		const gateway = sharedGateway()
-		const first = runOver(gateway)
-		const second = runOver(gateway)
-
-		await first.launch('reviewer')
-		await first.launch('reviewer')
-		await second.launch('researcher')
-
-		const listed = await second.list()
-		const data = listed.data as { summary: { total: number }; items: unknown[] }
-
-		expect(data.summary.total).toBe(1)
-		expect(data.items).toHaveLength(1)
-	})
-
-	it('refuses to wait on a task another run launched', async () => {
-		const gateway = sharedGateway()
-		const first = runOver(gateway)
-		const second = runOver(gateway)
-
-		await first.launch('reviewer')
-
-		const waited = await second.waitFor('tsk_1')
-
-		expect(waited.success).toBe(false)
-		expect(waited.output).not.toContain('output of reviewer')
-	})
-
-	it('says the same thing about a task that never existed', async () => {
-		// The refusal must not distinguish "belongs to someone else" from
-		// "never existed". Confirming a real id to a run that should not know
-		// it is the leak in miniature.
-		const gateway = sharedGateway()
-		const first = runOver(gateway)
-		const second = runOver(gateway)
-
-		await first.launch('reviewer')
-
-		const sibling = await second.waitFor('tsk_1')
-		const fictional = await second.waitFor('tsk_9999')
-
-		expect(sibling.output).toBe(fictional.output.replace('tsk_9999', 'tsk_1'))
-	})
-
-	it('still lets a run wait on its own task', async () => {
-		// The scope has to be a filter, not a wall — a run that launched a task
-		// must still be able to read it back, or the fix breaks delegation.
-		const gateway = sharedGateway()
-		const only = runOver(gateway)
-
-		await only.launch('reviewer')
-		const waited = await only.waitFor('tsk_1')
-
-		expect(waited.success).toBe(true)
-	})
-})

package/src/tools/coordinator/__tests__/a-plan-step-reports-its-own-outcome.test.ts

@@ -1,215 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { PlanManager } from '../../../manager/plan/lifecycle.js'
-import type { TaskGateway, TaskHandle } from '../../../types/agent/gateway.js'
-import type { RunId, TaskId } from '../../../types/ids/index.js'
-import type { ToolContext, ToolDefinition } from '../../../types/tool/index.js'
-import { buildCoordinatorTools } from '../index.js'
-
-/**
- * A plan's steps had no relationship to the work that carried them out.
- *
- * `approve_plan` built steps, `create_task` launched workers, and nothing
- * connected the two — so no step could ever be observed, `updateStepStatus` had
- * no production caller, and a plan could reach `failed` (the error path calls
- * `failPlan`) or sit at `executing` forever, but never `completed`.
- *
- * Two bindings close it, because there are two kinds of step. A DELEGATED step
- * reports through the `create_task` that carries it out. An ORCHESTRATOR-OWNED
- * step has no tool call to bind to at all, and reports through
- * `update_plan_step` — without which a plan containing one could never settle
- * however well it went.
- */
-
-const RUN = 'run_step_binding' as RunId
-
-function gatewayReturning(outcome: 'ok' | 'failed'): TaskGateway {
-	const handle = (taskId: TaskId): TaskHandle => ({
-		taskId,
-		agentId: 'worker',
-		state: 'completed',
-		createdAt: 1_000,
-		completedAt: 2_000,
-		result: (outcome === 'ok'
-			? { status: 'completed', result: 'the work' }
-			: { status: 'failed', lastError: 'the worker died' }) as TaskHandle['result'],
-	})
-	return {
-		async createTask() {
-			return handle('tsk_1' as TaskId)
-		},
-		async waitForTask(id) {
-			return handle(id)
-		},
-		async continueTask() {},
-		cancelTask() {},
-		getTask(id) {
-			return handle(id)
-		},
-		listTasks() {
-			return []
-		},
-		onTaskCompleted() {
-			return () => {}
-		},
-	}
-}
-
-function ctx(): ToolContext {
-	return {
-		runId: RUN,
-		workingDirectory: '/tmp/test',
-		abortSignal: new AbortController().signal,
-		env: {},
-		log: () => {},
-	}
-}
-
-/** An approved two-step plan: one delegated, one the orchestrator's own. */
-function approvedPlan(): PlanManager {
-	const pm = new PlanManager(RUN, async () => ({ approved: true }))
-	pm.startGenerating('do the work')
-	pm.addStep({
-		id: 'step_1',
-		description: 'delegated work',
-		agentId: 'worker',
-		dependsOn: [],
-		order: 1,
-	})
-	pm.addStep({ id: 'step_2', description: 'my own work', dependsOn: [], order: 2 })
-	pm.markReady()
-	pm.approve()
-	pm.startExecution()
-	return pm
-}
-
-function toolsOver(pm: PlanManager, gateway: TaskGateway): (name: string) => ToolDefinition {
-	const tools = buildCoordinatorTools({
-		gateway,
-		workingDirectory: '/tmp/test',
-		allowedAgentIds: ['worker'],
-		getPlanManager: () => pm,
-	})
-	return (name: string) => {
-		const t = tools.find((tool) => tool.name === name)
-		if (!t) throw new Error(`${name} missing from coordinator builder`)
-		return t
-	}
-}
-
-const stepStatus = (pm: PlanManager, id: string) =>
-	pm.active?.steps.find((s) => s.id === id)?.status
-
-describe('a delegated step reports through the launch that carries it out', () => {
-	it('completes the step when the worker succeeded', async () => {
-		const pm = approvedPlan()
-		const named = toolsOver(pm, gatewayReturning('ok'))
-
-		await named('create_task').execute(
-			{ agent_id: 'worker', prompt: 'go', description: 'do it', plan_step_id: 'step_1' },
-			ctx(),
-		)
-
-		expect(stepStatus(pm, 'step_1')).toBe('completed')
-	})
-
-	it('fails the step when the worker failed, from both authorities', async () => {
-		// The handle is `state: 'completed'` with `result.status: 'failed'` —
-		// the split that made a failed worker read as an answer. The step must
-		// follow the run status, not the gateway state.
-		const pm = approvedPlan()
-		const named = toolsOver(pm, gatewayReturning('failed'))
-
-		await named('create_task').execute(
-			{ agent_id: 'worker', prompt: 'go', description: 'do it', plan_step_id: 'step_1' },
-			ctx(),
-		)
-
-		expect(stepStatus(pm, 'step_1')).toBe('failed')
-	})
-
-	it('leaves the plan alone when the launch names no step', async () => {
-		// A launch outside the approved plan must not silently settle one.
-		const pm = approvedPlan()
-		const named = toolsOver(pm, gatewayReturning('ok'))
-
-		await named('create_task').execute(
-			{ agent_id: 'worker', prompt: 'go', description: 'unrelated work' },
-			ctx(),
-		)
-
-		expect(stepStatus(pm, 'step_1')).toBe('pending')
-	})
-})
-
-describe('an orchestrator-owned step reports through update_plan_step', () => {
-	it('records the outcome and says what is still outstanding', async () => {
-		const pm = approvedPlan()
-		const named = toolsOver(pm, gatewayReturning('ok'))
-
-		const result = await named('update_plan_step').execute(
-			{ step_id: 'step_2', status: 'completed' },
-			ctx(),
-		)
-
-		expect(result.success).toBe(true)
-		expect(stepStatus(pm, 'step_2')).toBe('completed')
-		// step_1 has not reported, and saying so is the point — this is what
-		// tells the model the plan cannot settle yet.
-		expect(result.output).toContain('step_1')
-	})
-
-	it('treats skipped as a real outcome, not a failure', async () => {
-		const pm = approvedPlan()
-		const named = toolsOver(pm, gatewayReturning('ok'))
-
-		await named('update_plan_step').execute({ step_id: 'step_2', status: 'skipped' }, ctx())
-
-		expect(stepStatus(pm, 'step_2')).toBe('skipped')
-	})
-
-	it('refuses an id the plan does not have, and names the ones it does', async () => {
-		const pm = approvedPlan()
-		const named = toolsOver(pm, gatewayReturning('ok'))
-
-		const result = await named('update_plan_step').execute(
-			{ step_id: 'step_9', status: 'completed' },
-			ctx(),
-		)
-
-		expect(result.success).toBe(false)
-		expect(result.error).toContain('step_1')
-		expect(result.error).toContain('step_2')
-	})
-})
-
-describe('the two bindings together let a plan settle', () => {
-	it('reaches completed once every step has reported', async () => {
-		const pm = approvedPlan()
-		const named = toolsOver(pm, gatewayReturning('ok'))
-
-		await named('create_task').execute(
-			{ agent_id: 'worker', prompt: 'go', description: 'do it', plan_step_id: 'step_1' },
-			ctx(),
-		)
-		await named('update_plan_step').execute({ step_id: 'step_2', status: 'completed' }, ctx())
-
-		expect(pm.unreportedSteps).toHaveLength(0)
-		expect(pm.completePlan()?.status).toBe('completed')
-	})
-
-	it('leaves the plan unsettled while a step is still silent', async () => {
-		// The state the kernel reads before deciding whether to settle. An
-		// unreported step means the caller and the plan disagree about whether
-		// the work is over, and the run must not resolve that by guessing.
-		const pm = approvedPlan()
-		const named = toolsOver(pm, gatewayReturning('ok'))
-
-		await named('create_task').execute(
-			{ agent_id: 'worker', prompt: 'go', description: 'do it', plan_step_id: 'step_1' },
-			ctx(),
-		)
-
-		expect(pm.unreportedSteps.map((s) => s.id)).toEqual(['step_2'])
-	})
-})