@gajae-code/coding-agent 0.14.2 → 0.15.0

package/src/crash/index-store.ts

@@ -78,6 +78,9 @@ export interface CrashSignatureEntry {
 	relayedAt?: number;
 	/** Occurrence record represented by the durable upstream watermark. */
 	relayedRecordId?: string;
+	/** Refusal marker for the exact record and sanitizer contract. */
+	relayRefusedRecordId?: string;
+	relayRefusedVersion?: string;
 	/** Issues this install already "+1"ed, so re-invocations cannot spam comments. */
 	commentedIssues?: string[];
 }
@@ -151,6 +154,8 @@ const ENTRY_KEYS = new Set([
 	"acknowledgedAt",
 	"relayedAt",
 	"relayedRecordId",
+	"relayRefusedRecordId",
+	"relayRefusedVersion",
 	"commentedIssues",
 ]);
 const INDEX_KEYS = new Set([
@@ -240,6 +245,12 @@ function parseEntry(value: unknown, now: number): CrashSignatureEntry | undefine
 		(typeof raw.lastAppendRecordId !== "string" || !/^[0-9a-f]{8,32}$/.test(raw.lastAppendRecordId))
 	)
 		return undefined;
+	if (
+		raw.relayRefusedRecordId !== undefined &&
+		(typeof raw.relayRefusedRecordId !== "string" || !/^[0-9a-f]{8,32}$/.test(raw.relayRefusedRecordId))
+	)
+		return undefined;
+	if (raw.relayRefusedVersion !== undefined && !isCleanString(raw.relayRefusedVersion, 64)) return undefined;
 	if (raw.reportedAt !== undefined && !isTimestamp(raw.reportedAt, now)) return undefined;
 	if (raw.acknowledgedAt !== undefined && !isTimestamp(raw.acknowledgedAt, now)) return undefined;
 	if (raw.relayedAt !== undefined && !isTimestamp(raw.relayedAt, now)) return undefined;
@@ -262,21 +273,49 @@ function parseEntry(value: unknown, now: number): CrashSignatureEntry | undefine
 		firstSeen: raw.firstSeen,
 		lastSeen: raw.lastSeen,
 		lastRecordId: raw.lastRecordId,
-		lastAppendRecordId: typeof raw.lastAppendRecordId === "string" ? raw.lastAppendRecordId : raw.lastRecordId,
+		// Legacy entries do not carry append order. Keep it absent until a new
+		// journal occurrence supplies authoritative append-order evidence.
+		...(typeof raw.lastAppendRecordId === "string" ? { lastAppendRecordId: raw.lastAppendRecordId } : {}),
 	};
-	if (raw.reportedAt !== undefined) entry.reportedAt = raw.reportedAt;
-	if (raw.reportedIssueUrl !== undefined) entry.reportedIssueUrl = raw.reportedIssueUrl;
-	if (raw.acknowledgedAt !== undefined) entry.acknowledgedAt = raw.acknowledgedAt;
-	if (raw.relayedAt !== undefined) entry.relayedAt = raw.relayedAt;
-	if (raw.relayedRecordId !== undefined) entry.relayedRecordId = raw.relayedRecordId;
-	if (raw.commentedIssues !== undefined) entry.commentedIssues = [...(raw.commentedIssues as string[])];
-	if (Buffer.byteLength(JSON.stringify(entry), "utf8") > CRASH_INDEX_ENTRY_MAX_BYTES) {
-		// A legacy entry may already occupy the complete serialized budget. The
-		// derived append watermark is redundant for that format, because the old
-		// lastRecordId remains the only known append-order id. Keep the entry
-		// readable rather than quarantining an otherwise valid index during upgrade.
-		if (raw.lastAppendRecordId === undefined) delete entry.lastAppendRecordId;
+	// Preserve idempotency and append-order watermarks before display metadata.
+	// A legacy entry may be exactly at the 1 KiB cap; dropping these fields would
+	// make a successful relay/comment look new on every subsequent invocation.
+	const optional: readonly [keyof CrashSignatureEntry, unknown][] = [
+		["relayedAt", raw.relayedAt],
+		["relayedRecordId", raw.relayedRecordId],
+		["relayRefusedRecordId", raw.relayRefusedRecordId],
+		["relayRefusedVersion", raw.relayRefusedVersion],
+		["commentedIssues", raw.commentedIssues === undefined ? undefined : [...(raw.commentedIssues as string[])]],
+		["reportedAt", raw.reportedAt],
+		["reportedIssueUrl", raw.reportedIssueUrl],
+		["acknowledgedAt", raw.acknowledgedAt],
+	];
+	for (const [key, value] of optional) {
+		if (value === undefined) continue;
+		if (key === "commentedIssues" && Array.isArray(value)) {
+			// Keep the newest idempotency markers that fit.  Silently dropping the
+			// whole list would make a capped entry comment the same issue again.
+			for (let start = 0; start < value.length; start++) {
+				const candidate = { ...entry, [key]: value.slice(start) };
+				if (Buffer.byteLength(JSON.stringify(candidate), "utf8") <= CRASH_INDEX_ENTRY_MAX_BYTES) {
+					(entry as unknown as Record<string, unknown>)[key] = value.slice(start);
+					break;
+				}
+			}
+			continue;
+		}
+		const candidate = { ...entry, [key]: value };
+		if (Buffer.byteLength(JSON.stringify(candidate), "utf8") <= CRASH_INDEX_ENTRY_MAX_BYTES)
+			(entry as unknown as Record<string, unknown>)[key] = value;
 	}
+	if (raw.relayedRecordId !== undefined && entry.relayedRecordId !== raw.relayedRecordId) return undefined;
+	if (raw.relayRefusedRecordId !== undefined && entry.relayRefusedRecordId !== raw.relayRefusedRecordId)
+		return undefined;
+	if (raw.relayRefusedVersion !== undefined && entry.relayRefusedVersion !== raw.relayRefusedVersion) return undefined;
+	// A legacy entry may be exactly at the cap.  Display/report metadata is
+	// bounded normalization fodder, so it is safe to drop when upgrading it;
+	// refusing the whole entry would lose the occurrence and make a later
+	// journal merge quarantine an otherwise valid index.
 	if (Buffer.byteLength(JSON.stringify(entry), "utf8") > CRASH_INDEX_ENTRY_MAX_BYTES) return undefined;
 	return entry;
 }
@@ -474,6 +513,51 @@ function evictOne(index: CrashIndex): boolean {
 	return true;
 }
 
+/**
+ * Add a refusal watermark without allowing optional presentation/report data
+ * to make the entry unpersistable at the hard 1 KiB boundary.  The marker is
+ * the durable safety property; older display metadata is deliberately the
+ * first thing sacrificed.  Build the candidate first so callers never see a
+ * partially-mutated entry when even the mandatory fields cannot fit.
+ */
+function normalizeEntryForPersistence(candidate: CrashSignatureEntry): CrashSignatureEntry | undefined {
+	const fits = (value: CrashSignatureEntry): boolean =>
+		Buffer.byteLength(JSON.stringify(value), "utf8") <= CRASH_INDEX_ENTRY_MAX_BYTES;
+	if (fits(candidate)) return candidate;
+	if (candidate.commentedIssues !== undefined) {
+		for (let start = 0; start < candidate.commentedIssues.length; start++) {
+			const trimmed = { ...candidate, commentedIssues: candidate.commentedIssues.slice(start) };
+			if (fits(trimmed)) return trimmed;
+		}
+	}
+
+	// Report/display metadata is advisory and can be reconstructed from the
+	// journal or re-entered by the user. Relay watermarks are intentionally not
+	// in this list: dropping one would make a successful/refused batch repeat.
+	for (const key of ["commentedIssues", "reportedIssueUrl", "reportedAt", "acknowledgedAt"] as const) {
+		delete candidate[key];
+		if (fits(candidate)) return candidate;
+	}
+	// Keep the error identity while shrinking only its human-facing preview.
+	if (candidate.messageClass) {
+		candidate.messageClass = boundMessageClass(candidate.messageClass.slice(0, 128));
+		if (fits(candidate)) return candidate;
+	}
+	return undefined;
+}
+
+function withRefusalWatermark(
+	existing: CrashSignatureEntry,
+	recordId: string,
+	contractVersion: string,
+): CrashSignatureEntry | undefined {
+	return normalizeEntryForPersistence({
+		...existing,
+		relayRefusedRecordId: recordId,
+		relayRefusedVersion: contractVersion,
+	});
+}
+
 /** Apply one journal event to the in-memory index. Returns whether it changed anything. */
 export function applyCrashEvent(index: CrashIndex, event: CrashEvent, now: number): boolean {
 	if (event.at > now + MAX_FUTURE_SKEW_MS || event.at < MIN_TIMESTAMP_MS) return false;
@@ -511,6 +595,16 @@ export function applyCrashEvent(index: CrashIndex, event: CrashEvent, now: numbe
 		}
 		return true;
 	}
+	if (event.kind === "refused") {
+		if (!existing || existing.fpv !== event.fpv) return false;
+		if (existing.relayRefusedRecordId === event.recordId && existing.relayRefusedVersion === event.contractVersion)
+			return false;
+		const updated = withRefusalWatermark(existing, event.recordId, event.contractVersion);
+		if (!updated) return false;
+		for (const key of Object.keys(existing)) delete (existing as unknown as Record<string, unknown>)[key];
+		Object.assign(existing, updated);
+		return true;
+	}
 	if (event.kind === "acknowledged") {
 		if (!existing) return false;
 		if (existing.acknowledgedAt !== undefined && existing.acknowledgedAt >= event.at) return false;
@@ -527,21 +621,28 @@ export function applyCrashEvent(index: CrashIndex, event: CrashEvent, now: numbe
 		return false;
 	}
 	if (index.recentEventIds.includes(event.recordId)) return false;
-	index.recentEventIds.push(event.recordId);
-	if (index.recentEventIds.length > RECENT_EVENT_ID_LIMIT)
-		index.recentEventIds.splice(0, index.recentEventIds.length - RECENT_EVENT_ID_LIMIT);
 	// A journal occurrence is newer authority than a prior eviction tombstone.
 	// Clear it before capacity eviction so a full retirement ledger cannot block
 	// the signature's explicit revival.
 	if (existing) {
-		existing.lifetimeCount += 1;
-		existing.firstSeen = Math.min(existing.firstSeen, event.at);
-		existing.lastAppendRecordId = event.recordId;
+		const updated: CrashSignatureEntry = {
+			...existing,
+			lifetimeCount: existing.lifetimeCount + 1,
+			firstSeen: Math.min(existing.firstSeen, event.at),
+			lastAppendRecordId: event.recordId,
+		};
 		if (event.at >= existing.lastSeen) {
-			existing.lastSeen = event.at;
-			existing.lastRecordId = event.recordId;
-			if (event.messageClass) existing.messageClass = boundMessageClass(event.messageClass);
+			updated.lastSeen = event.at;
+			updated.lastRecordId = event.recordId;
+			if (event.messageClass) updated.messageClass = boundMessageClass(event.messageClass);
 		}
+		const normalized = normalizeEntryForPersistence(updated);
+		if (!normalized) return false;
+		for (const key of Object.keys(existing)) delete (existing as unknown as Record<string, unknown>)[key];
+		Object.assign(existing, normalized);
+		index.recentEventIds.push(event.recordId);
+		if (index.recentEventIds.length > RECENT_EVENT_ID_LIMIT)
+			index.recentEventIds.splice(0, index.recentEventIds.length - RECENT_EVENT_ID_LIMIT);
 		return true;
 	}
 	if (Object.keys(index.signatures).length >= CRASH_INDEX_MAX_SIGNATURES && !evictOne(index)) {
@@ -561,6 +662,9 @@ export function applyCrashEvent(index: CrashIndex, event: CrashEvent, now: numbe
 		lastRecordId: event.recordId,
 		lastAppendRecordId: event.recordId,
 	};
+	index.recentEventIds.push(event.recordId);
+	if (index.recentEventIds.length > RECENT_EVENT_ID_LIMIT)
+		index.recentEventIds.splice(0, index.recentEventIds.length - RECENT_EVENT_ID_LIMIT);
 	return true;
 }
 

package/src/crash/record-loader.ts

@@ -147,3 +147,10 @@ export function findLatestRecord(contents: string, fingerprint: string): LoadedC
 	const matches = parseCrashRecords(contents).filter(record => record.fingerprint === fingerprint);
 	return matches.at(-1);
 }
+
+/** Identity-bearing record bound to the indexed append-order identity. */
+export function findRecordById(contents: string, fingerprint: string, recordId: string): LoadedCrashRecord | undefined {
+	return parseRecoverableCrashRecords(contents).find(
+		record => record.fingerprint === fingerprint && record.recordId === recordId,
+	);
+}

package/src/crash/upstream/relay.ts

@@ -22,18 +22,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import {
-	getCrashEventsPath,
-	getCrashIndexPath,
-	getCrashLogPath,
-	getHandledErrorEventsPath,
-	getHandledErrorIndexPath,
-	getHandledErrorLogPath,
-	getTrustedAgentFile,
-	isProjectEnvDeclaration,
-	normalizeCrashFrames,
-	VERSION,
-} from "@gajae-code/utils";
+import { getTrustedAgentFile, normalizeCrashFrames, VERSION } from "@gajae-code/utils";
 import { $credentialEnv } from "@gajae-code/utils/env";
 import {
 	type CrashSignatureView,
@@ -42,10 +31,13 @@ import {
 	listCrashSignatures,
 	recordCrashStateEvent,
 } from "../index-store";
-import { findLatestRecord } from "../record-loader";
+import { findRecordById } from "../record-loader";
 import { parseSentryDsn, type SentryDsn } from "./dsn";
 import { buildCrashEnvelope, type CrashEventFrame, sentryAuthHeader } from "./envelope";
 
+/** Version of the complete sanitizer/egress contract persisted in refusals. */
+export const SANITIZER_EGRESS_CONTRACT_VERSION = "sanitize-external-crash-v1";
+
 /** Trusted environment variable form of the DSN, for CI and one-off runs. */
 export const CRASH_UPSTREAM_DSN_ENV = "GJC_CRASH_SENTRY_DSN";
 
@@ -56,6 +48,25 @@ export const CRASH_UPSTREAM_DSN_ENV = "GJC_CRASH_SENTRY_DSN";
 const MAX_RELAY_PER_RUN = 8;
 const RELAY_TIMEOUT_MS = 10_000;
 const RELAY_CLAIM_TTL_MS = RELAY_TIMEOUT_MS * 2;
+const CRASH_LOG_READ_MAX_BYTES = 1024 * 1024;
+const NOFOLLOW = typeof fs.constants.O_NOFOLLOW === "number" ? fs.constants.O_NOFOLLOW : 0;
+
+async function readCrashLogNoFollow(filePath: string): Promise<string | undefined> {
+	let handle: fs.FileHandle | undefined;
+	try {
+		handle = await fs.open(filePath, fs.constants.O_RDONLY | NOFOLLOW);
+		const stat = await handle.stat();
+		if (!stat.isFile()) return undefined;
+		const length = Math.min(stat.size, CRASH_LOG_READ_MAX_BYTES);
+		const buffer = Buffer.allocUnsafe(length);
+		await handle.read(buffer, 0, length, Math.max(0, stat.size - length));
+		return buffer.toString("utf8");
+	} catch {
+		return undefined;
+	} finally {
+		await handle?.close().catch(() => {});
+	}
+}
 
 export interface CrashRelayConfig {
 	readonly upstream: "off" | "sentry";
@@ -170,6 +181,18 @@ export function resolveRelayDsn(
  */
 export function isRelayDue(signature: CrashSignatureView): boolean {
 	const appendId = signature.lastAppendRecordId ?? signature.lastRecordId;
+	if (
+		signature.relayRefusedRecordId === appendId &&
+		signature.relayRefusedVersion === SANITIZER_EGRESS_CONTRACT_VERSION
+	)
+		return false;
+	// Modern entries with a durable relay record id use exact identity. Legacy
+	// entries upgraded from a wall-clock-only relay have no relayedRecordId, so
+	// retain their timestamp coverage compatibility until a new append exists.
+	if (signature.lastAppendRecordId !== undefined) {
+		if (signature.relayedRecordId !== undefined) return signature.relayedRecordId !== appendId;
+		return true;
+	}
 	if (signature.relayedRecordId !== undefined) {
 		if (signature.relayedRecordId === appendId) return false;
 		if (
@@ -195,26 +218,51 @@ function relayEventId(signature: CrashSignatureView): string {
 		.slice(0, 32);
 }
 
+async function persistRefusal(
+	paths: CrashStatePaths,
+	signature: CrashSignatureView,
+	now: () => number,
+): Promise<boolean> {
+	try {
+		const index = await recordCrashStateEvent(
+			{
+				kind: "refused",
+				fingerprint: signature.fingerprint,
+				fpv: signature.fpv,
+				recordId: relayAppendRecordId(signature),
+				contractVersion: SANITIZER_EGRESS_CONTRACT_VERSION,
+				at: signature.lastSeen,
+			},
+			{ paths, now: now() },
+		);
+		const entry = index.signatures[signature.fingerprint];
+		return (
+			entry?.relayRefusedRecordId === relayAppendRecordId(signature) &&
+			entry.relayRefusedVersion === SANITIZER_EGRESS_CONTRACT_VERSION
+		);
+	} catch {
+		return false;
+	}
+}
+
 /**
- * Automatic relay stores use the normal XDG state location only when the XDG
- * value came from a trusted environment. `dirs.ts` rejects checkout `.env`
- * declarations before resolving these paths, including dotenv-expanded values.
+ * Automatic relay always reads the trusted agent stores. XDG-aware paths remain
+ * available to ordinary crash state operations, but never select automatic-egress
+ * input files.
  */
 export function resolveTrustedRelayStatePaths(): CrashStatePaths {
-	const useTrustedAgent = isProjectEnvDeclaration("XDG_STATE_HOME");
 	return {
-		index: useTrustedAgent ? getTrustedAgentFile("gjc-crash-index.json") : getCrashIndexPath(),
-		events: useTrustedAgent ? getTrustedAgentFile("gjc-crash-events.jsonl") : getCrashEventsPath(),
-		crashLog: useTrustedAgent ? getTrustedAgentFile("gjc-crash.log") : getCrashLogPath(),
+		index: getTrustedAgentFile("gjc-crash-index.json"),
+		events: getTrustedAgentFile("gjc-crash-events.jsonl"),
+		crashLog: getTrustedAgentFile("gjc-crash.log"),
 	};
 }
 
 export function resolveTrustedHandledRelayStatePaths(): CrashStatePaths {
-	const useTrustedAgent = isProjectEnvDeclaration("XDG_STATE_HOME");
 	return {
-		index: useTrustedAgent ? getTrustedAgentFile("gjc-error-index.json") : getHandledErrorIndexPath(),
-		events: useTrustedAgent ? getTrustedAgentFile("gjc-error-events.jsonl") : getHandledErrorEventsPath(),
-		crashLog: useTrustedAgent ? getTrustedAgentFile("gjc-error.log") : getHandledErrorLogPath(),
+		index: getTrustedAgentFile("gjc-error-index.json"),
+		events: getTrustedAgentFile("gjc-error-events.jsonl"),
+		crashLog: getTrustedAgentFile("gjc-error.log"),
 	};
 }
 
@@ -292,10 +340,8 @@ export async function relayCrashSignatures(options: CrashRelayOptions): Promise<
 		.slice(0, limit);
 	if (signatures.length === 0) return { status: "skipped", reason: "nothing-to-relay" };
 
-	let crashLog = "";
-	try {
-		crashLog = await fs.readFile(paths.crashLog, "utf8");
-	} catch {
+	const crashLog = await readCrashLogNoFollow(paths.crashLog);
+	if (crashLog === undefined) {
 		// A missing or unreadable log means no stack to attach; the signature
 		// metadata alone is not worth a send.
 		return { status: "skipped", reason: "nothing-to-relay" };
@@ -314,9 +360,10 @@ export async function relayCrashSignatures(options: CrashRelayOptions): Promise<
 			if (claim.status === "failed") failed++;
 			continue;
 		}
-		const record = findLatestRecord(crashLog, signature.fingerprint);
-		if (!record) {
-			refused++;
+		const record = findRecordById(crashLog, signature.fingerprint, relayAppendRecordId(signature));
+		if (!record || record.fpv !== signature.fpv) {
+			if (await persistRefusal(paths, signature, now)) refused++;
+			else failed++;
 			await claim.release().catch(() => {});
 			continue;
 		}
@@ -324,8 +371,8 @@ export async function relayCrashSignatures(options: CrashRelayOptions): Promise<
 		const envelope = buildCrashEnvelope({
 			eventId,
 			fingerprint: signature.fingerprint,
-			errorName: signature.errorName,
-			messageClass: signature.messageClass,
+			errorName: record.errorName,
+			messageClass: record.messageClass,
 			frames: toEventFrames(record.body),
 			firstSeen: signature.firstSeen,
 			lastSeen: signature.lastSeen,
@@ -338,7 +385,8 @@ export async function relayCrashSignatures(options: CrashRelayOptions): Promise<
 		});
 		if (!envelope.ok) {
 			// Fail closed. Deliberately no retry with a reduced payload.
-			refused++;
+			if (await persistRefusal(paths, signature, now)) refused++;
+			else failed++;
 			await claim.release().catch(() => {});
 			continue;
 		}

package/src/cursor.ts

@@ -14,6 +14,14 @@ import type {
 	CursorExecHandlers as ICursorExecHandlers,
 	ToolResultMessage,
 } from "@gajae-code/ai/core";
+import {
+	piEscapeRegexLiteral,
+	piJoinPath,
+	piLimit,
+	piLsPath,
+	piReadPath,
+	piTimeout,
+} from "@gajae-code/ai/providers/cursor/exec-modern";
 import { sanitizeText } from "@gajae-code/utils";
 import { resolveToCwd } from "./tools/path-utils";
 
@@ -32,6 +40,8 @@ type CursorExecEventEmitter = (event: AgentEvent, dispatchedTool?: AgentTool) =>
 interface CursorExecBridgeOptions {
 	cwd: string;
 	tools: Map<string, AgentTool>;
+	getEditReplaceTool?: () => AgentTool | undefined;
+	createSearchTool?: (options: { context?: number; totalMatchLimit?: number }) => AgentTool | undefined;
 	getToolContext?: () => AgentToolContext | undefined;
 	emitEvent?: CursorExecEventEmitter;
 	createEventEmitter?: () => ((event: AgentEvent) => void) | undefined;
@@ -66,8 +76,9 @@ async function executeTool(
 	toolName: string,
 	toolCallId: string,
 	args: Record<string, unknown>,
+	overrideTool?: AgentTool,
 ): Promise<ToolResultMessage> {
-	const tool = options.tools.get(toolName);
+	const tool = overrideTool ?? options.tools.get(toolName);
 	if (!tool) {
 		const result = buildToolErrorResult(`Tool "${toolName}" not available`);
 		return createToolResultMessage(toolCallId, toolName, result, true);
@@ -109,6 +120,7 @@ async function executeTool(
 		result = buildToolErrorResult(message);
 		isError = true;
 	}
+	isError ||= result.isError === true;
 
 	const sanitizedFinalResult: AgentToolResult<unknown> = {
 		content: result.content.map(c => (c.type === "text" ? { ...c, text: sanitizeText(c.text) } : c)),
@@ -203,6 +215,13 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		this.shellStream = this.shellStream.bind(this);
 		this.diagnostics = this.diagnostics.bind(this);
 		this.mcp = this.mcp.bind(this);
+		this.piRead = this.piRead.bind(this);
+		this.piBash = this.piBash.bind(this);
+		this.piEdit = this.piEdit.bind(this);
+		this.piWrite = this.piWrite.bind(this);
+		this.piGrep = this.piGrep.bind(this);
+		this.piFind = this.piFind.bind(this);
+		this.piLs = this.piLs.bind(this);
 	}
 
 	#optionsForCall(): CursorExecBridgeOptions {
@@ -390,6 +409,70 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		return createToolResultMessage(toolCallId, toolName, result, isError);
 	}
 
+	async piRead(call: Parameters<NonNullable<ICursorExecHandlers["piRead"]>>[0]) {
+		const composed = piReadPath(call.args.path, call.args.offset, call.args.limit);
+		if (composed === null) {
+			return createToolResultMessage(call.toolCallId, "read", { content: [{ type: "text", text: "" }] }, false);
+		}
+		return executeTool(this.#optionsForCall(), "read", call.toolCallId, { path: composed });
+	}
+
+	async piBash(call: Parameters<NonNullable<ICursorExecHandlers["piBash"]>>[0]) {
+		return executeTool(this.#optionsForCall(), "bash", call.toolCallId, {
+			command: call.args.command,
+			timeout: piTimeout(call.args.timeout),
+		});
+	}
+
+	async piEdit(call: Parameters<NonNullable<ICursorExecHandlers["piEdit"]>>[0]) {
+		const edits = call.args.edits.map(edit => ({
+			old_text: edit.oldText,
+			new_text: edit.newText,
+		}));
+		return executeTool(
+			this.#optionsForCall(),
+			"edit",
+			call.toolCallId,
+			{ path: call.args.path, edits },
+			this.options.getEditReplaceTool?.(),
+		);
+	}
+
+	async piWrite(call: Parameters<NonNullable<ICursorExecHandlers["piWrite"]>>[0]) {
+		return executeTool(this.#optionsForCall(), "write", call.toolCallId, {
+			path: call.args.path,
+			content: call.args.content,
+		});
+	}
+
+	async piGrep(call: Parameters<NonNullable<ICursorExecHandlers["piGrep"]>>[0]) {
+		const { pattern, path, glob, ignoreCase, literal, context, limit } = call.args;
+		const perCallSearch = this.options.createSearchTool?.({
+			context: context === undefined ? undefined : Math.max(0, Math.floor(context)),
+			totalMatchLimit: piLimit(limit),
+		});
+		const args: Record<string, unknown> = {
+			pattern: literal === true ? piEscapeRegexLiteral(pattern) : pattern,
+			paths: [glob ? piJoinPath(path, glob) : path || "."],
+		};
+		if (ignoreCase === true) args.i = true;
+		return executeTool(this.#optionsForCall(), "search", call.toolCallId, args, perCallSearch);
+	}
+
+	async piFind(call: Parameters<NonNullable<ICursorExecHandlers["piFind"]>>[0]) {
+		const { pattern, path, limit } = call.args;
+		return executeTool(this.#optionsForCall(), "find", call.toolCallId, {
+			paths: [piJoinPath(path, pattern)],
+			limit: piLimit(limit),
+		});
+	}
+
+	async piLs(call: Parameters<NonNullable<ICursorExecHandlers["piLs"]>>[0]) {
+		return executeTool(this.#optionsForCall(), "read", call.toolCallId, {
+			path: piLsPath(call.args.path),
+		});
+	}
+
 	async diagnostics(args: Parameters<NonNullable<ICursorExecHandlers["diagnostics"]>>[0]) {
 		const toolCallId = decodeToolCallId(args.toolCallId);
 		const toolResultMessage = await executeTool(this.#optionsForCall(), "lsp", toolCallId, {

package/src/debug/index.ts

@@ -327,9 +327,27 @@ export class DebugSelectorComponent extends Container {
 	}
 
 	async #handleViewLogs(): Promise<void> {
+		// The selector restores the reusable composer synchronously before this
+		// async operation starts. Capture both the exact mounted child and the
+		// container revision so a stale completion cannot mistake a newer
+		// non-Container owner (RawSSE/Input) for the composer, or reclaim the
+		// same composer after a newer overlay has already opened and closed.
+		const expectedComposerMount =
+			this.ctx.editorContainer.children.length === 1 ? this.ctx.editorContainer.children[0] : undefined;
+		const expectedMountRevision = this.ctx.editorContainer.getRenderRevision();
 		try {
 			const logSource = await createDebugLogSource();
 			const logs = await logSource.getInitialText();
+			// The awaits above leave a window where a newer overlay can take over
+			// the editor container (or the UI can stop). Mount only when the exact
+			// child and the mount revision captured before the awaits still match.
+			if (
+				expectedComposerMount === undefined ||
+				this.ctx.editorContainer.getRenderRevision() !== expectedMountRevision ||
+				this.ctx.editorContainer.children.length !== 1 ||
+				this.ctx.editorContainer.children[0] !== expectedComposerMount
+			)
+				return;
 			if (!logs && !logSource.hasOlderLogs()) {
 				this.ctx.showWarning("No log entries found for today.");
 				return;
@@ -345,6 +363,10 @@ export class DebugSelectorComponent extends Container {
 				logSource,
 			});
 
+			// The composer is reusable across overlays; detach it before clearing
+			// so clear() disposes only the transient viewer, not the editor's
+			// tab-width listener (disposal is terminal).
+			this.ctx.editorContainer.detachChild(this.ctx.editor);
 			this.ctx.editorContainer.clear();
 			this.ctx.editorContainer.addChild(viewer);
 			this.ctx.ui.setFocus(viewer);
@@ -364,6 +386,10 @@ export class DebugSelectorComponent extends Container {
 			onUpdate: () => this.ctx.ui.requestRender(),
 		});
 
+		// The composer is reusable across overlays; detach it before clearing
+		// so clear() disposes only the transient viewer, not the editor's
+		// tab-width listener (disposal is terminal).
+		this.ctx.editorContainer.detachChild(this.ctx.editor);
 		this.ctx.editorContainer.clear();
 		this.ctx.editorContainer.addChild(viewer);
 		this.ctx.ui.setFocus(viewer);