@openclaw/copilot 2026.5.28

package/dist/attempt-DMegR4ua.js

@@ -0,0 +1,1667 @@
+import { n as createInfiniteSessionConfig, r as resolveCopilotAuth } from "./harness-Blgz_qk3.js";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import fsp from "node:fs/promises";
+import { acquireSessionWriteLock, appendSessionTranscriptMessage, applyEmbeddedAttemptToolsAllow, buildEmbeddedAttemptToolRunContext, detectAndLoadAgentHarnessPromptImages, emitSessionTranscriptUpdate, getPluginToolMeta, isSubagentSessionKey, resolveAttemptFsWorkspaceOnly, resolveAttemptSpawnWorkspaceDir, resolveBootstrapContextForRun, resolveEmbeddedAttemptToolConstructionPlan, resolveModelAuthMode, resolveSandboxContext, resolveSessionAgentIds, resolveSessionWriteLockAcquireTimeoutMs, resolveUserPath, runAgentHarnessBeforeMessageWriteHook } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/copilot/src/dual-write-transcripts.ts
+/**
+* Mirrors the AgentMessages produced by the copilot agent runtime into the
+* OpenClaw audit transcript that sits next to (but is distinct from) the
+* SDK's own session storage.
+*
+* The OpenClaw shell (src/agents/command/attempt-execution.ts) already
+* writes the user prompt and the terminal assistant text into the
+* transcript at the end of each attempt. That is the bare minimum to
+* keep `/history` working. It does NOT capture tool calls, tool
+* results, or intermediate assistant turns — those live only in the
+* SDK's own session file.
+*
+* For audit/compliance and for the codex-parity guarantees we promised
+* in the proposal, we mirror the full `messagesSnapshot` (user +
+* assistant + toolResult) into the OpenClaw transcript via the same
+* plugin-sdk primitives that the codex extension uses
+* (extensions/codex/src/app-server/transcript-mirror.ts). Both writers
+* cooperate via idempotency-key dedupe: each mirrored entry carries a
+* stable `${idempotencyScope}:${identity}` key, and we skip any key
+* already present in the transcript on disk before appending. Both
+* attempt-execution's untagged entries (no idempotencyKey) and our
+* tagged mirror entries can coexist; attempt-execution dedupes its own
+* final-assistant append via `embeddedAssistantGapFill` content match.
+*
+* Failures (lock contention, fs errors, etc.) are swallowed by the
+* caller-side `dualWriteCopilotTranscriptBestEffort` wrapper used
+* in attempt.ts so they cannot break the attempt; this module itself
+* throws on infrastructure failure so callers can choose policy.
+*/
+const MIRROR_IDENTITY_META_KEY = "mirrorIdentity";
+/**
+* Tag a message with a stable logical identity for mirror dedupe.
+* Callers should use a value that is invariant for the same logical
+* message across re-emits (e.g. `${sdkSessionId}:assistant:${turnIndex}`)
+* but distinct for genuinely-distinct messages. When present this
+* identity replaces the role/content fingerprint in the idempotency
+* key, so the dedupe survives caller-scope rotation without collapsing
+* distinct same-content turns. Symmetric to
+* `attachCodexMirrorIdentity` in the codex extension.
+*/
+function attachCopilotMirrorIdentity(message, identity) {
+	const record = message;
+	const existing = record["__openclaw"];
+	const baseMeta = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+	return {
+		...record,
+		__openclaw: {
+			...baseMeta,
+			[MIRROR_IDENTITY_META_KEY]: identity
+		}
+	};
+}
+function readMirrorIdentity(message) {
+	const meta = message["__openclaw"];
+	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
+	const id = meta[MIRROR_IDENTITY_META_KEY];
+	return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+function fingerprintMirrorMessageContent(message) {
+	const payload = JSON.stringify({
+		role: message.role,
+		content: message.content
+	});
+	return createHash("sha256").update(payload).digest("hex").slice(0, 16);
+}
+function buildMirrorDedupeIdentity(message) {
+	const explicit = readMirrorIdentity(message);
+	if (explicit) return explicit;
+	return `${message.role}:${fingerprintMirrorMessageContent(message)}`;
+}
+async function mirrorCopilotTranscript(params) {
+	const messages = params.messages.filter((message) => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
+	if (messages.length === 0) return;
+	const lock = await acquireSessionWriteLock({
+		sessionFile: params.sessionFile,
+		timeoutMs: resolveSessionWriteLockAcquireTimeoutMs(params.config)
+	});
+	try {
+		const existingIdempotencyKeys = await readTranscriptIdempotencyKeys(params.sessionFile);
+		for (const message of messages) {
+			const dedupeIdentity = buildMirrorDedupeIdentity(message);
+			const idempotencyKey = params.idempotencyScope ? `${params.idempotencyScope}:${dedupeIdentity}` : void 0;
+			if (idempotencyKey && existingIdempotencyKeys.has(idempotencyKey)) continue;
+			const nextMessage = runAgentHarnessBeforeMessageWriteHook({
+				message: {
+					...message,
+					...idempotencyKey ? { idempotencyKey } : {}
+				},
+				agentId: params.agentId,
+				sessionKey: params.sessionKey
+			});
+			if (!nextMessage) continue;
+			const messageToAppend = idempotencyKey ? {
+				...nextMessage,
+				idempotencyKey
+			} : nextMessage;
+			await appendSessionTranscriptMessage({
+				transcriptPath: params.sessionFile,
+				message: messageToAppend,
+				config: params.config
+			});
+			if (idempotencyKey) existingIdempotencyKeys.add(idempotencyKey);
+		}
+	} finally {
+		await lock.release();
+	}
+	if (params.sessionKey) emitSessionTranscriptUpdate({
+		sessionFile: params.sessionFile,
+		sessionKey: params.sessionKey
+	});
+	else emitSessionTranscriptUpdate(params.sessionFile);
+}
+async function readTranscriptIdempotencyKeys(sessionFile) {
+	const keys = /* @__PURE__ */ new Set();
+	let raw;
+	try {
+		raw = await fsp.readFile(sessionFile, "utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		return keys;
+	}
+	for (const line of raw.split(/\r?\n/)) {
+		if (!line.trim()) continue;
+		try {
+			const parsed = JSON.parse(line);
+			if (typeof parsed.message?.idempotencyKey === "string") keys.add(parsed.message.idempotencyKey);
+		} catch {
+			continue;
+		}
+	}
+	return keys;
+}
+/**
+* Caller-side wrapper that swallows mirror failures. attempt.ts uses
+* this so that a transient transcript-mirror failure (lock contention,
+* disk full, etc.) never breaks an otherwise-successful attempt. The
+* SDK's own session file remains the source of truth in that case;
+* the OpenClaw audit trail just misses the intermediate messages for
+* this turn.
+*/
+async function dualWriteCopilotTranscriptBestEffort(params) {
+	try {
+		await mirrorCopilotTranscript(params);
+	} catch (error) {
+		console.warn("[copilot-attempt] dual-write transcript mirror failed", error);
+	}
+}
+//#endregion
+//#region extensions/copilot/src/usage-bridge.ts
+function isCopilotUsageSource(data) {
+	return typeof data === "object" && data !== null;
+}
+function buildZeroCost() {
+	return {
+		cacheRead: 0,
+		cacheWrite: 0,
+		input: 0,
+		output: 0,
+		total: 0
+	};
+}
+function coerceTokenCount(value) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : void 0;
+}
+function normalizeCopilotUsage(data) {
+	if (!isCopilotUsageSource(data)) return;
+	const input = coerceTokenCount(data.inputTokens);
+	const output = coerceTokenCount(data.outputTokens);
+	const cacheRead = coerceTokenCount(data.cacheReadTokens);
+	const cacheWrite = coerceTokenCount(data.cacheWriteTokens);
+	return {
+		cacheRead,
+		cacheWrite,
+		input,
+		output,
+		total: (input ?? 0) + (output ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0)
+	};
+}
+function buildCopilotAssistantUsage(params) {
+	const usage = params.usage ?? normalizeCopilotUsage({ outputTokens: params.fallbackOutputTokens });
+	return {
+		cacheRead: usage?.cacheRead ?? 0,
+		cacheWrite: usage?.cacheWrite ?? 0,
+		cost: buildZeroCost(),
+		input: usage?.input ?? 0,
+		output: usage?.output ?? 0,
+		totalTokens: usage?.total ?? 0
+	};
+}
+//#endregion
+//#region extensions/copilot/src/event-bridge.ts
+function attachEventBridge(session, options) {
+	const messageOrder = [];
+	const messagesById = /* @__PURE__ */ new Map();
+	const reasoningOrder = [];
+	const reasoningById = /* @__PURE__ */ new Map();
+	let lastAssistantEvent;
+	let usage;
+	let streamError;
+	const toolMetas = [];
+	const toolNamesByCallId = /* @__PURE__ */ new Map();
+	let startedCount = 0;
+	let completedCount = 0;
+	let deltaQueue = Promise.resolve();
+	let deltaChain = Promise.resolve();
+	let firstDeltaError;
+	let detached = false;
+	const unsubscribeFns = [];
+	registerListener(session, unsubscribeFns, "assistant.message_delta", (event) => {
+		const messageId = readString$2(event.data.messageId) ?? "assistant-message";
+		const delta = event.data.deltaContent;
+		if (!delta) return;
+		const entry = ensureMessageAccumulator(messagesById, messageOrder, messageId);
+		entry.text += delta;
+		const onAssistantDelta = options.onAssistantDelta;
+		if (!onAssistantDelta) return;
+		const payload = {
+			delta,
+			sessionId: options.getSdkSessionId(),
+			text: entry.text,
+			usage
+		};
+		deltaQueue = deltaQueue.then(() => onAssistantDelta(payload), () => onAssistantDelta(payload)).catch((error) => {
+			firstDeltaError ??= error;
+		});
+		deltaChain = deltaQueue.then(() => {
+			if (firstDeltaError !== void 0) throw firstDeltaError;
+		});
+		deltaChain.catch(() => void 0);
+	});
+	registerListener(session, unsubscribeFns, "assistant.reasoning_delta", (event) => {
+		const reasoningId = readString$2(event.data.reasoningId) ?? "assistant-reasoning";
+		const delta = event.data.deltaContent;
+		if (!delta) return;
+		if (!reasoningById.has(reasoningId)) {
+			reasoningById.set(reasoningId, "");
+			reasoningOrder.push(reasoningId);
+		}
+		reasoningById.set(reasoningId, `${reasoningById.get(reasoningId) ?? ""}${delta}`);
+	});
+	registerListener(session, unsubscribeFns, "assistant.message", (event) => {
+		lastAssistantEvent = event;
+		const entry = ensureMessageAccumulator(messagesById, messageOrder, event.data.messageId);
+		if (typeof event.data.content === "string" && event.data.content.length >= entry.text.length) entry.text = event.data.content;
+	});
+	registerListener(session, unsubscribeFns, "assistant.usage", (event) => {
+		usage = normalizeCopilotUsage(event.data);
+	});
+	registerListener(session, unsubscribeFns, "tool.execution_start", (event) => {
+		startedCount += 1;
+		toolNamesByCallId.set(event.data.toolCallId, event.data.toolName);
+		toolMetas.push({ toolName: event.data.toolName });
+	});
+	registerListener(session, unsubscribeFns, "tool.execution_complete", (event) => {
+		completedCount += 1;
+		const toolName = toolNamesByCallId.get(event.data.toolCallId);
+		const meta = event.data.success ? event.data.result?.detailedContent ?? event.data.result?.content : event.data.error?.message;
+		if (toolName) toolMetas.push({
+			meta,
+			toolName
+		});
+	});
+	registerListener(session, unsubscribeFns, "session.error", (event) => {
+		if (!options.isAborted()) streamError = createPromptError$1(event.data.errorCode ?? event.data.errorType, event.data.message);
+	});
+	registerListener(session, unsubscribeFns, "abort", (event) => {
+		if (!options.isAborted()) streamError = createPromptError$1("session_aborted", `[copilot-attempt] session aborted: ${event.data.reason}`);
+	});
+	return {
+		recordSendResult(result) {
+			if (!isAssistantMessageEvent(result)) return false;
+			lastAssistantEvent = result;
+			return true;
+		},
+		awaitDeltaChain() {
+			return deltaChain;
+		},
+		snapshot() {
+			return {
+				assistantTexts: finalizeAssistantTexts(messageOrder, messagesById, lastAssistantEvent),
+				completedCount,
+				lastAssistantEvent,
+				startedCount,
+				streamError,
+				toolMetas: toolMetas.map((toolMeta) => Object.assign({}, toolMeta)),
+				usage: usage ? { ...usage } : void 0
+			};
+		},
+		buildAssistantMessage(args) {
+			return buildAssistantMessage({
+				event: lastAssistantEvent,
+				modelRef: args.modelRef,
+				now: args.now,
+				reasoningById,
+				reasoningOrder,
+				usage,
+				assistantTexts: finalizeAssistantTexts(messageOrder, messagesById, lastAssistantEvent)
+			});
+		},
+		finalizeAssistantTexts() {
+			return finalizeAssistantTexts(messageOrder, messagesById, lastAssistantEvent);
+		},
+		detach() {
+			if (detached) return;
+			detached = true;
+			for (const unsubscribe of [...unsubscribeFns].toReversed()) try {
+				unsubscribe();
+			} catch {}
+			unsubscribeFns.length = 0;
+		}
+	};
+}
+function buildAssistantMessage(params) {
+	const event = params.event;
+	const text = event ? event.data.content || params.assistantTexts[params.assistantTexts.length - 1] || "" : "";
+	const reasoningText = event?.data.reasoningText ?? joinReasoning(params.reasoningOrder, params.reasoningById);
+	const toolRequests = event?.data.toolRequests ?? [];
+	if (!text && !reasoningText && toolRequests.length === 0) return;
+	const content = [];
+	if (reasoningText) content.push({
+		thinking: reasoningText,
+		type: "thinking"
+	});
+	if (text) content.push({
+		text,
+		type: "text"
+	});
+	for (const request of toolRequests) content.push({
+		arguments: request.arguments ?? {},
+		id: request.toolCallId,
+		name: request.name,
+		type: "toolCall"
+	});
+	return {
+		api: params.modelRef.api ?? "openai-responses",
+		content,
+		model: event?.data.model ?? params.modelRef.id,
+		provider: params.modelRef.provider,
+		role: "assistant",
+		stopReason: toolRequests.length > 0 ? "toolUse" : "stop",
+		timestamp: params.now(),
+		usage: buildCopilotAssistantUsage({
+			fallbackOutputTokens: event?.data.outputTokens,
+			usage: params.usage
+		})
+	};
+}
+function createPromptError$1(code, message, cause) {
+	const error = new Error(message);
+	error.code = code;
+	if (cause !== void 0) error.cause = cause;
+	return error;
+}
+function ensureMessageAccumulator(messagesById, messageOrder, messageId) {
+	let entry = messagesById.get(messageId);
+	if (!entry) {
+		entry = {
+			messageId,
+			text: ""
+		};
+		messagesById.set(messageId, entry);
+		messageOrder.push(messageId);
+	}
+	return entry;
+}
+function finalizeAssistantTexts(messageOrder, messagesById, event) {
+	const texts = messageOrder.map((messageId) => messagesById.get(messageId)?.text ?? "").filter((text) => text.length > 0);
+	if (texts.length > 0) return texts;
+	if (event?.data.content) return [event.data.content];
+	return [];
+}
+function isAssistantMessageEvent(event) {
+	return event?.type === "assistant.message";
+}
+function joinReasoning(order, reasoningById) {
+	return order.map((reasoningId) => reasoningById.get(reasoningId) ?? "").join("");
+}
+function readString$2(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function registerListener(session, unsubscribeFns, eventType, handler) {
+	const maybeUnsubscribe = session.on(eventType, handler);
+	if (typeof maybeUnsubscribe === "function") {
+		unsubscribeFns.push(maybeUnsubscribe);
+		return;
+	}
+	unsubscribeFns.push(() => {
+		session.off?.(eventType, handler);
+	});
+}
+//#endregion
+//#region extensions/copilot/src/hooks-bridge.ts
+const DEFAULT_HOOK_ERROR_HANDLER = ({ hookName, error }) => {
+	console.warn(`[copilot hooks-bridge] ${hookName} handler threw:`, error);
+};
+/**
+* Wrap a host handler in an error-isolating envelope so it cannot
+* throw out into the SDK. Returns `undefined` (no opinion) when the
+* host handler throws, so the SDK falls back to its default behaviour
+* for that hook.
+*/
+function isolate(hookName, handler, onError) {
+	if (!handler) return;
+	return async (...args) => {
+		try {
+			return await handler(...args);
+		} catch (error) {
+			try {
+				onError({
+					hookName,
+					error
+				});
+			} catch {}
+			return;
+		}
+	};
+}
+/**
+* Build an SDK-shaped `SessionHooks` object from a host-supplied
+* `CopilotHooksConfig`. Returns `undefined` when no handlers were
+* supplied so the SDK skips the hook subsystem entirely.
+*/
+function createHooksBridge(config) {
+	if (!config) return;
+	const onError = config.onHookError ?? DEFAULT_HOOK_ERROR_HANDLER;
+	const hooks = {};
+	const pre = isolate("onPreToolUse", config.onPreToolUse, onError);
+	const post = isolate("onPostToolUse", config.onPostToolUse, onError);
+	const userPrompt = isolate("onUserPromptSubmitted", config.onUserPromptSubmitted, onError);
+	const sessionStart = isolate("onSessionStart", config.onSessionStart, onError);
+	const sessionEnd = isolate("onSessionEnd", config.onSessionEnd, onError);
+	const errorOccurred = isolate("onErrorOccurred", config.onErrorOccurred, onError);
+	if (pre) hooks.onPreToolUse = pre;
+	if (post) hooks.onPostToolUse = post;
+	if (userPrompt) hooks.onUserPromptSubmitted = userPrompt;
+	if (sessionStart) hooks.onSessionStart = sessionStart;
+	if (sessionEnd) hooks.onSessionEnd = sessionEnd;
+	if (errorOccurred) hooks.onErrorOccurred = errorOccurred;
+	if (Object.keys(hooks).length === 0) return;
+	return hooks;
+}
+//#endregion
+//#region extensions/copilot/src/permission-bridge.ts
+/** Built-in fail-closed default. Mirrors the pre-bridge attempt.ts stub. */
+const REJECT_ALL_FEEDBACK = "copilot agent runtime: no permission policy installed (fail-closed default)";
+const rejectAllPolicy = () => ({
+	kind: "reject",
+	feedback: REJECT_ALL_FEEDBACK
+});
+/**
+* Adapt a `CopilotPermissionPolicy` to the SDK's
+* `PermissionHandler` shape. The returned handler always resolves
+* (never rejects), defaulting to fail-closed when the policy returns
+* undefined or throws.
+*/
+function createPermissionBridge(policy = rejectAllPolicy) {
+	return async (request, invocation) => {
+		const ctx = {
+			request,
+			sessionId: invocation.sessionId
+		};
+		try {
+			const result = await policy(ctx);
+			if (result !== void 0) return result;
+		} catch (error) {
+			return {
+				kind: "reject",
+				feedback: `copilot permission policy threw: ${formatError(error)}`
+			};
+		}
+		return {
+			kind: "reject",
+			feedback: REJECT_ALL_FEEDBACK
+		};
+	};
+}
+function formatError(error) {
+	if (error instanceof Error) return error.message;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
+//#endregion
+//#region extensions/copilot/src/replay-shim.ts
+function normalizeSdkSessionId(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/**
+* Pure pre-call decision: should attempt.ts call resumeSession or
+* createSession?
+*
+* Rules:
+*   - No input                            → create (no-replay-state)
+*   - No (trimmed) sdkSessionId          → create (no-sdk-session-id)
+*   - sdkSessionId + replayInvalid=true   → create (replay-invalid),
+*                                            downgradedFromResume=true
+*   - sdkSessionId + replayInvalid=false  → resume
+*/
+function decideReplayAction(input) {
+	if (!input) return {
+		action: "create",
+		downgradedFromResume: false,
+		downgradeReason: "no-replay-state"
+	};
+	const sdkSessionId = normalizeSdkSessionId(input.sdkSessionId);
+	if (!sdkSessionId) return {
+		action: "create",
+		downgradedFromResume: false,
+		downgradeReason: "no-sdk-session-id"
+	};
+	if (input.replayInvalid === true) return {
+		action: "create",
+		downgradedFromResume: true,
+		downgradeReason: "replay-invalid"
+	};
+	return {
+		action: "resume",
+		sdkSessionId,
+		downgradedFromResume: false
+	};
+}
+const MISSING_SESSION_CODES = new Set([
+	"SESSION_NOT_FOUND",
+	"session_not_found",
+	"NotFound",
+	"ENOENT"
+]);
+const MISSING_SESSION_MESSAGE_PATTERNS = [
+	/\bsession not found\b/i,
+	/\bsession .* not found\b/i,
+	/\bunknown session id\b/i,
+	/\bsession id .* (does not exist|not found)\b/i,
+	/\bsession .* does not exist\b/i,
+	/\bno such session\b/i
+];
+function readErrorField(error, key) {
+	if (!error || typeof error !== "object") return;
+	return error[key];
+}
+/**
+* Post-call: classify a resumeSession() failure so attempt.ts can
+* decide whether to downgrade silently to createSession.
+*
+* Conservative: only treats clearly session-gone signals as recoverable.
+* Structured signals (status === 404, recognised code strings) are
+* checked first; message matching is a fallback because SDK error
+* messages are not part of the typed contract.
+*
+* Everything else (transport errors, auth failures, generic Error) is
+* unrecoverable and should surface to the outer attempt.ts try/catch
+* which converts it to a prompt error.
+*/
+function classifyResumeFailure(error) {
+	if (error === void 0 || error === null) return {
+		recoverable: false,
+		kind: "unknown"
+	};
+	if (readErrorField(error, "status") === 404) return {
+		recoverable: true,
+		kind: "missing"
+	};
+	if (readErrorField(error, "statusCode") === 404) return {
+		recoverable: true,
+		kind: "missing"
+	};
+	const code = readErrorField(error, "code");
+	if (typeof code === "string" && MISSING_SESSION_CODES.has(code)) return {
+		recoverable: true,
+		kind: "missing"
+	};
+	const message = error instanceof Error ? error.message : typeof error === "object" ? typeof error.message === "string" ? error.message : void 0 : void 0;
+	if (typeof message === "string") {
+		for (const pattern of MISSING_SESSION_MESSAGE_PATTERNS) if (pattern.test(message)) return {
+			recoverable: true,
+			kind: "missing"
+		};
+	}
+	return {
+		recoverable: false,
+		kind: "unknown"
+	};
+}
+/**
+* Compute the `EmbeddedRunReplayMetadata` to attach to the attempt
+* result. Worst-case-wins:
+*
+*   hadPotentialSideEffects = priorHadPotentialSideEffects OR timedOut
+*     OR thisAttemptHadPotentialSideEffects
+*     (timeout means we cannot prove the prompt was not partially
+*     committed server-side; treat as side-effecting so the
+*     orchestrator will not blindly re-issue the same prompt).
+*
+*   replaySafe = NOT (
+*     priorReplayInvalid
+*     OR thisAttemptDowngradedFromResume
+*     OR thisAttemptResumeFailureRecovered
+*     OR hadPotentialSideEffects
+*   )
+*
+* Matches the parity rule in
+* `src/agents/pi-embedded-runner/replay-state.ts#replayMetadataFromState`.
+*/
+function computeReplayMetadata(input) {
+	const priorReplayInvalid = input.priorReplayInvalid === true;
+	const priorHadPotentialSideEffects = input.priorHadPotentialSideEffects === true;
+	const timedOut = input.thisAttemptTimedOut === true;
+	const thisAttemptHadPotentialSideEffects = input.thisAttemptHadPotentialSideEffects === true;
+	const downgraded = input.thisAttemptDowngradedFromResume === true;
+	const recovered = input.thisAttemptResumeFailureRecovered === true;
+	const hadPotentialSideEffects = priorHadPotentialSideEffects || timedOut || thisAttemptHadPotentialSideEffects;
+	return {
+		hadPotentialSideEffects,
+		replaySafe: !(priorReplayInvalid || downgraded || recovered || hadPotentialSideEffects)
+	};
+}
+const COPILOT_REPLAY_SAFE_READ_ONLY_TOOL_NAMES = new Set([
+	"get",
+	"file_read",
+	"glob",
+	"grep",
+	"inspect",
+	"list",
+	"ls",
+	"memory_get",
+	"memory_search",
+	"probe",
+	"query",
+	"read",
+	"search",
+	"sessions_history",
+	"sessions_list",
+	"status",
+	"tool_search",
+	"update_plan",
+	"view",
+	"web_fetch",
+	"web_search"
+]);
+function copilotToolMetasHavePotentialSideEffects(toolMetas) {
+	return (toolMetas ?? []).some((entry) => entry.asyncStarted === true || !isReplaySafeReadOnlyToolName(entry.toolName));
+}
+function isReplaySafeReadOnlyToolName(toolName) {
+	const normalized = toolName.trim().toLowerCase();
+	return COPILOT_REPLAY_SAFE_READ_ONLY_TOOL_NAMES.has(normalized);
+}
+//#endregion
+//#region extensions/copilot/src/tool-bridge.ts
+const SUPPORTED_TOOL_PROVIDERS = new Set(["github-copilot"]);
+const BASE_COPILOT_CODING_TOOL_NAMES = new Set([
+	"edit",
+	"read",
+	"write"
+]);
+const SHELL_COPILOT_CODING_TOOL_NAMES = new Set([
+	"apply_patch",
+	"exec",
+	"process"
+]);
+function supportsModelTools(modelProvider) {
+	return SUPPORTED_TOOL_PROVIDERS.has(modelProvider);
+}
+async function createCopilotToolBridge(input) {
+	if (!supportsModelTools(input.modelProvider)) return {
+		sdkTools: [],
+		sourceTools: []
+	};
+	const attemptParams = input.attemptParams ?? {};
+	const toolPlan = resolveEmbeddedAttemptToolConstructionPlan({
+		disableTools: attemptParams.disableTools,
+		forceMessageTool: shouldForceCopilotMessageTool(attemptParams),
+		isRawModelRun: isCopilotRawModelRun(attemptParams),
+		toolsAllow: attemptParams.toolsAllow
+	});
+	const effectiveToolPlan = hasNonWildcardGlobAllowlist(toolPlan.runtimeToolAllowlist) ? {
+		...toolPlan,
+		codingToolConstructionPlan: {
+			includeBaseCodingTools: true,
+			includeChannelTools: true,
+			includeOpenClawTools: true,
+			includePluginTools: true,
+			includeShellTools: true
+		},
+		constructTools: true,
+		includeCoreTools: true
+	} : toolPlan;
+	if (!effectiveToolPlan.constructTools) return {
+		sdkTools: [],
+		sourceTools: []
+	};
+	const createOpenClawCodingTools = input.createOpenClawCodingTools ?? (await import("openclaw/plugin-sdk/agent-harness")).createOpenClawCodingTools;
+	const toolOptions = buildOpenClawCodingToolsOptions(input, effectiveToolPlan);
+	let sourceTools;
+	try {
+		sourceTools = await createOpenClawCodingTools(toolOptions);
+	} catch (error) {
+		throw createError(`[copilot-tool-bridge] createOpenClawCodingTools failed: ${toError$1(error).message}`, error);
+	}
+	if (!Array.isArray(sourceTools)) throw new Error("[copilot-tool-bridge] createOpenClawCodingTools must return an array of tools");
+	const filteredTools = filterCopilotToolsForAllowlist(filterCopilotToolsForConstructionPlan(sourceTools, effectiveToolPlan.codingToolConstructionPlan), effectiveToolPlan.runtimeToolAllowlist);
+	const duplicateNames = findDuplicateToolNames(filteredTools);
+	if (duplicateNames.length > 0) throw new Error(`[copilot-tool-bridge] duplicate tool names: ${duplicateNames.join(", ")}`);
+	return {
+		sdkTools: filteredTools.map((sourceTool) => convertOpenClawToolToSdkTool(sourceTool, {
+			abortSignal: input.abortSignal,
+			beforeExecute: input.beforeExecute
+		})),
+		sourceTools: filteredTools
+	};
+}
+/**
+* Builds the full `createOpenClawCodingTools` options bag mirroring the
+* PI in-tree call at `src/agents/pi-embedded-runner/run/attempt.ts:1029-1117`.
+*
+* Why PI parity matters: bridged OpenClaw tools register with the SDK
+* as `overridesBuiltInTool: true, skipPermission: true` (see
+* `convertOpenClawToolToSdkTool` below). That means the wrapped-tool
+* enforcement layer
+* (`src/agents/pi-tools.before-tool-call.ts → wrapToolWithBeforeToolCallHook`)
+* is the single gate for permission, owner-only allowlists, loop
+* detection, trusted-plugin policies, and two-phase plugin approvals.
+* That layer reads its context from the fields forwarded here; missing
+* fields silently degrade policy decisions. See docs/plugins/copilot.md.
+*
+* The shared embedded-runner tool plan is forwarded so the bridge does
+* not construct broad tool families only to filter them later. That
+* preserves PI allowlist semantics such as `write` not materializing
+* `apply_patch`.
+* Sandbox is forwarded via the explicit `sandbox` field on
+* {@link CopilotToolBridgeInput}; callers resolve it via
+* `resolveSandboxContext` before constructing the bridge.
+*/
+function buildOpenClawCodingToolsOptions(input, toolPlan) {
+	const a = input.attemptParams ?? {};
+	const sandboxSessionKey = a.sandboxSessionKey?.trim() || a.sessionKey?.trim() || input.sessionKey || input.sessionId;
+	const liveSessionKey = a.sessionKey ?? input.sessionKey;
+	const runSessionKey = liveSessionKey && liveSessionKey !== sandboxSessionKey ? liveSessionKey : void 0;
+	const workspaceDir = input.workspaceDir ?? a.workspaceDir;
+	const cwd = input.cwd ?? a.cwd;
+	const agentDir = input.agentDir ?? a.agentDir;
+	const sandbox = input.sandbox ?? void 0;
+	const spawnWorkspaceDir = input.spawnWorkspaceDir ?? (workspaceDir ? resolveAttemptSpawnWorkspaceDir({
+		sandbox,
+		resolvedWorkspace: workspaceDir
+	}) : void 0);
+	const model = a.model;
+	const modelHasVision = Array.isArray(model?.input) && model.input.includes("image");
+	const modelCompat = model && typeof model === "object" && "compat" in model && model.compat && typeof model.compat === "object" ? model.compat : void 0;
+	return {
+		agentId: input.agentId,
+		...buildEmbeddedAttemptToolRunContext({
+			trigger: a.trigger,
+			jobId: a.jobId,
+			memoryFlushWritePath: a.memoryFlushWritePath,
+			toolsAllow: a.toolsAllow
+		}),
+		exec: {
+			...a.execOverrides,
+			elevated: a.bashElevated
+		},
+		messageProvider: a.messageProvider ?? a.messageChannel,
+		agentAccountId: a.agentAccountId,
+		messageTo: a.messageTo,
+		messageThreadId: a.messageThreadId,
+		groupId: a.groupId,
+		groupChannel: a.groupChannel,
+		groupSpace: a.groupSpace,
+		memberRoleIds: a.memberRoleIds,
+		spawnedBy: a.spawnedBy,
+		senderId: a.senderId,
+		senderName: a.senderName,
+		senderUsername: a.senderUsername,
+		senderE164: a.senderE164,
+		senderIsOwner: a.senderIsOwner,
+		allowGatewaySubagentBinding: a.allowGatewaySubagentBinding,
+		sessionKey: sandboxSessionKey,
+		runSessionKey,
+		sessionId: input.sessionId,
+		runId: a.runId,
+		agentDir,
+		workspaceDir,
+		cwd,
+		sandbox,
+		spawnWorkspaceDir,
+		config: a.config,
+		abortSignal: input.abortSignal,
+		modelProvider: input.modelProvider,
+		modelId: input.modelId,
+		includeCoreTools: toolPlan.includeCoreTools,
+		runtimeToolAllowlist: toolPlan.runtimeToolAllowlist,
+		toolConstructionPlan: toolPlan.codingToolConstructionPlan,
+		modelCompat,
+		modelApi: model?.api,
+		modelContextWindowTokens: model?.contextWindow,
+		modelAuthMode: resolveModelAuthMode(input.modelProvider, a.config, void 0, { workspaceDir }),
+		currentChannelId: a.currentChannelId,
+		currentThreadTs: a.currentThreadTs,
+		currentMessageId: a.currentMessageId,
+		replyToMode: a.replyToMode,
+		hasRepliedRef: a.hasRepliedRef,
+		modelHasVision,
+		requireExplicitMessageTarget: a.requireExplicitMessageTarget ?? isSubagentSessionKey(liveSessionKey),
+		sourceReplyDeliveryMode: a.sourceReplyDeliveryMode,
+		disableMessageTool: a.disableMessageTool,
+		forceMessageTool: a.forceMessageTool,
+		enableHeartbeatTool: a.enableHeartbeatTool,
+		forceHeartbeatTool: a.forceHeartbeatTool,
+		authProfileStore: a.toolAuthProfileStore ?? a.authProfileStore,
+		onToolOutcome: a.onToolOutcome,
+		onYield: (message) => {
+			try {
+				input.onYieldDetected?.(message);
+			} catch (error) {
+				console.warn("[copilot-tool-bridge] onYieldDetected handler threw; continuing", error);
+			}
+			(input.sessionRef?.current)?.abort?.();
+		}
+	};
+}
+function convertOpenClawToolToSdkTool(sourceTool, ctx) {
+	if (typeof sourceTool.name !== "string" || sourceTool.name.trim().length === 0) throw new Error("[copilot-tool-bridge] tool name must be a non-empty string");
+	if (typeof sourceTool.execute !== "function") throw new Error(`[copilot-tool-bridge] tool '${sourceTool.name}' must define an execute function`);
+	let sequentialLock = Promise.resolve();
+	const executeOnce = async (args, invocation) => {
+		if (ctx.abortSignal?.aborted) {
+			const error = /* @__PURE__ */ new Error("[copilot-tool-bridge] aborted before execution");
+			return createFailureResult(error.message, error);
+		}
+		try {
+			await ctx.beforeExecute?.({
+				args,
+				invocation,
+				sourceTool,
+				toolCallId: invocation.toolCallId,
+				toolName: sourceTool.name
+			});
+		} catch (error) {
+			return createFailureResult(`[copilot-tool-bridge] beforeExecute failed for tool '${sourceTool.name}': ${toError$1(error).message}`, error);
+		}
+		let preparedArgs = args;
+		try {
+			preparedArgs = sourceTool.prepareArguments ? sourceTool.prepareArguments(args) : args;
+		} catch (error) {
+			return createFailureResult(`[copilot-tool-bridge] prepareArguments failed for tool '${sourceTool.name}': ${toError$1(error).message}`, error);
+		}
+		let result;
+		try {
+			result = await sourceTool.execute(invocation.toolCallId, preparedArgs, ctx.abortSignal, void 0);
+		} catch (error) {
+			return createFailureResult(`[copilot-tool-bridge] tool '${sourceTool.name}' failed: ${toError$1(error).message}`, error);
+		}
+		return agentToolResultToSdk(result);
+	};
+	const handler = sourceTool.executionMode === "sequential" ? (args, invocation) => {
+		const run = sequentialLock.then(() => executeOnce(args, invocation), () => executeOnce(args, invocation));
+		sequentialLock = run.then(() => void 0, () => void 0);
+		return run;
+	} : executeOnce;
+	return {
+		description: sourceTool.description,
+		handler,
+		name: sourceTool.name,
+		overridesBuiltInTool: true,
+		parameters: sourceTool.parameters,
+		skipPermission: true
+	};
+}
+function agentToolResultToSdk(result) {
+	const content = result?.content;
+	if (content == null) return createSuccessResult("");
+	if (!Array.isArray(content)) return createUnsupportedContentFailure(typeof content);
+	const textParts = [];
+	const binaryResults = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") return createUnsupportedContentFailure(typeof block);
+		const kind = readString$1(block.type);
+		if (kind === "text") {
+			const text = readString$1(block.text, { allowEmpty: true });
+			if (text === void 0) return createUnsupportedContentFailure(kind);
+			textParts.push(text);
+			continue;
+		}
+		if (kind === "image") {
+			const base64Data = readString$1(block.data);
+			const mimeType = readString$1(block.mimeType);
+			if (!base64Data || !mimeType) return createUnsupportedContentFailure(kind);
+			binaryResults.push({
+				base64Data,
+				data: base64Data,
+				mimeType,
+				type: "image"
+			});
+			continue;
+		}
+		return createUnsupportedContentFailure(kind ?? typeof block);
+	}
+	return {
+		...binaryResults.length > 0 ? { binaryResultsForLlm: binaryResults } : {},
+		resultType: "success",
+		textResultForLlm: textParts.join("\n")
+	};
+}
+function createUnsupportedContentFailure(kind) {
+	const message = `[copilot-tool-bridge] unsupported AgentToolResult content shape: ${kind}`;
+	return createFailureResult(message, new Error(message));
+}
+function createSuccessResult(textResultForLlm) {
+	return {
+		resultType: "success",
+		textResultForLlm
+	};
+}
+function createFailureResult(message, error) {
+	return {
+		error: toError$1(error).message,
+		resultType: "failure",
+		textResultForLlm: message
+	};
+}
+function createError(message, cause) {
+	const error = new Error(message);
+	error.cause = cause;
+	return error;
+}
+/**
+* Returns true when the attempt was launched as a raw-model run, which
+* suppresses tool construction in PI
+* (`src/agents/pi-embedded-runner/run/attempt.ts:1305-1310` and
+* `attempt-tool-construction-plan.ts:165-184`). A run is raw when the
+* caller explicitly sets `modelRun: true` or asks for no system prompt
+* via `promptMode: "none"`.
+*/
+function isCopilotRawModelRun(params) {
+	return params.modelRun === true || params.promptMode === "none";
+}
+/**
+* Mirrors PI's `shouldForceMessageTool` semantics: a message tool is
+* forced when the caller asked for it explicitly or when the source
+* reply delivery mode is `message_tool_only`, but never when
+* `disableMessageTool` is set (the suppress flag always wins). Compare
+* `src/agents/pi-embedded-runner/run/attempt.ts:1361-1366` and the
+* codex equivalent at
+* `extensions/codex/src/app-server/run-attempt.ts:4253-4258`.
+*/
+function shouldForceCopilotMessageTool(params) {
+	if (params.disableMessageTool === true) return false;
+	return params.forceMessageTool === true || params.sourceReplyDeliveryMode === "message_tool_only";
+}
+/**
+* Mirrors PI's `applyEmbeddedAttemptToolsAllow`
+* (`src/agents/embedded-agent-runner/run/attempt-tool-construction-plan.ts`)
+* so final filtering keeps aliases, groups, plugin policies, and glob
+* semantics identical to the in-tree embedded runner.
+*/
+function filterCopilotToolsForAllowlist(tools, toolsAllow) {
+	return applyEmbeddedAttemptToolsAllow(tools, toolsAllow, { toolMeta: (tool) => getPluginToolMeta(tool) ?? readInlinePluginToolMeta(tool) });
+}
+function filterCopilotToolsForConstructionPlan(tools, plan) {
+	if (plan.includeBaseCodingTools && plan.includeShellTools) return tools;
+	return tools.filter((tool) => {
+		if (!plan.includeBaseCodingTools && BASE_COPILOT_CODING_TOOL_NAMES.has(tool.name)) return false;
+		if (!plan.includeShellTools && SHELL_COPILOT_CODING_TOOL_NAMES.has(tool.name)) return false;
+		return true;
+	});
+}
+function hasNonWildcardGlobAllowlist(toolsAllow) {
+	return (toolsAllow ?? []).some((entry) => {
+		const trimmed = entry.trim();
+		return trimmed !== "*" && trimmed.includes("*");
+	});
+}
+function readInlinePluginToolMeta(tool) {
+	const pluginId = tool.pluginId;
+	return typeof pluginId === "string" && pluginId.trim() ? { pluginId } : void 0;
+}
+function findDuplicateToolNames(sourceTools) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const sourceTool of sourceTools) {
+		if (typeof sourceTool.name !== "string" || sourceTool.name.length === 0) continue;
+		counts.set(sourceTool.name, (counts.get(sourceTool.name) ?? 0) + 1);
+	}
+	return [...counts.entries()].filter(([, count]) => count > 1).map(([name]) => name).toSorted();
+}
+function readString$1(value, options = {}) {
+	if (typeof value !== "string") return;
+	if (options.allowEmpty || value.length > 0) return value;
+}
+function toError$1(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+//#endregion
+//#region extensions/copilot/src/workspace-bootstrap.ts
+const COPILOT_NATIVE_PROJECT_DOC_BASENAMES = new Set(["agents.md"]);
+const COPILOT_BOOTSTRAP_CONTEXT_ORDER = new Map([
+	["soul.md", 10],
+	["identity.md", 20],
+	["heartbeat.md", 30],
+	["bootstrap.md", 40],
+	["tools.md", 50],
+	["user.md", 60],
+	["memory.md", 70]
+]);
+/**
+* Loads OpenClaw workspace bootstrap files (IDENTITY.md, SOUL.md,
+* HEARTBEAT.md, USER.md, TOOLS.md, BOOTSTRAP.md, MEMORY.md, ...) using
+* the shared core helper PI and codex both use, then renders them as a
+* single string suitable for `SessionConfig.systemMessage.content` on
+* the Copilot SDK.
+*
+* Returns `instructions: undefined` when there are no relevant files
+* (after filtering out SDK-native docs) so the caller can omit the
+* `systemMessage` field entirely rather than passing an empty string.
+*
+* Mirrors codex's `buildCodexWorkspaceBootstrapContext` /
+* `renderCodexWorkspaceBootstrapInstructions` pair
+* (`extensions/codex/src/app-server/run-attempt.ts:2877,3047`). The
+* shape divergence — codex returns instructions inside the same object
+* as bootstrapFiles+contextFiles for its developerInstructions field;
+* copilot exposes the rendered string for SDK `systemMessage` — is the
+* intended difference between the two runtimes' system-prompt
+* surfaces.
+*/
+async function resolveCopilotWorkspaceBootstrapContext(params) {
+	const { attempt } = params;
+	const workspaceDir = readResolvedWorkspacePath(attempt.workspaceDir);
+	if (!workspaceDir) return {
+		bootstrapFiles: [],
+		contextFiles: []
+	};
+	try {
+		const bootstrapContext = await resolveBootstrapContextForRun({
+			workspaceDir,
+			config: attempt.config,
+			sessionKey: readNonEmptyString(attempt.sessionKey),
+			sessionId: readNonEmptyString(attempt.sessionId),
+			agentId: readNonEmptyString(attempt.agentId),
+			warn: params.warn,
+			contextMode: attempt.bootstrapContextMode,
+			runKind: attempt.bootstrapContextRunKind
+		});
+		const contextFiles = remapCopilotBootstrapContextFiles({
+			files: bootstrapContext.contextFiles,
+			sourceWorkspaceDir: workspaceDir,
+			targetWorkspaceDir: readResolvedWorkspacePath(params.effectiveWorkspaceDir) ?? workspaceDir
+		});
+		return {
+			bootstrapFiles: bootstrapContext.bootstrapFiles,
+			contextFiles,
+			instructions: renderCopilotWorkspaceBootstrapInstructions(contextFiles)
+		};
+	} catch (error) {
+		params.warn?.(`[copilot-attempt] failed to load workspace bootstrap instructions: ${error instanceof Error ? error.message : String(error)}`);
+		return {
+			bootstrapFiles: [],
+			contextFiles: []
+		};
+	}
+}
+/**
+* Rewrites context-file paths from a source workspace root to a
+* target workspace root, mirroring PI's
+* `remapInjectedContextFilesToWorkspace`
+* (`src/agents/pi-embedded-runner/run/attempt.ts:603`). Files whose
+* resolved relative path escapes the source workspace (parent
+* traversal or absolute) are left untouched so we never pretend a
+* file lives inside the sandbox when it does not. Exported for unit
+* tests; intentionally local to the Copilot extension (codex keeps
+* similar helpers extension-local rather than importing from PI).
+*/
+function remapCopilotBootstrapContextFiles(params) {
+	if (params.sourceWorkspaceDir === params.targetWorkspaceDir) return params.files;
+	return params.files.map((file) => {
+		const relative = path.relative(params.sourceWorkspaceDir, file.path);
+		if (!isRelativePathInsideOrEqual(relative)) return file;
+		return {
+			...file,
+			path: relative === "" ? params.targetWorkspaceDir : path.join(params.targetWorkspaceDir, relative)
+		};
+	});
+}
+function isRelativePathInsideOrEqual(relativePath) {
+	return relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativePath);
+}
+/**
+* Renders bootstrap context files into a single string for
+* `SessionConfig.systemMessage.content` (append mode). Returns
+* `undefined` when no relevant files remain after filtering, so the
+* caller can skip setting `systemMessage` altogether.
+*
+* Files whose basename matches a doc the Copilot SDK already loads
+* natively (see {@link COPILOT_NATIVE_PROJECT_DOC_BASENAMES}) are
+* dropped to avoid duplication with SDK-managed sections.
+*/
+function renderCopilotWorkspaceBootstrapInstructions(contextFiles) {
+	const files = contextFiles.filter((file) => {
+		const baseName = getCopilotContextFileBasename(file.path);
+		return baseName.length > 0 && !COPILOT_NATIVE_PROJECT_DOC_BASENAMES.has(baseName);
+	}).toSorted(compareCopilotContextFiles);
+	if (files.length === 0) return;
+	const hasSoulFile = files.some((file) => getCopilotContextFileBasename(file.path) === "soul.md");
+	const lines = [
+		"OpenClaw loaded these user-editable workspace files. Treat them as project/user context. The Copilot SDK loads AGENTS.md natively from its instruction directories, so AGENTS.md is not repeated here.",
+		"",
+		"# Project Context",
+		"",
+		"The following project context files have been loaded:"
+	];
+	if (hasSoulFile) lines.push("SOUL.md: persona/tone. Follow it unless higher-priority instructions override.");
+	lines.push("");
+	for (const file of files) lines.push(`## ${file.path}`, "", file.content, "");
+	return lines.join("\n").trim();
+}
+function compareCopilotContextFiles(left, right) {
+	const leftBase = getCopilotContextFileBasename(left.path);
+	const rightBase = getCopilotContextFileBasename(right.path);
+	const leftOrder = COPILOT_BOOTSTRAP_CONTEXT_ORDER.get(leftBase) ?? Number.MAX_SAFE_INTEGER;
+	const rightOrder = COPILOT_BOOTSTRAP_CONTEXT_ORDER.get(rightBase) ?? Number.MAX_SAFE_INTEGER;
+	if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+	const leftPath = normalizeCopilotContextFilePath(left.path);
+	const rightPath = normalizeCopilotContextFilePath(right.path);
+	if (leftPath < rightPath) return -1;
+	if (leftPath > rightPath) return 1;
+	return 0;
+}
+function normalizeCopilotContextFilePath(filePath) {
+	return filePath.trim().replaceAll("\\", "/").toLowerCase();
+}
+function getCopilotContextFileBasename(filePath) {
+	return normalizeCopilotContextFilePath(filePath).split("/").pop() ?? "";
+}
+function readNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readResolvedWorkspacePath(value) {
+	const raw = readNonEmptyString(value);
+	if (!raw) return;
+	if (process.platform !== "win32" && /^[A-Za-z]:[\\/]/.test(raw)) return raw.trim();
+	return resolveUserPath(raw);
+}
+//#endregion
+//#region extensions/copilot/src/attempt.ts
+const SUPPORTED_PROVIDERS = new Set(["github-copilot"]);
+async function runCopilotAttempt(params, deps) {
+	const now = deps.now ?? Date.now;
+	const input = params;
+	const createToolBridge = deps.createToolBridge ?? createCopilotToolBridge;
+	const messages = getMessagesSnapshotInput(input);
+	if (params.abortSignal?.aborted) return createResult(input, {
+		aborted: true,
+		externalAbort: true,
+		messagesSnapshot: messages,
+		now,
+		promptError: void 0,
+		sdkSessionId: void 0,
+		sessionIdUsed: input.sessionId
+	});
+	const modelRef = resolveModelRef(input);
+	if (!SUPPORTED_PROVIDERS.has(modelRef.provider)) return createResult(input, {
+		messagesSnapshot: messages,
+		now,
+		promptError: createPromptError("model_not_supported", `[copilot-attempt] provider ${modelRef.provider} is not supported at MVP (subscription Copilot models only; BYOK arrives via byok-mapping-skeleton)`),
+		sdkSessionId: void 0,
+		sessionIdUsed: input.sessionId
+	});
+	let abortRequested = false;
+	let aborted = false;
+	let externalAbort = false;
+	let settled = false;
+	let sentTurnStarted = false;
+	let timedOut = false;
+	let promptError;
+	let sdkSessionId;
+	let sessionIdUsed = input.sessionId;
+	let disconnectError;
+	let handle;
+	let session;
+	let bridge;
+	let releaseError;
+	let downgradedFromResume = false;
+	let resumeFailureRecovered = false;
+	let yieldDetected = false;
+	const onAbort = () => {
+		abortRequested = true;
+		externalAbort = true;
+		aborted = true;
+		if (settled || !sentTurnStarted || !session) return;
+		session.abort().catch(() => void 0);
+	};
+	params.abortSignal?.addEventListener("abort", onAbort, { once: true });
+	const resolvedWorkspaceForSandbox = readResolvedAttemptPath(input.workspaceDir) ?? readResolvedAttemptPath(input.cwd);
+	const sandboxSessionKey = readString(input.sandboxSessionKey) ?? readString(input.sessionKey) ?? readString(input.sessionId);
+	const resolveSandbox = deps.resolveSandboxContextOverride ?? resolveSandboxContext;
+	let sandbox = null;
+	let effectiveWorkspaceDir = resolvedWorkspaceForSandbox;
+	if (resolvedWorkspaceForSandbox) try {
+		sandbox = await resolveSandbox({
+			config: input.config,
+			sessionKey: sandboxSessionKey,
+			workspaceDir: resolvedWorkspaceForSandbox
+		});
+		effectiveWorkspaceDir = sandbox?.enabled ? sandbox.workspaceAccess === "rw" ? resolvedWorkspaceForSandbox : sandbox.workspaceDir : resolvedWorkspaceForSandbox;
+		if (sandbox?.enabled && effectiveWorkspaceDir && effectiveWorkspaceDir !== resolvedWorkspaceForSandbox) await fsp.mkdir(effectiveWorkspaceDir, { recursive: true });
+	} catch (error) {
+		settled = true;
+		params.abortSignal?.removeEventListener("abort", onAbort);
+		if (abortRequested || params.abortSignal?.aborted) return createResult(input, {
+			aborted: true,
+			externalAbort: true,
+			messagesSnapshot: messages,
+			now,
+			promptError: void 0,
+			sdkSessionId: void 0,
+			sessionIdUsed: input.sessionId
+		});
+		return createResult(input, {
+			messagesSnapshot: messages,
+			now,
+			promptError: createPromptError("sandbox_resolution_failure", `[copilot-attempt] sandbox resolution failed: ${toError(error).message}`, error),
+			sdkSessionId: void 0,
+			sessionIdUsed: input.sessionId
+		});
+	}
+	const requestedCwd = readResolvedAttemptPath(input.cwd);
+	if (sandbox?.enabled && requestedCwd && requestedCwd !== resolvedWorkspaceForSandbox) {
+		settled = true;
+		params.abortSignal?.removeEventListener("abort", onAbort);
+		return createResult(input, {
+			messagesSnapshot: messages,
+			now,
+			promptError: createPromptError("sandbox_cwd_override_unsupported", "[copilot-attempt] cwd override is not supported for sandboxed Copilot runs; omit cwd or use the agent workspace as cwd"),
+			sdkSessionId: void 0,
+			sessionIdUsed: input.sessionId
+		});
+	}
+	const effectiveCwd = sandbox?.enabled ? effectiveWorkspaceDir : requestedCwd ?? effectiveWorkspaceDir;
+	const { sessionAgentId } = resolveSessionAgentIds({
+		sessionKey: readString(input.sessionKey),
+		config: input.config,
+		agentId: readString(params.agentId)
+	});
+	const effectiveFsWorkspaceOnly = resolveAttemptFsWorkspaceOnly({
+		config: input.config,
+		sessionAgentId
+	});
+	const sandboxAwareSpawnWorkspaceDir = resolvedWorkspaceForSandbox ? resolveAttemptSpawnWorkspaceDir({
+		sandbox,
+		resolvedWorkspace: resolvedWorkspaceForSandbox
+	}) : void 0;
+	const poolAcquire = resolvePoolAcquire(input);
+	const sessionRef = { current: void 0 };
+	try {
+		let sdkTools;
+		try {
+			sdkTools = (await createToolBridge({
+				modelProvider: modelRef.provider,
+				modelId: modelRef.id,
+				agentId: readString(params.agentId) ?? "copilot",
+				sessionId: readString(input.sessionId) ?? "copilot-session",
+				sessionKey: readString(input.sessionKey),
+				agentDir: readString(input.agentDir),
+				workspaceDir: effectiveWorkspaceDir,
+				cwd: effectiveCwd,
+				sandbox,
+				spawnWorkspaceDir: sandboxAwareSpawnWorkspaceDir,
+				abortSignal: params.abortSignal,
+				attemptParams: input,
+				sessionRef,
+				onYieldDetected: () => {
+					yieldDetected = true;
+				}
+			})).sdkTools;
+		} catch (error) {
+			return createResult(input, {
+				messagesSnapshot: messages,
+				now,
+				promptError: createPromptError("tool_bridge_failure", `[copilot-attempt] tool-bridge construction failed: ${toError(error).message}`, error),
+				sdkSessionId: void 0,
+				sessionIdUsed: input.sessionId
+			});
+		}
+		handle = await deps.pool.acquire(poolAcquire.key, poolAcquire.options);
+		const client = handle.client;
+		const workspaceBootstrap = await resolveCopilotWorkspaceBootstrapContext({
+			attempt: input,
+			effectiveWorkspaceDir,
+			warn: (message) => console.warn(message)
+		});
+		const sessionConfig = createSessionConfig(input, modelRef.id, sdkTools, poolAcquire.auth, workspaceBootstrap.instructions, effectiveWorkspaceDir, effectiveCwd);
+		const replayDecision = decideReplayAction({
+			sdkSessionId: input.initialReplayState?.sdkSessionId,
+			replayInvalid: input.initialReplayState?.replayInvalid
+		});
+		downgradedFromResume = replayDecision.downgradedFromResume;
+		const resumeSessionId = replayDecision.action === "resume" ? replayDecision.sdkSessionId : void 0;
+		if (resumeSessionId) try {
+			session = await client.resumeSession(resumeSessionId, {
+				...sessionConfig,
+				continuePendingWork: false
+			});
+		} catch (error) {
+			if (!classifyResumeFailure(error).recoverable) throw error;
+			resumeFailureRecovered = true;
+			session = await client.createSession(sessionConfig);
+		}
+		else session = await client.createSession(sessionConfig);
+		sessionRef.current = session;
+		sdkSessionId = readSessionId(session) ?? (resumeFailureRecovered ? void 0 : resumeSessionId);
+		sessionIdUsed = sdkSessionId ?? input.sessionId;
+		if (sdkSessionId && deps.onSessionEstablished) try {
+			deps.onSessionEstablished({
+				sdkSessionId,
+				pooledClient: handle
+			});
+		} catch {}
+		bridge = attachEventBridge(session, {
+			onAssistantDelta: input.onAssistantDelta,
+			getSdkSessionId: () => sdkSessionId,
+			isAborted: () => aborted
+		});
+		const messageOptions = await createMessageOptions(input, {
+			effectiveCwd,
+			effectiveWorkspaceDir,
+			sandbox,
+			workspaceOnly: effectiveFsWorkspaceOnly
+		});
+		if (abortRequested || params.abortSignal?.aborted) {
+			aborted = true;
+			externalAbort = true;
+		} else {
+			sentTurnStarted = true;
+			const result = await session.sendAndWait(messageOptions, input.timeoutMs);
+			await bridge.awaitDeltaChain();
+			if (!bridge.recordSendResult(result) && !aborted) timedOut = true;
+			const snap = bridge.snapshot();
+			if (!promptError && !timedOut && !aborted && snap.streamError) promptError = snap.streamError;
+		}
+	} catch (error) {
+		if (!aborted) if (isSdkSendAndWaitTimeoutError(error)) {
+			timedOut = true;
+			try {
+				await bridge?.awaitDeltaChain();
+			} catch {}
+		} else promptError = toError(error);
+	} finally {
+		settled = true;
+		bridge?.detach();
+		params.abortSignal?.removeEventListener("abort", onAbort);
+		if (session) try {
+			await session.disconnect();
+		} catch (error) {
+			disconnectError = toError(error);
+			if (!promptError && !timedOut) promptError = disconnectError;
+		}
+		if (handle) try {
+			await deps.pool.release(handle);
+		} catch (error) {
+			const releaseFailure = toError(error);
+			if (promptError) console.warn("[copilot-attempt] pool.release failed after primary error", releaseFailure);
+			else releaseError = releaseFailure;
+		}
+	}
+	if (releaseError) throw releaseError;
+	const snap = bridge?.snapshot();
+	const assistantTexts = bridge?.finalizeAssistantTexts() ?? [];
+	const lastAssistant = bridge?.buildAssistantMessage({
+		modelRef,
+		now
+	});
+	const syntheticUserText = readString(input.transcriptPrompt) ?? readString(input.prompt);
+	const tailUserText = readTailUserText(messages);
+	const syntheticUser = syntheticUserText && syntheticUserText !== tailUserText ? attachCopilotMirrorIdentity({
+		role: "user",
+		content: syntheticUserText,
+		timestamp: now()
+	}, `${input.runId}:prompt`) : void 0;
+	const taggedLastAssistant = lastAssistant ? attachCopilotMirrorIdentity(lastAssistant, `${input.runId}:assistant:final`) : void 0;
+	const messagesSnapshot = [
+		...messages,
+		...syntheticUser ? [syntheticUser] : [],
+		...taggedLastAssistant ? [taggedLastAssistant] : []
+	];
+	const sessionFileForMirror = readString(input.sessionFile);
+	const sessionIdForScope = sessionIdUsed ?? readString(input.sessionId);
+	if (sessionFileForMirror && messagesSnapshot.length > 0) {
+		const taggedMessages = messagesSnapshot.map((message, index) => {
+			if (message.role !== "user" && message.role !== "assistant" && message.role !== "toolResult") return message;
+			if (hasMirrorIdentity(message)) return message;
+			return attachCopilotMirrorIdentity(message, `${sdkSessionId ?? sessionIdForScope ?? "attempt"}:${message.role}:${index}`);
+		});
+		await dualWriteCopilotTranscriptBestEffort({
+			sessionFile: sessionFileForMirror,
+			sessionKey: readString(input.sessionKey),
+			agentId: readString(input.agentId),
+			messages: taggedMessages,
+			idempotencyScope: sessionIdForScope ? `copilot:${sessionIdForScope}` : void 0,
+			config: input.config
+		}).catch((mirrorError) => {
+			console.warn("[copilot-attempt] dual-write transcript wrapper rejected unexpectedly", mirrorError);
+		});
+	}
+	return createResult(input, {
+		aborted,
+		assistantTexts,
+		currentAttemptAssistant: lastAssistant,
+		downgradedFromResume,
+		externalAbort,
+		itemLifecycle: {
+			activeCount: Math.max((snap?.startedCount ?? 0) - (snap?.completedCount ?? 0), 0),
+			completedCount: snap?.completedCount ?? 0,
+			startedCount: snap?.startedCount ?? 0
+		},
+		lastAssistant,
+		messagesSnapshot,
+		now,
+		promptError,
+		resumeFailureRecovered,
+		sdkSessionId,
+		sessionIdUsed,
+		timedOut,
+		toolMetas: snap ? [...snap.toolMetas] : [],
+		usage: snap?.usage,
+		yieldDetected
+	});
+}
+function createResult(params, state) {
+	const promptError = state.promptError;
+	const timedOut = state.timedOut === true;
+	const toolMetas = state.toolMetas ?? [];
+	const replayMetadata = computeReplayMetadata({
+		priorReplayInvalid: params.initialReplayState?.replayInvalid,
+		priorHadPotentialSideEffects: params.initialReplayState?.hadPotentialSideEffects,
+		thisAttemptTimedOut: timedOut,
+		thisAttemptHadPotentialSideEffects: copilotToolMetasHavePotentialSideEffects(toolMetas),
+		thisAttemptDowngradedFromResume: state.downgradedFromResume,
+		thisAttemptResumeFailureRecovered: state.resumeFailureRecovered
+	});
+	return {
+		aborted: state.aborted === true,
+		...state.sdkSessionId ? { sdkSessionId: state.sdkSessionId } : {},
+		assistantTexts: state.assistantTexts ?? [],
+		attemptUsage: state.usage,
+		cloudCodeAssistFormatError: false,
+		currentAttemptAssistant: state.currentAttemptAssistant,
+		didSendViaMessagingTool: false,
+		externalAbort: state.externalAbort === true,
+		idleTimedOut: false,
+		itemLifecycle: state.itemLifecycle ?? {
+			activeCount: 0,
+			completedCount: 0,
+			startedCount: 0
+		},
+		lastAssistant: state.lastAssistant,
+		messagesSnapshot: state.messagesSnapshot,
+		messagingToolSentMediaUrls: [],
+		messagingToolSentTargets: [],
+		messagingToolSentTexts: [],
+		promptError,
+		promptErrorSource: promptError ? "prompt" : null,
+		replayMetadata,
+		sessionFileUsed: readString(params.sessionFile),
+		sessionIdUsed: state.sessionIdUsed ?? readString(params.sessionId) ?? "copilot-session",
+		timedOut,
+		timedOutDuringCompaction: false,
+		toolMetas,
+		yieldDetected: state.yieldDetected === true
+	};
+}
+function createPromptError(code, message, cause) {
+	const error = new Error(message);
+	error.code = code;
+	if (cause !== void 0) error.cause = cause;
+	return error;
+}
+function createSessionConfig(params, sdkModelId, sdkTools, resolvedAuth, workspaceBootstrapInstructions, effectiveWorkspaceDir, effectiveCwd) {
+	const permissionPolicy = params.permissionPolicy ?? rejectAllPolicy;
+	const hooks = createHooksBridge(params.hooksConfig);
+	const infiniteSessions = createInfiniteSessionConfig(params.infiniteSessionConfig);
+	const systemMessageContent = createSystemMessageContent(params, workspaceBootstrapInstructions);
+	return {
+		model: sdkModelId,
+		onPermissionRequest: createPermissionBridge(permissionPolicy),
+		...hooks ? { hooks } : {},
+		...typeof params.enableSessionTelemetry === "boolean" ? { enableSessionTelemetry: params.enableSessionTelemetry } : {},
+		...infiniteSessions ? { infiniteSessions } : {},
+		reasoningEffort: params.reasoningEffort,
+		tools: sdkTools,
+		availableTools: sdkTools.map((tool) => tool.name),
+		workingDirectory: effectiveCwd ?? effectiveWorkspaceDir ?? readResolvedAttemptPath(params.workspaceDir),
+		...effectiveWorkspaceDir && effectiveCwd && effectiveCwd !== effectiveWorkspaceDir ? { instructionDirectories: [effectiveWorkspaceDir] } : {},
+		...resolvedAuth.authMode === "gitHubToken" && resolvedAuth.gitHubToken ? { gitHubToken: resolvedAuth.gitHubToken } : {},
+		...systemMessageContent ? { systemMessage: {
+			mode: "append",
+			content: systemMessageContent
+		} } : {}
+	};
+}
+async function createMessageOptions(params, context) {
+	const attachments = createPromptImageAttachments(await resolvePromptImages(params, context));
+	return attachments.length > 0 ? {
+		prompt: params.prompt,
+		attachments
+	} : { prompt: params.prompt };
+}
+function createPromptImageAttachments(images) {
+	return images.flatMap((image, index) => {
+		if (!image || typeof image !== "object" || image.type !== "image" || typeof image.data !== "string" || typeof image.mimeType !== "string") return [];
+		return [{
+			type: "blob",
+			data: image.data,
+			mimeType: image.mimeType,
+			displayName: `prompt-image-${index + 1}`
+		}];
+	});
+}
+async function resolvePromptImages(params, context) {
+	const workspaceDir = context.effectiveCwd ?? context.effectiveWorkspaceDir ?? readResolvedAttemptPath(params.cwd) ?? readResolvedAttemptPath(params.workspaceDir);
+	if (!workspaceDir) return [];
+	const localRoots = context.workspaceOnly && context.effectiveWorkspaceDir ? [context.effectiveWorkspaceDir] : void 0;
+	return (await detectAndLoadAgentHarnessPromptImages({
+		prompt: params.prompt,
+		workspaceDir,
+		model: resolveImageCapabilityModel(params),
+		existingImages: Array.isArray(params.images) ? params.images : void 0,
+		imageOrder: Array.isArray(params.imageOrder) ? params.imageOrder : void 0,
+		config: params.config,
+		workspaceOnly: context.workspaceOnly,
+		localRoots,
+		sandbox: context.sandbox?.enabled && context.sandbox.fsBridge ? {
+			root: context.sandbox.workspaceDir,
+			bridge: context.sandbox.fsBridge
+		} : void 0
+	})).images;
+}
+function resolveImageCapabilityModel(params) {
+	const model = params.model;
+	if (model && typeof model === "object" && Array.isArray(model.input)) return { input: model.input };
+	return { input: ["image"] };
+}
+function createSystemMessageContent(params, workspaceBootstrapInstructions) {
+	const sections = [];
+	const bootstrap = workspaceBootstrapInstructions?.trim();
+	if (bootstrap) sections.push(bootstrap);
+	const extraSystemPrompt = readString(params.extraSystemPrompt)?.trim();
+	if (extraSystemPrompt && !isRawCopilotModelRun(params)) {
+		const contextHeader = params.promptMode === "minimal" ? "## Subagent Context" : "## Group Chat Context";
+		sections.push(`${contextHeader}\n${extraSystemPrompt}`);
+	}
+	return sections.length > 0 ? sections.join("\n\n") : void 0;
+}
+function isRawCopilotModelRun(params) {
+	return params.modelRun === true || params.promptMode === "none";
+}
+function getMessagesSnapshotInput(params) {
+	return Array.isArray(params.messages) ? [...params.messages] : [];
+}
+function readTailUserText(messages) {
+	const tail = messages[messages.length - 1];
+	if (!tail || tail.role !== "user") return;
+	const content = tail.content;
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		for (const part of content) if (part && typeof part === "object" && part.type === "text") {
+			const text = part.text;
+			if (typeof text === "string" && text.length > 0) return text;
+		}
+	}
+}
+function hasMirrorIdentity(message) {
+	const meta = message["__openclaw"];
+	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return false;
+	const id = meta.mirrorIdentity;
+	return typeof id === "string" && id.length > 0;
+}
+function readSessionId(session) {
+	if (!session) return;
+	return readString(session.sessionId) ?? readString(session.id);
+}
+function readString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readResolvedAttemptPath(value) {
+	const raw = readString(value)?.trim();
+	if (!raw) return;
+	if (process.platform !== "win32" && /^[A-Za-z]:[\\/]/.test(raw)) return raw;
+	return resolveUserPath(raw);
+}
+function resolveModelRef(params) {
+	const rawModel = params.model;
+	if (rawModel && typeof rawModel === "object") return {
+		api: readString(rawModel.api),
+		id: readString(rawModel.id) ?? readString(params.modelId) ?? "unknown-model",
+		provider: readString(rawModel.provider) ?? readString(params.provider) ?? "unknown-provider"
+	};
+	return {
+		id: readString(typeof rawModel === "string" ? rawModel : void 0) ?? readString(params.modelId) ?? "unknown-model",
+		provider: readString(params.provider) ?? "unknown-provider"
+	};
+}
+function resolvePoolAcquire(params) {
+	const resolved = resolveCopilotAuth({
+		agentId: readString(params.agentId),
+		agentDir: readString(params.agentDir),
+		workspaceDir: readString(params.workspaceDir),
+		copilotHome: readString(params.copilotHome),
+		auth: params.auth,
+		resolvedApiKey: readString(params.resolvedApiKey),
+		authProfileId: readString(params.authProfileId),
+		profileVersion: readString(params.profileVersion)
+	});
+	return {
+		key: {
+			agentId: resolved.agentId,
+			authMode: resolved.authMode,
+			...resolved.authMode === "gitHubToken" ? {
+				authProfileId: resolved.authProfileId,
+				authProfileVersion: resolved.authProfileVersion
+			} : {},
+			copilotHome: resolved.copilotHome
+		},
+		options: {
+			copilotHome: resolved.copilotHome,
+			cwd: readString(params.cwd) ?? readString(params.workspaceDir),
+			gitHubToken: resolved.authMode === "gitHubToken" ? resolved.gitHubToken : void 0,
+			useLoggedInUser: resolved.authMode === "useLoggedInUser"
+		},
+		auth: resolved
+	};
+}
+function toError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+/**
+* Detect the @github/copilot-sdk `session.sendAndWait` timeout
+* rejection shape. The SDK's `sendAndWait` races the internal
+* `session.idle` event against a timer; when the timer fires first
+* it REJECTS the promise with
+* `new Error(`Timeout after ${effectiveTimeout}ms waiting for
+* session.idle`)` (see
+* `node_modules/@github/copilot-sdk/dist/session.js:156-164`), and
+* the SDK docs explicitly note the timeout "does not abort in-flight
+* agent work". The caller is therefore responsible for setting the
+* timed-out state and (for paths where in-flight work should be
+* stopped) calling `session.abort()`.
+*
+* Keep the regex anchored and narrow so unrelated errors that happen
+* to mention "Timeout" are NOT mis-classified. The shape is a literal
+* template-string concatenation in the 1.0.0-beta line; a minor
+* version bump that changes the wording will safely fall through to
+* the generic prompt-error path.
+*/
+function isSdkSendAndWaitTimeoutError(error) {
+	if (error === null || typeof error !== "object") return false;
+	const message = error.message;
+	if (typeof message !== "string") return false;
+	return /^Timeout after \d+ms waiting for session\.idle$/.test(message);
+}
+//#endregion
+export { runCopilotAttempt };