@oh-my-pi/pi-coding-agent 17.1.6 → 17.1.8

package/dist/types/utils/sample-profile.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Parser and renderer for macOS `/usr/bin/sample` call-tree reports
+ * (conventionally saved as `*.sample.txt`).
+ *
+ * The raw report is a 10k+ line ASCII call tree with mangled symbols —
+ * expensive for an agent to digest. `renderSampleProfile` converts it into a
+ * compact bottleneck summary:
+ *
+ * - per-thread hot paths, pruned to frames with meaningful on-CPU samples,
+ *   with pass-through chains collapsed and direct recursion flattened
+ * - blocked/idle threads reduced to a one-line classification
+ * - a process-wide "top functions by self samples" table
+ * - Rust v0 and legacy symbols demangled (best-effort, path extraction)
+ *
+ * Consumed by the read tool: `*.sample.txt` reads show the summary, `:raw`
+ * returns the original bytes.
+ */
+/** Matches paths the read tool should treat as macOS sample reports. */
+export declare function isSampleProfilePath(filePath: string): boolean;
+/** One frame in the sampled call tree. Counts are sample hits (subtree total). */
+export interface SampleFrame {
+    count: number;
+    symbol: string;
+    module?: string;
+    children: SampleFrame[];
+}
+/** One sampled thread: `Thread_<id>` root plus its call tree. */
+export interface SampleThread {
+    id: string;
+    name?: string;
+    total: number;
+    roots: SampleFrame[];
+}
+/** Metadata from the report preamble (everything before `Call graph:`). */
+export interface SampleProfileHeader {
+    process: string;
+    pid: number;
+    intervalMs: number;
+    path?: string;
+    codeType?: string;
+    osVersion?: string;
+    footprint?: string;
+    footprintPeak?: string;
+}
+/** Parsed macOS sample report. */
+export interface SampleProfile {
+    header: SampleProfileHeader;
+    threads: SampleThread[];
+}
+/**
+ * Parse a macOS `sample` report. Returns null when the text does not look
+ * like sample output (missing analysis preamble or `Call graph:` section).
+ */
+export declare function parseSampleProfile(text: string): SampleProfile | null;
+/**
+ * Best-effort demangle of Rust symbols (v0 `_R…` and legacy `_ZN…E`).
+ * For v0 this is a path extractor, not a full demangler: identifiers are
+ * pulled out in order and joined with `::`, so generic arguments appear as
+ * extra path segments. Non-Rust symbols pass through unchanged.
+ */
+export declare function demangleSymbol(raw: string): string;
+/**
+ * Render a macOS sample report as an agent-friendly bottleneck summary.
+ * Returns null when `text` is not sample output (caller falls back to the
+ * plain-text path).
+ */
+export declare function renderSampleProfile(text: string): string | null;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.1.6",
+	"version": "17.1.8",
 	"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.1.6",
-		"@oh-my-pi/omp-stats": "17.1.6",
-		"@oh-my-pi/pi-agent-core": "17.1.6",
-		"@oh-my-pi/pi-ai": "17.1.6",
-		"@oh-my-pi/pi-catalog": "17.1.6",
-		"@oh-my-pi/pi-mnemopi": "17.1.6",
-		"@oh-my-pi/pi-natives": "17.1.6",
-		"@oh-my-pi/pi-tui": "17.1.6",
-		"@oh-my-pi/pi-utils": "17.1.6",
-		"@oh-my-pi/pi-wire": "17.1.6",
-		"@oh-my-pi/snapcompact": "17.1.6",
+		"@oh-my-pi/hashline": "17.1.8",
+		"@oh-my-pi/omp-stats": "17.1.8",
+		"@oh-my-pi/pi-agent-core": "17.1.8",
+		"@oh-my-pi/pi-ai": "17.1.8",
+		"@oh-my-pi/pi-catalog": "17.1.8",
+		"@oh-my-pi/pi-mnemopi": "17.1.8",
+		"@oh-my-pi/pi-natives": "17.1.8",
+		"@oh-my-pi/pi-tui": "17.1.8",
+		"@oh-my-pi/pi-utils": "17.1.8",
+		"@oh-my-pi/pi-wire": "17.1.8",
+		"@oh-my-pi/snapcompact": "17.1.8",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
@@ -107,6 +107,10 @@
 		"dist/cli.js",
 		"dist/CHANGELOG-*.md",
 		"dist/*.node",
+		"dist/template-*.css",
+		"dist/template-*.html",
+		"dist/template-*.js",
+		"dist/tool-views.generated-*.js",
 		"scripts",
 		"examples",
 		"README.md",

package/scripts/bundle-dist.ts

@@ -9,6 +9,7 @@ const packageDir = path.join(import.meta.dir, "..");
 const outDir = path.join(packageDir, "dist");
 const cliPath = path.join(outDir, "cli.js");
 const shebang = "#!/usr/bin/env bun\n";
+const legacyHtmlExportAssetPattern = /^(?:template-[^.]+\.(?:css|html|js)|tool-views\.generated-[^.]+\.js)$/;
 
 // Native / optional / platform-specific deps are loaded from installed files.
 // `omp-legacy-pi-modules` exists only in compiled binaries via the build plugin;
@@ -80,7 +81,8 @@ async function cleanBundleOutputs(): Promise<void> {
 					entry === "cli.js" ||
 					entry.endsWith(".node") ||
 					entry.endsWith(".js.map") ||
-					(entry.startsWith("CHANGELOG-") && entry.endsWith(".md")),
+					(entry.startsWith("CHANGELOG-") && entry.endsWith(".md")) ||
+					legacyHtmlExportAssetPattern.test(entry),
 			)
 			.map(entry => fs.rm(path.join(outDir, entry), { force: true })),
 	);

package/src/advisor/advise-tool.ts

@@ -75,17 +75,6 @@ export function isInterruptingSeverity(severity: AdvisorSeverity | undefined): b
 	return severity === "concern" || severity === "blocker";
 }
 
-/**
- * Append a staleness caveat to an advisor note when newer primary turns arrived
- * after the reviewed transcript window (i.e. `hasFreshBacklog` is true on the
- * advisor runtime at delivery time). Pure function — no session coupling — so it
- * can be unit-tested in isolation and called from `AgentSession#routeAdvice`.
- */
-export function annotateForStaleness(note: string, hasFreshBacklog: boolean): string {
-	if (!hasFreshBacklog) return note;
-	return `${note}\n\n_(Note: newer primary turns arrived after this reviewed window — verify this still applies.)_`;
-}
-
 /** 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. */

package/src/advisor/runtime.ts

@@ -340,18 +340,6 @@ export class AdvisorRuntime {
 		return this.#halted;
 	}
 
-	/**
-	 * True when `#pending` is non-empty while the drain loop is busy — i.e., newer
-	 * primary turns arrived after the current batch's transcript window was fixed
-	 * but before the advisor model finished processing it. The delivery path uses
-	 * this to annotate advice that was generated without seeing those newer turns.
-	 * Can be true during `agent.prompt()`, a `maintainContext` await, or a retry
-	 * sleep — any time `#drain` is busy and a concurrent `onTurnEnd` pushed.
-	 */
-	get hasFreshBacklog(): boolean {
-		return this.#pending.length > 0;
-	}
-
 	/**
 	 * Called after each primary turn ends. Renders the incremental delta and
 	 * queues it for the advisor model.

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/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)
+	);
+}