@oh-my-pi/pi-coding-agent 17.1.7 → 17.2.0

package/src/advisor/transcript-recorder.ts

@@ -1,7 +1,9 @@
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { Message, UserMessage } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
+import { visitEntriesFromFileStream } from "../session/session-loader";
 import { SessionManager } from "../session/session-manager";
 
 /**
@@ -31,6 +33,60 @@ export function isAdvisorTranscriptName(name: string): boolean {
 	);
 }
 
+/**
+ * Sum the advisor spend already persisted next to a primary session transcript,
+ * keyed by advisor slug.
+ *
+ * The ledger a session keeps in memory only covers the current process, so a
+ * resumed session would report zero until the next advisor turn. The recorded
+ * transcripts are the durable copy of exactly the same finalized messages, so
+ * they are read back through the shared loader - no lock, no writer, and no
+ * second parser to keep in step with the session format.
+ *
+ * Only the session's own advisors count: subagent advisors write to
+ * `<session>/<SubId>/__advisor.jsonl`, and their spend belongs to the subagent,
+ * not to this roster. Hence the scan stays at the top level of the directory.
+ */
+export async function loadAdvisorTranscriptCosts(sessionFile: string | undefined): Promise<Map<string, number>> {
+	const costs = new Map<string, number>();
+	if (!sessionFile?.endsWith(JSONL_SUFFIX)) return costs;
+	const directory = sessionFile.slice(0, -JSONL_SUFFIX.length);
+	const dirents = await fs.readdir(directory, { withFileTypes: true }).catch(() => []);
+	for (const dirent of dirents) {
+		if (!dirent.isFile() || !isAdvisorTranscriptName(dirent.name)) continue;
+		const slug =
+			dirent.name === ADVISOR_TRANSCRIPT_FILENAME
+				? ""
+				: dirent.name.slice(`${ADVISOR_TRANSCRIPT_STEM}.`.length, -JSONL_SUFFIX.length);
+		let total = 0;
+		let validHeader: boolean | undefined;
+		try {
+			await visitEntriesFromFileStream(path.join(directory, dirent.name), entry => {
+				const isObject = typeof entry === "object" && entry !== null;
+				if (validHeader === undefined) {
+					validHeader = isObject && entry.type === "session" && typeof entry.id === "string";
+					return;
+				}
+				// A syntactically valid but non-object entry (e.g. a bare `null`
+				// line) must cost only itself, not crash entry.type access and
+				// discard everything accumulated for this transcript.
+				if (!validHeader || !isObject || entry.type !== "message") return;
+				const message = entry.message;
+				if (!message || typeof message !== "object" || message.role !== "assistant") return;
+				// One malformed usage block must cost that entry only, not the
+				// whole transcript's total.
+				const total_ = message.usage?.cost?.total;
+				if (typeof total_ === "number" && Number.isFinite(total_)) total += total_;
+			});
+		} catch (err) {
+			logger.debug("advisor transcript cost read failed", { file: dirent.name, err: String(err) });
+			continue;
+		}
+		if (total > 0) costs.set(slug, total);
+	}
+	return costs;
+}
+
 /**
  * Append-only persister for an advisor agent's transcript.
  *

package/src/async/job-manager.ts

@@ -417,6 +417,26 @@ export class AsyncJobManager {
 		}
 	}
 
+	/**
+	 * Immediately evict completed and failed jobs matching the filter instead of
+	 * waiting for retention expiry, dropping every queued delivery so a prior
+	 * session's result can never be injected into a later transcript. Returns the
+	 * number of jobs evicted.
+	 *
+	 * A delivery whose sink call is already in flight (or drained onto a caller's
+	 * yield queue) is guarded by the owner's delivery generation, not the per-id
+	 * suppression marker — that marker is cleared when the id is reused.
+	 */
+	evictCompletedJobs(filter?: AsyncJobFilter): number {
+		let evicted = 0;
+		for (const job of this.#filterJobs(this.#jobs.values(), filter)) {
+			if (job.status !== "completed" && job.status !== "failed") continue;
+			this.acknowledgeDeliveries([job.id]);
+			if (this.#evictJob(job.id)) evicted += 1;
+		}
+		return evicted;
+	}
+
 	async waitForAll(): Promise<void> {
 		await Promise.all(Array.from(this.#jobs.values()).map(job => job.promise));
 	}
@@ -579,12 +599,18 @@ export class AsyncJobManager {
 		return candidate;
 	}
 
+	#evictJob(jobId: string): boolean {
+		clearTimeout(this.#evictionTimers.get(jobId));
+		this.#evictionTimers.delete(jobId);
+		this.#suppressedDeliveries.delete(jobId);
+		this.#watchedJobs.delete(jobId);
+		return this.#jobs.delete(jobId);
+	}
+
 	#scheduleEviction(jobId: string): void {
 		if (this.#disposed) return;
 		if (this.#retentionMs <= 0) {
-			this.#jobs.delete(jobId);
-			this.#suppressedDeliveries.delete(jobId);
-			this.#watchedJobs.delete(jobId);
+			this.#evictJob(jobId);
 			return;
 		}
 		const existing = this.#evictionTimers.get(jobId);
@@ -592,10 +618,7 @@ export class AsyncJobManager {
 			clearTimeout(existing);
 		}
 		const timer = setTimeout(() => {
-			this.#evictionTimers.delete(jobId);
-			this.#jobs.delete(jobId);
-			this.#suppressedDeliveries.delete(jobId);
-			this.#watchedJobs.delete(jobId);
+			this.#evictJob(jobId);
 		}, this.#retentionMs);
 		timer.unref();
 		this.#evictionTimers.set(jobId, timer);

package/src/auto-thinking/classifier.ts

@@ -5,7 +5,8 @@
  * {@link Effort}, clamped into the active model's supported range (never below
  * {@link Effort.Low}). Two backends, selected by `providers.autoThinkingModel`:
  *
- * - `online` (default): a smol model classifies into `low|medium|high|xhigh`.
+ * - `online` (default): a smol model classifies into `low|medium|high|xhigh`,
+ *   plus `max` when the target model exposes that tier.
  * - a local key: an on-device memory model classifies into the coarser
  *   `trivial|moderate|hard` scheme (3-class is more reliable than 4-way ordinal
  *   on sub-2B models), mapped to `low|high|xhigh`.
@@ -14,6 +15,7 @@
  * the caller falls back to a concrete level and continues the turn.
  */
 import { type AssistantMessage, completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
+import { getSupportedEfforts } from "@oh-my-pi/pi-catalog/model-thinking";
 import { prompt } from "@oh-my-pi/pi-utils";
 
 import type { ModelRegistry } from "../config/model-registry";
@@ -30,7 +32,31 @@ import {
 } from "../tiny/models";
 import { tinyModelClient } from "../tiny/title-client";
 
-const DIFFICULTY_SYSTEM_PROMPT = prompt.render(difficultySystemPrompt);
+/**
+ * Rendered classifier prompts, keyed by whether `max` is offered as a label.
+ * Two variants only, so both are memoized on first use.
+ */
+const DIFFICULTY_SYSTEM_PROMPTS: Partial<Record<"max" | "xhigh", string>> = {};
+
+/**
+ * Highest effort this turn's classification may resolve to: the configured
+ * ceiling, further limited by what the target model actually exposes. The
+ * default keeps `auto` one tier below the top, so only an explicit
+ * `ultrathink` reaches {@link Effort.Max}.
+ */
+function autoEffortCeiling(deps: ClassifyDifficultyDeps): Effort {
+	if (deps.settings.get("providers.autoThinkingMaxEffort") !== Effort.Max) return Effort.XHigh;
+	return getSupportedEfforts(deps.model).includes(Effort.Max) ? Effort.Max : Effort.XHigh;
+}
+
+function difficultySystemPromptFor(ceiling: Effort): string {
+	const key = ceiling === Effort.Max ? "max" : "xhigh";
+	const cached = DIFFICULTY_SYSTEM_PROMPTS[key];
+	if (cached !== undefined) return cached;
+	const rendered = prompt.render(difficultySystemPrompt, { allowMax: key === "max" });
+	DIFFICULTY_SYSTEM_PROMPTS[key] = rendered;
+	return rendered;
+}
 
 /** Local classifiers occasionally need more room for chat-template boilerplate. */
 const LOCAL_ANSWER_MAX_TOKENS = 16;
@@ -64,14 +90,18 @@ export async function classifyDifficulty(
 ): Promise<Effort | undefined> {
 	const backend = deps.settings.get("providers.autoThinkingModel");
 	const input = preprocessTinyMessage(promptText);
-	const effort =
-		backend === ONLINE_AUTO_THINKING_MODEL_KEY
-			? await classifyOnline(input, deps)
-			: await classifyLocal(input, backend, deps);
-	return clampAutoThinkingEffort(deps.model, effort);
+	const online = backend === ONLINE_AUTO_THINKING_MODEL_KEY;
+	// The 3-bucket local classifier cannot select `max`, so its ceiling stays at
+	// XHigh whatever the setting says — otherwise a sparse ladder would snap its
+	// `hard` bucket up to a tier it never chose.
+	const ceiling = online ? autoEffortCeiling(deps) : Effort.XHigh;
+	const effort = online ? await classifyOnline(input, deps, ceiling) : await classifyLocal(input, backend, deps);
+	// The ceiling goes into the clamp itself: capping the request alone is not
+	// enough, because a sparse ladder snaps an excluded request back up.
+	return clampAutoThinkingEffort(deps.model, effort, ceiling);
 }
 
-async function classifyOnline(input: string, deps: ClassifyDifficultyDeps): Promise<Effort> {
+async function classifyOnline(input: string, deps: ClassifyDifficultyDeps, ceiling: Effort): Promise<Effort> {
 	const resolved = resolveRoleSelection(["tiny", "smol"], deps.settings, deps.registry.getAvailable());
 	const model = resolved?.model;
 	if (!model) {
@@ -88,7 +118,7 @@ async function classifyOnline(input: string, deps: ClassifyDifficultyDeps): Prom
 	const response = await completeSimple(
 		model,
 		{
-			systemPrompt: [DIFFICULTY_SYSTEM_PROMPT],
+			systemPrompt: [difficultySystemPromptFor(ceiling)],
 			messages: [{ role: "user", content: input, timestamp: Date.now() }],
 		},
 		{
@@ -134,7 +164,13 @@ async function classifyLocal(input: string, modelKey: string, deps: ClassifyDiff
 	return effort;
 }
 
-/** Map the online 4-way level keyword to an {@link Effort}; earliest match wins. */
+/**
+ * Map an online level keyword to an {@link Effort}; earliest match wins.
+ *
+ * `max` is only offered to the classifier when the target model exposes that
+ * tier, but it is always parsed: an unsupported `max` is snapped back down by
+ * {@link clampAutoThinkingEffort} rather than failing the turn.
+ */
 export function parseDifficultyLevel(text: string): Effort | undefined {
 	const lower = text.toLowerCase();
 	const candidates: Array<[number, Effort]> = [];
@@ -142,6 +178,8 @@ export function parseDifficultyLevel(text: string): Effort | undefined {
 	// inside "xhigh" (no word boundary between `x` and `h`), so the two never collide.
 	const xhigh = lower.search(/x[\s_-]?high/);
 	if (xhigh >= 0) candidates.push([xhigh, Effort.XHigh]);
+	const max = lower.search(/\bmax\b/);
+	if (max >= 0) candidates.push([max, Effort.Max]);
 	const high = lower.search(/\bhigh\b/);
 	if (high >= 0) candidates.push([high, Effort.High]);
 	const medium = lower.search(/\bmed(?:ium)?\b/);

package/src/cleanse/agent.ts

@@ -0,0 +1,226 @@
+import { getProjectDir, prompt } from "@oh-my-pi/pi-utils";
+import { ModelRegistry } from "../config/model-registry";
+import { formatModelString, resolveCliModel } from "../config/model-resolver";
+import { Settings } from "../config/settings";
+import { MAIN_AGENT_ID } from "../registry/agent-registry";
+import { discoverAuthStorage } from "../sdk";
+import { SessionManager } from "../session/session-manager";
+import { mapWithConcurrencyLimitAllSettled } from "../task/parallel";
+import { runStructuredSubagent } from "../task/structured-subagent";
+import type { ToolSession } from "../tools";
+import { EventBus } from "../utils/event-bus";
+import assignmentPrompt from "./prompts/assignment.md" with { type: "text" };
+import type {
+	CleanseAgentOutcome,
+	CleanseAssignment,
+	CleanseCheckResult,
+	CleanseDiagnostic,
+	CleanseDiagnosticReport,
+	CleanseLoopResult,
+} from "./types";
+
+const MAX_DIAGNOSTIC_MESSAGE = 4_000;
+
+/** Hooks used by the standalone command to render subagent lifecycle progress. */
+export interface CleanseAgentHooks {
+	onStart?(name: string, assignment: CleanseAssignment): void;
+	onFinish?(outcome: CleanseAgentOutcome, assignment: CleanseAssignment): void;
+}
+
+/** Persisted parent session that dispatches file-disjoint cleanse workers. */
+export interface CleanseAgentRuntime {
+	readonly model: string;
+	readonly sessionFile: string;
+	dispatch(
+		assignments: CleanseAssignment[],
+		wave: number,
+		report: CleanseDiagnosticReport,
+		signal?: AbortSignal,
+	): Promise<CleanseAgentOutcome[]>;
+	close(result?: CleanseLoopResult): Promise<void>;
+}
+
+/** Resolve the requested model and create a fresh persisted cleanse session. */
+export async function createCleanseAgentRuntime(options: {
+	cwd?: string;
+	model: string;
+	hooks?: CleanseAgentHooks;
+}): Promise<CleanseAgentRuntime> {
+	const cwd = options.cwd ?? getProjectDir();
+	const [settings, authStorage] = await Promise.all([Settings.init({ cwd }), discoverAuthStorage()]);
+	const modelRegistry = new ModelRegistry(authStorage);
+	await modelRegistry.refresh();
+	const resolved = resolveCliModel({ cliModel: options.model, modelRegistry, settings });
+	if (resolved.error || !resolved.model) {
+		throw new Error(resolved.error ?? `Model "${options.model}" not found`);
+	}
+	const modelSelector = resolved.selector ?? formatModelString(resolved.model);
+	const modelDisplay = formatModelString(resolved.model);
+	const sessionManager = SessionManager.create(cwd);
+	await sessionManager.setSessionName("Cleanse", "auto");
+	sessionManager.appendCustomEntry("cleanse", {
+		status: "running",
+		model: modelDisplay,
+		selector: options.model,
+	});
+	await sessionManager.ensureOnDisk();
+	const sessionFile = sessionManager.getSessionFile();
+	if (!sessionFile) throw new Error("Cleanse session could not be persisted");
+	const eventBus = new EventBus();
+	const toolSession: ToolSession = {
+		cwd,
+		hasUI: false,
+		suppressSpawnAdvisory: true,
+		enableLsp: true,
+		enableIrc: true,
+		enableMCP: false,
+		eventBus,
+		getSessionFile: () => sessionFile,
+		getSessionId: () => sessionManager.getSessionId(),
+		getArtifactsDir: () => sessionManager.getArtifactsDir(),
+		getArtifactManager: () => sessionManager.getArtifactManager(),
+		getAgentId: () => MAIN_AGENT_ID,
+		getSessionSpawns: () => "sonic",
+		getModelString: () => modelSelector,
+		getActiveModelString: () => modelSelector,
+		getActiveModel: () => resolved.model,
+		sessionManager,
+		settings,
+		authStorage,
+		modelRegistry,
+	};
+	let closed = false;
+
+	return {
+		model: modelDisplay,
+		sessionFile,
+		async dispatch(
+			assignments: CleanseAssignment[],
+			wave: number,
+			report: CleanseDiagnosticReport,
+			signal?: AbortSignal,
+		): Promise<CleanseAgentOutcome[]> {
+			sessionManager.appendCustomEntry("cleanse_wave", {
+				wave,
+				assignments: assignments.map(assignment => ({
+					weight: assignment.weight,
+					files: assignment.groups.map(group => group.file ?? "<project>"),
+				})),
+			});
+			const settled = await mapWithConcurrencyLimitAllSettled(
+				assignments,
+				assignments.length,
+				async (assignment, index, workerSignal) => {
+					const name = `CleanseW${wave}A${index + 1}`;
+					options.hooks?.onStart?.(name, assignment);
+					const result = await runStructuredSubagent({
+						session: toolSession,
+						invocationKind: "task",
+						assignment: renderAssignment(assignment, assignments, wave, index + 1, report.checks),
+						agent: "sonic",
+						model: modelSelector,
+						identity: { label: name },
+						index,
+						enableLsp: true,
+						enableIrc: true,
+						signal: workerSignal,
+					});
+					const outcome: CleanseAgentOutcome = {
+						name,
+						success: result.result.exitCode === 0 && !result.result.error && result.result.aborted !== true,
+						output: result.result.output,
+						error: result.result.error ?? (result.result.stderr || undefined),
+						resolvedModel: result.result.resolvedModel,
+					};
+					options.hooks?.onFinish?.(outcome, assignment);
+					return outcome;
+				},
+				signal,
+			);
+			const outcomes: CleanseAgentOutcome[] = [];
+			for (let index = 0; index < settled.results.length; index += 1) {
+				const result = settled.results[index];
+				if (!result) {
+					outcomes.push({ name: `CleanseW${wave}A${index + 1}`, success: false, output: "", error: "Cancelled" });
+				} else if (result.status === "fulfilled") {
+					outcomes.push(result.value);
+				} else {
+					const error = result.reason instanceof Error ? result.reason.message : String(result.reason);
+					const outcome = { name: `CleanseW${wave}A${index + 1}`, success: false, output: "", error };
+					options.hooks?.onFinish?.(outcome, assignments[index]);
+					outcomes.push(outcome);
+				}
+			}
+			return outcomes;
+		},
+		async close(result?: CleanseLoopResult): Promise<void> {
+			if (closed) return;
+			closed = true;
+			sessionManager.appendCustomEntry("cleanse", {
+				status: result?.status ?? "interrupted",
+				waves: result?.waves ?? 0,
+				remaining: result?.report.diagnostics.length,
+			});
+			await sessionManager.close();
+		},
+	};
+}
+
+function renderAssignment(
+	assignment: CleanseAssignment,
+	allAssignments: readonly CleanseAssignment[],
+	wave: number,
+	worker: number,
+	checks: readonly CleanseCheckResult[],
+): string {
+	const hasProjectIssues = assignment.groups.some(group => group.file === undefined);
+	const files = assignment.groups.flatMap(group => (group.file ? [group.file] : []));
+	const writeScope = [
+		...(files.length > 0 ? files.map(file => `- ${file}`) : ["- No file is named by the project-level diagnostic."]),
+		...(hasProjectIssues ? ["- Minimal additional files strictly required by project-level diagnostics."] : []),
+	].join("\n");
+	return prompt.render(assignmentPrompt, {
+		wave,
+		worker,
+		write_scope: writeScope,
+		diagnostics: formatDiagnostics(assignment.groups.flatMap(group => group.diagnostics)),
+		checker_commands: formatCheckerCommands(checks),
+		peer_assignments: formatPeerAssignments(assignment, allAssignments),
+	});
+}
+
+function formatDiagnostics(diagnostics: readonly CleanseDiagnostic[]): string {
+	return diagnostics
+		.map(diagnostic => {
+			const location = diagnostic.file
+				? `${diagnostic.file}${diagnostic.line ? `:${diagnostic.line}${diagnostic.column ? `:${diagnostic.column}` : ""}` : ""}`
+				: "<project>";
+			const code = diagnostic.code ? ` ${diagnostic.code}` : "";
+			const message = diagnostic.message.slice(0, MAX_DIAGNOSTIC_MESSAGE);
+			const suggestion = diagnostic.suggestion ? `\n  Suggested fix: ${diagnostic.suggestion}` : "";
+			return `- [${diagnostic.severity}] ${location} — ${diagnostic.checker}${code}: ${message}${suggestion}`;
+		})
+		.join("\n");
+}
+
+function formatCheckerCommands(checks: readonly CleanseCheckResult[]): string {
+	const seen = new Set<string>();
+	const lines: string[] = [];
+	for (const check of checks) {
+		const key = `${check.cwd}\u0000${check.command}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		lines.push(`- [${check.cwd}] ${check.command}`);
+	}
+	return lines.join("\n") || "- No command metadata available.";
+}
+
+function formatPeerAssignments(current: CleanseAssignment, assignments: readonly CleanseAssignment[]): string {
+	const lines: string[] = [];
+	for (const assignment of assignments) {
+		if (assignment.index === current.index) continue;
+		const files = assignment.groups.map(group => group.file ?? "<project-level>").join(", ");
+		lines.push(`- Worker ${assignment.index + 1}: ${files}`);
+	}
+	return lines.join("\n") || "- None.";
+}

package/src/cleanse/balance.ts

@@ -0,0 +1,79 @@
+import type { CleanseAssignment, CleanseDiagnostic, CleanseFileIssues, CleanseSeverity } from "./types";
+
+const SEVERITY_WEIGHT: Record<CleanseSeverity, number> = {
+	error: 5,
+	warning: 3,
+	info: 1,
+};
+
+/** Estimate repair burden from severity and available location/fix evidence. */
+export function diagnosticWeight(diagnostic: CleanseDiagnostic): number {
+	let weight = SEVERITY_WEIGHT[diagnostic.severity];
+	if (diagnostic.line === undefined) weight += 2;
+	if (!diagnostic.code) weight += 1;
+	if (!diagnostic.suggestion) weight += 1;
+	return weight;
+}
+
+/** Group diagnostics by file while keeping project-level failures together. */
+export function groupDiagnosticsByFile(diagnostics: readonly CleanseDiagnostic[]): CleanseFileIssues[] {
+	const groups = new Map<string, CleanseDiagnostic[]>();
+	for (const diagnostic of diagnostics) {
+		const key = diagnostic.file ?? "";
+		const existing = groups.get(key);
+		if (existing) existing.push(diagnostic);
+		else groups.set(key, [diagnostic]);
+	}
+	return [...groups.entries()]
+		.map(([file, entries]) => ({
+			file: file || undefined,
+			diagnostics: entries.sort(compareDiagnostics),
+			weight: entries.reduce((sum, diagnostic) => sum + diagnosticWeight(diagnostic), 0),
+		}))
+		.sort((left, right) => right.weight - left.weight || (left.file ?? "").localeCompare(right.file ?? ""));
+}
+
+/** Balance whole-file workloads with longest-processing-time bin packing. */
+export function balanceDiagnostics(diagnostics: readonly CleanseDiagnostic[], maxAgents: number): CleanseAssignment[] {
+	if (!Number.isInteger(maxAgents) || maxAgents <= 0) {
+		throw new Error("maxAgents must be a positive integer");
+	}
+	const groups = groupDiagnosticsByFile(diagnostics);
+	if (groups.length === 0) return [];
+	const count = Math.min(maxAgents, groups.length);
+	const assignments: CleanseAssignment[] = Array.from({ length: count }, (_, index) => ({
+		index,
+		groups: [],
+		weight: 0,
+	}));
+	for (const group of groups) {
+		let lightest = assignments[0];
+		for (let index = 1; index < assignments.length; index += 1) {
+			const candidate = assignments[index];
+			if (
+				candidate.weight < lightest.weight ||
+				(candidate.weight === lightest.weight && candidate.groups.length < lightest.groups.length) ||
+				(candidate.weight === lightest.weight &&
+					candidate.groups.length === lightest.groups.length &&
+					candidate.index < lightest.index)
+			) {
+				lightest = candidate;
+			}
+		}
+		lightest.groups.push(group);
+		lightest.weight += group.weight;
+	}
+	for (const assignment of assignments) {
+		assignment.groups.sort((left, right) => (left.file ?? "").localeCompare(right.file ?? ""));
+	}
+	return assignments;
+}
+
+function compareDiagnostics(left: CleanseDiagnostic, right: CleanseDiagnostic): number {
+	return (
+		(left.line ?? 0) - (right.line ?? 0) ||
+		(left.column ?? 0) - (right.column ?? 0) ||
+		left.checker.localeCompare(right.checker) ||
+		left.message.localeCompare(right.message)
+	);
+}