@oh-my-pi/pi-coding-agent 13.0.2 → 13.1.1

package/src/prompts/tools/task.md

@@ -1,317 +1,135 @@
 # Task
 
-Launch subagents to execute parallel, well-scoped tasks.
+Launches subagents to parallelize workflows.
+
 {{#if asyncEnabled}}
-Use `read jobs://` to inspect background task state and `read jobs://<job-id>` for detailed status/output when needed.
-When you need to wait for async results before continuing, call `poll_jobs` — it blocks until jobs complete. You MUST NOT poll `read jobs://` in a loop or yield and hope for delivery.
+- Use `read jobs://` to inspect state; `read jobs://<job_id>` for detail.
+- Use the `await` tool to wait until completion. You MUST NOT poll `read jobs://` in a loop.
 {{/if}}
 
-## What subagents inherit automatically
-Subagents receive the **full system prompt**, including AGENTS.md, context files, and skills. You MUST NOT repeat project rules, coding conventions, or style guidelines in `context` — they already have them.
-
-## What subagents do NOT have
-Subagents have no access to your conversation history. They don't know:
-- Decisions you made but didn't write down
-- Which approach you chose among alternatives
-- What you learned from reading files during this session
-- Requirements the user stated only in conversation
-
-Subagents CAN grep the parent conversation file for supplementary details.
-
-For large intermediate outputs (long traces, JSON payloads, temporary analysis snapshots), you SHOULD write them to `local://<path>` and pass the path in task context instead of inlining bulky text.
-
-## Parameters
-
-### `agent` (required)
+Subagents lack your conversation history. Every decision, file content, and user requirement they need MUST be explicit in `context` or `assignment`.
 
-Agent type for all tasks in this batch.
-
-### `context` (optional — strongly recommended)
-
-Shared background prepended verbatim to every task `assignment`. Use only for session-specific information subagents lack.
+<parameters>
+- `agent`: Agent type for all tasks.
+  - `.id`: CamelCase, max 32 chars
+  - `.description`: UI display only — subagent never sees it
+  - `.assignment`: Complete self-contained instructions. One-liners PROHIBITED; missing acceptance criteria = too vague.
+  - `.skills`: Skill names to preload
+- `context`: Shared background prepended to every assignment. Session-specific info only.
+- `schema`: JTD schema for expected output. Format lives here — MUST NOT be duplicated in assignments.
+- `tasks`: Tasks to execute in parallel.
+- `isolated`: Run in isolated git worktree; returns patches. Use when tasks edit overlapping files.
+</parameters>
 
 <critical>
-You MUST NOT include project rules, coding conventions, or style guidelines — subagents already have AGENTS.md and context files in their system prompt. Repeating them wastes tokens and inflates context. Restating any rule from AGENTS.md in `context` is a bug — treat it like a lint error.
+- MUST NOT include AGENTS.md rules, coding conventions, or style guidelines — subagents already have them.
+- MUST NOT duplicate shared constraints across assignments — put them in `context` once.
+- MUST NOT tell tasks to run project-wide build/test/lint. Parallel agents share the working tree; each task edits, stops. Caller verifies after all complete.
+- For large payloads (traces, JSON blobs), write to `local://<path>` and pass the path in context.
+- If scope is unclear, run a **Discovery task** first to enumerate files and callsites, then fan out.
 </critical>
-**Before writing each line of context, ask:** "Would this sentence be true for ANY task in this repo, or only for THIS specific batch?" If it applies to any task → it's a project rule → the subagent already has it → you MUST delete the line.
 
-WRONG — restating project rules the subagent already has:
-```
-## Constraints
-- Use X import style, not Y (per AGENTS.md)
-- Use Z for private fields per AGENTS.md
-- Run the formatter after changes
-- Follow the logging convention
-```
-Every line above restates a project convention. The subagent reads AGENTS.md. You MUST delete them all.
+<scope>
+Each task: **at most 3–5 files**. Globs in file paths, "update all", or package-wide scope = too broad. Enumerate files explicitly and fan out to a cluster of agents.
+</scope>
 
-RIGHT — only session-specific decisions the subagent cannot infer from project files:
-```
-## Constraints
-- We decided to use approach A over B (session decision)
-- The migration target type is `Foo` from `bar` package (looked up this session)
-```
-
-Use template; omit non-applicable sections:
-
-````
-## Goal
-One sentence: batch accomplishes together.
-
-## Non-goals
-Explicitly exclude tempting scope — what tasks must not touch/attempt.
-
-## Constraints
-- Task-specific MUST / MUST NOT rules not already in AGENTS.md
-- Decisions made during this session that affect implementation
-
-## Reference Files
-- `path/to/file.ext` — pattern demo
-- `path/to/other.ext` — reuse or avoid
-
-## API Contract (if tasks produce/consume shared interface)
-```language
-// Exact type definitions, function signatures, interface shapes
-```
+<parallelization>
+**Test:** Can task B produce correct output without seeing A's result? Yes → parallel. No → sequential.
 
-## Acceptance (global)
-- Definition of "done" for batch
-- Note: build/test/lint verification happens AFTER all tasks complete — not inside tasks (see below)
-````
-**Belongs in `context`**: task-specific goal, non-goals, session decisions, reference paths, shared type definitions, API contracts, global acceptance commands — anything 2+ tasks need that isn't already in AGENTS.md.
-**Rule of thumb:** if repeat in 2+ tasks, belongs in `context`.
-**Does NOT belong in `context`**: project rules already in AGENTS.md/context files, per-task file lists, one-off requirements (go in `assignment`), structured output format (goes in `schema`).
-
-### `tasks` (required)
-
-Array tasks execute in parallel.
-
-|Field|Required|Purpose|
+|Sequential first|Then|Reason|
 |---|---|---|
-|`id`|✓|CamelCase identifier, max 32 chars|
-|`description`|✓|Short one-liner for UI display only — not seen by subagent|
-|`assignment`|✓|Complete per-task instructions. See [Writing an assignment](#writing-an-assignment).|
-|`skills`||Skill names preload. Use only when changes correctness — don’t spam every task.|
-
-{{#if isolationEnabled}}
-### `isolated` (optional)
-
-Run in isolated git worktree; returns patches. Use when tasks edit overlapping files or when you want clean per-task diffs.
-{{/if}}
-### `schema` (optional — recommended for structured output)
-
-JTD schema defining expected response structure. Use typed properties. If you care about parsing result, define here — you MUST NOT describe output format in `context` or `assignment`.
-
-<caution>
-**Schema vs agent mismatch causes null output.** Agents with `output="structured"` (e.g., `explore`) have a built-in schema. If you also pass `schema`, yours takes precedence — but if you describe output format in `context`/`assignment` instead, the agent's built-in schema wins. The agent gets confused trying to fit your requested format into its schema shape and submits `null`. Either: (1) use `schema` to override the built-in one, (2) use `task` agent which has no built-in schema, or (3) match your instructions to the agent's expected output shape.
-</caution>
----
-
-## Writing an assignment
-
-<critical>## Task scope
-
-`assignment` MUST contain enough info for agent to act **without asking a clarifying question**.
-**Minimum bar:** assignment under ~8 lines or missing acceptance criteria = too vague. One-liners guaranteed failure.
-
-Use structure every assignment:
-
+|Types/interfaces|Consumers|Need contract|
+|API exports|Callers|Need signatures|
+|Core module|Dependents|Import dependency|
+|Schema/migration|App logic|Schema dependency|
+**Safe to parallelize:** independent modules, isolated file-scoped refactors, tests for existing code.
+</parallelization>
+
+<templates>
+**context:**
 ```
-## Target
-- Files: exact path(s)
-- Symbols/entrypoints: specific functions, types, exports
-- Non-goals: what task must NOT touch (prevents scope creep)
-
-## Change
-- Step-by-step: add/remove/rename/restructure
-- Patterns/APIs to use; reference files if applicable
-
-## Edge Cases / Don't Break
-- Tricky case 1: …
-- Tricky case 2: …
-- Existing behavior must survive: …
-
-## Acceptance (task-local)
-- Expected behavior or observable result
-- DO NOT include project-wide build/test/lint commands (see below)
+## Goal         ← one sentence: what the batch accomplishes
+## Non-goals    ← what tasks must not touch
+## Constraints  ← MUST/MUST NOT rules beyond AGENTS.md; session decisions
+## API Contract ← exact types/signatures if tasks share an interface (omit if N/A)
+## Acceptance   ← definition of done; build/lint runs AFTER all tasks complete
 ```
-
-`context` carries shared background. `assignment` carries only delta: file-specific instructions, local edge cases, per-task acceptance checks. You MUST NOT duplicate shared constraints across assignments.
-
-### Anti-patterns (ban these)
-**Vague assignments** — agent guesses wrong or stalls:
-- "Refactor this to be cleaner."
-- "Migrate to N-API."
-- "Fix the bug in streaming."
-- "Update all constructors in `src/**/*.ts`."
-  **Vague context** — forces agent invent conventions:
-- "Use existing patterns."
-- "Follow conventions."
-- "No WASM."
-  **Redundant context** — wastes tokens repeating what subagents already have:
-- Restating AGENTS.md rules (coding style, import conventions, formatting commands, logger usage, etc.)
-- Repeating project constraints from context files
-- Listing tool/framework preferences already documented in the repo
-
-If a constraint appears in AGENTS.md, it MUST NOT appear in `context`. The subagent has the full system prompt.
-
-If tempted to write above, expand using templates.
-**Output format in prose instead of `schema`** — agent returns null:
-Structured agents (`explore`, `reviewer`) have built-in output schemas. Describing a different output format in `context`/`assignment` without overriding via `schema` creates a mismatch — the agent can't reconcile your prose instructions with its schema and submits null data. You MUST use `schema` for output structure, or pick an agent whose built-in schema matches your needs.
-**Test/lint commands in parallel tasks** — edit wars:
-Parallel agents share working tree. If two agents run `bun check` or `bun test` concurrently, they see each other's half-finished edits, "fix" phantom errors, loop. You MUST NOT tell parallel tasks to run project-wide build/test/lint commands. Each task edits, stops. Caller verifies after all tasks complete.
-**If you can't specify scope yet**, create **Discovery task** first: enumerate files, find callsites, list candidates. Then fan out with explicit paths.
-
-### Delegate intent, not keystrokes
-
-Your role as tech lead: set direction, define boundaries, call out pitfalls — then get out of way. Don’t read every file, decide every edit, dictate line-by-line. That makes you bottleneck; agent typist.
-**Be specific about:** constraints, naming conventions, API contracts, "don’t break" items, acceptance criteria.
-**Delegate:** code reading, approach selection, exact edit locations, implementation details. Agent has tools, can reason about code.
-
-Micromanaging (you think, agent types):
-```
-assignment: "In src/api/handler.ts, line 47, change `throw err` to `throw new ApiError(err.message, 500)`.
-On line 63, wrap fetch call try/catch return 502 on failure.
-On line 89, add null check before accessing resp.body…"
+**assignment:**
 ```
-
-Delegating (agent thinks within constraints):
+## Target       ← exact file paths; named symbols; explicit non-goals
+## Change       ← step-by-step what to add/remove/rename; patterns/APIs to use
+## Edge Cases   ← tricky inputs; existing behavior that must survive
+## Acceptance   ← observable result proving the task is done; no project-wide commands
 ```
-assignment: "## Target\n- Files: src/api/handler.ts\n\n## Change\nImprove error handling: replace raw throws
-with typed ApiError instances, add try/catch around external calls, guard against null responses.\n\n
-## Edge Cases / Don't Break\n- Existing error codes in tests must still match\n
-- Don't change public function signatures"
-```
-
-First style wastes your time, brittle if code shifts. Second gives agent room to do work.
-</critical>
+</templates>
 
-## Example
+<checklist>
+Before invoking:
+- `context` contains only session-specific info not in AGENTS.md
+- Every `assignment` follows the template; no one-liners; edge cases covered
+- Tasks are truly parallel — you can articulate why none depends on another's output
+- File paths are explicit; no globs
+- `schema` is set if you expect structured output
+</checklist>
 
-<example type="bad" label="Duplicated context inflates tokens">
-<tasks>
-  <task name="Grep">
-    <description>Port grep module from WASM to N-API…</description>
-    <assignment>Port grep module from WASM to N-API… (same blob repeated)</assignment>
-  </task>
-</tasks>
-</example>
+<example label="Rename exported symbol + update all call sites">
+Two tasks with non-overlapping file sets. Neither depends on the other's edits.
 
-<example type="good" label="Shared rules in context, only deltas in assignment">
 <context>
 ## Goal
-Port WASM modules to N-API, matching existing pi-natives conventions.
-
+Rename `parseConfig` → `loadConfig` in `src/config/parser.ts` and all callers.
 ## Non-goals
-Do not touch TS bindings or downstream consumers — separate phase.
-
-## Constraints
-- MUST use `#[napi]` attribute macro on all exports
-- MUST return `napi::Result<T>` for fallible ops; never panic
-- MUST use `spawn_blocking` for filesystem I/O or >1ms work
-  …
-
+Do not change function behavior, signature, or tests — rename only.
 ## Acceptance (global)
-- Caller verifies after all tasks: `cargo test -p pi-natives` and `cargo build -p pi-natives` with no warnings
-- Individual tasks must NOT run these commands themselves
+Caller runs `bun check:ts` after both tasks complete. Tasks must NOT run it.
 </context>
-
 <tasks>
-  <task name="PortGrep">
-    <description>Port grep module to N-API</description>
+  <task name="RenameExport">
+    <description>Rename the export in parser.ts</description>
     <assignment>
 ## Target
-- Files: `src/grep.rs`, `src/lib.rs` (registration only)
-- Symbols: search, search_multi, compile_pattern
+- File: `src/config/parser.ts`
+- Symbol: exported function `parseConfig`
+- Non-goals: do not touch callers or tests
 
 ## Change
-- Implement three N-API exports in grep.rs:
-  - `search(pattern: JsString, path: JsString, env: Env) → napi::Result<Vec<Match>>`
-…
+- Rename `parseConfig` → `loadConfig` (declaration + any JSDoc referencing it)
+- If `src/config/index.ts` re-exports `parseConfig`, update that re-export too
+
+## Edge Cases
+- If the function is overloaded, rename all overload signatures
+- Internal helpers named `_parseConfigValue` or similar: leave untouched — different symbols
+- Do not add a backwards-compat alias
 
-## Acceptance (task-local)
-- Three functions exported with correct signatures (caller verifies build after all tasks)
+## Acceptance
+- `src/config/parser.ts` exports `loadConfig`; `parseConfig` no longer appears as a top-level export in that file
     </assignment>
   </task>
-
-  <task name="PortHighlight">
-    <description>Port highlight module to N-API</description>
+  <task name="UpdateCallers">
+    <description>Update import and call sites in consuming modules</description>
     <assignment>
 ## Target
-- Files: `src/highlight.rs`, `src/lib.rs` (registration only)
-  …
+- Files: `src/cli/init.ts`, `src/server/bootstrap.ts`, `src/worker/index.ts`
+- Non-goals: do not touch `src/config/parser.ts` or `src/config/index.ts` — handled by sibling task
+
+## Change
+- In each file: replace `import { parseConfig }` → `import { loadConfig }` from its config path
+- Replace every call site `parseConfig(` → `loadConfig(`
+
+## Edge Cases
+- If a file spreads the import (`import * as cfg from "…"`) and calls `cfg.parseConfig(…)`, update the property access too
+- String literals containing "parseConfig" (log messages, comments) are documentation — leave them
+- If any file re-exports `parseConfig` to an external package boundary, keep the old name via `export { loadConfig as parseConfig }` and add a `// TODO: remove after next major` comment
+
+## Acceptance
+- No bare reference to `parseConfig` (as identifier, not string) remains in the three target files
     </assignment>
   </task>
 </tasks>
 </example>
----
-
-## Task scope
-
-Each task MUST have small, well-defined scope — **at most 3–5 files**.
-**Signs task too broad:**
-- File paths use globs (`src/**/*.ts`) instead of explicit names
-- Assignment says "update all" / "migrate everything" / "refactor across"
-- Scope covers entire package or directory tree
-  **Fix:** You MUST enumerate files first (grep/glob discovery), then fan out one task per file or small cluster.
----
-
-## Parallelization
-**Test:** Can task B produce correct output without seeing task A's result?
-- **Yes** → parallelize
-- **No** → run sequentially (A completes, then launch B with A output in context)
-
-### Must be sequential
-
-|First|Then|Reason|
-|---|---|---|
-|Define types/interfaces|Implement consumers|Consumers need contract|
-|Create API exports|Write bindings/callers|Callers need export names/signatures|
-|Scaffold structure|Implement bodies|Bodies need shape|
-|Core module|Dependent modules|Dependents import from core|
-|Schema/DB migration|Application logic|Logic depends on new schema shape|
-
-### Safe to parallelize
-- Independent modules, no cross-imports
-- Tests for already-implemented code
-- Isolated file-scoped refactors
-- Documentation for stable APIs
-
-### Phased execution
-
-<caution>
-**Parallel agents share the working tree.** They see each other's half-finished edits in real time. This is why:
-- Parallel tasks MUST NOT run project-wide build/test/lint — they will collide on phantom errors
-- Tasks editing overlapping files MUST use `isolated: true` (worktree isolation) or be made sequential
-- The caller MUST run verification after all tasks complete, not inside any individual task
-</caution>
-
-Layered work with dependencies:
-**Phase 1 — Foundation** (caller MUST do this, MUST NOT delegate): define interfaces, create scaffolds, establish API shape. You MUST NOT fan out until contract is known.
-**Phase 2 — Parallel implementation**: fan out tasks consuming same known interface. Include Phase 1 API contract in `context`.
-**Phase 3 — Integration** (caller MUST do this, MUST NOT delegate): wire modules, fix mismatches, verify builds.
-**Phase 4 — Dependent layer**: fan out tasks consuming Phase 2 outputs.
----
-
-## Pre-flight checklist
-
-<critical>
-Before calling tool, verify each item:
-- [ ] `context` MUST include only session-specific info not already in AGENTS.md/context files
-- [ ] Each `assignment` MUST follow the assignment template — one-liners are PROHIBITED
-- [ ] Each `assignment` MUST include edge cases / "don't break" items
-- [ ] Tasks MUST be truly parallel — you MUST be able to articulate why no task depends on another's output
-- [ ] Scope MUST be small; file paths MUST be explicit (no globs)
-- [ ] Tasks MUST NOT run project-wide build/test/lint — caller MUST verify after all tasks complete
-- [ ] `schema` MUST be used if you expect structured output
-</critical>
----
-
-## Agents
 
 {{#list agents join="\n"}}
-<agent name="{{name}}"{{#if output}} output="structured"{{/if}}>
-<description>{{description}}</description>
-<tools>{{default (join tools ", ") "All tools"}}</tools>
-</agent>
+### Agent: {{name}}
+**Tools:** {{default (join tools ", ") "All"}}
+{{description}}
 {{/list}}

package/src/prompts/tools/web-search.md

@@ -7,13 +7,6 @@ Search the web for up-to-date information beyond Claude's knowledge cutoff.
 - You MUST include links for cited sources in the final response
 </instruction>
 
-<output>
-Returns search results formatted as blocks with:
-- Result summaries and relevant excerpts
-- Links as markdown hyperlinks for citation
-- Provider-dependent structure based on selected backend
-</output>
-
 <caution>
 Searches are performed automatically within a single API call—no pagination or follow-up requests needed.
 </caution>

package/src/prompts/tools/write.md

@@ -5,13 +5,8 @@ Creates or overwrites file at specified path.
 <conditions>
 - Creating new files explicitly required by task
 - Replacing entire file contents when editing would be more complex
-- Prefer `local://<path>` for large temporary artifacts, subagent handoff payloads, and reusable planning artifacts that should survive within the session
 </conditions>
 
-<output>
-Confirmation of file creation/write with path. When LSP available, content may be auto-formatted before writing and diagnostics returned. Returns error if write fails (permissions, invalid path, disk full).
-</output>
-
 <critical>
 - You SHOULD use Edit tool for modifying existing files (more precise, preserves formatting)
 - You MUST NOT create documentation files (*.md, README) unless explicitly requested

package/src/sdk.ts

@@ -1,4 +1,11 @@
-import { Agent, type AgentEvent, type AgentMessage, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import {
+	Agent,
+	type AgentEvent,
+	type AgentMessage,
+	type AgentTool,
+	INTENT_FIELD,
+	type ThinkingLevel,
+} from "@oh-my-pi/pi-agent-core";
 import { type Message, type Model, supportsXhigh } from "@oh-my-pi/pi-ai";
 import { prewarmOpenAICodexResponses } from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
 import type { Component } from "@oh-my-pi/pi-tui";
@@ -1114,6 +1121,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	});
 
 	const repeatToolDescriptions = settings.get("repeatToolDescriptions");
+	const intentField = settings.get("tools.intentTracing") || $env.PI_INTENT_TRACING === "1" ? INTENT_FIELD : undefined;
 	const rebuildSystemPrompt = async (toolNames: string[], tools: Map<string, AgentTool>): Promise<string> => {
 		toolContextStore.setToolNames(toolNames);
 		const memoryInstructions = await buildMemoryToolDeveloperInstructions(agentDir, settings);
@@ -1128,6 +1136,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			skillsSettings: settings.getGroup("skills") as SkillsSettings,
 			appendSystemPrompt: memoryInstructions,
 			repeatToolDescriptions,
+			intentField,
 		});
 
 		if (options.systemPrompt === undefined) {
@@ -1146,6 +1155,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				customPrompt: options.systemPrompt,
 				appendSystemPrompt: memoryInstructions,
 				repeatToolDescriptions,
+				intentField,
 			});
 		}
 		return options.systemPrompt(defaultPrompt);
@@ -1283,7 +1293,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		},
 		cursorExecHandlers,
 		transformToolCallArguments: obfuscator?.hasSecrets() ? args => obfuscator!.deobfuscateObject(args) : undefined,
-		intentTracing: settings.get("tools.intentTracing") || $env.PI_INTENT_TRACING === "1",
+		intentTracing: !!intentField,
 	});
 	cursorEventEmitter = event => agent.emitExternalEvent(event);
 

package/src/system-prompt.ts

@@ -419,6 +419,8 @@ export interface BuildSystemPromptOptions {
 	preloadedSkills?: Skill[];
 	/** Pre-loaded rulebook rules (rules with descriptions, excluding TTSR and always-apply). */
 	rules?: Array<{ name: string; description?: string; path: string; globs?: string[] }>;
+	/** Intent field name injected into every tool schema. If set, explains the field in the prompt. */
+	intentField?: string;
 }
 
 /** Build the system prompt with tools, guidelines, and context */
@@ -439,6 +441,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		skills: providedSkills,
 		preloadedSkills: providedPreloadedSkills,
 		rules,
+		intentField,
 	} = options;
 	const resolvedCwd = cwd ?? getProjectDir();
 	const preloadedSkills = providedPreloadedSkills;
@@ -609,5 +612,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		dateTime,
 		cwd: resolvedCwd,
 		appendSystemPrompt: resolvedAppendPrompt ?? "",
+		intentTracing: !!intentField,
+		intentField: intentField ?? "",
 	});
 }

package/src/tools/{poll-jobs.ts → await-tool.ts}

@@ -1,10 +1,10 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type Static, Type } from "@sinclair/typebox";
 import { renderPromptTemplate } from "../config/prompt-templates";
-import pollJobsDescription from "../prompts/tools/poll-jobs.md" with { type: "text" };
+import awaitDescription from "../prompts/tools/await.md" with { type: "text" };
 import type { ToolSession } from "./index";
 
-const pollJobsSchema = Type.Object({
+const awaitSchema = Type.Object({
 	job_ids: Type.Optional(
 		Type.Array(Type.String(), {
 			description: "Specific job IDs to wait for. If omitted, waits for any running job.",
@@ -17,9 +17,9 @@ const pollJobsSchema = Type.Object({
 	),
 });
 
-type PollJobsParams = Static<typeof pollJobsSchema>;
+type AwaitParams = Static<typeof awaitSchema>;
 
-interface PollJobResult {
+interface AwaitResult {
 	id: string;
 	type: "bash" | "task";
 	status: "running" | "completed" | "failed" | "cancelled";
@@ -29,34 +29,34 @@ interface PollJobResult {
 	errorText?: string;
 }
 
-export interface PollJobsToolDetails {
-	jobs: PollJobResult[];
+export interface AwaitToolDetails {
+	jobs: AwaitResult[];
 	timedOut: boolean;
 }
 
-export class PollJobsTool implements AgentTool<typeof pollJobsSchema, PollJobsToolDetails> {
-	readonly name = "poll_jobs";
-	readonly label = "PollJobs";
+export class AwaitTool implements AgentTool<typeof awaitSchema, AwaitToolDetails> {
+	readonly name = "await";
+	readonly label = "Await";
 	readonly description: string;
-	readonly parameters = pollJobsSchema;
+	readonly parameters = awaitSchema;
 	readonly strict = true;
 
 	constructor(private readonly session: ToolSession) {
-		this.description = renderPromptTemplate(pollJobsDescription);
+		this.description = renderPromptTemplate(awaitDescription);
 	}
 
-	static createIf(session: ToolSession): PollJobsTool | null {
+	static createIf(session: ToolSession): AwaitTool | null {
 		if (!session.settings.get("async.enabled")) return null;
-		return new PollJobsTool(session);
+		return new AwaitTool(session);
 	}
 
 	async execute(
 		_toolCallId: string,
-		params: PollJobsParams,
+		params: AwaitParams,
 		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<PollJobsToolDetails>,
+		_onUpdate?: AgentToolUpdateCallback<AwaitToolDetails>,
 		_context?: AgentToolContext,
-	): Promise<AgentToolResult<PollJobsToolDetails>> {
+	): Promise<AgentToolResult<AwaitToolDetails>> {
 		const manager = this.session.asyncJobManager;
 		if (!manager) {
 			return {
@@ -129,12 +129,12 @@ export class PollJobsTool implements AgentTool<typeof pollJobsSchema, PollJobsTo
 			errorText?: string;
 		}[],
 		timedOut: boolean,
-	): AgentToolResult<PollJobsToolDetails> {
+	): AgentToolResult<AwaitToolDetails> {
 		const now = Date.now();
-		const jobResults: PollJobResult[] = jobs.map(j => ({
+		const jobResults: AwaitResult[] = jobs.map(j => ({
 			id: j.id,
 			type: j.type,
-			status: j.status as PollJobResult["status"],
+			status: j.status as AwaitResult["status"],
 			label: j.label,
 			durationMs: Math.max(0, now - j.startTime),
 			...(j.resultText ? { resultText: j.resultText } : {}),