@namzu/sdk 2.0.0 → 3.1.0

package/src/tools/builtins/grep.ts

@@ -1,7 +1,61 @@
 import { glob, readFile } from 'node:fs/promises'
-import { relative, resolve } from 'node:path'
+import { relative, resolve, sep } from 'node:path'
 import { z } from 'zod'
+import type { Sandbox } from '../../types/sandbox/index.js'
 import { defineTool } from '../defineTool.js'
+import { matchesGlob } from '../glob-match.js'
+import { resolveWithin } from '../paths.js'
+import { joinPosix, relativePosix, resolveWithinPosix } from '../posix-path.js'
+
+/**
+ * Where the files come from.
+ *
+ * The host and the sandbox differ in exactly two operations — enumerate
+ * and read — so that is all this abstracts. Matching, context lines and
+ * the caps stay in one implementation; duplicating them per source is how
+ * the two would drift apart, and the sandbox path is the one nobody runs
+ * by accident.
+ */
+interface FileSource {
+	/** The root every reported path is relative to. */
+	readonly root: string
+	/** True when paths are the sandbox's, not the host's. */
+	readonly posix?: boolean
+	list(searchRoot: string, pattern: string): AsyncIterable<string>
+	read(path: string): Promise<Buffer>
+}
+
+function hostSource(workingDirectory: string): FileSource {
+	return {
+		root: workingDirectory,
+		async *list(searchRoot, pattern) {
+			for await (const entry of glob(pattern, { cwd: searchRoot })) {
+				yield resolve(searchRoot, entry)
+			}
+		},
+		read: (path) => readFile(path),
+	}
+}
+
+function sandboxSource(sandbox: Sandbox): FileSource {
+	return {
+		root: sandbox.rootDir,
+		posix: true,
+		async *list(searchRoot, pattern) {
+			for (const entry of await sandbox.listFiles(searchRoot)) {
+				// Sandbox paths stay in the sandbox's own coordinate system.
+				// Running them through the host's path module would rewrite a
+				// POSIX container path into a host-shaped one whenever the
+				// two disagree, and then hand the model a path its own
+				// sandbox cannot open.
+				const absolute = joinPosix(searchRoot, entry.path)
+				const relPath = relativePosix(sandbox.rootDir, absolute)
+				if (matchesGlob(relPath, pattern)) yield absolute
+			}
+		},
+		read: (path) => sandbox.readFile(path),
+	}
+}
 
 const inputSchema = z.object({
 	pattern: z.string().describe('Regular expression pattern to search for in file contents'),
@@ -63,9 +117,25 @@ export const GrepTool = defineTool({
 			}
 		}
 
-		const searchRoot = input.path
-			? resolve(context.workingDirectory, input.path)
-			: context.workingDirectory
+		// Inside the sandbox when there is one, on the host otherwise. Only
+		// the file SOURCE differs — matching, context lines and the caps are
+		// one implementation, because duplicating the substantive half is
+		// how the two paths would drift.
+		//
+		// This tool read the host filesystem through `node:fs` and
+		// referenced `context.sandbox` nowhere, so with a container backend
+		// wired in the sandbox was not a read boundary at all — and grep
+		// returns file CONTENT, so what leaked was not a listing.
+		const source: FileSource = context.sandbox
+			? sandboxSource(context.sandbox)
+			: hostSource(context.workingDirectory)
+
+		// Contained, not merely resolved — see `resolveWithin`. Bare
+		// resolution let `path: "../../.."` read whatever sits above the
+		// working directory, with no sandbox needed to make it work.
+		const searchRoot = source.posix
+			? resolveWithinPosix(source.root, input.path)
+			: resolveWithin(source.root, input.path)
 
 		// Auto-prepend **/ for simple patterns (e.g. "*.ts" → "**/*.ts")
 		let filePattern = input.include ?? '**/*'
@@ -78,13 +148,12 @@ export const GrepTool = defineTool({
 		let filesSearched = 0
 		let filesMatched = 0
 
-		for await (const entry of glob(filePattern, { cwd: searchRoot })) {
-			const filePath = resolve(searchRoot, entry)
+		for await (const filePath of source.list(searchRoot, filePattern)) {
 			filesSearched++
 
 			let content: string
 			try {
-				const buffer = await readFile(filePath)
+				const buffer = await source.read(filePath)
 				if (buffer.length > MAX_FILE_SIZE) continue
 				if (isBinaryContent(buffer)) continue
 				content = buffer.toString('utf-8')
@@ -105,7 +174,12 @@ export const GrepTool = defineTool({
 					filesMatched++
 				}
 
-				const relPath = `./${relative(context.workingDirectory, filePath)}`
+				// Relative to the root the file came FROM. Reporting a
+				// host-relative path for a file read inside the sandbox would
+				// hand the model a string `read` then resolves somewhere else.
+				const relPath = source.posix
+					? `./${relativePosix(source.root, filePath)}`
+					: `./${relative(source.root, filePath).split(sep).join('/')}`
 
 				if (input.context_lines > 0) {
 					const start = Math.max(0, i - input.context_lines)

package/src/tools/builtins/index.ts

@@ -22,12 +22,12 @@ import { WriteFileTool } from './write-file.js'
 // because it requires a schema parameter and is created per-use case.
 //
 // `LsTool` and `SearchToolsTool` are still exported for direct use but are
-// NOT in the default builtin set. Claude Code's training distribution (per
-// `code.claude.com/docs/en/tools-reference`) does NOT include `LS` —
-// directory listing is canonical `Bash` + `Glob`. `search_tools` has no
-// Claude analogue at all. Including these in the defaults gives the model
-// tools that look right but degrade alignment. File extension uses canonical
-// exact replacement against a unique tail or deterministic marker.
+// NOT in the default builtin set. A directory listing is already reachable
+// through `bash` + `glob`, and `search_tools` answers a question the tool
+// catalog in the prompt has already answered. Offering a model two ways to
+// do one thing costs a decision on every turn and buys nothing. File
+// extension is canonical `edit` with `insertLine: "end"` — the legacy
+// `Append` tool is gone.
 // Hosts that genuinely want LS/search can still register them explicitly.
 
 export function getBuiltinTools(): ToolDefinition[] {

package/src/tools/builtins/ls.ts

@@ -1,7 +1,8 @@
 import { readdir, stat } from 'node:fs/promises'
-import { join, relative, resolve } from 'node:path'
+import { join, relative } from 'node:path'
 import { z } from 'zod'
 import { defineTool } from '../defineTool.js'
+import { resolveWithin } from '../paths.js'
 
 const inputSchema = z.object({
 	path: z.string().default('.').describe('Directory path to list. Defaults to working directory.'),
@@ -116,7 +117,8 @@ export const LsTool = defineTool({
 	concurrencySafe: true,
 
 	async execute(input, context) {
-		const targetPath = resolve(context.workingDirectory, input.path)
+		// Contained, not merely resolved — see `resolveWithin`.
+		const targetPath = resolveWithin(context.workingDirectory, input.path)
 
 		if (input.recursive) {
 			const output: string[] = []

package/src/tools/builtins/read-file.ts

@@ -23,7 +23,7 @@ const inputSchema = z.object({
 export const ReadFileTool = defineTool({
 	name: 'read',
 	description:
-		'Reads a file and returns its contents with line numbers. Supports readRange ([start,end], 1-indexed inclusive) or offset/limit for large files.',
+		'Reads a file and returns its contents with line numbers. Supports readRange ([start,end], 1-indexed inclusive) or offset/limit for large files. Without a window it returns the first 2000 lines and says so — pass offset/limit to continue.',
 	inputSchema,
 	category: 'filesystem',
 	permissions: ['file_read'],
@@ -55,14 +55,19 @@ export const ReadFileTool = defineTool({
 
 			const numberedLines = selectedLines.map((line, i) => `${start + i + 1}\t${line}`).join('\n')
 
-			context.fileReadTracker?.recordRead(input.path)
+			// The WHOLE body, not the selected window: a later edit is checked
+			// against the file, and a partial read must not fingerprint a
+			// fragment as if it were the file.
+			context.fileReadTracker?.recordRead(input.path, content)
 
+			const partial = selectedLines.length < lines.length
 			return {
 				success: true,
-				output: numberedLines,
+				output: numberedLines + partialViewNotice(start, selectedLines.length, lines.length),
 				data: {
 					totalLines: lines.length,
 					returnedLines: selectedLines.length,
+					truncated: partial,
 					path: input.path,
 					sandboxed: true,
 				},
@@ -90,14 +95,17 @@ export const ReadFileTool = defineTool({
 
 		const numberedLines = selectedLines.map((line, i) => `${start + i + 1}\t${line}`).join('\n')
 
-		context.fileReadTracker?.recordRead(filePath)
+		context.fileReadTracker?.recordRead(filePath, content)
+
+		const isPartial = selectedLines.length < lines.length
 
 		return {
 			success: true,
-			output: numberedLines,
+			output: numberedLines + partialViewNotice(start, selectedLines.length, lines.length),
 			data: {
 				totalLines: lines.length,
 				returnedLines: selectedLines.length,
+				truncated: isPartial,
 				path: filePath,
 			},
 		}
@@ -128,6 +136,34 @@ function buildStructuredBinaryGuidance(path: string, format: string, extractor:
 	].join('\n')
 }
 
+/**
+ * Lines returned when the caller specifies no window.
+ *
+ * Chosen to cover the overwhelming majority of source files whole while
+ * bounding the pathological case.
+ */
+const DEFAULT_READ_LINES = 2000
+
+/**
+ * Tell the model, explicitly, when it is looking at a window rather than
+ * the file.
+ *
+ * Without this a truncated read is indistinguishable from a short file, and
+ * the agent reasons about a fragment as if it were the whole thing — the
+ * most expensive silent failure a read tool can have. The notice names the
+ * exact next call rather than describing it.
+ */
+function partialViewNotice(start: number, returned: number, total: number): string {
+	if (returned >= total) return ''
+	const shownTo = start + returned
+	return [
+		'',
+		'',
+		`[PARTIAL view — lines ${start + 1}-${shownTo} of ${total}.`,
+		`Continue with read({ offset: ${shownTo}, limit: N }), or narrow with grep.]`,
+	].join('\n')
+}
+
 function resolveReadWindow(
 	input: z.infer<typeof inputSchema>,
 	totalLines: number,
@@ -139,6 +175,9 @@ function resolveReadWindow(
 		return { start, end }
 	}
 	const start = Math.max(0, input.offset ?? 0)
-	const end = input.limit ? start + input.limit : totalLines
+	// A bare `read({ path })` used to return the entire file, so a 2 MB
+	// lockfile became ~500k tokens in one tool_result. Default to a window
+	// and say so in the output; the model asks for more when it needs it.
+	const end = input.limit ? start + input.limit : Math.min(totalLines, start + DEFAULT_READ_LINES)
 	return { start, end }
 }

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

@@ -1,5 +1,5 @@
-import { access } from 'node:fs/promises'
-import { resolve } from 'node:path'
+import { access, mkdir } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
 import { z } from 'zod'
 import type { ToolContext } from '../../types/tool/index.js'
 import { defineTool } from '../defineTool.js'
@@ -10,30 +10,48 @@ const inputSchema = z
 	.object({
 		path: z
 			.string()
-			.refine((value) => value.trim().length > 0, 'Path must not be empty.')
+			.min(1)
 			.describe(
-				'Relative path to the file to write (e.g. "outputs/report.md"). Must not be empty.',
+				'Relative path to the file to write (e.g. "outputs/report.md"). Required. Must be a non-empty string.',
 			),
 		content: z
 			.string()
+			.optional()
 			.describe(
-				'Complete bounded file body. Use "" only for an intentionally empty file. Keep under 12000 characters. For longer documents, include a deterministic marker such as {{CHUNK_001}} and advance it with exact edit calls.',
+				'Full file body to write. Required (use "" only for an intentionally empty file). The file is fully overwritten — pass the COMPLETE intended content for this bounded chunk, not a diff. Self-budget content under 12000 characters before calling; if the intended body is longer, write a smaller opening section here, then use `edit` with insertLine: "end" to extend the file section by section. Do NOT try to chain multiple `write` calls, since each one overwrites the previous.',
+			),
+		newStr: z
+			.string()
+			.optional()
+			.describe(
+				'Alias for content. Useful for hosts that expose create/write operations as newStr. Self-budget this payload under 12000 characters before calling.',
 			),
 	})
 	.strict()
+	.refine((value) => typeof value.content === 'string' || typeof value.newStr === 'string', {
+		message: 'Either content or newStr is required.',
+	})
 
 type WriteInput = z.infer<typeof inputSchema>
 
+/**
+ * The single shape a model is constrained to emit.
+ *
+ * `newStr` is a host affordance and deliberately absent here: a model given
+ * two names for the body has to pick, and picking is what produces the
+ * half-filled calls this schema exists to prevent.
+ */
 const modelInputSchema: Record<string, unknown> = {
 	type: 'object',
 	properties: {
 		path: {
 			type: 'string',
-			description: 'Non-empty path to the file to write.',
+			description: 'Relative path to the file to write. Must not be empty.',
 		},
 		content: {
 			type: 'string',
-			description: 'Complete bounded file body. May be empty only for an intentionally empty file.',
+			description:
+				'Complete file body. Use "" only for an intentionally empty file. Keep under 12000 characters.',
 		},
 	},
 	required: ['path', 'content'],
@@ -43,11 +61,12 @@ const modelInputSchema: Record<string, unknown> = {
 export const WriteFileTool = defineTool({
 	name: 'write',
 	description:
-		'Writes a complete bounded file body. Pass exactly path + content. If the file exists, read it first; prefer edit for targeted changes. Self-budget content under 12000 characters. For longer documents, write an opening with a deterministic marker such as {{CHUNK_001}}, then use exact edit calls that advance the marker one chunk at a time. Do not chain write calls because each overwrites the file.',
+		'Writes a file to the local filesystem. Overwrites the existing file at the path if there is one.\n\n- If the file already exists, you must use the `read` tool on it first in this conversation, or this call will fail.\n- Prefer the `edit` tool for modifying existing files — it only sends the diff and preserves the rest of the file byte-for-byte.\n- Use `write` to create a new file or to perform a deliberate full rewrite of a file you have already read.\n- Self-budget content/newStr under 12000 characters before emitting the tool call. For long content, write a smaller opening section, then use `edit` with insertLine: "end" to extend the file section by section. Do not chain multiple `write` calls — each one overwrites the previous.',
 	inputSchema,
 	modelInputSchema,
 	enforceModelInput: true,
-	validationErrorHint: 'Required shape: {"path":"file.md","content":"complete bounded file body"}.',
+	validationErrorHint:
+		'Required shape: {"path":"file.md","content":"complete file body"}. Pass the whole body, not a diff.',
 	category: 'filesystem',
 	permissions: ['file_write'],
 	readOnly: false,
@@ -55,6 +74,9 @@ export const WriteFileTool = defineTool({
 	concurrencySafe: false,
 
 	async execute(input: WriteInput, context) {
+		// `execute` is reachable without going through the registry, so the
+		// closed contract has to be enforced on this path too or it is not
+		// closed at all.
 		const parsed = inputSchema.safeParse(input)
 		if (!parsed.success) {
 			return {
@@ -63,27 +85,27 @@ export const WriteFileTool = defineTool({
 				error: `Invalid write input: ${parsed.error.issues.map((issue) => issue.message).join('; ')}`,
 			}
 		}
-		const canonicalInput = parsed.data
-
-		const filePath = resolve(context.workingDirectory, canonicalInput.path)
+		const valid = parsed.data
+		const content = valid.content ?? valid.newStr ?? ''
+		const filePath = resolve(context.workingDirectory, valid.path)
+		// The exists-check and the write are a check-then-act pair. Unlocked,
+		// two writers both see "absent", both skip the read-before-overwrite
+		// guard, and the second silently discards the first.
 		const lockKey = `${context.sandbox ? 'sandbox' : 'local'}:${filePath}`
+
 		return withFileMutationLock(lockKey, async () => {
 			if (context.sandbox) {
-				const sandboxExists = await sandboxFileExists(context, canonicalInput.path)
+				const sandboxExists = await sandboxFileExists(context, valid.path)
 				if (sandboxExists) {
-					const guard = enforceReadBeforeOverwrite(context, canonicalInput.path)
+					const guard = enforceReadBeforeOverwrite(context, valid.path)
 					if (guard) return guard
 				}
-				await context.sandbox.writeFile(canonicalInput.path, canonicalInput.content)
-				context.fileReadTracker?.recordRead(canonicalInput.path)
+				await context.sandbox.writeFile(valid.path, content)
+				context.fileReadTracker?.recordRead(valid.path)
 				return {
 					success: true as const,
-					output: `File written successfully: ${canonicalInput.path} (${canonicalInput.content.length} chars) [sandboxed]`,
-					data: {
-						path: canonicalInput.path,
-						size: canonicalInput.content.length,
-						sandboxed: true,
-					},
+					output: `File written successfully: ${valid.path} (${content.length} chars) [sandboxed]`,
+					data: { path: valid.path, size: content.length, sandboxed: true },
 				}
 			}
 
@@ -93,12 +115,17 @@ export const WriteFileTool = defineTool({
 				if (guard) return guard
 			}
 
-			await atomicWriteFile(filePath, canonicalInput.content)
+			await mkdir(dirname(filePath), { recursive: true })
+			// Temp file, fsync, rename. A plain write that fails partway
+			// leaves the destination truncated — and this tool overwrites a
+			// whole file, so the truncation is the user's previous work.
+			await atomicWriteFile(filePath, content)
 			context.fileReadTracker?.recordRead(filePath)
+
 			return {
 				success: true as const,
-				output: `File written successfully: ${filePath} (${canonicalInput.content.length} chars)`,
-				data: { path: filePath, size: canonicalInput.content.length },
+				output: `File written successfully: ${filePath} (${content.length} chars)`,
+				data: { path: filePath, size: content.length },
 			}
 		})
 	},

package/src/tools/coordinator/__tests__/agent.test.ts

@@ -4,7 +4,7 @@
  * - Reports `success: true` only when BOTH the gateway task state and
  *   the underlying `BaseAgentResult.status` say completed.
  * - Reports `success: false` and surfaces `lastError` when either
- *   layer disagrees — the canonical bug Codex caught was that a
+ *   layer disagrees — the canonical bug review caught was that a
  *   failed subagent could be reported as successful when the gateway
  *   forwarded `state: 'completed'` from a manager that did not
  *   propagate the run's `status: 'failed'`.
@@ -152,7 +152,7 @@ describe('buildAgentTool', () => {
 	it("does not accept a taskStore or runId — plan-task lifecycle is the parent's job", () => {
 		// Compile-time pin: AgentToolOptions must NOT include `taskStore`
 		// or `runId`. The Agent tool used to manage a per-call plan task
-		// internally and Codex caught a leak: when the subagent failed,
+		// internally and review caught a leak: when the subagent failed,
 		// the plan task stayed `'in_progress'` forever because
 		// `TaskStatus` has no `'failed'` value to flip to. Drop the
 		// integration entirely; if a host wants to track delegations as

package/src/tools/coordinator/__tests__/ask-user-question.test.ts

@@ -368,3 +368,71 @@ describe('coordinator ask_user_question decision -> output mapping', () => {
 		expect(result.output).toBe('User answered "Who is the audience?": "Board"')
 	})
 })
+
+describe('the question contract is closed, not merely shaped', () => {
+	const noopHandler: ResumeHandler = async () => ({ action: 'continue' })
+
+	it('publishes one closed model-facing schema', () => {
+		const tool = askTool(noopHandler)
+
+		expect(tool.modelInputSchema).toMatchObject({
+			type: 'object',
+			required: ['question', 'options'],
+			additionalProperties: false,
+		})
+		// The whole point of the array declaration: a model that serializes
+		// its options once tends to keep doing it, and a closed schema makes
+		// a capable provider refuse at generation time instead of after.
+		const properties = (tool.modelInputSchema as { properties: Record<string, { type: string }> })
+			.properties
+		expect(properties.options?.type).toBe('array')
+		expect(tool.enforceModelInput).toBe(true)
+	})
+
+	it('rejects a serialized options string and other malformed option shapes', () => {
+		const tool = askTool(noopHandler)
+
+		for (const options of [
+			'<options><option><label>Board</label></option></options>',
+			'[{"label":"Board"},{"label":"Engineering"}]',
+			[42, { label: 'Engineering' }],
+			[{ description: 'Missing label' }, { label: 'Engineering' }],
+			[{ label: 'Board', description: 42 }, { label: 'Engineering' }],
+		]) {
+			expect(
+				tool.inputSchema.safeParse({ question: 'Who is the audience?', options }).success,
+				JSON.stringify(options),
+			).toBe(false)
+		}
+	})
+
+	it('rejects a field it does not declare, rather than dropping it', () => {
+		const tool = askTool(noopHandler)
+		const valid = {
+			question: 'Who is the audience?',
+			options: [{ label: 'Board' }, { label: 'Engineering' }],
+		}
+
+		expect(tool.inputSchema.safeParse(valid).success).toBe(true)
+
+		// Without `.strict()` zod strips these, so the call proceeds as if the
+		// caller had never written them — a misspelling becomes a silent no-op.
+		for (const extra of [
+			{ ...valid, multiSelct: true },
+			{ ...valid, choices: ['a', 'b'] },
+			{
+				...valid,
+				options: [{ label: 'Board', reason: 'why' }, { label: 'Engineering' }],
+			},
+		]) {
+			expect(tool.inputSchema.safeParse(extra).success, JSON.stringify(extra)).toBe(false)
+		}
+	})
+
+	it('carries a recovery hint that names the shape to retry with', () => {
+		const tool = askTool(noopHandler)
+
+		expect(tool.validationErrorHint).toContain('"options" must be a JSON array')
+		expect(tool.validationErrorHint).toContain('never a string')
+	})
+})

package/src/tools/coordinator/agent.ts

@@ -8,9 +8,7 @@ import { defineTool } from '../defineTool.js'
 import type { TaskLaunchedCallback } from './index.js'
 
 /**
- * Build the canonical Claude Code `Agent` tool — synchronous subagent
- * delegation that mirrors what Claude is trained against in
- * `code.claude.com/docs/en/sub-agents`.
+ * Build the `Agent` tool — synchronous subagent delegation.
  *
  * Semantics: parent calls `Agent({ description, prompt, subagent_type })`,
  * the runtime spawns the chosen subagent with its own context window,
@@ -19,12 +17,14 @@ import type { TaskLaunchedCallback } from './index.js'
  * subagent tool calls are isolated — only the summary surfaces to
  * the parent.
  *
- * This is **NOT** the same shape as the coordinator `create_task`
- * tool that this package ships alongside it. That tool exposes
- * Namzu's task IDs and optional planning integration, while still
- * returning results synchronously. For free agentic alignment,
- * prefer the canonical `Agent` tool; use the coordinator tool when
- * the host needs task tracking.
+ * This is **NOT** the same shape as the legacy `create_task` /
+ * `continue_task` / `cancel_task` trio that this package ships
+ * alongside it: those are non-blocking and use a `<task-notification>`
+ * callback model. The async pattern is useful for hosts that want a
+ * work-queue surface, but it asks the model to track work it cannot
+ * see finish. Prefer the blocking `Agent` tool; keep the legacy
+ * coordinator tools only when you genuinely need fire-and-forget
+ * multi-task fan-out.
  */
 export interface AgentToolOptions {
 	gateway: TaskGateway
@@ -33,6 +33,18 @@ export interface AgentToolOptions {
 	allowedAgentIds: string[]
 
 	onTaskLaunched?: TaskLaunchedCallback
+
+	/**
+	 * Settle the parent run with the subagent's answer instead of looping
+	 * once more to restate it. See {@link ToolDefinition.terminal}.
+	 *
+	 * For a router — an agent whose whole job is to pick a specialist —
+	 * the relay turn is pure overhead at the parent's full context size,
+	 * and it hands the caller the parent's paraphrase rather than the
+	 * specialist's answer. Off by default: an agent that delegates as one
+	 * step of a longer plan needs the loop to continue.
+	 */
+	terminal?: boolean
 }
 
 export function buildAgentTool(opts: AgentToolOptions): ToolDefinition {
@@ -62,6 +74,7 @@ export function buildAgentTool(opts: AgentToolOptions): ToolDefinition {
 		readOnly: false,
 		destructive: false,
 		concurrencySafe: true,
+		...(opts.terminal !== undefined ? { terminal: opts.terminal } : {}),
 		async execute({ description, prompt, subagent_type }, context) {
 			// With a single registered subagent the type is optional — default to
 			// it so the model can't trip the "subagent_type required" validation.
@@ -109,7 +122,7 @@ export function buildAgentTool(opts: AgentToolOptions): ToolDefinition {
 			// Treat the subagent as successful only when BOTH agree.
 			// Reporting a failed subagent as successful would silently
 			// hand the parent garbage output and make debugging
-			// impossible, which is what Codex flagged on the first cut.
+			// impossible, which is what review flagged on the first cut.
 			const runStatus = completed.result?.status
 			const succeeded =
 				completed.state === 'completed' && (runStatus === undefined || runStatus === 'completed')