@fitchmultz/pi-subagents 0.0.0-stage → 0.44.5

package/src/runs/shared/child-execution-cwd.ts

@@ -0,0 +1,91 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+const RESOLVE_CWD = "pi-change-working-dir:resolve-execution-cwd";
+const SET_CWD = "pi-change-working-dir:set-execution-cwd";
+const intentPath = (sessionFile: string): string => `${sessionFile}.subagent-cwd-init`;
+type CwdIntent = { cwd?: string };
+type CwdRequest = { sessionManager: ExtensionContext["sessionManager"]; path?: string; result?: { cwd: string; error?: string } };
+
+/** Call once for a new fork or explicit resume override; undo only if launch fails before starting. */
+export function requestChildExecutionCwd(sessionFile: string, cwd?: string): () => void {
+	if (cwd !== undefined && !path.isAbsolute(cwd)) throw new Error("Child execution cwd must be absolute.");
+	const previous = readIntent(sessionFile);
+	fs.writeFileSync(intentPath(sessionFile), JSON.stringify({ cwd }), { mode: 0o600 });
+	return () => {
+		if (previous) fs.writeFileSync(intentPath(sessionFile), JSON.stringify(previous), { mode: 0o600 });
+		else fs.unlinkSync(intentPath(sessionFile));
+	};
+}
+
+function readIntent(sessionFile: string): CwdIntent | undefined {
+	let raw: string;
+	try {
+		raw = fs.readFileSync(intentPath(sessionFile), "utf8");
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw error;
+	}
+	const value: unknown = JSON.parse(raw);
+	if (!value || typeof value !== "object" || Array.isArray(value)
+		|| ("cwd" in value && (typeof value.cwd !== "string" || !path.isAbsolute(value.cwd)))) {
+		throw new Error("Invalid child execution cwd initialization request.");
+	}
+	return value as CwdIntent;
+}
+
+/** Freeze the new fork's requested directory once the actual launch cwd is known. */
+export function prepareChildExecutionCwd(sessionFile: string, cwd?: string): void {
+	const intent = readIntent(sessionFile);
+	if (intent && intent.cwd === undefined) {
+		if (!cwd) throw new Error("New fork execution cwd was not supplied.");
+		requestChildExecutionCwd(sessionFile, cwd);
+	}
+}
+
+export function hasExecutionCwdOwner(pi: Pick<ExtensionAPI, "getAllTools" | "getCommands">): boolean {
+	// excludeTools can hide change_dir while the owner's /cwd command remains loaded.
+	const fromOwner = ({ sourceInfo }: { sourceInfo: { source: string; path: string } }) =>
+		/(?:^|[/\\:@])(?:pi-)?change-working-dir(?:[/\\@:.>]|$)/.test(`${sourceInfo.source}/${sourceInfo.path}`);
+	return pi.getAllTools().some((tool) => tool.name === "change_dir" || fromOwner(tool))
+		|| pi.getCommands().some((command) => command.source === "extension" && (/^cwd(?::\d+)?$/.test(command.name) || fromOwner(command)));
+}
+
+export function registerChildExecutionCwd(pi: ExtensionAPI): void {
+	let initialized = false;
+	pi.on("input", (_event, ctx) => {
+		if (initialized) return;
+		try {
+			const sessionFile = ctx.sessionManager.getSessionFile();
+			const intent = sessionFile ? readIntent(sessionFile) : undefined;
+			const request: CwdRequest = { sessionManager: ctx.sessionManager };
+			pi.events.emit(RESOLVE_CWD, request);
+			if (request.result?.error) throw new Error(request.result.error);
+			const owned = Boolean(request.result) || hasExecutionCwdOwner(pi);
+			if (owned && !request.result?.cwd) throw new Error("The loaded directory extension did not resolve the child directory. Update pi-change-working-dir and ensure session startup has completed.");
+			if (!intent) {
+				initialized = true;
+				return;
+			}
+			if (!intent.cwd) throw new Error("New fork execution cwd was not prepared before startup.");
+			if (owned) {
+				const selection: CwdRequest = { sessionManager: ctx.sessionManager, path: intent.cwd };
+				pi.events.emit(SET_CWD, selection);
+				if (!selection.result) throw new Error("The loaded directory extension did not initialize the child directory. Update pi-change-working-dir and ensure session startup has completed.");
+				if (selection.result.error) throw new Error(selection.result.error);
+				if (fs.realpathSync(selection.result.cwd) !== fs.realpathSync(intent.cwd)) throw new Error("The directory extension selected a different child directory.");
+			} else if (fs.realpathSync(ctx.cwd) !== fs.realpathSync(intent.cwd)) {
+				throw new Error("Native child directory does not match the requested execution cwd.");
+			}
+			// This is a launch intent, not another directory store. Only the owner persists selection.
+			fs.unlinkSync(intentPath(sessionFile!));
+			initialized = true;
+		} catch (error) {
+			console.error(`Subagent directory initialization failed: ${error instanceof Error ? error.message : String(error)}`);
+			process.exitCode = 1;
+			// Native hook exceptions are swallowed. Handled input stops before provider/tool dispatch.
+			return { action: "handled" };
+		}
+	});
+}

package/src/runs/shared/child-observations.ts

@@ -0,0 +1,99 @@
+import type { Message } from "@earendil-works/pi-ai";
+import type { NativeUsageMetadata } from "./native-usage.ts";
+
+/** Match each native ID once, keeping FIFO assignment for identical message identities. */
+export function createMessageReferenceIndex<T extends { message?: Message; nativeEntryId?: string }>() {
+	type Queue = { items: T[]; offset: number };
+	const byId = new Map<string, T>();
+	const buckets = new Map<string, Map<number | undefined, { all: Queue; tools: Map<string, Queue> }>>();
+	const matches = (item: T, message: NonNullable<NativeUsageMetadata["message"]>) => item.message?.role === message.role
+		&& item.message.timestamp === message.timestamp
+		&& (!message.toolCallId || item.message.role === "toolResult" && item.message.toolCallId === message.toolCallId);
+	return {
+		add(item: T): void {
+			if (!item.message) return;
+			const { role, timestamp } = item.message;
+			let timestamps = buckets.get(role);
+			if (!timestamps) buckets.set(role, timestamps = new Map());
+			let bucket = timestamps.get(timestamp);
+			if (!bucket) timestamps.set(timestamp, bucket = { all: { items: [], offset: 0 }, tools: new Map() });
+			bucket.all.items.push(item);
+			if (item.message.role === "toolResult" && item.message.toolCallId) {
+				let queue = bucket.tools.get(item.message.toolCallId);
+				if (!queue) bucket.tools.set(item.message.toolCallId, queue = { items: [], offset: 0 });
+				queue.items.push(item);
+			}
+		},
+		reference(entry: NativeUsageMetadata): T | undefined {
+			if (!entry.message) return;
+			const existing = byId.get(entry.id);
+			if (existing && matches(existing, entry.message)) return existing;
+			const bucket = buckets.get(entry.message.role)?.get(entry.message.timestamp);
+			const queue = entry.message.toolCallId ? bucket?.tools.get(entry.message.toolCallId) : bucket?.all;
+			if (!queue) return;
+			while (queue.offset < queue.items.length && queue.items[queue.offset]!.nativeEntryId) queue.offset++;
+			const item = queue.items[queue.offset];
+			if (item) { item.nativeEntryId = entry.id; byId.set(entry.id, item); }
+			return item;
+		},
+	};
+}
+
+/** Streaming equivalent of the existing exit/status diagnostic expression. */
+export class ExitCodeObservation {
+	private tail = "";
+	private collecting = false;
+	private complete = false;
+	value?: number;
+	write(text: string): void {
+		if (this.complete) return;
+		if (this.collecting) {
+			for (const character of text) {
+				if (character < "0" || character > "9") { this.complete = true; return; }
+				this.value = this.value! * 10 + Number(character);
+			}
+			return;
+		}
+		const normalized = (this.tail + text.replace(/\s+/g, " ")).replace(/ +/g, " ");
+		const match = /exit(?:ed)? *(?:with *)?(?:code|status)? *[: ]? *(\d+)/i.exec(normalized);
+		if (match) {
+			this.value = Number(match[1]);
+			this.collecting = match.index + match[0].length === normalized.length;
+			this.complete = !this.collecting;
+			this.tail = "";
+		} else this.tail = normalized.slice(-32);
+	}
+}
+
+function argumentPreview(arguments_: Record<string, unknown>): Record<string, string | boolean | number> {
+	const result: Record<string, string | boolean | number> = {};
+	for (const [key, value] of Object.entries(arguments_)) {
+		if (typeof value === "string") result[key] = value.slice(0, 2048);
+		else if (typeof value === "boolean" || typeof value === "number") result[key] = value;
+	}
+	return result;
+}
+/** Facts consumed by guards/reports; full bodies belong to native history or the audit. */
+export function compactObservedMessage(message: Message): Message {
+	const firstText = Array.isArray(message.content) ? message.content.find((part) => part.type === "text") : undefined;
+	const observedExitCode = message.role === "toolResult" && firstText?.type === "text"
+		? (message as Message & { observedExitCode?: number }).observedExitCode ?? Number(firstText.text.match(/exit(?:ed)?\s*(?:with\s*)?(?:code|status)?\s*[:\s]?\s*(\d+)/i)?.[1])
+		: undefined;
+	const content = Array.isArray(message.content) ? message.content.map((part) => {
+		if (part.type === "text") {
+			const preview = part.text.slice(0, 4096);
+			return { type: "text" as const, text: preview + (!preview.trim() && part.text.trim() ? "…" : "") };
+		}
+		if (part.type === "toolCall") return { ...part, arguments: part.name === "structured_output" ? part.arguments : argumentPreview(part.arguments ?? {}) };
+		if (part.type === "thinking") return { type: "thinking" as const, thinking: "" };
+		return { type: "image" as const, data: "", mimeType: part.mimeType };
+	}) : typeof message.content === "string" ? message.content.slice(0, 4096) : [];
+	if (message.role === "toolResult") {
+		const details = message.details as { preview?: unknown; modifiedFiles?: unknown } | undefined;
+		return { ...message, ...(observedExitCode !== undefined && !Number.isNaN(observedExitCode) ? { observedExitCode } : {}), content: content as typeof message.content, details: details ? {
+			...(typeof details.preview === "boolean" ? { preview: details.preview } : {}),
+			...(Array.isArray(details.modifiedFiles) ? { modifiedFiles: details.modifiedFiles.filter((file): file is string => typeof file === "string") } : {}),
+		} : undefined };
+	}
+	return { ...message, content } as Message;
+}

package/src/runs/shared/claude-code.ts

@@ -0,0 +1,243 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+import type { Message } from "@earendil-works/pi-ai";
+import type { JsonSchemaObject } from "../../shared/types.ts";
+import { splitKnownThinkingSuffix } from "../../shared/model-info.ts";
+import { scanJournal } from "../../shared/journal-reader.ts";
+import { writeAtomicJson } from "../../shared/atomic-json.ts";
+
+const PREFIX = "claude-code/";
+const DEFAULT_CONTEXT = "300k";
+const CONTEXT_TOKENS: Record<"300k" | "1m", string> = {
+	"300k": "300000",
+	"1m": "1000000",
+};
+const FAMILY_ALIASES = new Set(["fable", "opus", "sonnet", "haiku"]);
+const SESSION_EVENT_TYPE = "claude_code_session";
+
+export interface ClaudeCodeModelSpec {
+	inputModel: string;
+	family: "fable" | "opus" | "sonnet" | "haiku";
+	context: "300k" | "1m" | "native";
+	thinking?: string;
+	cliModel: string;
+	autoCompactWindow?: string;
+}
+
+export interface ClaudeCodeSessionMetadata {
+	sessionId: string;
+	model: string;
+	cliModel: string;
+	family: ClaudeCodeModelSpec["family"];
+	context: ClaudeCodeModelSpec["context"];
+	updatedAt: number;
+}
+
+export interface ClaudeCodeInvocation {
+	command: string;
+	args: string[];
+	env: Record<string, string | undefined>;
+	sessionId: string;
+	resuming: boolean;
+	model: ClaudeCodeModelSpec;
+}
+
+export interface ClaudeCodeResultEvent {
+	type?: string;
+	subtype?: string;
+	is_error?: boolean;
+	api_error_status?: number | null;
+	result?: string;
+	stop_reason?: string;
+	session_id?: string;
+	total_cost_usd?: number;
+	usage?: {
+		input_tokens?: number;
+		output_tokens?: number;
+		cache_read_input_tokens?: number;
+		cache_creation_input_tokens?: number;
+	};
+	modelUsage?: Record<string, { contextWindow?: number; maxOutputTokens?: number }>;
+	structured_output?: unknown;
+}
+
+export function isClaudeCodeModel(model: string | undefined): boolean {
+	return Boolean(model?.startsWith(PREFIX));
+}
+
+function splitThinking(input: string): { model: string; thinking?: string } {
+	const { baseModel, thinkingSuffix } = splitKnownThinkingSuffix(input);
+	return thinkingSuffix ? { model: baseModel, thinking: thinkingSuffix.slice(1) } : { model: input };
+}
+
+export function parseClaudeCodeModel(model: string): ClaudeCodeModelSpec {
+	if (!isClaudeCodeModel(model)) throw new Error(`Not a Claude Code model: ${model}`);
+	const { model: withoutThinking, thinking } = splitThinking(model);
+	const raw = withoutThinking.slice(PREFIX.length).trim().toLowerCase();
+	const [familyRaw, contextRaw] = raw.split("@", 2);
+	if (!FAMILY_ALIASES.has(familyRaw)) {
+		throw new Error(`Unsupported Claude Code model '${model}'. Use claude-code/fable, claude-code/opus, claude-code/sonnet, or claude-code/haiku.`);
+	}
+	const family = familyRaw as ClaudeCodeModelSpec["family"];
+	const context = contextRaw ?? (family === "haiku" ? "native" : DEFAULT_CONTEXT);
+	if (context !== "300k" && context !== "1m" && context !== "native") {
+		throw new Error(`Unsupported Claude Code context '${context}' in '${model}'. Use @300k or @1m.`);
+	}
+	if (family === "haiku" && context === "1m") throw new Error("Claude Code haiku does not support @1m context.");
+	if (family === "haiku" && context === "300k") throw new Error("Claude Code haiku does not support @300k context.");
+	const cliModel = context === "1m" && (family === "opus" || family === "sonnet") ? `${family}[1m]` : family;
+	return {
+		inputModel: model,
+		family,
+		context,
+		...(thinking && thinking !== "off" ? { thinking } : {}),
+		cliModel,
+		...(context === "300k" ? { autoCompactWindow: CONTEXT_TOKENS[context] } : {}),
+	};
+}
+
+export function readClaudeCodeSessionMetadata(sessionFile: string | undefined): ClaudeCodeSessionMetadata | undefined {
+	if (!sessionFile) return;
+	const validate = (value: Partial<ClaudeCodeSessionMetadata> | undefined): ClaudeCodeSessionMetadata | undefined => {
+		if (!value || typeof value.sessionId !== "string" || !value.sessionId || typeof value.model !== "string" || typeof value.cliModel !== "string"
+			|| !["fable", "opus", "sonnet", "haiku"].includes(value.family ?? "") || !["300k", "1m", "native"].includes(value.context ?? "")) return;
+		return { ...value, updatedAt: Number(value.updatedAt) || 0 } as ClaudeCodeSessionMetadata;
+	};
+	try { return validate(JSON.parse(fs.readFileSync(`${sessionFile}.metadata.json`, "utf8"))); }
+	catch (error) { if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; }
+	if (!fs.existsSync(sessionFile)) return;
+	let metadata: ClaudeCodeSessionMetadata | undefined;
+	// Legacy metadata is recovered read-only; new updates never rewrite its audit messages.
+	scanJournal(sessionFile, (path) => !path.length || ["type", "claudeCode"].includes(String(path[0])) ? 4096 : false, ({ value }) => {
+		if (value?.type === SESSION_EVENT_TYPE) metadata ??= validate(value.claudeCode);
+	}, { policy: "inspect" });
+	return metadata;
+}
+
+export function writeClaudeCodeSessionMetadata(sessionFile: string, metadata: ClaudeCodeSessionMetadata): void {
+	fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+	writeAtomicJson(`${sessionFile}.metadata.json`, metadata);
+	fs.closeSync(fs.openSync(sessionFile, "a", 0o600));
+}
+
+export function appendClaudeCodeMessage(sessionFile: string | undefined, message: Message, observation?: Omit<ClaudeCodeResultEvent, "result" | "structured_output">): void {
+	if (!sessionFile) return;
+	fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+	fs.appendFileSync(sessionFile, `${JSON.stringify({ type: "message_end", message, ...(observation ? { claudeCodeResult: observation } : {}) })}\n`, { mode: 0o600 });
+}
+
+function hasNonMetadataContent(sessionFile: string): boolean {
+	if (!fs.existsSync(sessionFile)) return false;
+	let content = false;
+	scanJournal(sessionFile, (path) => !path.length || path.length === 1 && path[0] === "type", ({ value }) => {
+		if (value?.type !== SESSION_EVENT_TYPE) content = true;
+	}, { policy: "inspect", malformed: () => { content = true; } });
+	return content;
+}
+
+export function buildClaudeCodeInvocation(input: {
+	model: string;
+	task: string;
+	systemPrompt?: string;
+	systemPromptMode?: "append" | "replace";
+	sessionFile?: string;
+	sessionName?: string;
+	tools?: string[];
+	mcpDirectTools?: string[];
+	allowSubagents?: boolean;
+	inheritProjectContext?: boolean;
+	inheritSkills?: boolean;
+	outputSchema?: JsonSchemaObject;
+}): ClaudeCodeInvocation {
+	const parsed = parseClaudeCodeModel(input.model);
+	const existing = readClaudeCodeSessionMetadata(input.sessionFile);
+	if (input.sessionFile && !existing && hasNonMetadataContent(input.sessionFile)) {
+		throw new Error(`Claude Code backend cannot resume non-Claude session file: ${input.sessionFile}. Use fresh context for claude-code/* subagents.`);
+	}
+	const sessionId = existing?.sessionId ?? randomUUID();
+	const args = ["-p", "--dangerously-skip-permissions", "--model", parsed.cliModel, "--output-format", "stream-json", "--verbose"];
+	if (parsed.thinking && parsed.thinking !== "minimal") args.push("--effort", parsed.thinking);
+	if (input.sessionName) args.push("--name", input.sessionName);
+	if (existing) args.push("--resume", sessionId);
+	else args.push("--session-id", sessionId);
+	if (input.systemPrompt?.trim()) {
+		args.push(input.systemPromptMode === "replace" ? "--system-prompt" : "--append-system-prompt", input.systemPrompt);
+	}
+	if (input.allowSubagents) throw new Error("Claude Code backend does not support nested subagent fanout. Use a Pi-backed model for allowSubagents.");
+	const inheritProjectContext = input.inheritProjectContext ?? true;
+	const inheritSkills = input.inheritSkills ?? true;
+	if (!inheritProjectContext && inheritSkills) {
+		throw new Error("Claude Code cannot disable project setting sources while preserving their skills. Set inheritSkills: false or use a Pi-backed model.");
+	}
+	if (!inheritProjectContext) args.push("--setting-sources", "");
+	if (!inheritSkills) args.push("--disable-slash-commands");
+	args.push("--disallowedTools=Agent");
+	const mappedTools = mapClaudeCodeTools(input.tools, input.mcpDirectTools);
+	if (input.outputSchema) args.push("--json-schema", JSON.stringify(input.outputSchema));
+	args.push(input.task);
+	if (mappedTools) args.push("--tools", mappedTools);
+	return {
+		command: "claude",
+		args,
+		env: parsed.autoCompactWindow ? { CLAUDE_CODE_AUTO_COMPACT_WINDOW: parsed.autoCompactWindow } : {},
+		sessionId,
+		resuming: Boolean(existing),
+		model: parsed,
+	};
+}
+
+function mapClaudeCodeTools(tools: string[] | undefined, mcpDirectTools: string[] | undefined): string | undefined {
+	if (mcpDirectTools?.length) {
+		throw new Error(`Claude Code backend does not support MCP direct tool allowlist entries: ${mcpDirectTools.join(", ")}. Use a Pi-backed model for MCP direct tools.`);
+	}
+	if (!tools || tools.length === 0) return undefined;
+	const map: Record<string, string> = {
+		bash: "Bash",
+		read: "Read",
+		edit: "Edit",
+		write: "Write",
+		grep: "Grep",
+		glob: "Glob",
+		web_fetch: "WebFetch",
+		webfetch: "WebFetch",
+		web_search: "WebSearch",
+		websearch: "WebSearch",
+	};
+	const mapped: string[] = [];
+	const unsupported: string[] = [];
+	for (const tool of tools) {
+		const name = tool.trim();
+		if (!name) continue;
+		const mappedTool = map[name.toLowerCase()];
+		if (mappedTool) mapped.push(mappedTool);
+		else unsupported.push(name);
+	}
+	if (unsupported.length > 0 || mapped.length === 0) {
+		throw new Error(`Claude Code backend does not support tool allowlist entr${unsupported.length === 1 ? "y" : "ies"}: ${(unsupported.length ? unsupported : tools).join(", ")}. Supported tools: bash, read, edit, write, grep, glob, web_fetch, web_search.`);
+	}
+	return [...new Set(mapped)].join(",");
+}
+
+export function claudeCodeMessageFromResult(event: ClaudeCodeResultEvent, fallbackModel: string): Message {
+	const resultText = event.result ?? "";
+	const isError = event.is_error === true || event.subtype === "error" || Boolean(event.api_error_status);
+	const counters = { input: event.usage?.input_tokens, output: event.usage?.output_tokens,
+		cacheRead: event.usage?.cache_read_input_tokens, cacheWrite: event.usage?.cache_creation_input_tokens };
+	const observed = Object.fromEntries(Object.entries(counters).filter(([, value]) => value !== undefined));
+	if (Object.values(counters).every((value) => typeof value === "number")) observed.totalTokens = Object.values(counters).reduce<number>((sum, value) => sum + value!, 0);
+	return {
+		role: "assistant",
+		content: [{ type: "text", text: resultText }],
+		model: resolveClaudeCodeResultModel(event) ?? fallbackModel,
+		stopReason: isError ? "error" : "stop",
+		...(isError ? { errorMessage: resultText || `Claude Code failed${event.api_error_status ? ` (${event.api_error_status})` : ""}.` } : {}),
+		usage: Object.keys(observed).length || event.total_cost_usd !== undefined
+			? { ...observed, ...(event.total_cost_usd !== undefined ? { cost: { total: event.total_cost_usd } } : {}) } : undefined,
+	} as Message;
+}
+
+export function resolveClaudeCodeResultModel(event: ClaudeCodeResultEvent): string | undefined {
+	const keys = Object.keys(event.modelUsage ?? {});
+	return keys.find((key) => !key.includes("haiku")) ?? keys[0];
+}

package/src/runs/shared/completion-guard.ts

@@ -0,0 +1,35 @@
+import type { Message } from "@earendil-works/pi-ai";
+import { createMutationCompletionTracker } from "./mutating-tool-guard.ts";
+
+export type CompletionPolicy = "none" | "mutation-guard" | "acceptance-contract";
+
+export function resolveCompletionPolicy(input: {
+	completionGuardEnabled: boolean;
+	usesAcceptanceContract: boolean;
+}): CompletionPolicy {
+	if (input.usesAcceptanceContract) return "acceptance-contract";
+	return input.completionGuardEnabled ? "mutation-guard" : "none";
+}
+
+export function hasCompletedMutationToolCall(messages: Message[]): boolean {
+	const mutations = createMutationCompletionTracker();
+	for (const message of messages) {
+		if (message.role === "assistant") {
+			for (const part of message.content) {
+				if (part.type !== "toolCall") continue;
+				const args = typeof part.arguments === "object" && part.arguments !== null && !Array.isArray(part.arguments)
+					? part.arguments as Record<string, unknown>
+					: {};
+				mutations.recordToolStart({
+					id: typeof part.id === "string" ? part.id : undefined,
+					toolName: typeof part.name === "string" ? part.name : undefined,
+					args,
+				});
+			}
+			continue;
+		}
+		if (message.role !== "toolResult") continue;
+		if (mutations.recordToolResult(message as { toolCallId?: unknown; toolName?: unknown; isError?: unknown })?.completedMutation) return true;
+	}
+	return false;
+}