@oh-my-pi/pi-coding-agent 17.0.4 → 17.0.5

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

@@ -7,9 +7,10 @@ import type { OutputMeta } from "./output-meta.js";
 /** Runs `gh --json` for issue data, retrying without optional stateReason on older gh releases. */
 export declare function githubIssueJsonWithStateReasonFallback<T>(cwd: string, args: readonly string[], signal: AbortSignal | undefined, options?: git.GhCommandOptions): Promise<T>;
 declare const githubSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-    op: "pr_checkout" | "pr_create" | "pr_push" | "repo_view" | "run_watch" | "search_code" | "search_commits" | "search_issues" | "search_prs" | "search_repos";
+    op: "file_read" | "pr_checkout" | "pr_create" | "pr_push" | "repo_view" | "run_watch" | "search_code" | "search_commits" | "search_issues" | "search_prs" | "search_repos";
     repo?: string | undefined;
     branch?: string | undefined;
+    path?: string | undefined;
     pr?: string | string[] | undefined;
     force?: boolean | undefined;
     forceWithLease?: boolean | undefined;
@@ -219,14 +220,15 @@ export declare class GithubTool implements AgentTool<typeof githubSchema, GhTool
     private readonly session;
     readonly name = "github";
     readonly approval: (args: unknown) => ToolApprovalDecision;
-    readonly summary = "Interact with GitHub issues, pull requests, and repositories";
+    readonly summary = "Interact with GitHub repositories, files, pull requests, and Actions";
     readonly loadMode = "discoverable";
     readonly label = "GitHub";
     readonly description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
-        op: "pr_checkout" | "pr_create" | "pr_push" | "repo_view" | "run_watch" | "search_code" | "search_commits" | "search_issues" | "search_prs" | "search_repos";
+        op: "file_read" | "pr_checkout" | "pr_create" | "pr_push" | "repo_view" | "run_watch" | "search_code" | "search_commits" | "search_issues" | "search_prs" | "search_repos";
         repo?: string | undefined;
         branch?: string | undefined;
+        path?: string | undefined;
         pr?: string | string[] | undefined;
         force?: boolean | undefined;
         forceWithLease?: boolean | undefined;

package/dist/types/tools/hub/index.d.ts

@@ -117,7 +117,7 @@ export declare class HubTool implements AgentTool<typeof hubSchema, HubDetails>
         timeout?: number | undefined;
     }, {}>;
     readonly strict = true;
-    readonly interruptible = true;
+    readonly interruptible: (params: Partial<HubParams>) => boolean;
     readonly loadMode = "essential";
     readonly examples: readonly ToolExample<typeof hubSchema.infer>[];
     constructor(session: ToolSession);

package/dist/types/tools/hub/jobs.d.ts

@@ -44,6 +44,7 @@ interface TrackedJobLike {
     status: string;
     label: string;
     startTime: number;
+    latestDetails?: Record<string, unknown>;
     resultText?: string;
     errorText?: string;
 }

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

@@ -30,6 +30,8 @@ export interface JobSnapshot {
     status: "running" | "completed" | "failed" | "cancelled";
     label: string;
     durationMs: number;
+    /** Effective task model selector, including an explicit reasoning suffix when configured. */
+    resolvedModel?: string;
     resultText?: string;
     errorText?: string;
 }

package/dist/types/tools/tool-timeouts.d.ts

@@ -35,7 +35,7 @@ export declare const TOOL_TIMEOUTS: {
     readonly lsp: {
         readonly default: 20;
         readonly min: 5;
-        readonly max: 60;
+        readonly max: 300;
     };
     readonly debug: {
         readonly default: 30;

package/dist/types/utils/git.d.ts

@@ -219,6 +219,39 @@ export declare function fetch(cwd: string, remote: string, source: string, targe
 export declare function readTree(cwd: string, treeish: string, options?: Pick<CommandOptions, "env" | "signal">): Promise<void>;
 /** Write the current index as a tree and return its object id. */
 export declare function writeTree(cwd: string, options?: Pick<CommandOptions, "env" | "signal">): Promise<string>;
+/** Outcome of {@link detachGitDir}. */
+export type DetachGitDirResult = 
+/** `worktreeRoot` had no `.git`; nothing to detach. */
+"no-git"
+/** `.git` already resolves to an independent object DB — left untouched. */
+ | "independent"
+/** Detached into a standalone repo borrowing `sourceCommonDir`'s objects. */
+ | "detached";
+/**
+ * Sever a copied/mounted working tree from the git metadata it shares with a
+ * source checkout, turning it into a standalone repository that borrows the
+ * source object database through `objects/info/alternates`.
+ *
+ * Isolation backends (reflink/apfs/btrfs/rcopy…) materialise `merged` by
+ * copying `worktreeRoot` byte-for-byte. When `worktreeRoot` is a **linked git
+ * worktree** its `.git` is a pointer file (`gitdir: …/worktrees/<name>`), so
+ * the copy still resolves HEAD/index/refs through the source repo — a task's
+ * `git checkout`/`commit` inside the isolation then mutates the *parent*
+ * checkout. The rcopy `git worktree add` path leaks the other way: task
+ * branches land in the shared ref namespace and stack on each other.
+ *
+ * After detaching, the working tree keeps its files verbatim while:
+ * - HEAD, refs, and the index are frozen to the snapshot at call time;
+ * - all commits/branches the task creates stay private to the isolation;
+ * - objects resolve against `sourceCommonDir` via alternates, so history reads
+ *   and later `git fetch <merged>` object transfer keep working;
+ * - the source checkout's HEAD, branch, index, and working tree are untouched.
+ *
+ * A full-copy `.git` (non-worktree source) already owns its object DB and is
+ * returned as `"independent"` without modification. `worktreeRoot` without a
+ * `.git` yields `"no-git"`.
+ */
+export declare function detachGitDir(worktreeRoot: string, sourceCommonDir: string): Promise<DetachGitDirResult>;
 /** Run `git show` on a revision. */
 export declare const show: ((cwd: string, revision: string, options?: {
     format?: string;

package/dist/types/web/search/providers/codex.d.ts

@@ -25,7 +25,7 @@ export interface CodexSearchParams {
  */
 export declare function searchCodex(params: SearchParams): Promise<SearchResponse>;
 /**
- * Checks if Codex web search is available.
+ * Checks whether Codex web search has an API key or OAuth credential.
  */
 export declare function hasCodexSearch(authStorage: AuthStorage): Promise<boolean>;
 /** Search provider for OpenAI Codex web search. */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.0.4",
+	"version": "17.0.5",
 	"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": "17.0.4",
-		"@oh-my-pi/omp-stats": "17.0.4",
-		"@oh-my-pi/pi-agent-core": "17.0.4",
-		"@oh-my-pi/pi-ai": "17.0.4",
-		"@oh-my-pi/pi-catalog": "17.0.4",
-		"@oh-my-pi/pi-mnemopi": "17.0.4",
-		"@oh-my-pi/pi-natives": "17.0.4",
-		"@oh-my-pi/pi-tui": "17.0.4",
-		"@oh-my-pi/pi-utils": "17.0.4",
-		"@oh-my-pi/pi-wire": "17.0.4",
-		"@oh-my-pi/snapcompact": "17.0.4",
+		"@oh-my-pi/hashline": "17.0.5",
+		"@oh-my-pi/omp-stats": "17.0.5",
+		"@oh-my-pi/pi-agent-core": "17.0.5",
+		"@oh-my-pi/pi-ai": "17.0.5",
+		"@oh-my-pi/pi-catalog": "17.0.5",
+		"@oh-my-pi/pi-mnemopi": "17.0.5",
+		"@oh-my-pi/pi-natives": "17.0.5",
+		"@oh-my-pi/pi-tui": "17.0.5",
+		"@oh-my-pi/pi-utils": "17.0.5",
+		"@oh-my-pi/pi-wire": "17.0.5",
+		"@oh-my-pi/snapcompact": "17.0.5",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

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

@@ -2,6 +2,7 @@ import { describe, expect, it, vi } from "bun:test";
 import type { AgentMessage, AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import * as AIError from "@oh-my-pi/pi-ai/error";
+import { kCursorExecResolved } from "@oh-my-pi/pi-ai/utils/block-symbols";
 import type { TUI } from "@oh-my-pi/pi-tui";
 import { type } from "arktype";
 import type { ModelRegistry } from "../../config/model-registry";
@@ -519,6 +520,58 @@ describe("advisor", () => {
 			expect(message.content).toBe(originalContent);
 		});
 
+		it("keeps advise when Cursor emits exec-resolved native tools outside the grant (issue #5900)", () => {
+			const message = {
+				role: "assistant",
+				content: [
+					{ type: "text", text: "Investigating the networking design." },
+					{
+						type: "toolCall",
+						id: "tc-grep",
+						name: "grep",
+						arguments: { pattern: "backoff" },
+						[kCursorExecResolved]: true,
+					},
+					{
+						type: "toolCall",
+						id: "tc-bash",
+						name: "bash",
+						arguments: { command: "ls" },
+						[kCursorExecResolved]: true,
+					},
+					{
+						type: "toolCall",
+						id: "tc-advise",
+						name: "advise",
+						arguments: { note: "The retry backoff looks unbounded." },
+					},
+				],
+				stopReason: "toolUse",
+			} as unknown as AssistantMessage;
+			const originalContent = message.content;
+
+			// Grant is `advise` only (WATCHDOG.yml `tools: []`). The native grep/bash
+			// frames already ran server-side through the advisor-scoped bridge, which
+			// rejected them in-band; they must not discard the legitimate advise.
+			expect(quarantineAdvisorUnsafeOutput(message, new Set(["advise"]))).toBeUndefined();
+			expect(message.stopReason).toBe("toolUse");
+			expect(message.content).toBe(originalContent);
+			expect(JSON.stringify(message)).toContain("unbounded");
+		});
+
+		it("still quarantines an ungranted native tool that was not exec-resolved", () => {
+			const message = {
+				role: "assistant",
+				content: [{ type: "toolCall", id: "tc-bash", name: "bash", arguments: { command: "ls" } }],
+				stopReason: "toolUse",
+			} as unknown as AssistantMessage;
+
+			expect(quarantineAdvisorUnsafeOutput(message, new Set(["advise"]))).toBe(
+				"Advisor response quarantined: requested unavailable tool bash",
+			);
+			expect(message.stopReason).toBe("error");
+		});
+
 		it("sanitizes destructive advise notes even when advise is an allowed tool", () => {
 			const message = {
 				role: "assistant",
@@ -865,6 +918,65 @@ describe("advisor", () => {
 			expect(promptInputs[1]).toContain("second");
 		});
 
+		it("waits for an in-flight review within the catch-up deadline", async () => {
+			const promptStarted = Promise.withResolvers<void>();
+			const releasePrompt = Promise.withResolvers<void>();
+			const messages: AgentMessage[] = [{ role: "user", content: "first", timestamp: 1 } as AgentMessage];
+			const agent: AdvisorAgent = {
+				prompt: async () => {
+					promptStarted.resolve();
+					await releasePrompt.promise;
+				},
+				abort: () => {},
+				reset: () => {},
+				state: { messages: [] },
+			};
+			const runtime = new AdvisorRuntime(agent, {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+			});
+
+			runtime.onTurnEnd();
+			await promptStarted.promise;
+			let settled = false;
+			const catchup = runtime.waitForCatchup(1000, 1).then(caughtUp => {
+				settled = true;
+				return caughtUp;
+			});
+			await Promise.resolve();
+			expect(settled).toBe(false);
+
+			releasePrompt.resolve();
+			expect(await catchup).toBe(true);
+		});
+
+		it("reports an in-flight review that exceeds the catch-up deadline", async () => {
+			const promptStarted = Promise.withResolvers<void>();
+			const releasePrompt = Promise.withResolvers<void>();
+			const messages: AgentMessage[] = [{ role: "user", content: "first", timestamp: 1 } as AgentMessage];
+			const agent: AdvisorAgent = {
+				prompt: async () => {
+					promptStarted.resolve();
+					await releasePrompt.promise;
+				},
+				abort: () => {},
+				reset: () => {},
+				state: { messages: [] },
+			};
+			const runtime = new AdvisorRuntime(agent, {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+			});
+
+			runtime.onTurnEnd();
+			await promptStarted.promise;
+			expect(await runtime.waitForCatchup(20, 1)).toBe(false);
+			expect(runtime.backlog).toBe(1);
+
+			releasePrompt.resolve();
+			await settleUntil(() => runtime.backlog === 0);
+		});
+
 		it("preserves the next user turn when an accepted empty stop is pruned", async () => {
 			const promptInputs: string[] = [];
 			const agent = makeAgent(promptInputs);
@@ -3779,6 +3891,44 @@ describe("advisor", () => {
 	// or it strands and #drainStrandedQueuedMessages auto-resumes it. Do not swap
 	// the call site back to session `isStreaming`.
 	describe("resolveAdvisorDeliveryChannel", () => {
+		it("preserves every severity when a headless drain forbids primary turns", () => {
+			for (const severity of [undefined, "nit", "concern", "blocker"] as const) {
+				expect(
+					resolveAdvisorDeliveryChannel({
+						severity,
+						autoResumeSuppressed: false,
+						streaming: false,
+						aborting: false,
+						terminalAnswerNoQueuedWork: true,
+						preserveOnly: true,
+					}),
+				).toBe("preserve");
+			}
+		});
+
+		it("keeps live headless advice on normal delivery channels until the primary finishes", () => {
+			expect(
+				resolveAdvisorDeliveryChannel({
+					severity: "nit",
+					autoResumeSuppressed: false,
+					streaming: true,
+					aborting: false,
+					preserveOnly: true,
+				}),
+			).toBe("aside");
+			for (const severity of ["concern", "blocker"] as const) {
+				expect(
+					resolveAdvisorDeliveryChannel({
+						severity,
+						autoResumeSuppressed: false,
+						streaming: true,
+						aborting: false,
+						preserveOnly: true,
+					}),
+				).toBe("steer");
+			}
+		});
+
 		it("routes a non-interrupting nit to the aside queue regardless of state", () => {
 			expect(
 				resolveAdvisorDeliveryChannel({

package/src/advisor/advise-tool.ts

@@ -101,6 +101,8 @@ export function isAdvisorInterruptImmuneTurnActive(opts: {
 /**
  * Decide how one advisor note reaches the primary agent.
  *
+ * - A `preserveOnly` caller records every note that arrives while the primary
+ *   is idle as a visible card and never starts a new primary turn.
  * - A non-interrupting `nit` always rides the non-interrupting aside queue.
  * - An interrupting `concern`/`blocker` is normally steered into the agent: into
  *   the live turn while one is streaming, or (when idle) a triggered turn so the
@@ -129,7 +131,9 @@ export function resolveAdvisorDeliveryChannel(opts: {
 	aborting: boolean;
 	terminalAnswerNoQueuedWork?: boolean;
 	interruptImmuneTurnActive?: boolean;
+	preserveOnly?: boolean;
 }): AdvisorDeliveryChannel {
+	if (opts.preserveOnly && !opts.streaming) return "preserve";
 	if (!isInterruptingSeverity(opts.severity)) return "aside";
 	if (opts.autoResumeSuppressed && (opts.aborting || !opts.streaming)) return "preserve";
 	if (opts.terminalAnswerNoQueuedWork && opts.severity !== "blocker" && !opts.streaming && !opts.aborting)

package/src/advisor/runtime.ts

@@ -2,6 +2,7 @@ import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
 import type { AssistantMessage, ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import * as AIError from "@oh-my-pi/pi-ai/error";
+import { type CursorExecResolvedCarrier, kCursorExecResolved } from "@oh-my-pi/pi-ai/utils/block-symbols";
 import { logger } from "@oh-my-pi/pi-utils";
 import { obfuscateToolArguments, type SecretObfuscator } from "../secrets/obfuscator";
 import { formatSessionHistoryMarkdown, PRIMARY_CONTEXT_CUSTOM_TYPES } from "../session/session-history-format";
@@ -129,7 +130,20 @@ export function quarantineAdvisorUnsafeOutput(
 	const unavailableToolNames = new Set<string>();
 	const generatedParts: string[] = [];
 	for (const block of message.content) {
-		if (block.type === "toolCall" && !availableToolNames.has(block.name)) unavailableToolNames.add(block.name);
+		// Cursor exec-channel native blocks (bash/read/grep/...) are stamped
+		// kCursorExecResolved: they already ran server-side through the
+		// advisor-scoped CursorExecHandlers bridge, which rejects ungranted
+		// tools in-band ("Tool not available") and lets the model self-correct.
+		// Quarantining them would discard the legitimate advise emitted in the
+		// same turn (issue #5900). The scoped bridge is the grant gate here, not
+		// this pre-dispatch check.
+		if (
+			block.type === "toolCall" &&
+			!availableToolNames.has(block.name) &&
+			(block as CursorExecResolvedCarrier)[kCursorExecResolved] !== true
+		) {
+			unavailableToolNames.add(block.name);
+		}
 		if (block.type === "toolCall" && block.name === "advise" && typeof block.arguments.note === "string") {
 			generatedParts.push(block.arguments.note);
 		}
@@ -219,8 +233,7 @@ interface PendingDelta {
 
 interface CatchupWaiter {
 	threshold: number;
-	resolve: () => void;
-	finish: () => void;
+	finish: (caughtUp: boolean) => void;
 	timer?: NodeJS.Timeout;
 }
 
@@ -366,7 +379,13 @@ export class AdvisorRuntime {
 		}
 	}
 
-	waitForCatchup(maxMs: number, threshold: number, signal?: AbortSignal): Promise<void> {
+	/**
+	 * Wait until the advisor backlog falls below `threshold`.
+	 *
+	 * Returns `false` when the deadline, abort signal, or a runtime failure releases
+	 * the waiter before the requested backlog was drained.
+	 */
+	waitForCatchup(maxMs: number, threshold: number, signal?: AbortSignal): Promise<boolean> {
 		if (
 			this.disposed ||
 			signal?.aborted ||
@@ -378,21 +397,26 @@ export class AdvisorRuntime {
 			// primary would otherwise park for the full catch-up budget.
 			this.#failing
 		)
-			return Promise.resolve();
-		const { promise, resolve } = Promise.withResolvers<void>();
+			return Promise.resolve(this.#backlog < threshold);
+		const { promise, resolve } = Promise.withResolvers<boolean>();
 		let waiter!: CatchupWaiter;
-		const finish = (): void => {
+		const finish = (caughtUp: boolean): void => {
 			const idx = this.#waiters.indexOf(waiter);
 			if (idx >= 0) this.#waiters.splice(idx, 1);
 			clearTimeout(waiter.timer);
-			signal?.removeEventListener("abort", finish);
-			resolve();
+			signal?.removeEventListener("abort", abort);
+			resolve(caughtUp);
+		};
+		const abort = (): void => finish(false);
+		waiter = {
+			threshold,
+			finish,
+			timer: setTimeout(abort, maxMs),
 		};
-		waiter = { threshold, resolve, finish, timer: setTimeout(finish, maxMs) };
 		this.#waiters.push(waiter);
-		signal?.addEventListener("abort", finish, { once: true });
+		signal?.addEventListener("abort", abort, { once: true });
 		if (signal?.aborted) {
-			finish();
+			abort();
 		}
 		return promise;
 	}
@@ -571,14 +595,14 @@ export class AdvisorRuntime {
 		for (let i = this.#waiters.length - 1; i >= 0; i--) {
 			const w = this.#waiters[i];
 			if (this.#backlog < w.threshold) {
-				w.finish();
+				w.finish(true);
 			}
 		}
 	}
 
 	#wakeAllWaiters(): void {
 		for (const w of [...this.#waiters]) {
-			w.finish();
+			w.finish(false);
 		}
 	}
 

package/src/async/job-manager.ts

@@ -37,6 +37,8 @@ export interface AsyncJob {
 	promise: Promise<void>;
 	resultText?: string;
 	errorText?: string;
+	/** Latest tool-render details reported by the running job. */
+	latestDetails?: Record<string, unknown>;
 	/**
 	 * Registry id of the agent that registered the job (e.g. "Main",
 	 * "AuthLoader"). Used by scoped cancel/list APIs so a subagent's teardown
@@ -205,6 +207,7 @@ export class AsyncJobManager {
 		};
 
 		const reportProgress = async (text: string, details?: Record<string, unknown>): Promise<void> => {
+			if (details) job.latestDetails = details;
 			if (!options?.onProgress) return;
 			try {
 				await options.onProgress(text, details);

package/src/cli/bench-cli.ts

@@ -443,7 +443,7 @@ function resolveBenchModels(
 	const resolved: BenchTarget[] = [];
 	const errors: string[] = [];
 	for (const selector of selectors) {
-		const result = resolveCliModel({ cliModel: selector, modelRegistry, preferences });
+		const result = resolveCliModel({ cliModel: selector, modelRegistry, settings, preferences });
 		if (result.error) {
 			errors.push(`${selector}: ${result.error}`);
 			continue;
@@ -454,7 +454,13 @@ function resolveBenchModels(
 		}
 		if (result.warning) writeStderr(`${chalk.yellow(`Warning: ${result.warning}`)}\n`);
 		let model = result.model;
-		const authenticated = resolveAuthenticatedAlternative(selector, model, modelRegistry, preferences.providerOrder);
+		const authSelector = result.configuredPatterns?.[result.configuredPatternIndex ?? 0] ?? selector;
+		const authenticated = resolveAuthenticatedAlternative(
+			authSelector,
+			model,
+			modelRegistry,
+			preferences.providerOrder,
+		);
 		if (authenticated) {
 			writeStderr(
 				`${chalk.yellow(

package/src/cli/dry-balance-cli.ts

@@ -555,6 +555,7 @@ async function resolveDryBalanceModel(
 		const resolved = resolveCliModel({
 			cliModel: modelSelector,
 			modelRegistry,
+			settings,
 			preferences,
 		});
 		if (resolved.error) throw new Error(resolved.error);