pi-crew 0.9.16 → 0.9.17

package/src/runtime/process-status.ts

@@ -1,5 +1,6 @@
-import type { CrewAgentRecord } from "./crew-agent-runtime.ts";
 import type { TeamRunManifest } from "../state/types.ts";
+import type { CrewAgentRecord } from "./crew-agent-runtime.ts";
+
 export { hasAsyncStartMarker } from "./async-marker.ts";
 
 export interface ProcessLiveness {
@@ -34,7 +35,12 @@ export function checkProcessLiveness(pid: number | undefined): ProcessLiveness {
 		return { pid, alive: true, detail: "process is alive" };
 	} catch (error) {
 		const nodeError = error as NodeJS.ErrnoException;
-		if (nodeError.code === "EPERM") return { pid, alive: true, detail: "process exists but permission is denied" };
+		if (nodeError.code === "EPERM")
+			return {
+				pid,
+				alive: true,
+				detail: "process exists but permission is denied",
+			};
 		if (nodeError.code === "ESRCH") return { pid, alive: false, detail: "process does not exist" };
 		const message = error instanceof Error ? error.message : String(error);
 		return { pid, alive: false, detail: message };
@@ -56,7 +62,12 @@ export function isFinishedRunStatus(status: string): boolean {
  */
 const ORPHANED_NO_PROGRESS_MS = 5 * 60 * 1000;
 
-export function isLikelyOrphanedActiveRun(run: TeamRunManifest, agents: CrewAgentRecord[] = [], now = Date.now(), staleMs = ORPHANED_ACTIVE_RUN_MS): boolean {
+export function isLikelyOrphanedActiveRun(
+	run: TeamRunManifest,
+	agents: CrewAgentRecord[] = [],
+	now = Date.now(),
+	staleMs = ORPHANED_ACTIVE_RUN_MS,
+): boolean {
 	if (!isActiveRunStatus(run.status)) return false;
 	if (run.async?.pid !== undefined) return false;
 	const updatedAt = new Date(run.updatedAt).getTime();
@@ -91,8 +102,8 @@ function hasDurableActiveAgentEvidence(agent: CrewAgentRecord): boolean {
 		// spawned-but-never-executed agents should not appear as active.
 		return Boolean(
 			(agent.progress && (agent.progress.toolCount > 0 || agent.progress.recentOutput.length > 0)) ||
-			(agent.jsonEvents && agent.jsonEvents > 0) ||
-			(agent.toolUses && agent.toolUses > 0),
+				(agent.jsonEvents && agent.jsonEvents > 0) ||
+				(agent.toolUses && agent.toolUses > 0),
 		);
 	}
 	return false;

package/src/runtime/progress-event-coalescer.ts

@@ -38,6 +38,7 @@ export function shouldAppendProgressEventUpdate(input: ProgressEventCoalesceInpu
 	if (numericIncrease(input.previous.turns, input.next.turns) > 0) return { shouldAppend: true, reason: "turns_increased" };
 	const tokenIncrease = numericIncrease(input.previous.tokens, input.next.tokens);
 	if (tokenIncrease >= (input.tokenThreshold ?? DEFAULT_TOKEN_THRESHOLD)) return { shouldAppend: true, reason: "tokens_increased" };
-	if (input.lastAppendMs === undefined || input.nowMs - input.lastAppendMs >= input.minIntervalMs) return { shouldAppend: true, reason: "interval" };
+	if (input.lastAppendMs === undefined || input.nowMs - input.lastAppendMs >= input.minIntervalMs)
+		return { shouldAppend: true, reason: "interval" };
 	return { shouldAppend: false, reason: "coalesced" };
 }

package/src/runtime/progress-tracker.ts

@@ -2,123 +2,123 @@ import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import { crewEventBus } from "../observability/event-bus.ts";
 
 export interface AgentProgress {
-  toolCalls: number;
-  currentTool: string | null;
-  toolStartTime: number | null;
-  errors: string[];
-  turns: number;
-  tokens: { input: number; output: number };
-  status: "idle" | "running" | "completed" | "error";
+	toolCalls: number;
+	currentTool: string | null;
+	toolStartTime: number | null;
+	errors: string[];
+	turns: number;
+	tokens: { input: number; output: number };
+	status: "idle" | "running" | "completed" | "error";
 }
 
 export class ProgressTracker {
-  private sessions = new Map<string, {
-    unsubscribe: () => void;
-    progress: AgentProgress;
-  }>();
+	private sessions = new Map<
+		string,
+		{
+			unsubscribe: () => void;
+			progress: AgentProgress;
+		}
+	>();
 
-  track(
-    session: { subscribe: (listener: (event: AgentSessionEvent) => void) => () => void },
-    agentId: string,
-    runId: string
-  ): AgentProgress {
-    if (this.sessions.has(agentId)) {
-      return this.sessions.get(agentId)!.progress;
-    }
+	track(
+		session: {
+			subscribe: (listener: (event: AgentSessionEvent) => void) => () => void;
+		},
+		agentId: string,
+		runId: string,
+	): AgentProgress {
+		if (this.sessions.has(agentId)) {
+			return this.sessions.get(agentId)!.progress;
+		}
 
-    const progress: AgentProgress = {
-      toolCalls: 0,
-      currentTool: null,
-      toolStartTime: null,
-      errors: [],
-      turns: 0,
-      tokens: { input: 0, output: 0 },
-      status: "running",
-    };
+		const progress: AgentProgress = {
+			toolCalls: 0,
+			currentTool: null,
+			toolStartTime: null,
+			errors: [],
+			turns: 0,
+			tokens: { input: 0, output: 0 },
+			status: "running",
+		};
 
-    const unsubscribe = session.subscribe((event: AgentSessionEvent) => {
-      this.handleEvent(event, progress, agentId, runId);
-    });
+		const unsubscribe = session.subscribe((event: AgentSessionEvent) => {
+			this.handleEvent(event, progress, agentId, runId);
+		});
 
-    this.sessions.set(agentId, { unsubscribe, progress });
-    return progress;
-  }
+		this.sessions.set(agentId, { unsubscribe, progress });
+		return progress;
+	}
 
-  private handleEvent(
-    event: AgentSessionEvent,
-    progress: AgentProgress,
-    agentId: string,
-    runId: string
-  ): void {
-    switch (event.type) {
-      case "tool_execution_start":
-        progress.toolCalls++;
-        progress.currentTool = event.toolName;
-        progress.toolStartTime = Date.now();
-        crewEventBus.emit({
-          type: "agent:progress",
-          runId,
-          agentId,
-          payload: { ...progress },
-          timestamp: Date.now(),
-        });
-        break;
+	private handleEvent(event: AgentSessionEvent, progress: AgentProgress, agentId: string, runId: string): void {
+		switch (event.type) {
+			case "tool_execution_start":
+				progress.toolCalls++;
+				progress.currentTool = event.toolName;
+				progress.toolStartTime = Date.now();
+				crewEventBus.emit({
+					type: "agent:progress",
+					runId,
+					agentId,
+					payload: { ...progress },
+					timestamp: Date.now(),
+				});
+				break;
 
-      case "tool_execution_end":
-        progress.currentTool = null;
-        progress.toolStartTime = null;
-        if (event.isError) {
-          progress.errors.push(String(event.result ?? "Unknown error"));
-          crewEventBus.emit({
-            type: "agent:error",
-            runId,
-            agentId,
-            payload: String(event.result ?? "Unknown error"),
-            timestamp: Date.now(),
-          });
-        }
-        crewEventBus.emit({
-          type: "agent:progress",
-          runId,
-          agentId,
-          payload: { ...progress },
-          timestamp: Date.now(),
-        });
-        break;
+			case "tool_execution_end":
+				progress.currentTool = null;
+				progress.toolStartTime = null;
+				if (event.isError) {
+					progress.errors.push(String(event.result ?? "Unknown error"));
+					crewEventBus.emit({
+						type: "agent:error",
+						runId,
+						agentId,
+						payload: String(event.result ?? "Unknown error"),
+						timestamp: Date.now(),
+					});
+				}
+				crewEventBus.emit({
+					type: "agent:progress",
+					runId,
+					agentId,
+					payload: { ...progress },
+					timestamp: Date.now(),
+				});
+				break;
 
-      case "turn_start":
-        progress.turns++;
-        break;
+			case "turn_start":
+				progress.turns++;
+				break;
 
-      case "agent_end":
-        progress.status = "completed";
-        crewEventBus.emit({
-          type: "agent:complete",
-          runId,
-          agentId,
-          payload: { ...progress },
-          timestamp: Date.now(),
-        });
-        break;
+			case "agent_end":
+				progress.status = "completed";
+				crewEventBus.emit({
+					type: "agent:complete",
+					runId,
+					agentId,
+					payload: { ...progress },
+					timestamp: Date.now(),
+				});
+				break;
 
-      case "agent_start":
-        progress.status = "running";
-        break;
-    }
-  }
+			case "agent_start":
+				progress.status = "running";
+				break;
+		}
+	}
 
-  untrack(agentId: string): void {
-    const tracked = this.sessions.get(agentId);
-    if (tracked) {
-      tracked.unsubscribe();
-      this.sessions.delete(agentId);
-    }
-  }
+	untrack(agentId: string): void {
+		const tracked = this.sessions.get(agentId);
+		if (tracked) {
+			tracked.unsubscribe();
+			this.sessions.delete(agentId);
+		}
+	}
 
-  getProgress(agentId: string): AgentProgress | undefined {
-    return this.sessions.get(agentId)?.progress;
-  }
+	getProgress(agentId: string): AgentProgress | undefined {
+		return this.sessions.get(agentId)?.progress;
+	}
 }
 
 // Export singleton instance
-export const globalProgressTracker = new ProgressTracker();
+export const globalProgressTracker = new ProgressTracker();

package/src/runtime/prose-compressor.ts

@@ -14,14 +14,14 @@
 // ---------------------------------------------------------------------------
 
 const PROTECTED_PATTERNS: readonly RegExp[] = [
-	/```[\s\S]*?```/g,                                    // fenced code blocks
-	/`[^`\n]+`/g,                                         // inline code
-	/\bhttps?:\/\/\S+/gi,                                 // URLs
-	/\b[\w.-]*[/\\][\w./\\-]+/g,                       // paths with / or \
-	/\b[A-Z][A-Z0-9]*(?:_[A-Z][A-Z0-9]*)+\b/g,           // CONSTANT_CASE
-	/\b\w+(?:\.\w+)+\(\)/g,                               // dotted.method() calls
-	/[A-Za-z_][A-Za-z0-9_]*\s*\([^)]*\)/g,                // function calls: name(args)
-	/\b\d+\.\d+\.\d+\b/g,                                 // version numbers x.y.z
+	/```[\s\S]*?```/g, // fenced code blocks
+	/`[^`\n]+`/g, // inline code
+	/\bhttps?:\/\/\S+/gi, // URLs
+	/\b[\w.-]*[/\\][\w./\\-]+/g, // paths with / or \
+	/\b[A-Z][A-Z0-9]*(?:_[A-Z][A-Z0-9]*)+\b/g, // CONSTANT_CASE
+	/\b\w+(?:\.\w+)+\(\)/g, // dotted.method() calls
+	/[A-Za-z_][A-Za-z0-9_]*\s*\([^)]*\)/g, // function calls: name(args)
+	/\b\d+\.\d+\.\d+\b/g, // version numbers x.y.z
 ];
 
 // ---------------------------------------------------------------------------
@@ -143,9 +143,7 @@ export function compressProse(text: string): CompressResult {
 
 	const originalLength = text.length;
 	const compressedLength = restored.length;
-	const savingsPercent = originalLength > 0
-		? Math.round(((originalLength - compressedLength) / originalLength) * 100 * 100) / 100
-		: 0;
+	const savingsPercent = originalLength > 0 ? Math.round(((originalLength - compressedLength) / originalLength) * 100 * 100) / 100 : 0;
 
 	return {
 		compressed: restored,

package/src/runtime/recovery-recipes.ts

@@ -1,7 +1,27 @@
 import type { PolicyDecision, PolicyDecisionReason } from "../state/types.ts";
 
-export type FailureScenario = "trust_prompt_unresolved" | "prompt_misdelivery" | "stale_branch" | "compile_red_cross_crate" | "mcp_handshake_failure" | "partial_plugin_startup" | "provider_failure" | "task_failed" | "worker_stale" | "green_unsatisfied";
-export type RecoveryStep = "accept_trust_prompt" | "redirect_prompt_to_agent" | "rebase_branch" | "clean_build" | "retry_mcp_handshake" | "restart_plugin" | "restart_worker" | "rerun_task" | "collect_verification_evidence" | "escalate_to_human";
+export type FailureScenario =
+	| "trust_prompt_unresolved"
+	| "prompt_misdelivery"
+	| "stale_branch"
+	| "compile_red_cross_crate"
+	| "mcp_handshake_failure"
+	| "partial_plugin_startup"
+	| "provider_failure"
+	| "task_failed"
+	| "worker_stale"
+	| "green_unsatisfied";
+export type RecoveryStep =
+	| "accept_trust_prompt"
+	| "redirect_prompt_to_agent"
+	| "rebase_branch"
+	| "clean_build"
+	| "retry_mcp_handshake"
+	| "restart_plugin"
+	| "restart_worker"
+	| "rerun_task"
+	| "collect_verification_evidence"
+	| "escalate_to_human";
 export type RecoveryResultState = "planned" | "skipped" | "escalation_required";
 
 export interface RecoveryRecipe {
@@ -28,26 +48,91 @@ export interface RecoveryLedger {
 
 export function scenarioForPolicyReason(reason: PolicyDecisionReason): FailureScenario {
 	switch (reason) {
-		case "branch_stale": return "stale_branch";
-		case "worker_stale": return "worker_stale";
-		case "green_unsatisfied": return "green_unsatisfied";
-		case "task_failed": return "task_failed";
-		default: return "provider_failure";
+		case "branch_stale":
+			return "stale_branch";
+		case "worker_stale":
+			return "worker_stale";
+		case "green_unsatisfied":
+			return "green_unsatisfied";
+		case "task_failed":
+			return "task_failed";
+		default:
+			return "provider_failure";
 	}
 }
 
 export function recipeFor(scenario: FailureScenario): RecoveryRecipe {
 	switch (scenario) {
-		case "trust_prompt_unresolved": return { scenario, steps: ["accept_trust_prompt"], maxAttempts: 1, escalationPolicy: "alert_human" };
-		case "prompt_misdelivery": return { scenario, steps: ["redirect_prompt_to_agent"], maxAttempts: 1, escalationPolicy: "alert_human" };
-		case "stale_branch": return { scenario, steps: ["rebase_branch", "clean_build"], maxAttempts: 1, escalationPolicy: "alert_human" };
-		case "compile_red_cross_crate": return { scenario, steps: ["clean_build"], maxAttempts: 1, escalationPolicy: "alert_human" };
-		case "mcp_handshake_failure": return { scenario, steps: ["retry_mcp_handshake"], maxAttempts: 1, escalationPolicy: "abort" };
-		case "partial_plugin_startup": return { scenario, steps: ["restart_plugin", "retry_mcp_handshake"], maxAttempts: 1, escalationPolicy: "log_and_continue" };
-		case "worker_stale": return { scenario, steps: ["restart_worker"], maxAttempts: 1, escalationPolicy: "alert_human" };
-		case "green_unsatisfied": return { scenario, steps: ["collect_verification_evidence"], maxAttempts: 1, escalationPolicy: "alert_human" };
-		case "task_failed": return { scenario, steps: ["rerun_task"], maxAttempts: 1, escalationPolicy: "alert_human" };
-		case "provider_failure": return { scenario, steps: ["restart_worker"], maxAttempts: 1, escalationPolicy: "alert_human" };
+		case "trust_prompt_unresolved":
+			return {
+				scenario,
+				steps: ["accept_trust_prompt"],
+				maxAttempts: 1,
+				escalationPolicy: "alert_human",
+			};
+		case "prompt_misdelivery":
+			return {
+				scenario,
+				steps: ["redirect_prompt_to_agent"],
+				maxAttempts: 1,
+				escalationPolicy: "alert_human",
+			};
+		case "stale_branch":
+			return {
+				scenario,
+				steps: ["rebase_branch", "clean_build"],
+				maxAttempts: 1,
+				escalationPolicy: "alert_human",
+			};
+		case "compile_red_cross_crate":
+			return {
+				scenario,
+				steps: ["clean_build"],
+				maxAttempts: 1,
+				escalationPolicy: "alert_human",
+			};
+		case "mcp_handshake_failure":
+			return {
+				scenario,
+				steps: ["retry_mcp_handshake"],
+				maxAttempts: 1,
+				escalationPolicy: "abort",
+			};
+		case "partial_plugin_startup":
+			return {
+				scenario,
+				steps: ["restart_plugin", "retry_mcp_handshake"],
+				maxAttempts: 1,
+				escalationPolicy: "log_and_continue",
+			};
+		case "worker_stale":
+			return {
+				scenario,
+				steps: ["restart_worker"],
+				maxAttempts: 1,
+				escalationPolicy: "alert_human",
+			};
+		case "green_unsatisfied":
+			return {
+				scenario,
+				steps: ["collect_verification_evidence"],
+				maxAttempts: 1,
+				escalationPolicy: "alert_human",
+			};
+		case "task_failed":
+			return {
+				scenario,
+				steps: ["rerun_task"],
+				maxAttempts: 1,
+				escalationPolicy: "alert_human",
+			};
+		case "provider_failure":
+			return {
+				scenario,
+				steps: ["restart_worker"],
+				maxAttempts: 1,
+				escalationPolicy: "alert_human",
+			};
 	}
 }
 
@@ -93,17 +178,26 @@ export interface RerunDecision {
 	reason: string;
 }
 
-export function shouldRerunFailedTask(
-	task: { policy?: { retryCount?: number } },
-	limits?: { maxRetriesPerTask?: number },
-): RerunDecision {
+export function shouldRerunFailedTask(task: { policy?: { retryCount?: number } }, limits?: { maxRetriesPerTask?: number }): RerunDecision {
 	const maxRetries = limits?.maxRetriesPerTask ?? 0;
 	const retryCount = task.policy?.retryCount ?? 0;
 	if (maxRetries <= 0) {
-		return { rerun: false, newRetryCount: retryCount, reason: "maxRetriesPerTask not set (opt-in) — no whole-task rerun" };
+		return {
+			rerun: false,
+			newRetryCount: retryCount,
+			reason: "maxRetriesPerTask not set (opt-in) — no whole-task rerun",
+		};
 	}
 	if (retryCount >= maxRetries) {
-		return { rerun: false, newRetryCount: retryCount, reason: `retryCount ${retryCount} >= maxRetriesPerTask ${maxRetries} — rerun budget exhausted` };
+		return {
+			rerun: false,
+			newRetryCount: retryCount,
+			reason: `retryCount ${retryCount} >= maxRetriesPerTask ${maxRetries} — rerun budget exhausted`,
+		};
 	}
-	return { rerun: true, newRetryCount: retryCount + 1, reason: `whole-task rerun ${retryCount + 1}/${maxRetries}` };
+	return {
+		rerun: true,
+		newRetryCount: retryCount + 1,
+		reason: `whole-task rerun ${retryCount + 1}/${maxRetries}`,
+	};
 }

package/src/runtime/replace.ts

@@ -462,12 +462,7 @@ const REPLACERS: Replacer[] = [
  *   occurrences. Only safe for exact matches (simple replacer).
  * @returns ReplaceResult with the new content and match strategy info.
  */
-export function replace(
-	content: string,
-	oldString: string,
-	newString: string,
-	options?: { replaceAll?: boolean },
-): ReplaceResult {
+export function replace(content: string, oldString: string, newString: string, options?: { replaceAll?: boolean }): ReplaceResult {
 	if (oldString.length === 0) {
 		return { content, changed: false, strategy: "none", count: 0 };
 	}
@@ -482,7 +477,12 @@ export function replace(
 		const result = content.replaceAll(oldString, newString);
 		if (result !== content) {
 			const count = countOccurrences(content, oldString);
-			return { content: result, changed: true, strategy: "simple-replaceAll", count };
+			return {
+				content: result,
+				changed: true,
+				strategy: "simple-replaceAll",
+				count,
+			};
 		}
 	}
 
@@ -494,7 +494,12 @@ export function replace(
 			if (idx === lastIdx) {
 				// Exactly one occurrence
 				const result = content.slice(0, idx) + newString + content.slice(idx + oldString.length);
-				return { content: result, changed: true, strategy: "simple", count: 1 };
+				return {
+					content: result,
+					changed: true,
+					strategy: "simple",
+					count: 1,
+				};
 			}
 			// Multiple occurrences — fall through to fuzzy strategies
 			// (we never auto-pick among duplicates)
@@ -529,7 +534,12 @@ export function replace(
 					.replace("Replacer", "")
 					.replace(/([a-z])([A-Z])/g, "$1-$2")
 					.toLowerCase();
-				return { content: result, changed: true, strategy: `${strategyName}-replaceAll`, count: totalCount };
+				return {
+					content: result,
+					changed: true,
+					strategy: `${strategyName}-replaceAll`,
+					count: totalCount,
+				};
 			}
 			continue;
 		}
@@ -544,7 +554,12 @@ export function replace(
 					.replace("Replacer", "")
 					.replace(/([a-z])([A-Z])/g, "$1-$2")
 					.toLowerCase();
-				return { content: result, changed: true, strategy: strategyName, count: 1 };
+				return {
+					content: result,
+					changed: true,
+					strategy: strategyName,
+					count: 1,
+				};
 			}
 		}
 		// Multiple candidates — skip this strategy (safety first)

package/src/runtime/resilient-edit.ts

@@ -23,7 +23,7 @@
  *   }
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { replace, type ReplaceResult } from "../runtime/replace.ts";
+import { type ReplaceResult, replace } from "../runtime/replace.ts";
 
 interface ToolLike {
 	name: string;
@@ -50,13 +50,7 @@ interface EditResult {
 	[key: string]: unknown;
 }
 
-const NOT_FOUND_PATTERNS = [
-	/old_string not found/i,
-	/oldstring not found/i,
-	/no match/i,
-	/could not find/i,
-	/string not found/i,
-];
+const NOT_FOUND_PATTERNS = [/old_string not found/i, /oldstring not found/i, /no match/i, /could not find/i, /string not found/i];
 
 function isNotFoundResult(result: unknown): boolean {
 	if (!result || typeof result !== "object") return false;
@@ -72,7 +66,7 @@ function isPiDiffLoaded(pi: ExtensionAPI): boolean {
 		const piAny = pi as any;
 		const extensions = piAny?.extensions ?? piAny?._extensions ?? [];
 		const names = Array.isArray(extensions)
-			? extensions.map((e: unknown) => (typeof e === "string" ? e : (e as { name?: string })?.name ?? ""))
+			? extensions.map((e: unknown) => (typeof e === "string" ? e : ((e as { name?: string })?.name ?? "")))
 			: Object.keys(extensions);
 		return names.some((n: string) => typeof n === "string" && n.includes("pi-diff"));
 	} catch {
@@ -94,7 +88,7 @@ export function wrapEditWithResilientReplace(pi: ExtensionAPI, tools?: { edit: T
 		return false;
 	}
 
-	const t = tools ?? ((pi as unknown as { tools?: { edit?: ToolLike } }).tools);
+	const t = tools ?? (pi as unknown as { tools?: { edit?: ToolLike } }).tools;
 	if (!t?.edit?.execute) return false;
 
 	const nativeExecute = t.edit.execute.bind(t.edit);
@@ -117,12 +111,7 @@ export function wrapEditWithResilientReplace(pi: ExtensionAPI, tools?: { edit: T
 
 	return true;
 
-	async function retryWithReplace(
-		params: EditParams,
-		toolCallId: string,
-		signal: any,
-		onUpdate: any,
-	): Promise<unknown> {
+	async function retryWithReplace(params: EditParams, toolCallId: string, signal: any, onUpdate: any): Promise<unknown> {
 		const filePath = params.path ?? params.filePath;
 		const oldStr = params.oldString ?? params.old_string;
 		const newStr = params.newString ?? params.new_string;
@@ -139,18 +128,14 @@ export function wrapEditWithResilientReplace(pi: ExtensionAPI, tools?: { edit: T
 		try {
 			content = await fs.readFile(filePath, "utf8");
 		} catch (readErr) {
-			throw new Error(
-				`resilient edit: could not read ${filePath}: ${
-					readErr instanceof Error ? readErr.message : String(readErr)
-				}`,
-			);
+			throw new Error(`resilient edit: could not read ${filePath}: ${readErr instanceof Error ? readErr.message : String(readErr)}`);
 		}
 
-		const result: ReplaceResult = replace(content, oldStr, newStr, { replaceAll });
+		const result: ReplaceResult = replace(content, oldStr, newStr, {
+			replaceAll,
+		});
 		if (!result.changed) {
-			throw new Error(
-				`old_string not found (resilient cascade exhausted, strategy=${result.strategy})`,
-			);
+			throw new Error(`old_string not found (resilient cascade exhausted, strategy=${result.strategy})`);
 		}
 
 		await fs.writeFile(filePath, result.content, "utf8");

package/src/runtime/result-extractor.ts

@@ -177,8 +177,7 @@ function tryMarkerExtraction(text: string): unknown | undefined {
 				if (jsonEnd > 0) {
 					try {
 						return JSON.parse(after.slice(0, jsonEnd));
-					} catch {
-					}
+					} catch {}
 				}
 			}
 		}