@oh-my-pi/pi-coding-agent 16.5.1 → 16.5.2

package/dist/types/config/settings-schema.d.ts

@@ -3699,6 +3699,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable the tts tool for on-device (Kokoro) or xAI Grok Voice speech-file synthesis";
         };
     };
+    readonly "generate_image.enabled": {
+        readonly type: "boolean";
+        readonly default: true;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly group: "Available Tools";
+            readonly label: "Generate Image";
+            readonly description: "Enable the generate_image tool for text-to-image generation and editing";
+        };
+    };
     readonly "inspect_image.enabled": {
         readonly type: "boolean";
         readonly default: false;

package/dist/types/discovery/substitute-plugin-root.d.ts

@@ -1 +1,23 @@
 export declare function substitutePluginRoot<T>(value: T, rootPath: string): T;
+/**
+ * Rebase relative filesystem values in a discovered plugin stdio config against
+ * the directory of the `.mcp.json` that declared them.
+ *
+ * External plugin configs (bundled ChatGPT/Codex plugins, Claude marketplace
+ * plugins) express `command`/`cwd` relative to their own config file, but MCP
+ * stdio spawning roots relative values at the session cwd — so a plugin shipping
+ * `command: "./bin/server"`, `cwd: "."` launches from the wrong directory and
+ * fails with ENOENT. This resolves those against `configDir` instead:
+ *
+ * - relative `cwd` → resolved against `configDir`;
+ * - path-like `command` (`./`, `../`, or the Windows `.\`/`..\` forms) →
+ *   resolved against `configDir`;
+ * - bare executables (`npx`, `uvx`, …) and absolute paths are left untouched.
+ */
+export declare function resolvePluginStdioPaths(config: {
+    command?: string;
+    cwd?: string;
+}, configDir: string): {
+    command?: string;
+    cwd?: string;
+};

package/dist/types/eval/backend.d.ts

@@ -13,10 +13,10 @@ export interface ExecutorBackendExecOptions {
      * driven entirely by `signal`, which the eval tool arms as a watchdog that
      * pauses on bridge timeout-control status events and fires a `TimeoutError`
      * reason only while the Python/JS runtime owns control. Backends use this
-     * value only for timeout-annotation text and as cold-start headroom; they MUST
-     * NOT derive a competing wall-clock timer from it.
+     * value only for timeout-annotation text and as cold-start headroom; undefined
+     * disables the cell timeout. Backends MUST NOT derive a competing wall-clock timer from it.
      */
-    idleTimeoutMs: number;
+    idleTimeoutMs?: number;
     reset: boolean;
     onChunk: (chunk: string) => void;
     /**

package/dist/types/extensibility/extensions/wrapper.d.ts

@@ -1,7 +1,7 @@
 /**
  * Tool wrappers for extensions.
  */
-import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Static, TSchema } from "@oh-my-pi/pi-ai";
 import type { ExtensionRunner } from "./runner.js";
 import type { RegisteredTool } from "./types.js";
@@ -19,7 +19,7 @@ export declare class RegisteredToolAdapter implements AgentTool<any, any, any> {
     renderCall?: (args: any, options: any, theme: any) => any;
     renderResult?: (result: any, options: any, theme: any, args?: any) => any;
     constructor(registeredTool: RegisteredTool, runner: ExtensionRunner);
-    execute(toolCallId: string, params: any, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<any>, _context?: AgentToolContext): Promise<import("@oh-my-pi/pi-agent-core").AgentToolResult<unknown, unknown>>;
+    execute(toolCallId: string, params: any, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<any>, _context?: AgentToolContext): Promise<AgentToolResult<unknown, unknown>>;
 }
 /**
  * Backward-compatible factory function wrapper.
@@ -47,8 +47,5 @@ export declare class ExtensionToolWrapper<TParameters extends TSchema = TSchema,
      * Forward browser mode changes when available.
      */
     restartForModeChange(): Promise<void>;
-    execute(toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails, TParameters>, context?: AgentToolContext): Promise<{
-        content: any;
-        details?: TDetails;
-    }>;
+    execute(toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails, TParameters>, context?: AgentToolContext): Promise<AgentToolResult<TDetails, TParameters>>;
 }

package/dist/types/extensibility/plugins/bun-git-cache.d.ts

@@ -0,0 +1,3 @@
+import type { GitSource } from "./git-url.js";
+/** Fetches current heads and tags into Bun's matching cached bare clone before a plugin update. */
+export declare function refreshBunGitCache(source: GitSource, cwd: string): Promise<void>;

package/dist/types/goals/guided-setup.d.ts

@@ -14,5 +14,17 @@ export type GuidedGoalTurnResult = {
 export interface GuidedGoalTurnOptions {
     messages: readonly GuidedGoalMessage[];
     signal?: AbortSignal;
+    /**
+     * Stable Codex transport session id reused across every turn of one
+     * interview. `handleGuidedGoalCommand` runs up to six turns; minting a fresh
+     * id per turn opens a new websocket-only Codex socket each time (kept in
+     * `providerSessionState` until session dispose), which can trip
+     * `websocket_connection_limit_reached` and drop back to the SSE path this
+     * fix avoids. Callers pass one id for the whole interview; omitted for
+     * one-shot callers, which mint a unique id per call.
+     */
+    sideSessionId?: string;
 }
+/** Mint a guided-goal Codex side-session id keyed off the main session id. */
+export declare function newGuidedGoalSessionId(session: AgentSession): string;
 export declare function runGuidedGoalTurn(session: AgentSession, options: GuidedGoalTurnOptions): Promise<GuidedGoalTurnResult>;

package/dist/types/internal-urls/history-protocol.d.ts

@@ -2,8 +2,9 @@ import type { InternalResource, InternalUrl, ProtocolHandler, UrlCompletion } fr
 /**
  * Handler for history:// URLs.
  *
- * Resolves agent ids against the global AgentRegistry, serving transcripts
- * for both live and parked agents.
+ * Resolves agent ids against the global AgentRegistry, then falls back to
+ * on-disk `.jsonl` transcripts, serving read-only history for live, parked,
+ * and unregistered agents alike.
  */
 export declare class HistoryProtocolHandler implements ProtocolHandler {
     #private;

package/dist/types/internal-urls/registry-helpers.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Shared helpers for internal-url protocol handlers that resolve IDs against
+ * registered agent sessions.
+ */
 export declare function registerArtifactsDir(dir: string): () => void;
 export declare function resetRegisteredArtifactDirsForTests(): void;
 /**
@@ -12,3 +16,18 @@ export declare function resetRegisteredArtifactDirsForTests(): void;
  * single entry.
  */
 export declare function artifactsDirsFromRegistry(): string[];
+/**
+ * Recursively scan artifacts dirs for agent session transcripts, keyed by
+ * agent id (the `.jsonl` basename). Used by `history://` so transcripts of
+ * agents no longer in the registry (unregistered one-shot helpers, released
+ * agents, or any agent after session resume) remain reachable — mirroring how
+ * `agent://` reads `.md` outputs straight off disk.
+ *
+ * Layout follows `task/index.ts`: a subagent's transcript is
+ * `<artifactsDir>/<AgentId>.jsonl`, and its own children nest one level deeper
+ * under `<artifactsDir>/<AgentId>/<AgentId>.<ChildId>.jsonl`. Advisor
+ * transcripts (`__advisor*.jsonl`) are observability-only and excluded;
+ * EPERM-rewrite backups (`.bak`) are skipped. When the same id appears in
+ * multiple dirs, the first hit wins (registry dirs are scanned first).
+ */
+export declare function sessionFilesFromDisk(): Promise<Map<string, string>>;

package/dist/types/mcp/oauth-discovery.d.ts

@@ -3,6 +3,8 @@ export interface OAuthEndpoints {
     authorizationUrl: string;
     tokenUrl: string;
     clientId?: string;
+    /** Dynamic client registration endpoint advertised by the authorization server. */
+    registrationUrl?: string;
     scopes?: string;
     resource?: string;
 }

package/dist/types/mcp/oauth-flow.d.ts

@@ -52,6 +52,8 @@ export interface MCPOAuthConfig {
     authorizationUrl: string;
     /** Token endpoint URL */
     tokenUrl: string;
+    /** Dynamic client registration endpoint advertised by the authorization server. */
+    registrationUrl?: string;
     /** Client ID (optional when already embedded in authorization URL) */
     clientId?: string;
     /** Client secret (optional for PKCE flows) */

package/dist/types/modes/components/__tests__/dynamic-border.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/modes/components/agent-hub.d.ts

@@ -69,6 +69,16 @@ export declare class AgentHubOverlayComponent extends Container {
     dispose(): void;
     render(width: number): readonly string[];
     handleInput(keyData: string): void;
+    /**
+     * Seed the table's left-left close detector with the current time so a single
+     * subsequent `←` (within {@link LEFT_TAP_WINDOW_MS}) dismisses the hub.
+     *
+     * The editor's own double-tap detector consumes the `←←` that opens the hub,
+     * leaving this detector at its fresh `0` — without this handoff the user would
+     * have to press `←←` a second time to escape. Called by the opener when the hub
+     * was raised by that gesture.
+     */
+    armCloseTap(): void;
     /**
      * Open the fullscreen transcript viewer for an agent id (public for table Enter
      * and tests). Mounts {@link AgentTranscriptViewer} as a `fullscreen` overlay so it

package/dist/types/modes/components/dynamic-border.d.ts

@@ -2,9 +2,11 @@ import type { Component } from "@oh-my-pi/pi-tui";
 /**
  * Dynamic border component that adjusts to viewport width.
  *
- * Note: When used from hooks loaded via jiti, the global `theme` may be undefined
- * because jiti creates a separate module cache. Always pass an explicit color
- * function when using DynamicBorder in components exported for hook use.
+ * Note: the module-level `theme` may be `undefined` — when loaded through jiti
+ * (separate module cache) or from a second `src` module graph in npm-package
+ * installs, where the host bundle assigns `theme` but this copy never sees it
+ * (issue #5366). Both the default color and `render()` degrade to plain,
+ * unstyled output instead of crashing the TUI.
  */
 export declare class DynamicBorder implements Component {
     #private;

package/dist/types/modes/components/login-dialog.d.ts

@@ -36,5 +36,7 @@ export declare class LoginDialogComponent extends Container {
      * Called by onProgress callback
      */
     showProgress(message: string): void;
+    /** Route non-bracketed paste transports into the active login input. */
+    pasteText(text: string): void;
     handleInput(data: string): void;
 }

package/dist/types/modes/components/mcp-add-wizard.d.ts

@@ -21,6 +21,7 @@ export interface MCPAddWizardOAuthResult {
 interface MCPAddWizardOAuthOptions {
     serverUrl?: string;
     resource?: string;
+    registrationUrl?: string;
     /**
      * External cancellation source. Aborting it tears down the in-flight OAuth
      * flow and surfaces a neutral cancellation error. The wizard wires its own

package/dist/types/modes/components/read-tool-group.d.ts

@@ -6,8 +6,6 @@ export declare function readArgsTargetInternalUrl(args: unknown): boolean;
 type ReadRenderArgs = {
     path?: string;
     file_path?: string;
-    selector?: string;
-    sel?: string;
 };
 type ReadToolGroupOptions = {
     showContentPreview?: boolean;

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -57,5 +57,6 @@ export declare class SelectorController {
     showDebugSelector(): Promise<void>;
     showAgentHub(observers: SessionObserverRegistry, options?: {
         requireContent?: boolean;
+        armCloseTap?: boolean;
     }): void;
 }

package/dist/types/modes/interactive-mode.d.ts

@@ -330,6 +330,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     showDebugSelector(): Promise<void>;
     showAgentHub(options?: {
         requireContent?: boolean;
+        armCloseTap?: boolean;
     }): void;
     resetObserverRegistry(): void;
     handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;

package/dist/types/modes/types.d.ts

@@ -345,6 +345,7 @@ export interface InteractiveModeContext {
     showDebugSelector(): Promise<void>;
     showAgentHub(options?: {
         requireContent?: boolean;
+        armCloseTap?: boolean;
     }): void;
     resetObserverRegistry(): void;
     handleCtrlC(): void;

package/dist/types/session/messages.d.ts

@@ -134,6 +134,21 @@ export declare function wrapSteeringForModel(messages: AgentMessage[]): AgentMes
  * pure local mutation and intentionally does neither.
  */
 export declare function stripImagesFromMessage(message: AgentMessage): number;
+/**
+ * Replace every `ImageContent` block in already-converted LLM {@link Message}s
+ * with a text placeholder, returning a new array only when something changed.
+ *
+ * Unlike {@link stripImagesFromMessage} (which mutates persisted `AgentMessage`s
+ * in place), this operates on the ephemeral provider-request view produced by
+ * {@link convertToLlm}, so history on disk keeps its images while the outbound
+ * request is scrubbed. Used to keep image blocks off the wire when the active
+ * model has no vision support (or `images.blockImages` is set) — e.g. after
+ * switching from a vision model to a text-only one mid-session (#5400).
+ *
+ * Consecutive placeholder texts collapse into one so a message that was nothing
+ * but images does not balloon into a run of identical notes.
+ */
+export declare function replaceLlmImagesWithText(messages: Message[], placeholder: string): Message[];
 /**
  * Message type for bash executions via the ! command.
  */

package/dist/types/tools/grep.d.ts

@@ -8,7 +8,6 @@ import type { OutputMeta } from "./output-meta.js";
 declare const searchSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     pattern: string;
     path?: string | undefined;
-    selector?: string | undefined;
     case?: boolean | undefined;
     gitignore?: boolean | undefined;
     skip?: number | null | undefined;
@@ -67,7 +66,6 @@ export declare class GrepTool implements AgentTool<typeof searchSchema, GrepTool
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
         pattern: string;
         path?: string | undefined;
-        selector?: string | undefined;
         case?: boolean | undefined;
         gitignore?: boolean | undefined;
         skip?: number | null | undefined;

package/dist/types/tools/read.d.ts

@@ -7,7 +7,6 @@ import { type TruncationResult } from "../session/streaming-output.js";
 import { type OutputMeta } from "./output-meta.js";
 declare const readSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     path: string;
-    selector?: string | undefined;
 }, {}>;
 export type ReadToolInput = typeof readSchema.infer;
 export interface ReadToolDetails {
@@ -60,7 +59,6 @@ export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDe
     readonly description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
         path: string;
-        selector?: string | undefined;
     }, {}>;
     readonly strict = true;
     constructor(session: ToolSession);
@@ -69,8 +67,6 @@ export declare class ReadTool implements AgentTool<typeof readSchema, ReadToolDe
 interface ReadRenderArgs {
     path?: unknown;
     file_path?: unknown;
-    selector?: unknown;
-    sel?: string;
     offset?: number;
     limit?: number;
     raw?: boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.5.1",
+	"version": "16.5.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -52,17 +52,17 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.5.1",
-		"@oh-my-pi/omp-stats": "16.5.1",
-		"@oh-my-pi/pi-agent-core": "16.5.1",
-		"@oh-my-pi/pi-ai": "16.5.1",
-		"@oh-my-pi/pi-catalog": "16.5.1",
-		"@oh-my-pi/pi-mnemopi": "16.5.1",
-		"@oh-my-pi/pi-natives": "16.5.1",
-		"@oh-my-pi/pi-tui": "16.5.1",
-		"@oh-my-pi/pi-utils": "16.5.1",
-		"@oh-my-pi/pi-wire": "16.5.1",
-		"@oh-my-pi/snapcompact": "16.5.1",
+		"@oh-my-pi/hashline": "16.5.2",
+		"@oh-my-pi/omp-stats": "16.5.2",
+		"@oh-my-pi/pi-agent-core": "16.5.2",
+		"@oh-my-pi/pi-ai": "16.5.2",
+		"@oh-my-pi/pi-catalog": "16.5.2",
+		"@oh-my-pi/pi-mnemopi": "16.5.2",
+		"@oh-my-pi/pi-natives": "16.5.2",
+		"@oh-my-pi/pi-tui": "16.5.2",
+		"@oh-my-pi/pi-utils": "16.5.2",
+		"@oh-my-pi/pi-wire": "16.5.2",
+		"@oh-my-pi/snapcompact": "16.5.2",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.220.0",

package/src/advisor/__tests__/advisor.test.ts

@@ -1856,23 +1856,141 @@ describe("advisor", () => {
 			expect(failures).toHaveLength(2);
 		});
 
-		it("treats an empty stop turn without advise as a failed advisor turn", async () => {
-			const promptInputs: string[] = [];
+		it("accepts a zero-usage empty stop as a successful silent review", async () => {
 			const turnErrors: unknown[] = [];
 			const failures: unknown[] = [];
 			const adviceNotes: string[] = [];
 			const rollbackCalls: number[] = [];
-			const lengthsBeforePrompt: number[] = [];
-			const events: string[] = [];
 			const state: { messages: AgentMessage[]; error?: string } = { messages: [] };
 			let promptCalls = 0;
 			const agent: AdvisorAgent = {
 				prompt: async input => {
 					promptCalls++;
-					promptInputs.push(input);
-					lengthsBeforePrompt.push(state.messages.length);
-					events.push(`prompt:${promptCalls}`);
 					state.messages.push({ role: "user", content: input, timestamp: promptCalls * 2 - 1 } as AgentMessage);
+					state.messages.push({
+						role: "assistant",
+						content: [],
+						api: "mock",
+						provider: "mock",
+						model: "mock-advisor",
+						usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 },
+						stopReason: "stop",
+						timestamp: promptCalls * 2,
+					} as unknown as AgentMessage);
+					state.error = undefined;
+				},
+				abort: () => {},
+				reset: () => {
+					state.messages.length = 0;
+					state.error = undefined;
+				},
+				rollbackTo: count => {
+					rollbackCalls.push(count);
+					state.messages.length = count;
+					state.error = undefined;
+				},
+				state,
+			};
+			const messages: AgentMessage[] = [{ role: "user", content: "aaa", timestamp: 1 } as AgentMessage];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: note => adviceNotes.push(note),
+				onTurnError: error => {
+					turnErrors.push(error);
+				},
+				notifyFailure: error => {
+					failures.push(error);
+				},
+			};
+			const runtime = new AdvisorRuntime(agent, host, 0);
+
+			// A model that says nothing and yields completed its review; no retry,
+			// no rollback, no "Advisor unavailable" notification.
+			runtime.onTurnEnd(messages);
+			await runtime.waitForCatchup(1000, 1);
+
+			expect(promptCalls).toBe(1);
+			expect(turnErrors).toEqual([]);
+			expect(failures).toEqual([]);
+			expect(rollbackCalls).toEqual([]);
+			expect(adviceNotes).toEqual([]);
+			expect(state.messages).toHaveLength(2);
+			expect(runtime.backlog).toBe(0);
+		});
+
+		it("never warns for consecutive zero-usage silent stops — a quiet session is a valid session", async () => {
+			const turnErrors: unknown[] = [];
+			const failures: unknown[] = [];
+			const state: { messages: AgentMessage[]; error?: string } = { messages: [] };
+			let promptCalls = 0;
+			const agent: AdvisorAgent = {
+				prompt: async input => {
+					promptCalls++;
+					state.messages.push({ role: "user", content: input, timestamp: promptCalls * 2 - 1 } as AgentMessage);
+					state.messages.push({
+						role: "assistant",
+						content: [],
+						api: "mock",
+						provider: "mock",
+						model: "mock-advisor",
+						usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 },
+						stopReason: "stop",
+						timestamp: promptCalls * 2,
+					} as unknown as AgentMessage);
+					state.error = undefined;
+				},
+				abort: () => {},
+				reset: () => {
+					state.messages.length = 0;
+					state.error = undefined;
+				},
+				rollbackTo: count => {
+					state.messages.length = count;
+					state.error = undefined;
+				},
+				state,
+			};
+			const messages: AgentMessage[] = [{ role: "user", content: "turn-0", timestamp: 1 } as AgentMessage];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				onTurnError: error => {
+					turnErrors.push(error);
+				},
+				notifyFailure: error => {
+					failures.push(error);
+				},
+			};
+			const runtime = new AdvisorRuntime(agent, host, 0);
+
+			// Five consecutive turns where the advisor has nothing to add: every one
+			// completes as a single successful prompt — no retries, no rollbacks, no
+			// "Advisor unavailable" notification, ever.
+			for (let i = 0; i < 5; i++) {
+				if (i > 0) messages.push({ role: "user", content: `turn-${i}`, timestamp: i + 1 } as AgentMessage);
+				runtime.onTurnEnd(messages);
+				await runtime.waitForCatchup(1000, 1);
+			}
+
+			expect(promptCalls).toBe(5);
+			expect(turnErrors).toEqual([]);
+			expect(failures).toEqual([]);
+			expect(runtime.backlog).toBe(0);
+		});
+
+		it("treats a content-less stop that generated output tokens as a successful silent review", async () => {
+			const turnErrors: unknown[] = [];
+			const failures: unknown[] = [];
+			const adviceNotes: string[] = [];
+			const state: { messages: AgentMessage[]; error?: string } = { messages: [] };
+			let promptCalls = 0;
+			const agent: AdvisorAgent = {
+				prompt: async input => {
+					promptCalls++;
+					state.messages.push({ role: "user", content: input, timestamp: promptCalls * 2 - 1 } as AgentMessage);
+					// A real model turn that CHOSE silence: it reasoned, spent
+					// output/reasoning tokens, and emitted no `advise` call. This is
+					// the documented verifier behavior, not a provider malfunction.
 					state.messages.push({
 						role: "assistant",
 						content: [],
@@ -1880,11 +1998,12 @@ describe("advisor", () => {
 						provider: "mock",
 						model: "mock-advisor",
 						usage: {
-							input: 0,
-							output: 0,
+							input: 1200,
+							output: 340,
 							cacheRead: 0,
 							cacheWrite: 0,
-							totalTokens: 0,
+							totalTokens: 1540,
+							reasoningTokens: 300,
 						},
 						stopReason: "stop",
 						timestamp: promptCalls * 2,
@@ -1897,23 +2016,22 @@ describe("advisor", () => {
 					state.error = undefined;
 				},
 				rollbackTo: count => {
-					rollbackCalls.push(count);
 					state.messages.length = count;
 					state.error = undefined;
 				},
 				state,
 			};
-			const messages: AgentMessage[] = [{ role: "user", content: "aaa", timestamp: 1 } as AgentMessage];
+			const messages: AgentMessage[] = [
+				{ role: "user", content: "Reply exactly: OK", timestamp: 1 } as AgentMessage,
+			];
 			const host: AdvisorRuntimeHost = {
 				snapshotMessages: () => messages,
 				enqueueAdvice: note => adviceNotes.push(note),
 				onTurnError: error => {
 					turnErrors.push(error);
-					events.push(`hook:${error instanceof Error ? error.message : String(error)}`);
 				},
 				notifyFailure: error => {
 					failures.push(error);
-					events.push(`notify:${error instanceof Error ? error.message : String(error)}`);
 				},
 			};
 			const runtime = new AdvisorRuntime(agent, host, 0);
@@ -1921,42 +2039,11 @@ describe("advisor", () => {
 			runtime.onTurnEnd(messages);
 			await runtime.waitForCatchup(1000, 1);
 
-			expect(promptInputs).toHaveLength(3);
-			expect(promptInputs[0]).toContain("aaa");
-			expect(promptInputs[1]).toBe(promptInputs[0]);
-			expect(promptInputs[2]).toBe(promptInputs[0]);
-			expect(lengthsBeforePrompt).toEqual([0, 0, 0]);
-			expect(rollbackCalls).toEqual([0, 0, 0]);
-			expect(turnErrors).toHaveLength(3);
-			const turnErrorMessages = turnErrors.map(error =>
-				(error instanceof Error ? error.message : String(error)).toLowerCase(),
-			);
-			for (const message of turnErrorMessages) {
-				expect(message).toContain("advisor");
-				expect(message).toContain("empty");
-				expect(message).toContain("response");
-			}
-			expect(failures).toHaveLength(1);
-			const failure = failures[0];
-			if (!(failure instanceof Error)) throw new Error("expected advisor failure error");
-			expect(failure.message.toLowerCase()).toContain("advisor");
-			expect(failure.message.toLowerCase()).toContain("empty");
-			expect(failure.message.toLowerCase()).toContain("response");
-			expect(events).toHaveLength(7);
-			expect(events[0]).toBe("prompt:1");
-			expect(events[1].startsWith("hook:")).toBe(true);
-			expect(events[1].toLowerCase()).toContain("empty");
-			expect(events[2]).toBe("prompt:2");
-			expect(events[3].startsWith("hook:")).toBe(true);
-			expect(events[3].toLowerCase()).toContain("empty");
-			expect(events[4]).toBe("prompt:3");
-			expect(events[5].startsWith("hook:")).toBe(true);
-			expect(events[5].toLowerCase()).toContain("empty");
-			expect(events[6].toLowerCase()).toContain("empty");
-			expect(events[6].startsWith("notify:")).toBe(true);
+			// No retries, no failure hook, no unavailable notification.
+			expect(promptCalls).toBe(1);
+			expect(turnErrors).toEqual([]);
+			expect(failures).toEqual([]);
 			expect(adviceNotes).toEqual([]);
-			expect(state.messages).toHaveLength(0);
-			expect(state.error).toBeUndefined();
 			expect(runtime.backlog).toBe(0);
 		});