oh-my-opencode 4.8.1 → 4.9.0

package/packages/shared-skills/skills/lsp-setup/scripts/detect-lsp.ts

@@ -0,0 +1,210 @@
+#!/usr/bin/env bun
+// detect-lsp.ts <targetDir> [--json] — scan a directory for source languages and
+// report, per detected language: the builtin LSP server, whether its executable
+// is on PATH, an install hint, and whether a project LSP config references it.
+
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs"
+import { delimiter, extname, join, sep } from "node:path"
+import process from "node:process"
+
+import { LANGUAGES, type LanguageServer, PROJECT_CONFIG_FILES } from "./lsp-server-table"
+
+const SKIP_DIRECTORIES = new Set<string>([
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".next",
+	"out",
+	"target",
+	".venv",
+	"venv",
+	"vendor",
+	".cache",
+	"__pycache__",
+	".turbo",
+	"coverage",
+])
+
+const MAX_FILES = 50_000
+
+// Mirrors effectiveExtension() in packages/lsp-tools-mcp/src/lsp/effective-extension.ts:
+// extensionless Dockerfile/Containerfile resolve to .dockerfile (exact-case basenames).
+const BASENAME_EXTENSIONS: Record<string, string> = {
+	Dockerfile: ".dockerfile",
+	Containerfile: ".dockerfile",
+}
+
+interface ConfigFileState {
+	readonly path: string
+	readonly exists: boolean
+	readonly serverIds: readonly string[]
+}
+
+interface DetectionResult {
+	readonly server: LanguageServer
+	readonly executable: string
+	readonly installed: boolean
+	readonly resolvedPath: string | null
+	readonly configuredIn: readonly string[]
+}
+
+function collectExtensions(root: string): ReadonlySet<string> {
+	const found = new Set<string>()
+	const stack: string[] = [root]
+	let visited = 0
+
+	while (stack.length > 0) {
+		const current = stack.pop()
+		if (current === undefined) break
+
+		let entries: string[]
+		try {
+			entries = readdirSync(current)
+		} catch {
+			continue
+		}
+
+		for (const entry of entries) {
+			if (visited >= MAX_FILES) return found
+			const fullPath = join(current, entry)
+
+			let kind: "dir" | "file" | "other" = "other"
+			try {
+				const stat = statSync(fullPath)
+				kind = stat.isDirectory() ? "dir" : stat.isFile() ? "file" : "other"
+			} catch {
+				continue
+			}
+
+			if (kind === "dir") {
+				if (!SKIP_DIRECTORIES.has(entry)) stack.push(fullPath)
+			} else if (kind === "file") {
+				visited += 1
+				const ext = (BASENAME_EXTENSIONS[entry] ?? extname(entry)).toLowerCase()
+				if (ext.length > 0) found.add(ext)
+			}
+		}
+	}
+
+	return found
+}
+
+function pathDirectories(): readonly string[] {
+	return (process.env["PATH"] ?? "").split(delimiter).filter((dir: string) => dir.length > 0)
+}
+
+function resolveExecutable(command: string): string | null {
+	const extensions =
+		process.platform === "win32" ? (process.env["PATHEXT"]?.split(";") ?? [".EXE", ".CMD", ".BAT"]) : [""]
+	const bases = command.includes("/") || command.includes(sep) ? [command] : pathDirectories().map((dir: string) => join(dir, command))
+
+	for (const base of bases) {
+		for (const ext of extensions) {
+			const candidate = ext.length > 0 ? `${base}${ext}` : base
+			try {
+				if (existsSync(candidate) && statSync(candidate).isFile()) return candidate
+			} catch {
+				continue
+			}
+		}
+	}
+	return null
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function parseConfiguredServerIds(path: string): readonly string[] {
+	let parsed: unknown
+	try {
+		parsed = JSON.parse(readFileSync(path, "utf-8"))
+	} catch {
+		return []
+	}
+	if (!isRecord(parsed)) return []
+	const lsp = parsed["lsp"]
+	return isRecord(lsp) ? Object.keys(lsp) : []
+}
+
+function readConfigState(root: string): readonly ConfigFileState[] {
+	return PROJECT_CONFIG_FILES.map((relative: string): ConfigFileState => {
+		const path = join(root, relative)
+		if (!existsSync(path)) return { path: relative, exists: false, serverIds: [] }
+		return { path: relative, exists: true, serverIds: parseConfiguredServerIds(path) }
+	})
+}
+
+function detect(root: string, configState: readonly ConfigFileState[]): readonly DetectionResult[] {
+	const extensions = collectExtensions(root)
+	const results: DetectionResult[] = []
+
+	for (const server of LANGUAGES) {
+		if (!server.extensions.some((ext: string) => extensions.has(ext))) continue
+
+		const executable = server.command[0] ?? server.serverId
+		const resolvedPath = resolveExecutable(executable)
+		const configuredIn = configState
+			.filter((state) => state.serverIds.includes(server.serverId))
+			.map((state) => state.path)
+
+		results.push({ server, executable, installed: resolvedPath !== null, resolvedPath, configuredIn })
+	}
+
+	return results
+}
+
+function renderReport(root: string, results: readonly DetectionResult[], configState: readonly ConfigFileState[]): string {
+	const lines: string[] = [`LSP setup scan: ${root}`]
+	const configSummary = configState
+		.map((state) => `${state.path} (${state.exists ? `present: ${state.serverIds.length} server(s)` : "absent"})`)
+		.join(", ")
+	lines.push(`Config files: ${configSummary}`, "")
+
+	if (results.length === 0) {
+		lines.push("No languages with a builtin LSP server were detected here.")
+		return lines.join("\n")
+	}
+
+	lines.push("DETECTED LANGUAGES (primary builtin server per language)")
+	for (const result of results) {
+		const mark = result.installed ? "OK  " : "MISS"
+		const state = result.installed ? `installed (${result.resolvedPath})` : "NOT installed"
+		const config = result.configuredIn.length > 0 ? `configured in ${result.configuredIn.join(", ")}` : "builtin-default"
+		lines.push(`[${mark}] ${result.server.language.padEnd(12)} server=${result.server.serverId}  exe=${result.executable}  ${state}  ${config}`)
+		if (!result.installed) lines.push(`        install: ${result.server.installHint}`)
+	}
+
+	const missing = results.filter((result) => !result.installed)
+	lines.push(
+		"",
+		missing.length === 0
+			? `All ${results.length} detected server(s) installed.`
+			: `${missing.length}/${results.length} server(s) NOT installed: ${missing.map((m) => m.server.language).join(", ")}`,
+		"Next: read references/<language>/README.md, then configure .codex/lsp-client.json AND .opencode/lsp.json.",
+	)
+	return lines.join("\n")
+}
+
+function main(): void {
+	const args = process.argv.slice(2)
+	const wantsJson = args.includes("--json")
+	const root = args.find((arg: string) => !arg.startsWith("--")) ?? process.cwd()
+
+	if (!existsSync(root)) {
+		process.stderr.write(`detect-lsp: target directory does not exist: ${root}\n`)
+		process.exit(2)
+	}
+
+	const configState = readConfigState(root)
+	const results = detect(root, configState)
+
+	if (wantsJson) {
+		process.stdout.write(`${JSON.stringify({ root, configState, results }, null, 2)}\n`)
+		return
+	}
+	process.stdout.write(`${renderReport(root, results, configState)}\n`)
+}
+
+main()

package/packages/shared-skills/skills/lsp-setup/scripts/lsp-server-table.ts

@@ -0,0 +1,177 @@
+// SOURCE OF TRUTH: packages/lsp-tools-mcp/src/lsp/server-definitions.ts
+// (BUILTIN_SERVERS + LSP_INSTALL_HINTS). This is a hand-maintained snapshot of
+// the primary builtin server per reference language, embedded so detect-lsp.ts
+// runs standalone in any user project. Mirror command/extensions when that file
+// changes.
+
+export interface LanguageServer {
+	readonly language: string
+	readonly serverId: string
+	readonly command: readonly string[]
+	readonly extensions: readonly string[]
+	readonly installHint: string
+}
+
+export const LANGUAGES: readonly LanguageServer[] = [
+	{
+		language: "typescript",
+		serverId: "typescript",
+		command: ["typescript-language-server", "--stdio"],
+		extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+		installHint: "npm install -g typescript-language-server typescript",
+	},
+	{
+		language: "python",
+		serverId: "basedpyright",
+		command: ["basedpyright-langserver", "--stdio"],
+		extensions: [".py", ".pyi"],
+		installHint: "pip install basedpyright (or: uv tool install basedpyright)",
+	},
+	{
+		language: "go",
+		serverId: "gopls",
+		command: ["gopls"],
+		extensions: [".go"],
+		installHint: "go install golang.org/x/tools/gopls@latest",
+	},
+	{
+		language: "rust",
+		serverId: "rust",
+		command: ["rust-analyzer"],
+		extensions: [".rs"],
+		installHint: "rustup component add rust-analyzer",
+	},
+	{
+		language: "c-cpp",
+		serverId: "clangd",
+		command: ["clangd", "--background-index", "--clang-tidy"],
+		extensions: [".c", ".cpp", ".cc", ".cxx", ".c++", ".h", ".hpp", ".hh", ".hxx", ".h++"],
+		installHint: "macOS: brew install llvm | Linux: apt install clangd | https://clangd.llvm.org/installation",
+	},
+	{
+		language: "java",
+		serverId: "jdtls",
+		command: ["jdtls"],
+		extensions: [".java"],
+		installHint: "macOS: brew install jdtls | https://github.com/eclipse-jdtls/eclipse.jdt.ls",
+	},
+	{
+		language: "kotlin",
+		serverId: "kotlin-ls",
+		command: ["kotlin-lsp"],
+		extensions: [".kt", ".kts"],
+		installHint: "https://github.com/Kotlin/kotlin-lsp",
+	},
+	{
+		language: "csharp",
+		serverId: "csharp",
+		command: ["csharp-ls"],
+		extensions: [".cs"],
+		installHint: "dotnet tool install -g csharp-ls",
+	},
+	{
+		language: "razor",
+		serverId: "razor",
+		command: ["roslyn-language-server", "--stdio"],
+		extensions: [".razor", ".cshtml"],
+		installHint: "dotnet tool install -g roslyn-language-server --prerelease (see references/csharp/README.md)",
+	},
+	{
+		language: "swift",
+		serverId: "sourcekit-lsp",
+		command: ["sourcekit-lsp"],
+		extensions: [".swift", ".objc", ".objcpp"],
+		installHint: "Included with Xcode (xcode-select --install) or the Swift toolchain",
+	},
+	{
+		language: "ruby",
+		serverId: "ruby-lsp",
+		command: ["rubocop", "--lsp"],
+		extensions: [".rb", ".rake", ".gemspec", ".ru"],
+		installHint: "gem install ruby-lsp (builtin runs `rubocop --lsp`; gem install rubocop)",
+	},
+	{
+		language: "php",
+		serverId: "php",
+		command: ["intelephense", "--stdio"],
+		extensions: [".php"],
+		installHint: "npm install -g intelephense",
+	},
+	{
+		language: "dart",
+		serverId: "dart",
+		command: ["dart", "language-server", "--lsp"],
+		extensions: [".dart"],
+		installHint: "Included with the Dart/Flutter SDK",
+	},
+	{
+		language: "elixir",
+		serverId: "elixir-ls",
+		command: ["elixir-ls"],
+		extensions: [".ex", ".exs"],
+		installHint: "https://github.com/elixir-lsp/elixir-ls",
+	},
+	{
+		language: "zig",
+		serverId: "zls",
+		command: ["zls"],
+		extensions: [".zig", ".zon"],
+		installHint: "https://github.com/zigtools/zls (match zls version to your zig version)",
+	},
+	{
+		language: "lua",
+		serverId: "lua-ls",
+		command: ["lua-language-server"],
+		extensions: [".lua"],
+		installHint: "macOS: brew install lua-language-server | https://github.com/LuaLS/lua-language-server",
+	},
+	{
+		language: "bash",
+		serverId: "bash",
+		command: ["bash-language-server", "start"],
+		extensions: [".sh", ".bash", ".zsh", ".ksh"],
+		installHint: "npm install -g bash-language-server",
+	},
+	{
+		language: "yaml",
+		serverId: "yaml-ls",
+		command: ["yaml-language-server", "--stdio"],
+		extensions: [".yaml", ".yml"],
+		installHint: "npm install -g yaml-language-server",
+	},
+	{
+		language: "terraform",
+		serverId: "terraform",
+		command: ["terraform-ls", "serve"],
+		extensions: [".tf", ".tfvars"],
+		installHint: "macOS: brew install hashicorp/tap/terraform-ls | https://github.com/hashicorp/terraform-ls",
+	},
+	{
+		language: "dockerfile",
+		serverId: "dockerfile",
+		command: ["docker-langserver", "--stdio"],
+		extensions: [".dockerfile"],
+		installHint: "npm install -g dockerfile-language-server-nodejs",
+	},
+	{
+		language: "haskell",
+		serverId: "haskell-language-server",
+		command: ["haskell-language-server-wrapper", "--lsp"],
+		extensions: [".hs", ".lhs"],
+		installHint: "ghcup install hls",
+	},
+	{
+		language: "julia",
+		serverId: "julials",
+		command: ["julia", "--startup-file=no", "--history-file=no", "-e", "using LanguageServer; runserver()"],
+		extensions: [".jl"],
+		installHint: "julia -e 'using Pkg; Pkg.add(\"LanguageServer\")' (see references/julia/README.md)",
+	},
+] as const
+
+export const PROJECT_CONFIG_FILES: readonly string[] = [
+	".codex/lsp-client.json",
+	".opencode/lsp.json",
+	".omo/lsp.json",
+	".omo/lsp-client.json",
+] as const

package/packages/shared-skills/skills/lsp-setup/scripts/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "lib": ["ESNext"],
+    "types": ["bun-types"]
+  },
+  "include": ["*.ts"]
+}

package/packages/shared-skills/skills/lsp-setup/scripts/verify-lsp.ts

@@ -0,0 +1,147 @@
+#!/usr/bin/env bun
+// verify-lsp.ts <file> [--timeout=ms] — perform a real LSP diagnostics roundtrip
+// for <file> through the lsp-tools-mcp engine and report ok/fail with error text.
+// The engine source is located by walking up from this script and the cwd, so
+// run it inside the omo repo/worktree (where packages/lsp-tools-mcp/src exists).
+
+import { existsSync, statSync } from "node:fs"
+import { dirname, isAbsolute, join, resolve } from "node:path"
+import process from "node:process"
+import { fileURLToPath, pathToFileURL } from "node:url"
+
+const ENGINE_TOOLS = "packages/lsp-tools-mcp/src/tools.ts"
+const ENGINE_CONTEXT = "packages/lsp-tools-mcp/src/request-context.ts"
+const ENGINE_MANAGER = "packages/lsp-tools-mcp/src/lsp/manager.ts"
+const DEFAULT_TIMEOUT_MS = 60_000
+
+interface ToolExecutionResult {
+	readonly content: ReadonlyArray<{ readonly type: "text"; readonly text: string }>
+	readonly isError?: boolean
+	readonly details?: unknown
+}
+
+interface DiagnosticsDetails {
+	readonly mode: "file" | "directory"
+	readonly totalDiagnostics: number
+	readonly error?: string
+	readonly errorKind?: "missing_dependency" | "no_files" | "invalid_path"
+}
+
+interface ToolsModule {
+	readonly executeLspDiagnostics: (params: Record<string, unknown>, signal?: AbortSignal) => Promise<ToolExecutionResult>
+}
+
+interface ContextModule {
+	readonly runWithRequestContext: <T>(context: { cwd?: string; env?: Record<string, string> }, fn: () => T) => T
+}
+
+interface ManagerModule {
+	readonly disposeDefaultLspManager: () => Promise<void>
+}
+
+function findUp(relativeTarget: string): string | null {
+	const starts = [dirname(fileURLToPath(import.meta.url)), process.cwd()]
+	for (const start of starts) {
+		let current = start
+		while (true) {
+			const candidate = join(current, relativeTarget)
+			if (existsSync(candidate)) return candidate
+			const parent = dirname(current)
+			if (parent === current) break
+			current = parent
+		}
+	}
+	return null
+}
+
+function buildEnv(): Record<string, string> {
+	const env: Record<string, string> = {}
+	for (const [key, value] of Object.entries(process.env)) {
+		if (value !== undefined) env[key] = value
+	}
+	return env
+}
+
+function isDiagnosticsDetails(value: unknown): value is DiagnosticsDetails {
+	return typeof value === "object" && value !== null && "mode" in value && "totalDiagnostics" in value
+}
+
+async function loadModule<T>(relativeTarget: string): Promise<T> {
+	const path = findUp(relativeTarget)
+	if (path === null) {
+		throw new EngineNotFoundError(relativeTarget)
+	}
+	return (await import(pathToFileURL(path).href)) as T
+}
+
+class EngineNotFoundError extends Error {
+	constructor(public readonly target: string) {
+		super(`lsp-tools-mcp engine not found (looked for ${target}). Run verify-lsp.ts inside the omo repo/worktree.`)
+		this.name = "EngineNotFoundError"
+	}
+}
+
+function parseTimeout(args: readonly string[]): number {
+	const flag = args.find((arg) => arg.startsWith("--timeout="))
+	if (flag === undefined) return DEFAULT_TIMEOUT_MS
+	const parsed = Number.parseInt(flag.slice("--timeout=".length), 10)
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TIMEOUT_MS
+}
+
+async function run(filePath: string, timeoutMs: number): Promise<number> {
+	const tools = await loadModule<ToolsModule>(ENGINE_TOOLS)
+	const context = await loadModule<ContextModule>(ENGINE_CONTEXT)
+	const manager = await loadModule<ManagerModule>(ENGINE_MANAGER)
+	const absolute = isAbsolute(filePath) ? filePath : resolve(process.cwd(), filePath)
+
+	try {
+		const signal = AbortSignal.timeout(timeoutMs)
+		const result = await context.runWithRequestContext({ cwd: process.cwd(), env: buildEnv() }, () =>
+			tools.executeLspDiagnostics({ filePath: absolute, severity: "all" }, signal),
+		)
+		const details = isDiagnosticsDetails(result.details) ? result.details : null
+		const text = result.content.map((part) => part.text).join("\n")
+
+		if (details?.errorKind === "missing_dependency") {
+			process.stdout.write(`FAIL ${absolute}: language server not installed\n${text}\n`)
+			return 1
+		}
+		if (result.isError === true || details?.errorKind === "invalid_path" || details?.errorKind === "no_files") {
+			process.stdout.write(`FAIL ${absolute}: ${details?.error ?? text}\n`)
+			return 1
+		}
+
+		const count = details?.totalDiagnostics ?? 0
+		process.stdout.write(`OK ${absolute}: LSP roundtrip succeeded (${count} diagnostic(s))\n${text}\n`)
+		return 0
+	} finally {
+		await manager.disposeDefaultLspManager()
+	}
+}
+
+async function main(): Promise<void> {
+	const args = process.argv.slice(2)
+	const filePath = args.find((arg) => !arg.startsWith("--"))
+	if (filePath === undefined) {
+		process.stderr.write("Usage: bun verify-lsp.ts <file> [--timeout=ms]\n")
+		process.exit(2)
+	}
+	if (!existsSync(filePath) || !statSync(filePath).isFile()) {
+		process.stderr.write(`verify-lsp: not a file: ${filePath}\n`)
+		process.exit(2)
+	}
+
+	try {
+		const code = await run(filePath, parseTimeout(args))
+		process.exit(code)
+	} catch (error) {
+		if (error instanceof EngineNotFoundError) {
+			process.stderr.write(`SKIP: ${error.message}\n`)
+			process.exit(3)
+		}
+		process.stderr.write(`FAIL ${filePath}: ${error instanceof Error ? error.message : String(error)}\n`)
+		process.exit(1)
+	}
+}
+
+await main()

package/packages/shared-skills/skills/remove-ai-slops/SKILL.md

@@ -193,7 +193,7 @@ For each skipped issue, give reason.
 )
 ```
 
-**Batch failure handling**: a `wait_agent` timeout only means no new mailbox update arrived, not that a `deep` agent failed. For long passes, require each child to send `WORKING: <file> - <current phase>` and `BLOCKED: <reason>` only when it cannot progress. If you need reassurance after a timeout, run a single `list_agents` check for the named child; a running child or latest `WORKING:` message is alive. Mark a file for retry only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running. Do NOT block the remaining 4 in that batch; collect successful results and retry the failed file once later. If retry also fails, escalate that file under "Issues Found & Fixed" in the final report.
+**Batch failure handling**: a `multi_agent_v1.wait_agent` timeout only means no new mailbox update arrived, not that a `deep` agent failed. For long passes, require each child to send `WORKING: <file> - <current phase>` and `BLOCKED: <reason>` only when it cannot progress. Treat a running child as alive. Mark a file for retry only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running. Do NOT block the remaining 4 in that batch; collect successful results and retry the failed file once later. If retry also fails, escalate that file under "Issues Found & Fixed" in the final report.
 
 ### Phase 5: Verify with quality gates + critical review
 

package/packages/shared-skills/skills/review-work/SKILL.md

@@ -20,15 +20,14 @@ Codex full-history forks inherit parent context, so role-specific behavior must
 
 ## Codex Subagent Reliability
 
-Every `spawn_agent` message must be self-contained. Start with
+Every `multi_agent_v1.spawn_agent` message must be self-contained. Start with
 `TASK: <imperative assignment>`, then name `DELIVERABLE`, `SCOPE`, and
 `VERIFY`. State that it is an executable assignment, not a context
-handoff. Role or specialty instructions belong inside `message`; the
-Codex tool schema only accepts `task_name`, `message`, and `fork_turns`.
-Prefer `fork_turns: "none"` unless full history is truly
+handoff. Role or specialty instructions belong inside `message`.
+Use `fork_context: false` unless full history is truly
 required; paste only the review context that worker needs.
 
-Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short wait_agent cycles sized to the work. Never use a single long blocking wait for them, and never spin on tiny timeouts as a failure budget.
+Plan and reviewer agents may run for a long time; spawn them in the background, keep doing independent root work, and poll with short `multi_agent_v1.wait_agent` cycles sized to the work. Never use a single long blocking wait for them, and never spin on tiny timeouts as a failure budget.
 
 Treat child status as a progress signal, not a timeout counter. For
 work likely to exceed one wait cycle, require the child to send
@@ -37,16 +36,13 @@ review passes, and `BLOCKED: <reason>` only when it cannot progress.
 While any child is active, keep the parent visibly alive with active
 subagent count, agent names, latest `WORKING:` phase, and whether the
 parent is waiting for mailbox updates. Track spawned agent names
-locally. Use `wait_agent` for mailbox signals, not proof of completion.
-A timeout only means no new mailbox update arrived; after a timeout,
-run a single `list_agents` check for the named child when you need
-reassurance. If it is running or its latest message is `WORKING:`,
-treat it as alive. Do not use `list_agents` as a polling loop or status
-feed; it can replay large payloads. Fallback only when the child is
+locally. Use `multi_agent_v1.wait_agent` for mailbox signals, not proof of completion.
+A timeout only means no new mailbox update arrived. Treat a running child as alive.
+Fallback only when the child is
 completed without the deliverable, ack-only after followup, explicitly
 `BLOCKED:`, or no longer running. Then mark that review lane
 `INCONCLUSIVE`, do not count it as PASS or approval, close if safe, and
-respawn a smaller `fork_turns: "none"` reviewer with the missing
+respawn a smaller `fork_context: false` reviewer with the missing
 deliverable. Preserve completed lane results immediately. If the retry
 budget is exhausted, keep the lane `INCONCLUSIVE` and still emit a final
 aggregate result.
@@ -530,7 +526,7 @@ After launching all 5 agents in one turn, wait for completions in bounded
 cycles. Do not treat a timeout, ack-only reply, or empty child result as
 a PASS.
 
-As each completes, collect via the Codex mapping above (`wait_agent`,
+As each completes, collect via the Codex mapping above (`multi_agent_v1.wait_agent`,
 then the child's substantive final result). Preserve completed lane
 results immediately; never lose a PASS/FAIL because another lane is
 still running. Store each verdict independently:
@@ -550,7 +546,7 @@ inconclusive and respawn a smaller reviewer/worker for that exact lane.
 If it still remains unfinished after that retry, close the still-running
 agent if safe, keep the lane INCONCLUSIVE, and emit the final aggregate
 review result with the incomplete lane named. Do not spin in repeated
-wait/followup cycles. Do not use `send_message` as an interrupt; queued
+wait/followup cycles. Do not use `multi_agent_v1.send_input` as an interrupt; queued
 followups are not cancellation.
 
 ---