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

package/src/cleanse/progress.ts

@@ -0,0 +1,50 @@
+const BAR_WIDTH = 16;
+
+/** Minimal output contract used by the interactive cleanse progress reporter. */
+export interface CleanseProgressOutput {
+	isTTY?: boolean;
+	write(text: string): boolean;
+}
+
+/** Renders completed repair workers on one transient terminal line. */
+export interface CleanseProgressReporter {
+	readonly interactive: boolean;
+	start(total: number): void;
+	complete(): void;
+	finish(): void;
+}
+
+/** Create the TTY-only worker completion reporter used by `omp cleanse`. */
+export function createCleanseProgressReporter(output: CleanseProgressOutput = process.stdout): CleanseProgressReporter {
+	const interactive = output.isTTY === true;
+	let total = 0;
+	let completed = 0;
+	let rendered = false;
+
+	const render = (): void => {
+		if (!interactive || total === 0) return;
+		const ratio = Math.min(completed / total, 1);
+		const filled = Math.round(ratio * BAR_WIDTH);
+		const bar = `${"█".repeat(filled)}${"░".repeat(BAR_WIDTH - filled)}`;
+		output.write(`\rRepairing [${bar}] ${completed}/${total}\x1b[K`);
+		rendered = true;
+	};
+
+	return {
+		interactive,
+		start(nextTotal) {
+			total = Math.max(nextTotal, 0);
+			completed = 0;
+			render();
+		},
+		complete() {
+			completed = Math.min(completed + 1, total);
+			render();
+		},
+		finish() {
+			if (!rendered) return;
+			output.write("\n");
+			rendered = false;
+		},
+	};
+}

package/src/cleanse/prompts/assignment.md

@@ -0,0 +1,47 @@
+<critical>
+- You MUST fix every assigned diagnostic at its root cause.
+- You MUST stay inside the write scope below.
+- You NEVER suppress valid diagnostics to make checks pass.
+- You NEVER delegate or spawn another agent.
+- You NEVER run project-wide checks or formatters; the orchestrator reruns them.
+</critical>
+
+# Assignment
+
+Repair wave {{wave}}, worker {{worker}}.
+
+## Write scope
+
+{{write_scope}}
+
+Read related code freely. Project-level diagnostics MAY require the smallest necessary edit outside named files; use `hub` before touching a peer-owned file.
+
+## Diagnostics
+
+{{diagnostics}}
+
+## Checker commands
+
+{{checker_commands}}
+
+## Concurrent peer ownership
+
+{{peer_assignments}}
+
+<workflow>
+1. Inspect every assigned location and its local context.
+2. Fix causes, not emitted text or checker configuration.
+3. Preserve behavior unless a diagnostic proves it wrong.
+4. Run only targeted checks for assigned files when available.
+5. Re-read changed sections and resolve every assigned item.
+</workflow>
+
+<completeness>
+- Done means every assigned diagnostic has a concrete fix.
+- Blocked items MUST name the missing prerequisite in the final result.
+- Final output MUST list changed files and unresolved items.
+</completeness>
+
+<critical>
+You MUST leave peer-owned files untouched and complete the full assignment.
+</critical>

package/src/cleanse/types.ts

@@ -0,0 +1,72 @@
+/** Severity normalized across checker-specific output formats. */
+export type CleanseSeverity = "error" | "warning" | "info";
+
+/** One actionable problem reported by a project checker. */
+export interface CleanseDiagnostic {
+	checker: string;
+	file?: string;
+	line?: number;
+	column?: number;
+	endLine?: number;
+	endColumn?: number;
+	code?: string;
+	severity: CleanseSeverity;
+	message: string;
+	suggestion?: string;
+}
+
+/** Result metadata for one checker invocation. */
+export interface CleanseCheckResult {
+	id: string;
+	label: string;
+	language: string;
+	cwd: string;
+	command: string;
+	exitCode: number | null;
+	diagnostics: CleanseDiagnostic[];
+}
+
+/** Checker discovery result omitted because its required executable was unavailable. */
+export interface SkippedCleanseCheck {
+	label: string;
+	language: string;
+	reason: string;
+}
+
+/** Aggregate diagnostics from every checker selected for a project. */
+export interface CleanseDiagnosticReport {
+	checks: CleanseCheckResult[];
+	diagnostics: CleanseDiagnostic[];
+	skipped: SkippedCleanseCheck[];
+}
+
+/** All diagnostics attached to one file, which scheduling never splits across agents. */
+export interface CleanseFileIssues {
+	file?: string;
+	diagnostics: CleanseDiagnostic[];
+	weight: number;
+}
+
+/** One weighted, file-disjoint workload handed to a subagent. */
+export interface CleanseAssignment {
+	index: number;
+	groups: CleanseFileIssues[];
+	weight: number;
+}
+
+/** Settled result from one cleanse subagent. */
+export interface CleanseAgentOutcome {
+	name: string;
+	success: boolean;
+	output: string;
+	error?: string;
+	resolvedModel?: string;
+}
+
+/** Final state after one bounded repair wave and verification pass. */
+export interface CleanseLoopResult {
+	status: "clean" | "stalled" | "cancelled";
+	waves: number;
+	report: CleanseDiagnosticReport;
+	outcomes: CleanseAgentOutcome[];
+}

package/src/cli/update-cli.ts

@@ -231,6 +231,9 @@ export async function downloadVerifiedBinary(options: VerifiedBinaryDownloadOpti
 		await fs.promises.chmod(options.targetPath, 0o755);
 	} catch (err) {
 		await unlinkIfExists(options.targetPath);
+		if (isTimeoutError(err)) {
+			throw new Error("Timed out downloading release binary after 15 minutes", { cause: err });
+		}
 		throw err;
 	}
 }

package/src/cli/usage-cli.ts

@@ -560,9 +560,34 @@ function formatReloginDeadline(
  * automatically (refresh failure, upstream invalidation). Rows the user
  * replaced or deleted deliberately are lifecycle noise, not lost capacity.
  */
-function isActionableDisable(summary: DisabledCredentialSummary): boolean {
+function isActionableDisable(summary: DisabledCredentialSummary, activeAccounts: UsageAccountIdentity[] = []): boolean {
 	if (summary.type !== "oauth") return false;
-	return !/^(replaced by|deleted by user)/i.test(summary.cause);
+	if (/^(replaced by|deleted by user)/i.test(summary.cause)) return false;
+
+	// Do not display tombstone if there is an active account for the same provider
+	// matching the same identity (email, accountId, or org).
+	const summaryEmail = summary.email?.toLowerCase();
+	const summaryAccountId = summary.accountId?.toLowerCase();
+	const summaryOrgId = summary.orgId?.toLowerCase();
+
+	const matchesActive = activeAccounts.some(account => {
+		if (account.provider !== summary.provider) return false;
+
+		const accountEmail = account.email?.toLowerCase();
+		const accountAccountId = account.accountId?.toLowerCase();
+		const accountOrgId = account.orgId?.toLowerCase();
+
+		// If email or accountId match, it's the same identity
+		if (summaryEmail && accountEmail && summaryEmail === accountEmail) return true;
+		if (summaryAccountId && accountAccountId && summaryAccountId === accountAccountId) return true;
+
+		// Fallback: if orgId matches and neither email nor accountId contradicts
+		if (summaryOrgId && accountOrgId && summaryOrgId === accountOrgId) return true;
+
+		return false;
+	});
+
+	return !matchesActive;
 }
 
 /** Human-sized disable cause: the upstream `error_description` when embedded, else the first clause. */
@@ -610,7 +635,7 @@ export function formatUsageBreakdown(
 	}
 	const disabledByProvider = new Map<string, DisabledCredentialSummary[]>();
 	for (const summary of disabled) {
-		if (!isActionableDisable(summary)) continue;
+		if (!isActionableDisable(summary, accounts)) continue;
 		const list = disabledByProvider.get(summary.provider) ?? [];
 		list.push(summary);
 		disabledByProvider.set(summary.provider, list);
@@ -1018,7 +1043,7 @@ export async function runUsageCommand(cmd: UsageCommandArgs): Promise<void> {
 				const stats = computeProviderWindowStats(filteredReports.filter(peer => peer.provider === report.provider));
 				if (stats.length > 0) capacity[report.provider] = stats;
 			}
-			let disabledForJson = disabled.filter(isActionableDisable);
+			let disabledForJson = disabled.filter(summary => isActionableDisable(summary, accounts));
 			if (redaction) {
 				disabledForJson = disabledForJson.map(summary => ({
 					...summary,

package/src/cli/worktree-cli.ts

@@ -8,8 +8,10 @@
  *     `<parent-repo>/.git/worktrees/<name>/`.
  *   - **Task-isolation dirs** (`task/worktree.ts`): a wrapper dir with a
  *     compact `m` subdir mounted/cloned by `natives.isoStart`. Legacy `merged`
- *     subdirs are still recognized. These are ephemeral; `ensureIsolation`
- *     removes the base before re-creating it, so leftovers are crashed runs.
+ *     subdirs are still recognized. `ensureIsolation` writes an ownership
+ *     marker naming the live omp process; a
+ *     sandbox whose owner is still running is reported `live` and never
+ *     removed without `--all`, so `clear` reclaims only crashed leftovers.
  *
  * Legacy entries from before the encoding change keep working because git still
  * tracks them by branch name. This command exists to GC them on demand.
@@ -18,6 +20,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getWorktreesDir, isEnoent } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
+import { hasLiveIsolationOwner, ISOLATION_OWNER_FILE } from "../task/isolation-ownership";
 import * as git from "../utils/git";
 
 type WorktreeKind = "pr-checkout" | "task-isolation" | "empty" | "stray";
@@ -211,16 +214,30 @@ async function classifyDir(dir: string): Promise<WorktreeEntry | null> {
 	if (gitStat?.isFile()) {
 		return classifyPrCheckout(dir, gitEntry);
 	}
-	for (const mountDir of TASK_ISOLATION_MOUNT_DIRS) {
-		const mountStat = await fs.stat(path.join(dir, mountDir)).catch(() => null);
-		if (!mountStat?.isDirectory()) continue;
-		return {
-			path: dir,
-			kind: "task-isolation",
-			orphanReason: "task-isolation leftover (no live task owns it)",
-		};
+	// A task-isolation sandbox is identified by its ownership marker — written
+	// before the backend materialises the mount — or by the `m`/`merged` mount
+	// dir itself (legacy dirs and crashed pre-marker runs). Recognizing the
+	// marker alone keeps an in-progress sandbox from being mistaken for a stray
+	// during the window between marker creation and mount materialisation.
+	let isIsolation = await Bun.file(path.join(dir, ISOLATION_OWNER_FILE)).exists();
+	if (!isIsolation) {
+		for (const mountDir of TASK_ISOLATION_MOUNT_DIRS) {
+			const mountStat = await fs.stat(path.join(dir, mountDir)).catch(() => null);
+			if (mountStat?.isDirectory()) {
+				isIsolation = true;
+				break;
+			}
+		}
 	}
-	return null;
+	if (!isIsolation) return null;
+	const live = await hasLiveIsolationOwner(dir);
+	return {
+		path: dir,
+		kind: "task-isolation",
+		// Only after confirming no live owner is the "no live task" claim true.
+		// A running subagent's sandbox stays live so `clear` won't delete it.
+		orphanReason: live ? undefined : "task-isolation leftover (no live task owns it)",
+	};
 }
 
 async function classifyPrCheckout(dir: string, gitEntry: string): Promise<WorktreeEntry> {

package/src/cli-commands.ts

@@ -18,6 +18,7 @@ export const commands: CommandEntry[] = [
 	{ name: "auth-gateway", load: () => import("./commands/auth-gateway").then(m => m.default) },
 	{ name: "agents", load: () => import("./commands/agents").then(m => m.default) },
 	{ name: "bench", load: () => import("./commands/bench").then(m => m.default) },
+	{ name: "cleanse", load: () => import("./commands/cleanse").then(m => m.default) },
 	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },
 	{ name: "completions", load: () => import("./commands/completions").then(m => m.default) },
 	{ name: "__complete", load: () => import("./commands/complete").then(m => m.default) },

package/src/cli.ts

@@ -25,6 +25,7 @@ import {
 	VERSION,
 } from "@oh-my-pi/pi-utils/dirs";
 import { interceptUnhandledRejections } from "@oh-my-pi/pi-utils/postmortem";
+import { setProcessName } from "@oh-my-pi/pi-utils/process-name";
 import { declareWorkerHostEntry, installWorkerInbox, isWorkerHostSelector } from "@oh-my-pi/pi-utils/worker-host";
 import { installProfileAlias, resolveProfileAliasCommandFromProcess } from "./cli/profile-alias";
 import { extractProfileFlags } from "./cli/profile-bootstrap";
@@ -42,7 +43,7 @@ if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.exit(1);
 }
 
-process.title = APP_NAME;
+setProcessName(APP_NAME);
 
 // `Bun.build`-API compiled Windows executables report `import.meta.main ===
 // false`: the standalone loader keys the entry module with native backslashes

package/src/commands/cleanse.ts

@@ -0,0 +1,45 @@
+import { postmortem } from "@oh-my-pi/pi-utils";
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runCleanseCommand } from "../cleanse";
+import { CliUsageError } from "../cli/usage-error";
+
+export default class Cleanse extends Command {
+	static description = "Detect and fix project diagnostics with weighted parallel subagents";
+
+	static flags = {
+		agents: Flags.integer({
+			char: "n",
+			description: "Maximum number of file-disjoint subagents",
+			default: 8,
+		}),
+		model: Flags.string({
+			char: "m",
+			description: "Subagent model selector",
+			default: "@smol",
+		}),
+		tests: Flags.boolean({
+			char: "t",
+			description: "Also run configured project test suites",
+			default: false,
+		}),
+	};
+
+	static examples = [
+		"omp cleanse",
+		"omp cleanse -n 4",
+		"omp cleanse -m opus",
+		"omp cleanse -t",
+		"omp cleanse --agents 12 --model anthropic/claude-opus-4-6",
+	];
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Cleanse);
+		if (flags.agents <= 0) throw new CliUsageError("--agents must be a positive integer");
+		const result = await runCleanseCommand({
+			maxAgents: flags.agents,
+			model: flags.model,
+			includeTests: flags.tests,
+		});
+		await postmortem.quit(result.exitCode);
+	}
+}

package/src/config/settings-schema.ts

@@ -3835,14 +3835,28 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	// Legacy boolean kept only for back-compat migration to `inspect_image.mode`
+	// (see config/settings.ts). Hidden from UI.
 	"inspect_image.enabled": {
 		type: "boolean",
 		default: false,
+	},
+
+	"inspect_image.mode": {
+		type: "enum",
+		values: ["auto", "on", "off"] as const,
+		default: "auto",
 		ui: {
 			tab: "tools",
 			group: "Available Tools",
 			label: "Inspect Image",
-			description: "Enable the inspect_image tool, delegating image understanding to a vision-capable model",
+			description:
+				"Controls the inspect_image tool, which delegates image understanding to a vision-capable model. 'auto' exposes it only when the active model lacks native image input; 'on' always exposes it; 'off' never does.",
+			options: [
+				{ value: "auto", label: "Auto (only for models without vision)" },
+				{ value: "on", label: "On" },
+				{ value: "off", label: "Off" },
+			],
 		},
 	},
 

package/src/config/settings.ts

@@ -39,6 +39,7 @@ import { isLightTheme, setAutoThemeMapping, setColorBlindMode, setSymbolPreset }
 import { AgentStorage } from "../session/agent-storage";
 import { AUTO_IMAGE_PROVIDER_ORDER, isImageProviderId } from "../tools/image-providers";
 import { type EditMode, normalizeEditMode } from "../utils/edit-mode";
+import { INSPECT_IMAGE_MODES } from "../utils/inspect-image-mode";
 import { isSearchProviderId, SEARCH_PROVIDER_ORDER } from "../web/search/types";
 import { withFileLock } from "./file-lock";
 import {
@@ -1366,6 +1367,40 @@ export class Settings {
 			}
 		}
 
+		// inspect_image.enabled (boolean) -> inspect_image.mode (enum). Explicit
+		// user choices are preserved: true -> "on", false -> "off". Configs with
+		// no legacy key get the new "auto" default, which hides the tool for
+		// models with native image input. Handles nested and quoted-dotted
+		// ("inspect_image.enabled") sources; the target is always the nested
+		// form, which is the only shape the resolver reads.
+		const inspectImageObj = isRecord(raw.inspect_image) ? (raw.inspect_image as Record<string, unknown>) : undefined;
+		const legacyEnabled =
+			typeof inspectImageObj?.enabled === "boolean"
+				? inspectImageObj.enabled
+				: typeof raw["inspect_image.enabled"] === "boolean"
+					? (raw["inspect_image.enabled"] as boolean)
+					: undefined;
+		if (legacyEnabled !== undefined) {
+			if (!inspectImageObj) {
+				raw.inspect_image = {};
+			}
+			const target = raw.inspect_image as Record<string, unknown>;
+			const flatMode = raw["inspect_image.mode"];
+			if (target.mode === undefined) {
+				// A quoted-dotted explicit mode wins over the legacy boolean but
+				// must be normalized into the nested form the resolver reads.
+				target.mode =
+					typeof flatMode === "string" && (INSPECT_IMAGE_MODES as readonly string[]).includes(flatMode)
+						? flatMode
+						: legacyEnabled
+							? "on"
+							: "off";
+			}
+			delete target.enabled;
+			delete raw["inspect_image.enabled"];
+			delete raw["inspect_image.mode"];
+		}
+
 		// task.isolation.enabled (boolean) -> task.isolation.mode (enum)
 		const taskObj = raw.task as Record<string, unknown> | undefined;
 		const isolationObj = taskObj?.isolation as Record<string, unknown> | undefined;

package/src/cursor.ts

@@ -25,7 +25,8 @@ interface CursorExecBridgeOptions {
 	cwd: string;
 	getCwd?: () => string;
 	tools: Map<string, AgentTool>;
-	getTool?: (name: string) => AgentTool | undefined;
+	/** Resolves execution overrides (mounted-device permission wrappers) before the canonical map. */
+	getExecutableTool?: (name: string) => AgentTool | undefined;
 	getToolContext?: () => AgentToolContext | undefined;
 	emitEvent?: (event: AgentEvent) => void;
 	/**
@@ -81,7 +82,7 @@ async function executeTool(
 	toolCallId: string,
 	args: Record<string, unknown>,
 ): Promise<ToolResultMessage> {
-	const tool = options.tools.get(toolName) ?? options.getTool?.(toolName);
+	const tool = options.getExecutableTool?.(toolName) ?? options.tools.get(toolName);
 	if (!tool) {
 		const result = buildToolErrorResult(`Tool "${toolName}" not available`);
 		return createToolResultMessage(toolCallId, toolName, result, true);
@@ -497,7 +498,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 	async mcp(call: CursorMcpCall) {
 		const toolName = call.toolName || call.name;
 		const toolCallId = decodeToolCallId(call.toolCallId);
-		const tool = this.options.tools.get(toolName) ?? this.options.getTool?.(toolName);
+		const tool = this.options.getExecutableTool?.(toolName) ?? this.options.tools.get(toolName);
 		if (!tool) {
 			const availableTools = Array.from(this.options.tools.keys()).filter(name => name.startsWith("mcp__"));
 			const message = formatMcpToolErrorMessage(toolName, availableTools);

package/src/discovery/builtin-rules/index.ts

@@ -28,6 +28,7 @@ import tsNoAny from "./ts-no-any.md" with { type: "text" };
 import tsNoDeprecatedLeftovers from "./ts-no-deprecated-leftovers.md" with { type: "text" };
 import tsNoDynamicImport from "./ts-no-dynamic-import.md" with { type: "text" };
 import tsNoInlineCastAccess from "./ts-no-inline-cast-access.md" with { type: "text" };
+import tsNoLocalIsRecord from "./ts-no-local-is-record.md" with { type: "text" };
 import tsNoReturnType from "./ts-no-return-type.md" with { type: "text" };
 import tsNoTestTimers from "./ts-no-test-timers.md" with { type: "text" };
 import tsNoTinyFunctions from "./ts-no-tiny-functions.md" with { type: "text" };
@@ -63,6 +64,7 @@ export const BUILTIN_RULE_SOURCES: readonly BuiltinRuleSource[] = [
 	{ name: "ts-no-deprecated-leftovers", content: tsNoDeprecatedLeftovers },
 	{ name: "ts-no-dynamic-import", content: tsNoDynamicImport },
 	{ name: "ts-no-inline-cast-access", content: tsNoInlineCastAccess },
+	{ name: "ts-no-local-is-record", content: tsNoLocalIsRecord },
 	{ name: "ts-no-return-type", content: tsNoReturnType },
 	{ name: "ts-no-test-timers", content: tsNoTestTimers },
 	{ name: "ts-no-tiny-functions", content: tsNoTinyFunctions },

package/src/discovery/builtin-rules/ts-no-local-is-record.md

@@ -0,0 +1,48 @@
+---
+description: "Never use isRecord"
+condition:
+  - "\\bfunction\\s+isRecord(?:\\s*<[^>]*>)?\\s*\\("
+  - "\\b(?:const|let|var)\\s+isRecord\\b\\s*(?::[\\s\\S]{0,300}?)?=\\s*(?:async\\s+)?(?:function\\b|(?:<[^>\\n]*>\\s*)?(?:\\([^)]*\\)|[A-Za-z_$][\\w$]*)\\s*(?::[\\s\\S]{0,300}?)?=>)"
+scope: "tool:edit(*.{ts,tsx,mts,cts}), tool:write(*.{ts,tsx,mts,cts})"
+interruptMode: never
+---
+
+## Why it's wrong
+
+- A `Record<string, unknown>` guard proves only an object, not its fields.
+- It's either unnecessarily complicated, or not strong enough.
+- Repeated guards hide the actual data contract from readers and TypeScript.
+
+## Use
+
+`isRecord` narrows values to `Record<string, unknown>`; each field remains `unknown`.
+
+For network, config, IPC, persisted, or reused data shapes, parse once at the boundary with the project's schema validator and consume its named output type:
+
+```typescript
+const Config = z.object({ retries: z.number().int().nonnegative() });
+type Config = z.infer<typeof Config>;
+
+const config = Config.parse(raw);
+```
+
+If the runtime shape is uncertain, check the properties you use with `typeof`, `Array.isArray`, `in`, or a discriminant. If an existing invariant guarantees the shape, assert the named type at that boundary instead of duplicating a guard:
+
+```typescript
+const config = value as Config;
+```
+
+## Avoid
+
+```typescript
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+	value !== null && typeof value === "object";
+```
+
+## Exceptions
+
+A standalone package without a shared type-guard module may define its single canonical guard. Export it from the package's type-guard module; never recreate it at individual call sites.