@namzu/sdk 9.0.0 → 11.0.0

package/src/agents/SupervisorAgent.ts

@@ -3,7 +3,6 @@ import { CompletionInbox } from '../gateway/completion-inbox.js'
 import { LocalTaskGateway } from '../gateway/local.js'
 import { ToolNameCollisionError, ToolRegistry } from '../registry/tool/execute.js'
 import { drainQuery } from '../runtime/query/index.js'
-import type { LaunchedTaskMeta } from '../runtime/query/iteration/phases/context.js'
 import { PendingAnswers, QuestionParkBinding } from '../runtime/query/question-park.js'
 import { buildCoordinatorTools } from '../tools/coordinator/index.js'
 import type { TaskGateway, TaskHandle } from '../types/agent/gateway.js'
@@ -15,7 +14,7 @@ import type {
 	SupervisorAgentResult,
 } from '../types/agent/index.js'
 import type { AgentTaskContext } from '../types/agent/task.js'
-import type { AgentId, RunId, TaskId } from '../types/ids/index.js'
+import type { AgentId, RunId } from '../types/ids/index.js'
 import { deriveChildState } from '../types/invocation/index.js'
 import type { RunEventListener } from '../types/run/index.js'
 import type { ActorRef } from '../types/session/actor.js'
@@ -171,8 +170,6 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 			throw new Error("SupervisorAgentConfig requires either 'gateway' or 'agentManager'")
 		}
 
-		const launchedTasks = new Map<TaskId, LaunchedTaskMeta>()
-
 		let planManagerRef: import('../manager/plan/lifecycle.js').PlanManager | undefined
 
 		// Created here because the TOOLS are created here: the durability
@@ -212,9 +209,6 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 				taskStore: input.taskStore,
 				runId,
 				getPlanManager: () => planManagerRef,
-				onTaskLaunched: (agentTaskId, meta) => {
-					launchedTasks.set(agentTaskId, meta)
-				},
 				// With a resume handler present the coordinator surface gains
 				// ask_user_question — the model can park the run on a question
 				// routed through the same HITL channel as plan approvals.
@@ -334,7 +328,6 @@ export class SupervisorAgent extends AbstractAgent<SupervisorAgentConfig, Superv
 					runtimeContext: input.runtimeContext,
 					taskGateway: gateway,
 					completionInbox,
-					launchedTasks,
 					advisory: config.advisory,
 					invocationState: childInvocationState,
 					// HITL surface: forward optional review-time hooks so hosts can

package/src/manager/plan/lifecycle.ts

@@ -95,6 +95,20 @@ export class PlanManager {
 		return this.currentPlan?.status === 'pending_approval'
 	}
 
+	/**
+	 * Steps that have not said how they went — the reason `completePlan` may
+	 * refuse, exposed so a caller can ask before it commits.
+	 *
+	 * The kernel settles a successful plan only when this is empty. It cannot
+	 * catch the refusal instead: a throw on the success path would turn a run
+	 * that worked into a run that crashed on its way out, which is a worse
+	 * version of the bug the refusal exists to prevent.
+	 */
+	get unreportedSteps(): readonly PlanStep[] {
+		if (!this.currentPlan) return []
+		return this.currentPlan.steps.filter((s) => s.status === 'pending' || s.status === 'running')
+	}
+
 	startGenerating(title: string): Plan {
 		const plan: Plan = {
 			id: generatePlanId(),

package/src/runtime/query/__tests__/a-plan-that-succeeded-says-so.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it } from 'vitest'
+
+import type { PlanManager } from '../../../manager/plan/lifecycle.js'
+import { MockLLMProvider, registerMock } from '../../../provider/index.js'
+import { ToolRegistry } from '../../../registry/index.js'
+import {
+	generateProjectId,
+	generateSessionId,
+	generateTenantId,
+	generateThreadId,
+} from '../../../utils/id.js'
+import { drainQuery } from '../index.js'
+
+/**
+ * Nothing settled a plan that SUCCEEDED.
+ *
+ * The error path calls `failPlan`, so a run that blew up said so. The success
+ * path never touched the plan manager at all — so a plan could reach `failed`
+ * or sit at `executing` forever, but never `completed`. A host reading
+ * `plan.status` after a successful run was told the work was still going.
+ *
+ * Settlement is conditional on every step having reported, and the condition is
+ * read rather than caught: `completePlan` refuses an unreported step on
+ * purpose, and letting that throw here would turn a run that worked into a run
+ * that crashed on its way out — a worse version of the bug the refusal exists
+ * to prevent.
+ */
+
+registerMock()
+
+/** Run to completion, with a plan seeded through the host's own seam. */
+async function runWithPlan(seed: (pm: PlanManager) => void): Promise<PlanManager> {
+	let captured: PlanManager | undefined
+
+	await drainQuery({
+		provider: new MockLLMProvider({ responses: [{ content: 'done' }] } as never),
+		tools: new ToolRegistry(),
+		agentId: 'a',
+		agentName: 'A',
+		messages: [{ role: 'user', content: 'go' }],
+		workingDirectory: process.cwd(),
+		runConfig: { model: 'mock', tokenBudget: 100_000, timeoutMs: 30_000, maxIterations: 4 },
+		projectId: generateProjectId(),
+		sessionId: generateSessionId(),
+		threadId: generateThreadId(),
+		tenantId: generateTenantId(),
+		// The documented host seam: `drainQuery` hands the plan manager over
+		// BEFORE the iteration loop, which is exactly what makes a host-driven
+		// plan possible at all.
+		onContextCreated: ({ planManager }: { planManager: PlanManager }) => {
+			captured = planManager
+			seed(planManager)
+		},
+	} as never)
+
+	if (!captured) throw new Error('onContextCreated never fired')
+	return captured
+}
+
+function twoStepPlan(pm: PlanManager): void {
+	pm.startGenerating('the work')
+	pm.addStep({ id: 'step_1', description: 'first', dependsOn: [], order: 1 })
+	pm.addStep({ id: 'step_2', description: 'second', dependsOn: [], order: 2 })
+	pm.markReady()
+	pm.approve()
+	pm.startExecution()
+}
+
+describe('a run that succeeded settles the plan it was executing', () => {
+	it('reports completed when every step reported', async () => {
+		const pm = await runWithPlan((p) => {
+			twoStepPlan(p)
+			p.updateStepStatus('step_1', 'completed')
+			p.updateStepStatus('step_2', 'skipped')
+		})
+
+		expect(pm.active?.status).toBe('completed')
+	})
+
+	it('reports failed when a step actually failed', async () => {
+		const pm = await runWithPlan((p) => {
+			twoStepPlan(p)
+			p.updateStepStatus('step_1', 'completed')
+			p.updateStepStatus('step_2', 'failed')
+		})
+
+		expect(pm.active?.status).toBe('failed')
+	})
+
+	it('leaves it executing — and does not throw — when a step never reported', async () => {
+		// The honest answer. The caller and the plan disagree about whether the
+		// work is over, and the end of a successful run is not the place to
+		// resolve that by guessing. The run itself must still finish cleanly,
+		// which is the half that would break if the refusal were caught here
+		// instead of checked.
+		const pm = await runWithPlan((p) => {
+			twoStepPlan(p)
+			p.updateStepStatus('step_1', 'completed')
+		})
+
+		expect(pm.active?.status).toBe('executing')
+	})
+
+	it('does nothing when the run had no plan at all', async () => {
+		const pm = await runWithPlan(() => {})
+
+		expect(pm.active).toBeNull()
+	})
+})

package/src/runtime/query/index.ts

@@ -420,11 +420,6 @@ export interface QueryParams {
 	 */
 	completionInbox?: import('../../gateway/completion-inbox.js').CompletionInbox
 
-	launchedTasks?: Map<
-		import('../../types/ids/index.js').TaskId,
-		import('./iteration/phases/context.js').LaunchedTaskMeta
-	>
-
 	onContextCreated?: (ctx: {
 		planManager: import('../../manager/plan/lifecycle.js').PlanManager
 	}) => void
@@ -854,7 +849,6 @@ export async function* query(params: QueryParams): AsyncGenerator<RunEvent, Run>
 		taskGateway: params.taskGateway,
 		completionInbox: params.completionInbox,
 		taskStore: params.taskStore,
-		launchedTasks: params.launchedTasks ?? new Map(),
 		// Run-scoped. An approval is a statement about this run's work;
 		// carrying one into a later run would be reuse nobody agreed to.
 		toolGrants: new ToolGrantSet(),

package/src/runtime/query/iteration/phases/context.ts

@@ -14,7 +14,6 @@ import type {
 	IterationCheckpoint,
 	ResumeHandler,
 } from '../../../../types/hitl/index.js'
-import type { TaskId } from '../../../../types/ids/index.js'
 import type { LLMProvider } from '../../../../types/provider/index.js'
 import type { TaskRouterConfig } from '../../../../types/router/index.js'
 import type { ReviewAnswer } from '../../../../types/run/answer-review.js'
@@ -36,22 +35,6 @@ import type { GuardCoordinator } from '../../guard.js'
 import type { SteeringChannel } from '../../steering.js'
 import type { ToolGrantSet } from '../../tool-grants.js'
 
-export interface LaunchedTaskMeta {
-	readonly agentId: string
-	readonly description: string
-	readonly planTaskId?: string
-	/**
-	 * The `tool_use_id` of the assistant `create_task` block that
-	 * spawned this background task. Required to emit the canonical
-	 * `tool_result` content block when the task completes — without
-	 * it we'd fall back to the legacy synthetic-user-message inject
-	 * (see ses_009-task-notification-envelope). Optional because
-	 * older call paths that don't thread `ToolContext.toolUseId`
-	 * still publish the meta without it.
-	 */
-	readonly originalToolUseId?: string
-}
-
 export interface IterationContext {
 	readonly provider: LLMProvider
 	/**
@@ -115,8 +98,6 @@ export interface IterationContext {
 
 	readonly taskStore?: TaskStore
 
-	readonly launchedTasks: Map<TaskId, LaunchedTaskMeta>
-
 	/**
 	 * Approvals a human granted earlier in this run, at a scope they chose.
 	 *

package/src/runtime/query/result.ts

@@ -37,12 +37,29 @@ export class ResultAssembler {
 	}
 
 	async *completeRun(rootSpan: Span): AsyncGenerator<RunEvent> {
-		const { runMgr, activityStore, log, emitEvent, drainPending } = this.config
+		const { runMgr, planManager, activityStore, log, emitEvent, drainPending } = this.config
 
 		if (runMgr.status === 'running') {
 			runMgr.markCompleted(runMgr.stopReason)
 		}
 
+		// Settle the plan, which nothing did on this path — so a plan could
+		// reach `failed` (the error path calls `failPlan`) or stay `executing`
+		// forever, but never `completed`. A host reading `plan.status` after a
+		// successful run saw "still running".
+		//
+		// Only when every step has reported, and the check is a read rather
+		// than a caught throw: `completePlan` refuses an unreported step on
+		// purpose, and turning a run that worked into a run that crashed on its
+		// way out would be a worse version of the bug the refusal prevents.
+		//
+		// A plan with steps nobody reported is LEFT `executing`, which is the
+		// honest answer — the caller and the plan disagree about whether the
+		// work is over, and this is not the place to resolve that by guessing.
+		if (planManager.isActive && planManager.unreportedSteps.length === 0) {
+			planManager.completePlan()
+		}
+
 		await emitEvent({
 			type: 'run_completed',
 			runId: runMgr.id,

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

@@ -0,0 +1,171 @@
+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

@@ -0,0 +1,215 @@
+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'])
+	})
+})