@oh-my-pi/pi-coding-agent 16.0.4 → 16.0.6

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

@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from "bun:test";
-import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AgentMessage, AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core";
+import { type } from "arktype";
 import { createAdvisorMessageCard } from "../../modes/components/advisor-message";
 import { getThemeByName } from "../../modes/theme/theme";
 import { formatSessionHistoryMarkdown } from "../../session/session-history-format";
@@ -11,7 +12,9 @@ import {
 	type AdvisorNote,
 	AdvisorRuntime,
 	type AdvisorRuntimeHost,
+	deriveAdvisorTelemetry,
 	formatAdvisorBatchContent,
+	isAdvisorInterruptImmuneTurnActive,
 	isInterruptingSeverity,
 	resolveAdvisorDeliveryChannel,
 } from "..";
@@ -114,6 +117,16 @@ describe("advisor", () => {
 			expect(result.details).toEqual({ note: "x", severity: "concern" });
 			expect(result.useless).toBe(true);
 		});
+
+		it("validates parameters using ArkType", () => {
+			const onAdvice = vi.fn();
+			const tool = new AdviseTool(onAdvice);
+			const valid = tool.parameters({ note: "x", severity: "concern" });
+			expect(valid instanceof type.errors).toBe(false);
+
+			const invalid = tool.parameters({ note: 123, severity: "invalid" as any });
+			expect(invalid instanceof type.errors).toBe(true);
+		});
 	});
 
 	describe("advice delivery policy", () => {
@@ -124,6 +137,44 @@ describe("advisor", () => {
 			expect(isInterruptingSeverity(undefined)).toBe(false);
 		});
 
+		it("keeps the interrupt-immune turn fence half-open for the configured window", () => {
+			expect(
+				isAdvisorInterruptImmuneTurnActive({
+					completedTurns: 4,
+					immuneTurnStart: undefined,
+					immuneTurns: 2,
+				}),
+			).toBe(false);
+			expect(
+				isAdvisorInterruptImmuneTurnActive({
+					completedTurns: 4,
+					immuneTurnStart: 5,
+					immuneTurns: 0,
+				}),
+			).toBe(false);
+			expect(
+				isAdvisorInterruptImmuneTurnActive({
+					completedTurns: 4,
+					immuneTurnStart: 5,
+					immuneTurns: 2,
+				}),
+			).toBe(true);
+			expect(
+				isAdvisorInterruptImmuneTurnActive({
+					completedTurns: 6,
+					immuneTurnStart: 5,
+					immuneTurns: 2,
+				}),
+			).toBe(true);
+			expect(
+				isAdvisorInterruptImmuneTurnActive({
+					completedTurns: 7,
+					immuneTurnStart: 5,
+					immuneTurns: 2,
+				}),
+			).toBe(false);
+		});
+
 		it("wraps each note in an advisory tag with severity as an attribute and escapes the body", () => {
 			const content = formatAdvisorBatchContent([
 				{ note: "first note" },
@@ -142,6 +193,37 @@ describe("advisor", () => {
 		});
 	});
 
+	describe("deriveAdvisorTelemetry", () => {
+		it("returns undefined when the primary has no telemetry so the advisor stays a no-op", () => {
+			expect(deriveAdvisorTelemetry(undefined, { id: "s-advisor", name: "Advisor" })).toBeUndefined();
+		});
+
+		it("inherits the primary's usage/cost hooks but restamps identity and clears the conversation", () => {
+			const onChatUsage = vi.fn();
+			const costEstimator = vi.fn();
+			const primary: AgentTelemetryConfig = {
+				agent: { id: "main", name: "Main" },
+				conversationId: "session-1",
+				attributes: { "deployment.id": "prod" },
+				onChatUsage,
+				costEstimator,
+			};
+			const identity = { id: "session-1-advisor", name: "Advisor", description: "anthropic/claude-sonnet-4-5" };
+
+			const derived = deriveAdvisorTelemetry(primary, identity);
+
+			// Usage/cost hooks are inherited so the advisor model's calls report through
+			// the same pipeline as the primary — the whole point of the fix.
+			expect(derived?.onChatUsage).toBe(onChatUsage);
+			expect(derived?.costEstimator).toBe(costEstimator);
+			expect(derived?.attributes).toEqual({ "deployment.id": "prod" });
+			// Advisor identity replaces the primary's so spans are attributable to the advisor.
+			expect(derived?.agent).toEqual(identity);
+			// Conversation cleared so the advisor loop falls back to its own `-advisor` session id.
+			expect(derived?.conversationId).toBeUndefined();
+		});
+	});
+
 	describe("AdvisorRuntime", () => {
 		function makeAgent(promptInputs: string[]): AdvisorAgent {
 			return {
@@ -688,6 +770,26 @@ describe("advisor", () => {
 			}
 		});
 
+		it("routes interrupting notes to the aside queue during immune turns without overriding preservation", () => {
+			expect(
+				resolveAdvisorDeliveryChannel({
+					severity: "concern",
+					autoResumeSuppressed: false,
+					streaming: true,
+					aborting: false,
+					interruptImmuneTurnActive: true,
+				}),
+			).toBe("aside");
+			expect(
+				resolveAdvisorDeliveryChannel({
+					severity: "blocker",
+					autoResumeSuppressed: true,
+					streaming: false,
+					aborting: false,
+					interruptImmuneTurnActive: true,
+				}),
+			).toBe("preserve");
+		});
 		it("preserves an interrupting note while suppressed AND idle (no auto-resume of a stopped run)", () => {
 			for (const severity of ["concern", "blocker"] as const) {
 				expect(

package/src/advisor/advise-tool.ts

@@ -1,19 +1,23 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import type {
+	AgentIdentity,
+	AgentTelemetryConfig,
+	AgentTool,
+	AgentToolContext,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+} from "@oh-my-pi/pi-agent-core";
 import { escapeXmlText } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import adviseDescription from "../prompts/advisor/advise-tool.md" with { type: "text" };
 
-const adviseSchema = z.object({
-	note: z
-		.string()
-		.describe("One concrete piece of advice for the agent you are watching. Terse, specific, actionable."),
-	severity: z
-		.enum(["nit", "concern", "blocker"])
-		.optional()
-		.describe("How strongly to weigh this. Omit for a plain nit."),
+const adviseSchema = type({
+	note: type("string").describe(
+		"One concrete piece of advice for the agent you are watching. Terse, specific, actionable.",
+	),
+	"severity?": type("'nit' | 'concern' | 'blocker'").describe("How strongly to weigh this. Omit for a plain nit."),
 });
 
-export type AdviseParams = z.infer<typeof adviseSchema>;
+export type AdviseParams = typeof adviseSchema.infer;
 
 export type AdvisorSeverity = "nit" | "concern" | "blocker";
 
@@ -68,6 +72,15 @@ export function isInterruptingSeverity(severity: AdvisorSeverity | undefined): b
 
 /** How an advisor note is routed to the primary. */
 export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
+/** Half-open turn-count fence for the post-interrupt cooldown. */
+export function isAdvisorInterruptImmuneTurnActive(opts: {
+	completedTurns: number;
+	immuneTurnStart: number | undefined;
+	immuneTurns: number;
+}): boolean {
+	if (opts.immuneTurnStart === undefined || opts.immuneTurns <= 0) return false;
+	return opts.completedTurns < opts.immuneTurnStart + opts.immuneTurns;
+}
 
 /**
  * Decide how one advisor note reaches the primary agent.
@@ -84,18 +97,41 @@ export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
  *   auto-resume anything, so it is delivered live. Parking it during an active
  *   run instead strands it (it never reaches the running agent) and the withheld
  *   notes dump as one burst at the next user prompt — the bug this guards.
+ * - During the post-interrupt immune-turn window, further `concern`/`blocker`
+ *   notes are downgraded to asides; suppression preservation still wins.
  */
 export function resolveAdvisorDeliveryChannel(opts: {
 	severity: AdvisorSeverity | undefined;
 	autoResumeSuppressed: boolean;
 	streaming: boolean;
 	aborting: boolean;
+	interruptImmuneTurnActive?: boolean;
 }): AdvisorDeliveryChannel {
 	if (!isInterruptingSeverity(opts.severity)) return "aside";
 	if (opts.autoResumeSuppressed && (opts.aborting || !opts.streaming)) return "preserve";
+	if (opts.interruptImmuneTurnActive) return "aside";
 	return "steer";
 }
 
+/**
+ * Derive the advisor loop's telemetry from the primary session's config so the
+ * advisor model's GenAI spans and usage/cost hooks (onChatUsage, onCostDelta,
+ * costEstimator) fire under the same pipeline as every other model call —
+ * stamped with the advisor's own agent identity. `conversationId` is cleared so
+ * the advisor loop falls back to its own `-advisor` session id for
+ * `gen_ai.conversation.id` instead of inheriting the primary's conversation.
+ *
+ * Returns undefined when the primary has no telemetry (instrumentation off), so
+ * the advisor `Agent` stays a zero-overhead no-op as well.
+ */
+export function deriveAdvisorTelemetry(
+	primaryTelemetry: AgentTelemetryConfig | undefined,
+	identity: AgentIdentity,
+): AgentTelemetryConfig | undefined {
+	if (!primaryTelemetry) return undefined;
+	return { ...primaryTelemetry, agent: identity, conversationId: undefined };
+}
+
 /**
  * Side-effect-free investigation tools handed to the advisor agent so it can
  * inspect the workspace before weighing in. Names match the primary session's

package/src/autoresearch/tools/init-experiment.ts

@@ -1,7 +1,7 @@
 import * as path from "node:path";
 
 import { Text } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { Theme } from "../../modes/theme/theme";
 import { replaceTabs, truncateToWidth } from "../../tools/render-utils";
@@ -16,21 +16,18 @@ export const HARNESS_FILENAME = "autoresearch.sh";
 export const DEFAULT_HARNESS_COMMAND = `bash ${HARNESS_FILENAME}`;
 const HARNESS_COMMIT_TITLE = "autoresearch: harness setup";
 
-const initExperimentSchema = z.object({
-	name: z.string().describe("experiment name"),
-	goal: z.string().describe("session goal").optional(),
-	primary_metric: z.string().describe("primary metric name"),
-	metric_unit: z.string().describe("metric unit (e.g. ms, µs, mb)").optional(),
-	direction: z
-		.enum(["lower", "higher"] as const)
-		.describe("better direction (default lower)")
-		.optional(),
-	secondary_metrics: z.array(z.string()).describe("secondary metric names").optional(),
-	scope_paths: z.array(z.string()).describe("expected-to-modify paths").optional(),
-	off_limits: z.array(z.string()).describe("off-limits paths").optional(),
-	constraints: z.array(z.string()).describe("free-form constraints").optional(),
-	max_iterations: z.number().describe("soft iteration cap per segment").optional(),
-	new_segment: z.boolean().describe("bump to a new segment in existing session").optional(),
+const initExperimentSchema = type({
+	name: type("string").describe("experiment name"),
+	"goal?": type("string").describe("session goal"),
+	primary_metric: type("string").describe("primary metric name"),
+	"metric_unit?": type("string").describe("metric unit (e.g. ms, µs, mb)"),
+	"direction?": type("'lower' | 'higher'").describe("better direction (default lower)"),
+	"secondary_metrics?": type("string[]").describe("secondary metric names"),
+	"scope_paths?": type("string[]").describe("expected-to-modify paths"),
+	"off_limits?": type("string[]").describe("off-limits paths"),
+	"constraints?": type("string[]").describe("free-form constraints"),
+	"max_iterations?": type("number").describe("soft iteration cap per segment"),
+	"new_segment?": type("boolean").describe("bump to a new segment in existing session"),
 });
 
 interface InitExperimentDetails {

package/src/autoresearch/tools/log-experiment.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 
 import { Text } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { Theme } from "../../modes/theme/theme";
 import { replaceTabs, truncateToWidth } from "../../tools/render-utils";
@@ -36,23 +36,20 @@ import type {
 
 const EXPERIMENT_TOOL_NAMES = ["init_experiment", "run_experiment", "log_experiment", "update_notes"];
 
-const logExperimentSchema = z.object({
-	metric: z.number().describe("primary metric value"),
-	status: z.enum(["keep", "discard", "crash", "checks_failed"] as const).describe("run outcome"),
-	description: z.string().describe("short run description"),
-	metrics: z.record(z.string(), z.number()).describe("secondary metrics").optional(),
-	asi: z.object({}).passthrough().describe("free-form structured metadata").optional(),
-	commit: z.string().describe("override recorded commit hash").optional(),
-	justification: z.string().describe("required when keeping a scope-deviating run").optional(),
-	flag_runs: z
-		.array(
-			z.object({
-				run_id: z.number().describe("run id to flag"),
-				reason: z.string().describe("why this run is suspect"),
-			}),
-		)
-		.describe("flag earlier runs as suspect")
-		.optional(),
+const logExperimentSchema = type({
+	metric: type("number").describe("primary metric value"),
+	status: type("'keep'|'discard'|'crash'|'checks_failed'").describe("run outcome"),
+	description: type("string").describe("short run description"),
+	"metrics?": type({ "[string]": "number" }).describe("secondary metrics"),
+	"asi?": type({ "[string]": "unknown" }).describe("free-form structured metadata"),
+	"commit?": type("string").describe("override recorded commit hash"),
+	"justification?": type("string").describe("required when keeping a scope-deviating run"),
+	"flag_runs?": type({
+		run_id: type("number.integer").describe("run id to flag"),
+		reason: type("string").describe("why this run is suspect"),
+	})
+		.array()
+		.describe("flag earlier runs as suspect"),
 });
 
 export function createLogExperimentTool(

package/src/autoresearch/tools/run-experiment.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { Text } from "@oh-my-pi/pi-tui";
 import { formatBytes } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import { executeBash } from "../../exec/bash-executor";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { Theme } from "../../modes/theme/theme";
@@ -25,8 +25,8 @@ import { openAutoresearchStorageIfExists } from "../storage";
 import type { AutoresearchToolFactoryOptions, RunDetails, RunExperimentProgressDetails } from "../types";
 import { DEFAULT_HARNESS_COMMAND } from "./init-experiment";
 
-const runExperimentSchema = z.object({
-	timeout_seconds: z.number().describe("timeout in seconds (default 600)").optional(),
+const runExperimentSchema = type({
+	"timeout_seconds?": type("number").describe("timeout in seconds (default 600)"),
 });
 
 interface ProcessExecutionResult {

package/src/autoresearch/tools/update-notes.ts

@@ -1,5 +1,5 @@
 import { Text } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
+import { type } from "arktype";
 import type { ToolDefinition } from "../../extensibility/extensions";
 import type { Theme } from "../../modes/theme/theme";
 import { replaceTabs, truncateToWidth } from "../../tools/render-utils";
@@ -8,9 +8,9 @@ import { buildExperimentState } from "../state";
 import { openAutoresearchStorageIfExists } from "../storage";
 import type { AutoresearchToolFactoryOptions } from "../types";
 
-const updateNotesSchema = z.object({
-	body: z.string().describe("replacement notes body"),
-	append_idea: z.string().describe("append as bullet under Ideas instead of replacing body").optional(),
+const updateNotesSchema = type({
+	body: type("string").describe("replacement notes body"),
+	"append_idea?": type("string").describe("append as bullet under Ideas instead of replacing body"),
 });
 
 interface UpdateNotesDetails {

package/src/cli/args.ts

@@ -28,6 +28,7 @@ export interface Args {
 	smol?: string;
 	slow?: string;
 	plan?: string;
+	maxTime?: number;
 	apiKey?: string;
 	systemPrompt?: string;
 	appendSystemPrompt?: string;

package/src/cli/bench-cli.ts

@@ -17,7 +17,12 @@ import { formatDuration, getProjectDir } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import type { ApiKeyResolverModel } from "../config/api-key-resolver";
 import { type CanonicalModelQueryOptions, ModelRegistry } from "../config/model-registry";
-import { formatModelString, getModelMatchPreferences, resolveCliModel } from "../config/model-resolver";
+import {
+	formatModelSelectorValue,
+	formatModelString,
+	getModelMatchPreferences,
+	resolveCliModel,
+} from "../config/model-resolver";
 import { Settings } from "../config/settings";
 import benchPrompt from "../prompts/bench.md" with { type: "text" };
 import { discoverAuthStorage } from "../sdk";
@@ -144,9 +149,15 @@ function isFirstTokenEvent(event: AssistantMessageEvent): boolean {
  * latency does not dilute throughput. Falls back to total duration when the
  * response arrived as a single chunk (TTFT ~ duration).
  */
-function computeTokensPerSecond(outputTokens: number, durationMs: number, ttftMs: number): number {
+export function computeTokensPerSecond(
+	outputTokens: number,
+	durationMs: number,
+	ttftMs: number,
+	deltaChunkCount: number,
+): number {
 	const decodeMs = durationMs - ttftMs;
-	const windowMs = decodeMs > 0 ? decodeMs : durationMs;
+	// Fall back to total duration when the response arrived as a single chunk/non-streaming.
+	const windowMs = decodeMs > 0 && deltaChunkCount >= 2 ? decodeMs : durationMs;
 	return windowMs > 0 ? (outputTokens * 1000) / windowMs : 0;
 }
 
@@ -193,10 +204,17 @@ async function runBenchRequest(
 			headers: model.provider === "openrouter" ? { "X-OpenRouter-Cache": "false" } : undefined,
 		});
 		let message: AssistantMessage | undefined;
+		let deltaChunkCount = 0;
 		for await (const event of stream) {
 			if (firstTokenAt === undefined && isFirstTokenEvent(event)) {
 				firstTokenAt = now();
 			}
+			if (
+				(event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") &&
+				event.delta.length > 0
+			) {
+				deltaChunkCount++;
+			}
 			if (event.type === "error") {
 				return { ok: false, error: event.error.errorMessage ?? "request failed" };
 			}
@@ -218,7 +236,7 @@ async function runBenchRequest(
 			ttftMs,
 			durationMs,
 			outputTokens,
-			tokensPerSecond: computeTokensPerSecond(outputTokens, durationMs, ttftMs),
+			tokensPerSecond: computeTokensPerSecond(outputTokens, durationMs, ttftMs, deltaChunkCount),
 		};
 	} catch (error) {
 		return { ok: false, error: getErrorMessage(error) };
@@ -244,6 +262,10 @@ function buildModelReport(
 	return { selector, model: formatModelString(model), thinking, results, average };
 }
 
+function formatBenchModelLabel(report: BenchModelReport): string {
+	return formatModelSelectorValue(report.model, report.thinking);
+}
+
 function formatMs(ms: number): string {
 	return formatDuration(Math.max(0, Math.round(ms)));
 }
@@ -264,7 +286,7 @@ export function formatBenchTable(summary: BenchSummary): string {
 		return b.average.tokensPerSecond - a.average.tokensPerSecond;
 	});
 	const rows = ranked.map(report => ({
-		model: report.model,
+		model: formatBenchModelLabel(report),
 		ttft: report.average ? formatMs(report.average.ttftMs) : "-",
 		tps: report.average ? `${report.average.tokensPerSecond.toFixed(1)}/s` : "-",
 		tokens: report.average ? String(Math.round(report.average.outputTokens)) : "-",
@@ -382,8 +404,9 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 		const reports: BenchModelReport[] = [];
 		for (const { selector, model, thinking } of targets) {
 			if (!json) {
-				const resolvedNote = selector === formatModelString(model) ? "" : chalk.dim(` (${selector})`);
-				writeStdout(`${chalk.bold(formatModelString(model))}${resolvedNote}\n`);
+				const resolvedModel = formatModelSelectorValue(formatModelString(model), thinking);
+				const resolvedNote = selector === resolvedModel ? "" : chalk.dim(` (${selector})`);
+				writeStdout(`${chalk.bold(resolvedModel)}${resolvedNote}\n`);
 			}
 			const results: BenchRunResult[] = [];
 			for (let index = 0; index < runs; index++) {

package/src/cli/flag-tables.ts

@@ -120,6 +120,14 @@ export const STRING_SETTERS: Record<string, StringSetter> = {
 	"--plan": (result, value) => {
 		result.plan = value;
 	},
+	"--max-time": (result, value, deps) => {
+		const seconds = Number(value);
+		if (Number.isFinite(seconds) && seconds > 0) {
+			result.maxTime = seconds;
+		} else {
+			deps.logger.warn("Invalid seconds passed to --max-time", { value });
+		}
+	},
 	"--api-key": (result, value) => {
 		result.apiKey = value;
 	},