@openclaw/copilot 2026.6.9-beta.1 → 2026.6.10-beta.1

package/dist/{attempt-BMzeV7AP.js → attempt-BQoxgpM3.js}

@@ -1,5 +1,5 @@
-import { n as resolveCopilotAuth } from "./harness-BFRPethX.js";
-import { acquireSessionWriteLock, appendSessionTranscriptMessage, applyEmbeddedAttemptToolsAllow, buildEmbeddedAttemptToolRunContext, detectAndLoadAgentHarnessPromptImages, emitSessionTranscriptUpdate, getPluginToolMeta, isSubagentSessionKey, isToolResultError, resolveAttemptFsWorkspaceOnly, resolveAttemptSpawnWorkspaceDir, resolveBootstrapContextForRun, resolveEmbeddedAttemptToolConstructionPlan, resolveModelAuthMode, resolveSandboxContext, resolveSessionAgentIds, resolveSessionWriteLockAcquireTimeoutMs, resolveUserPath, runAgentHarnessBeforeMessageWriteHook, sanitizeToolResult } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { n as resolveCopilotAuth } from "./harness-I9ahzRYI.js";
+import { acquireSessionWriteLock, appendSessionTranscriptMessage, applyEmbeddedAttemptToolsAllow, awaitAgentEndSideEffects, buildAgentHookContextChannelFields, buildEmbeddedAttemptToolRunContext, detectAndLoadAgentHarnessPromptImages, emitSessionTranscriptUpdate, extractToolErrorMessage, getPluginToolMeta, isSubagentSessionKey, isToolResultError, resolveAgentHarnessBeforePromptBuildResult, resolveAttemptFsWorkspaceOnly, resolveAttemptSpawnWorkspaceDir, resolveBootstrapContextForRun, resolveCompactionTimeoutMs, resolveEmbeddedAttemptToolConstructionPlan, resolveModelAuthMode, resolveSandboxContext, resolveSessionAgentIds, resolveSessionWriteLockAcquireTimeoutMs, resolveUserPath, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessBeforeMessageWriteHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, sanitizeToolResult } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import fsp from "node:fs/promises";
@@ -225,8 +225,18 @@ function attachEventBridge(session, options) {
 	const toolNamesByCallId = /* @__PURE__ */ new Map();
 	let startedCount = 0;
 	let completedCount = 0;
+	let activeCompactionCount = 0;
+	let observedCompaction = false;
 	let deltaQueue = Promise.resolve();
 	let deltaChain = Promise.resolve();
+	let compactionChain = Promise.resolve();
+	let compactionIdle = Promise.resolve();
+	let resolveCompactionIdle;
+	let observedSessionIdle = false;
+	let resolveSessionIdle;
+	const sessionIdle = new Promise((resolve) => {
+		resolveSessionIdle = resolve;
+	});
 	let firstDeltaError;
 	let detached = false;
 	const unsubscribeFns = [];
@@ -284,6 +294,33 @@ function attachEventBridge(session, options) {
 			toolName
 		});
 	});
+	registerListener(session, unsubscribeFns, "session.compaction_start", (event) => {
+		if (!isRootCompactionEvent(event)) return;
+		observedCompaction = true;
+		if (activeCompactionCount === 0) compactionIdle = new Promise((resolve) => {
+			resolveCompactionIdle = resolve;
+		});
+		activeCompactionCount += 1;
+		enqueueCompactionCallback(options.onCompactionStart);
+	});
+	registerListener(session, unsubscribeFns, "session.compaction_complete", (event) => {
+		if (!isRootCompactionEvent(event)) return;
+		activeCompactionCount = Math.max(0, activeCompactionCount - 1);
+		enqueueCompactionCallback(() => options.onCompactionComplete?.({
+			...event.data.messagesRemoved !== void 0 ? { messagesRemoved: event.data.messagesRemoved } : {},
+			success: event.data.success
+		}));
+		if (activeCompactionCount === 0) {
+			resolveCompactionIdle?.();
+			resolveCompactionIdle = void 0;
+		}
+	});
+	registerListener(session, unsubscribeFns, "session.idle", (event) => {
+		if (!isRootCompactionEvent(event)) return;
+		observedSessionIdle = true;
+		resolveSessionIdle?.();
+		resolveSessionIdle = void 0;
+	});
 	registerListener(session, unsubscribeFns, "session.error", (event) => {
 		if (!options.isAborted()) streamError = createPromptError$1(event.data.errorCode ?? event.data.errorType, event.data.message);
 	});
@@ -296,9 +333,32 @@ function attachEventBridge(session, options) {
 			lastAssistantEvent = result;
 			return true;
 		},
+		awaitCompactionChain() {
+			return compactionChain;
+		},
+		async awaitCompactionCompletion() {
+			await awaitStableCompaction();
+		},
+		awaitSessionIdle() {
+			return observedSessionIdle ? Promise.resolve() : sessionIdle;
+		},
+		settleCompactionWait() {
+			activeCompactionCount = 0;
+			resolveCompactionIdle?.();
+			resolveCompactionIdle = void 0;
+		},
 		awaitDeltaChain() {
 			return deltaChain;
 		},
+		hasObservedCompaction() {
+			return observedCompaction;
+		},
+		hasObservedSessionIdle() {
+			return observedSessionIdle;
+		},
+		isCompacting() {
+			return activeCompactionCount > 0;
+		},
 		snapshot() {
 			return {
 				assistantTexts: finalizeAssistantTexts(messageOrder, messagesById, lastAssistantEvent),
@@ -333,6 +393,17 @@ function attachEventBridge(session, options) {
 			unsubscribeFns.length = 0;
 		}
 	};
+	function enqueueCompactionCallback(callback) {
+		if (!callback) return;
+		compactionChain = compactionChain.then(callback, callback).catch(() => void 0);
+	}
+	async function awaitStableCompaction() {
+		const idle = activeCompactionCount > 0 ? compactionIdle : void 0;
+		if (idle) await idle;
+		const callbacks = compactionChain;
+		await callbacks;
+		if (activeCompactionCount > 0 || compactionChain !== callbacks) await awaitStableCompaction();
+	}
 }
 function buildAssistantMessage(params) {
 	const event = params.event;
@@ -396,6 +467,9 @@ function finalizeAssistantTexts(messageOrder, messagesById, event) {
 function isAssistantMessageEvent(event) {
 	return event?.type === "assistant.message";
 }
+function isRootCompactionEvent(event) {
+	return event.agentId === void 0;
+}
 function joinReasoning(order, reasoningById) {
 	return order.map((reasoningId) => reasoningById.get(reasoningId) ?? "").join("");
 }
@@ -425,10 +499,8 @@ 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.
+* Wrap a native handler so it cannot throw into the SDK. Returning undefined
+* leaves the SDK's default decision in place.
 */
 function isolate(hookName, handler, onError) {
 	if (!handler) return;
@@ -447,28 +519,46 @@ function isolate(hookName, handler, onError) {
 	};
 }
 /**
-* 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.
+* Build an SDK-shaped hook object from native per-attempt configuration.
+* Omit the SDK hook subsystem when no handlers were configured.
 */
-function createHooksBridge(config) {
+function createHooksBridge(config, options) {
 	if (!config) return;
 	const onError = config.onHookError ?? DEFAULT_HOOK_ERROR_HANDLER;
 	const hooks = {};
 	const pre = isolate("onPreToolUse", config.onPreToolUse, onError);
+	const preMcp = isolate("onPreMcpToolCall", config.onPreMcpToolCall, onError);
 	const post = isolate("onPostToolUse", config.onPostToolUse, onError);
+	const postFailure = isolate("onPostToolUseFailure", config.onPostToolUseFailure, 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 (preMcp) hooks.onPreMcpToolCall = preMcp;
 	if (post) hooks.onPostToolUse = post;
-	if (userPrompt) hooks.onUserPromptSubmitted = userPrompt;
+	if (postFailure) hooks.onPostToolUseFailure = postFailure;
+	if (userPrompt) hooks.onUserPromptSubmitted = async (input, invocation) => {
+		const output = await userPrompt(input, invocation);
+		try {
+			options?.onUserPromptSubmitted?.({
+				prompt: output?.modifiedPrompt ?? input.prompt,
+				...output?.additionalContext ? { additionalContext: output.additionalContext } : {}
+			});
+		} catch (error) {
+			try {
+				onError({
+					hookName: "onUserPromptSubmitted",
+					error
+				});
+			} catch {}
+		}
+		return output;
+	};
 	if (sessionStart) hooks.onSessionStart = sessionStart;
 	if (sessionEnd) hooks.onSessionEnd = sessionEnd;
 	if (errorOccurred) hooks.onErrorOccurred = errorOccurred;
-	if (Object.keys(hooks).length === 0) return;
-	return hooks;
+	return Object.keys(hooks).length > 0 ? hooks : void 0;
 }
 //#endregion
 //#region extensions/copilot/src/permission-bridge.ts
@@ -737,7 +827,8 @@ async function createCopilotToolBridge(input) {
 		sdkTools: filteredTools.map((sourceTool) => convertOpenClawToolToSdkTool(sourceTool, {
 			abortSignal: input.abortSignal,
 			beforeExecute: input.beforeExecute,
-			onAgentToolResult: input.attemptParams?.onAgentToolResult
+			onAgentToolResult: input.attemptParams?.onAgentToolResult,
+			onToolCompleted: input.onToolCompleted
 		})),
 		sourceTools: filteredTools
 	};
@@ -867,7 +958,17 @@ function convertOpenClawToolToSdkTool(sourceTool, ctx) {
 			console.warn("[copilot-tool-bridge] onAgentToolResult handler threw; continuing", error);
 		}
 	};
-	const failureResult = (message, error) => {
+	const notifyToolCompleted = (completion) => {
+		try {
+			Promise.resolve(ctx.onToolCompleted?.(completion)).catch((error) => {
+				console.warn("[copilot-tool-bridge] onToolCompleted handler threw; continuing", error);
+			});
+		} catch (error) {
+			console.warn("[copilot-tool-bridge] onToolCompleted handler threw; continuing", error);
+		}
+	};
+	const failureResult = (executedArgs, invocation, startedAt, message, error) => {
+		const errorMessage = toError$1(error).message;
 		notifyToolResult(sanitizeToolResult({
 			content: [{
 				type: "text",
@@ -875,15 +976,23 @@ function convertOpenClawToolToSdkTool(sourceTool, ctx) {
 			}],
 			details: {
 				status: "failed",
-				error: toError$1(error).message
+				error: errorMessage
 			}
 		}), true);
+		notifyToolCompleted({
+			toolName: sourceTool.name,
+			toolCallId: invocation.toolCallId,
+			args: toToolStartArgs(executedArgs),
+			error: errorMessage,
+			startedAt
+		});
 		return createFailureResult(message, error);
 	};
 	const executeOnce = async (args, invocation) => {
+		const startedAt = Date.now();
 		if (ctx.abortSignal?.aborted) {
 			const error = /* @__PURE__ */ new Error("[copilot-tool-bridge] aborted before execution");
-			return failureResult(error.message, error);
+			return failureResult(args, invocation, startedAt, error.message, error);
 		}
 		try {
 			await ctx.beforeExecute?.({
@@ -894,23 +1003,33 @@ function convertOpenClawToolToSdkTool(sourceTool, ctx) {
 				toolName: sourceTool.name
 			});
 		} catch (error) {
-			return failureResult(`[copilot-tool-bridge] beforeExecute failed for tool '${sourceTool.name}': ${toError$1(error).message}`, error);
+			return failureResult(args, invocation, startedAt, `[copilot-tool-bridge] beforeExecute failed for tool '${sourceTool.name}': ${toError$1(error).message}`, error);
 		}
 		let preparedArgs;
 		try {
 			preparedArgs = sourceTool.prepareArguments ? sourceTool.prepareArguments(args) : args;
 		} catch (error) {
-			return failureResult(`[copilot-tool-bridge] prepareArguments failed for tool '${sourceTool.name}': ${toError$1(error).message}`, error);
+			return failureResult(args, invocation, startedAt, `[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 failureResult(`[copilot-tool-bridge] tool '${sourceTool.name}' failed: ${toError$1(error).message}`, error);
+			return failureResult(preparedArgs, invocation, startedAt, `[copilot-tool-bridge] tool '${sourceTool.name}' failed: ${toError$1(error).message}`, error);
 		}
 		const sdkResult = agentToolResultToSdk(result);
 		const sanitizedResult = sanitizeToolResult(result);
-		notifyToolResult(sanitizedResult, sdkResult.resultType === "failure" || isToolResultError(sanitizedResult));
+		const resultIsError = sdkResult.resultType === "failure" || isToolResultError(sanitizedResult);
+		const resultError = resultIsError ? extractToolErrorMessage(sanitizedResult) : void 0;
+		notifyToolResult(sanitizedResult, resultIsError);
+		notifyToolCompleted({
+			toolName: sourceTool.name,
+			toolCallId: invocation.toolCallId,
+			args: toToolStartArgs(preparedArgs),
+			result: sanitizedResult,
+			...resultError ? { error: resultError } : {},
+			startedAt
+		});
 		return sdkResult;
 	};
 	const handler = sourceTool.executionMode === "sequential" ? (args, invocation) => {
@@ -927,6 +1046,9 @@ function convertOpenClawToolToSdkTool(sourceTool, ctx) {
 		skipPermission: true
 	};
 }
+function toToolStartArgs(args) {
+	return args && typeof args === "object" && !Array.isArray(args) ? args : { value: args };
+}
 function agentToolResultToSdk(result) {
 	const content = result?.content;
 	if (content == null) return createSuccessResult("");
@@ -1202,12 +1324,135 @@ function readResolvedWorkspacePath(value) {
 //#endregion
 //#region extensions/copilot/src/attempt.ts
 const SUPPORTED_PROVIDERS = new Set(["github-copilot"]);
+const BACKGROUND_COMPACTION_CANCEL_TIMEOUT_MS = 5e3;
+async function runCopilotAgentEndHook(params, hookParams) {
+	if (!params.messageChannel && !params.messageProvider) {
+		await awaitAgentEndSideEffects(hookParams);
+		return;
+	}
+	runAgentEndSideEffects(hookParams);
+}
+async function finalizeCopilotAttempt(params, result, ctx, attemptStartedAt, now) {
+	await runCopilotAgentEndHook(params, {
+		event: {
+			messages: result.messagesSnapshot,
+			success: !result.aborted && !result.promptError && !result.timedOut,
+			...result.promptError ? { error: toError(result.promptError).message } : result.timedOut ? { error: "Copilot SDK turn timed out." } : {},
+			durationMs: now() - attemptStartedAt
+		},
+		ctx
+	});
+	return result;
+}
+async function awaitDeferredCleanupCompletionOrAbort(params) {
+	const awaitCompletion = async () => {
+		if (params.awaitSessionIdle) await params.bridge.awaitSessionIdle();
+		await params.bridge.awaitCompactionCompletion();
+	};
+	if (!params.abortSignal) {
+		await awaitCompletion();
+		return "completed";
+	}
+	if (params.abortSignal.aborted) return "aborted";
+	let resolveAbort = () => void 0;
+	const aborted = new Promise((resolve) => {
+		resolveAbort = () => resolve("aborted");
+	});
+	params.abortSignal.addEventListener("abort", resolveAbort, { once: true });
+	try {
+		return await Promise.race([awaitCompletion().then(() => "completed"), aborted]);
+	} finally {
+		params.abortSignal.removeEventListener("abort", resolveAbort);
+	}
+}
+function deferBackgroundCompactionCleanup(params) {
+	return (async () => {
+		let outcome = "deadline";
+		try {
+			outcome = await awaitDeferredCleanupBeforeDeadline({
+				abortSignal: params.abortSignal,
+				awaitSessionIdle: params.awaitSessionIdle,
+				bridge: params.bridge,
+				timeoutMs: params.timeoutMs
+			});
+		} catch {} finally {
+			if (outcome !== "completed") {
+				await cancelBackgroundCompactionBeforeTeardown(params.session);
+				params.bridge.settleCompactionWait();
+			}
+			params.bridge.detach();
+			try {
+				await params.session.disconnect();
+			} catch {}
+			if (outcome !== "completed" && params.sdkSessionId) try {
+				await params.handle.client.deleteSession(params.sdkSessionId);
+			} catch {}
+			try {
+				await params.pool.release(params.handle);
+			} catch {}
+		}
+		return outcome;
+	})();
+}
+async function cancelBackgroundCompactionBeforeTeardown(session) {
+	const cancelBackgroundCompaction = session.rpc?.history?.cancelBackgroundCompaction;
+	if (!cancelBackgroundCompaction) return;
+	let timeoutId;
+	const deadline = new Promise((resolve) => {
+		timeoutId = setTimeout(resolve, BACKGROUND_COMPACTION_CANCEL_TIMEOUT_MS);
+	});
+	try {
+		await Promise.race([Promise.resolve().then(() => cancelBackgroundCompaction()).catch(() => void 0), deadline]);
+	} finally {
+		if (timeoutId !== void 0) clearTimeout(timeoutId);
+	}
+}
+async function awaitDeferredCleanupBeforeDeadline(params) {
+	let timeoutId;
+	const deadline = new Promise((resolve) => {
+		timeoutId = setTimeout(() => resolve("deadline"), params.timeoutMs);
+	});
+	try {
+		return await Promise.race([awaitDeferredCleanupCompletionOrAbort(params), deadline]);
+	} finally {
+		if (timeoutId !== void 0) clearTimeout(timeoutId);
+	}
+}
 async function runCopilotAttempt(params, deps) {
 	const now = deps.now ?? Date.now;
+	const attemptStartedAt = now();
 	const input = params;
 	const createToolBridge = deps.createToolBridge ?? createCopilotToolBridge;
 	const messages = getMessagesSnapshotInput(input);
-	if (params.abortSignal?.aborted) return createResult(input, {
+	const modelRef = resolveModelRef(input);
+	const resolvedWorkspaceForSandbox = readResolvedAttemptPath(input.workspaceDir) ?? readResolvedAttemptPath(input.cwd);
+	const sandboxSessionKey = readString(input.sandboxSessionKey) ?? readString(input.sessionKey) ?? readString(input.sessionId);
+	const { sessionAgentId } = resolveSessionAgentIds({
+		sessionKey: readString(input.sessionKey),
+		config: input.config,
+		agentId: readString(params.agentId)
+	});
+	const hookContextWindowFields = {
+		...input.contextWindowInfo?.tokens ? { contextTokenBudget: input.contextWindowInfo.tokens } : input.contextTokenBudget ? { contextTokenBudget: input.contextTokenBudget } : {},
+		...input.contextWindowInfo?.source ? { contextWindowSource: input.contextWindowInfo.source } : {},
+		...input.contextWindowInfo?.referenceTokens ? { contextWindowReferenceTokens: input.contextWindowInfo.referenceTokens } : {}
+	};
+	const hookContext = {
+		runId: input.runId,
+		jobId: input.jobId,
+		agentId: sessionAgentId,
+		sessionKey: sandboxSessionKey,
+		sessionId: input.sessionId,
+		workspaceDir: resolvedWorkspaceForSandbox,
+		modelProviderId: modelRef.provider,
+		modelId: modelRef.id,
+		trigger: input.trigger,
+		...input.config ? { config: input.config } : {},
+		...hookContextWindowFields,
+		...buildAgentHookContextChannelFields(input)
+	};
+	const finishAttempt = (result) => finalizeCopilotAttempt(input, result, hookContext, attemptStartedAt, now);
+	if (params.abortSignal?.aborted) return finishAttempt(createResult(input, {
 		aborted: true,
 		externalAbort: true,
 		messagesSnapshot: messages,
@@ -1215,20 +1460,20 @@ async function runCopilotAttempt(params, deps) {
 		promptError: void 0,
 		sdkSessionId: void 0,
 		sessionIdUsed: input.sessionId
-	});
-	const modelRef = resolveModelRef(input);
-	if (!SUPPORTED_PROVIDERS.has(modelRef.provider)) return createResult(input, {
+	}));
+	if (!SUPPORTED_PROVIDERS.has(modelRef.provider)) return finishAttempt(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 timedOutDuringCompaction = false;
 	let timedOut = false;
 	let promptError;
 	let sdkSessionId;
@@ -1249,8 +1494,6 @@ async function runCopilotAttempt(params, deps) {
 		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;
@@ -1265,7 +1508,7 @@ async function runCopilotAttempt(params, deps) {
 	} catch (error) {
 		settled = true;
 		params.abortSignal?.removeEventListener("abort", onAbort);
-		if (abortRequested || params.abortSignal?.aborted) return createResult(input, {
+		if (abortRequested || params.abortSignal?.aborted) return finishAttempt(createResult(input, {
 			aborted: true,
 			externalAbort: true,
 			messagesSnapshot: messages,
@@ -1273,33 +1516,29 @@ async function runCopilotAttempt(params, deps) {
 			promptError: void 0,
 			sdkSessionId: void 0,
 			sessionIdUsed: input.sessionId
-		});
-		return createResult(input, {
+		}));
+		return finishAttempt(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
-		});
+		}));
 	}
+	hookContext.workspaceDir = effectiveWorkspaceDir;
 	const requestedCwd = readResolvedAttemptPath(input.cwd);
 	if (sandbox?.enabled && requestedCwd && requestedCwd !== resolvedWorkspaceForSandbox) {
 		settled = true;
 		params.abortSignal?.removeEventListener("abort", onAbort);
-		return createResult(input, {
+		return finishAttempt(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
@@ -1329,25 +1568,70 @@ async function runCopilotAttempt(params, deps) {
 				sessionRef,
 				onYieldDetected: () => {
 					yieldDetected = true;
-				}
+				},
+				onToolCompleted: ({ args, error, result, startedAt, toolCallId, toolName }) => runAgentHarnessAfterToolCallHook({
+					toolName,
+					toolCallId,
+					runId: input.runId,
+					agentId: sessionAgentId,
+					sessionId: input.sessionId,
+					sessionKey: sandboxSessionKey,
+					channelId: hookContext.channelId,
+					startArgs: args,
+					...result !== void 0 ? { result } : {},
+					...error ? { error } : {},
+					startedAt
+				})
 			})).sdkTools;
 		} catch (error) {
-			return createResult(input, {
+			return finishAttempt(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({
+		const originalDeveloperInstructions = createSystemMessageContent(input, (await resolveCopilotWorkspaceBootstrapContext({
 			attempt: input,
 			effectiveWorkspaceDir,
 			warn: (message) => console.warn(message)
+		})).instructions) ?? "";
+		const promptBuild = isRawCopilotModelRun(input) ? {
+			prompt: input.prompt,
+			developerInstructions: originalDeveloperInstructions
+		} : await resolveAgentHarnessBeforePromptBuildResult({
+			prompt: input.prompt,
+			developerInstructions: originalDeveloperInstructions,
+			messages,
+			ctx: hookContext,
+			..."beforeAgentStartResult" in input ? { beforeAgentStartResult: input.beforeAgentStartResult } : {}
 		});
-		const sessionConfig = createSessionConfig(input, modelRef.id, sdkTools, poolAcquire.auth, workspaceBootstrap.instructions, effectiveWorkspaceDir, effectiveCwd);
+		const attemptInput = promptBuild.prompt === input.prompt ? input : {
+			...input,
+			prompt: promptBuild.prompt
+		};
+		let promptImagesCount = 0;
+		const emitLlmInput = (prompt, additionalContext) => {
+			runAgentHarnessLlmInputHook({
+				event: {
+					runId: input.runId,
+					sessionId: input.sessionId,
+					provider: modelRef.provider,
+					model: modelRef.id,
+					...promptBuild.developerInstructions ? { systemPrompt: promptBuild.developerInstructions } : {},
+					prompt: additionalContext ? `${prompt}\n\n${additionalContext}` : prompt,
+					historyMessages: [],
+					imagesCount: promptImagesCount,
+					tools: sdkTools
+				},
+				ctx: hookContext
+			});
+		};
+		const hasNativePromptHook = Boolean(attemptInput.hooksConfig?.onUserPromptSubmitted);
+		const sessionConfig = createSessionConfig(attemptInput, modelRef.id, sdkTools, poolAcquire.auth, promptBuild.developerInstructions || void 0, effectiveWorkspaceDir, effectiveCwd, hasNativePromptHook ? { onUserPromptSubmitted: ({ additionalContext, prompt }) => emitLlmInput(prompt, additionalContext) } : void 0);
 		const replayDecision = decideReplayAction({
 			sdkSessionId: input.initialReplayState?.sdkSessionId,
 			replayInvalid: input.initialReplayState?.replayInvalid
@@ -1377,52 +1661,103 @@ async function runCopilotAttempt(params, deps) {
 		} catch {}
 		bridge = attachEventBridge(session, {
 			onAssistantDelta: input.onAssistantDelta,
+			onCompactionStart: async () => {
+				const sessionFile = readString(input.sessionFile);
+				if (!sessionFile) return;
+				await runAgentHarnessBeforeCompactionHook({
+					sessionFile,
+					ctx: hookContext
+				});
+			},
+			onCompactionComplete: async ({ messagesRemoved, success }) => {
+				const sessionFile = readString(input.sessionFile);
+				if (!success || !sessionFile) return;
+				await runAgentHarnessAfterCompactionHook({
+					sessionFile,
+					compactedCount: messagesRemoved ?? -1,
+					ctx: hookContext
+				});
+			},
 			getSdkSessionId: () => sdkSessionId,
 			isAborted: () => aborted
 		});
-		const messageOptions = await createMessageOptions(input, {
+		const messageOptions = await createMessageOptions(attemptInput, {
 			effectiveCwd,
 			effectiveWorkspaceDir,
 			sandbox,
 			workspaceOnly: effectiveFsWorkspaceOnly
 		});
+		promptImagesCount = messageOptions.attachments?.length ?? 0;
 		if (abortRequested || params.abortSignal?.aborted) {
 			aborted = true;
 			externalAbort = true;
 		} else {
 			sentTurnStarted = true;
+			if (!hasNativePromptHook) emitLlmInput(attemptInput.prompt);
 			const result = await session.sendAndWait(messageOptions, input.timeoutMs);
 			await bridge.awaitDeltaChain();
-			if (!bridge.recordSendResult(result) && !aborted) timedOut = true;
+			if (!bridge.recordSendResult(result) && !aborted) {
+				timedOut = true;
+				timedOutDuringCompaction = bridge.isCompacting();
+			}
 			const snap = bridge.snapshot();
 			if (!promptError && !timedOut && !aborted && snap.streamError) promptError = snap.streamError;
 		}
 	} catch (error) {
 		if (!aborted) if (isSdkSendAndWaitTimeoutError(error)) {
 			timedOut = true;
+			timedOutDuringCompaction = bridge?.isCompacting() === 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 ((bridge?.hasObservedCompaction() || timedOut && bridge?.hasObservedSessionIdle() === false) && bridge && session && handle) {
+			const cleanupAbort = new AbortController();
+			const abortCleanup = () => cleanupAbort.abort();
+			if (params.abortSignal?.aborted) abortCleanup();
+			else params.abortSignal?.addEventListener("abort", abortCleanup, { once: true });
+			const cleanup = deferBackgroundCompactionCleanup({
+				abortSignal: cleanupAbort.signal,
+				awaitSessionIdle: !bridge.hasObservedSessionIdle(),
+				bridge,
+				handle,
+				pool: deps.pool,
+				sdkSessionId,
+				session,
+				timeoutMs: resolveCompactionTimeoutMs(input.config)
+			});
+			cleanup.finally(() => {
+				params.abortSignal?.removeEventListener("abort", abortCleanup);
+			}).catch(() => void 0);
+			if (sdkSessionId) try {
+				deps.onDeferredCompaction?.({
+					abort: () => cleanupAbort.abort(),
+					cleanup,
+					sdkSessionId
+				});
+			} catch {}
+			params.abortSignal?.removeEventListener("abort", onAbort);
+		} else {
+			await bridge?.awaitCompactionChain();
+			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({
@@ -1461,7 +1796,7 @@ async function runCopilotAttempt(params, deps) {
 			console.warn("[copilot-attempt] dual-write transcript wrapper rejected unexpectedly", mirrorError);
 		});
 	}
-	return createResult(input, {
+	const result = createResult(input, {
 		aborted,
 		assistantTexts,
 		currentAttemptAssistant: lastAssistant,
@@ -1480,10 +1815,35 @@ async function runCopilotAttempt(params, deps) {
 		sdkSessionId,
 		sessionIdUsed,
 		timedOut,
+		timedOutDuringCompaction,
 		toolMetas: snap ? [...snap.toolMetas] : [],
 		usage: snap?.usage,
 		yieldDetected
 	});
+	if (sentTurnStarted) runAgentHarnessLlmOutputHook({
+		event: {
+			runId: input.runId,
+			sessionId: input.sessionId,
+			provider: modelRef.provider,
+			model: modelRef.id,
+			...hookContextWindowFields,
+			resolvedRef: input.runtimePlan?.observability.resolvedRef ?? `${modelRef.provider}/${modelRef.id}`,
+			...input.runtimePlan?.observability.harnessId ? { harnessId: input.runtimePlan.observability.harnessId } : {},
+			assistantTexts: result.assistantTexts,
+			...result.lastAssistant ? { lastAssistant: result.lastAssistant } : {},
+			...result.attemptUsage ? { usage: result.attemptUsage } : {},
+			...input.reasoningEffort ? { reasoningEffort: input.reasoningEffort } : {}
+		},
+		ctx: hookContext
+	});
+	if (releaseError) {
+		await finalizeCopilotAttempt(input, {
+			...result,
+			promptError: releaseError
+		}, hookContext, attemptStartedAt, now);
+		throw releaseError;
+	}
+	return finishAttempt(result);
 }
 function createResult(params, state) {
 	const promptError = state.promptError;
@@ -1523,7 +1883,7 @@ function createResult(params, state) {
 		sessionFileUsed: readString(params.sessionFile),
 		sessionIdUsed: state.sessionIdUsed ?? readString(params.sessionId) ?? "copilot-session",
 		timedOut,
-		timedOutDuringCompaction: false,
+		timedOutDuringCompaction: state.timedOutDuringCompaction === true,
 		toolMetas,
 		yieldDetected: state.yieldDetected === true
 	};
@@ -1534,11 +1894,10 @@ function createPromptError(code, message, cause) {
 	if (cause !== void 0) error.cause = cause;
 	return error;
 }
-function createSessionConfig(params, sdkModelId, sdkTools, resolvedAuth, workspaceBootstrapInstructions, effectiveWorkspaceDir, effectiveCwd) {
+function createSessionConfig(params, sdkModelId, sdkTools, resolvedAuth, systemMessageContent, effectiveWorkspaceDir, effectiveCwd, hooksBridgeOptions) {
 	const permissionPolicy = params.permissionPolicy ?? rejectAllPolicy;
-	const hooks = createHooksBridge(params.hooksConfig);
+	const hooks = createHooksBridge(params.hooksConfig, hooksBridgeOptions);
 	const infiniteSessions = createInfiniteSessionConfig(params.infiniteSessionConfig);
-	const systemMessageContent = createSystemMessageContent(params, workspaceBootstrapInstructions);
 	return {
 		model: sdkModelId,
 		onPermissionRequest: createPermissionBridge(permissionPolicy),

package/dist/{harness-BFRPethX.js → harness-I9ahzRYI.js}

@@ -1,4 +1,4 @@
-import { compactWithSafetyTimeout, resolveCompactionTimeoutMs } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { buildAgentHookContextChannelFields, compactWithSafetyTimeout, resolveCompactionTimeoutMs, runAgentHarnessAfterCompactionHook, runAgentHarnessBeforeCompactionHook } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
@@ -341,23 +341,65 @@ function computeSessionCompactKey(params) {
 		includeAuth: false
 	});
 }
+function buildCopilotCompactionHookContext(params) {
+	return {
+		...params.runId ? { runId: params.runId } : {},
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		workspaceDir: params.workspaceDir,
+		modelProviderId: params.provider,
+		modelId: params.model,
+		trigger: params.trigger,
+		...buildAgentHookContextChannelFields(params)
+	};
+}
 function createCopilotAgentHarness(options) {
 	let poolPromise;
 	let createdPool;
 	let disposed = false;
 	let disposePromise;
 	const inFlight = /* @__PURE__ */ new Set();
+	const deferredCompactionCleanups = /* @__PURE__ */ new Map();
 	const trackedSessions = /* @__PURE__ */ new Map();
 	const resetBlockedStoredSessions = /* @__PURE__ */ new Set();
 	async function getPool() {
 		if (options?.pool) return options.pool;
 		if (!poolPromise) poolPromise = (async () => {
-			const { createCopilotClientPool } = await import("./runtime-BUOrFPqD.js");
+			const { createCopilotClientPool } = await import("./runtime-Bo_ajDXI.js");
 			createdPool = createCopilotClientPool(options?.poolOptions);
 			return createdPool;
 		})();
 		return poolPromise;
 	}
+	function trackDeferredCompactionCleanup(params) {
+		const cleanups = deferredCompactionCleanups.get(params.sessionId) ?? /* @__PURE__ */ new Map();
+		cleanups.set(params.cleanup, {
+			abort: params.abort,
+			sdkSessionId: params.sdkSessionId
+		});
+		deferredCompactionCleanups.set(params.sessionId, cleanups);
+		params.cleanup.then(() => removeDeferredCompactionCleanup(params.sessionId, params.cleanup), () => removeDeferredCompactionCleanup(params.sessionId, params.cleanup));
+	}
+	function removeDeferredCompactionCleanup(sessionId, cleanup) {
+		const cleanups = deferredCompactionCleanups.get(sessionId);
+		if (!cleanups) return;
+		cleanups.delete(cleanup);
+		if (cleanups.size === 0) deferredCompactionCleanups.delete(sessionId);
+	}
+	function hasPendingDeferredCompactionCleanup(sessionId) {
+		const cleanups = deferredCompactionCleanups.get(sessionId);
+		if (!cleanups) return false;
+		const currentSdkSessionId = trackedSessions.get(sessionId)?.sdkSessionId ?? lookupStoredBinding(options?.sessionStore, sessionId)?.sdkSessionId;
+		return currentSdkSessionId !== void 0 && [...cleanups.values()].some((cleanup) => cleanup.sdkSessionId === currentSdkSessionId);
+	}
+	async function abortDeferredCompactionCleanups(sessionId) {
+		const cleanups = deferredCompactionCleanups.get(sessionId);
+		if (!cleanups) return;
+		const pending = [...cleanups.entries()];
+		for (const [, cleanup] of pending) cleanup.abort();
+		await Promise.allSettled(pending.map(([cleanup]) => cleanup));
+	}
 	return {
 		id: options?.id ?? "copilot",
 		label: options?.label ?? "GitHub Copilot agent runtime",
@@ -379,7 +421,7 @@ function createCopilotAgentHarness(options) {
 		async runAttempt(params) {
 			const attemptPromise = (async () => {
 				if (disposed) throw new Error("[copilot] harness has been disposed; cannot start new attempts");
-				const { resolvePoolAcquire, runCopilotAttempt } = await import("./attempt-BMzeV7AP.js");
+				const { resolvePoolAcquire, runCopilotAttempt } = await import("./attempt-BQoxgpM3.js");
 				if (disposed) throw new Error("[copilot] harness was disposed while starting an attempt");
 				const poolAcquire = resolvePoolAcquire(params);
 				const pool = await getPool();
@@ -387,8 +429,10 @@ function createCopilotAgentHarness(options) {
 				const openclawSessionId = typeof params.sessionId === "string" ? params.sessionId : void 0;
 				const currentCompatKey = computeSessionCompatKey(params);
 				const currentCompactKey = computeSessionCompactKey(params);
-				const tracked = openclawSessionId ? trackedSessions.get(openclawSessionId) : void 0;
-				const stored = openclawSessionId ? resetBlockedStoredSessions.has(openclawSessionId) ? void 0 : lookupStoredBinding(options?.sessionStore, openclawSessionId) : void 0;
+				const compactionCleanupPending = openclawSessionId !== void 0 && hasPendingDeferredCompactionCleanup(openclawSessionId);
+				const replayBlocked = openclawSessionId !== void 0 && (compactionCleanupPending || resetBlockedStoredSessions.has(openclawSessionId));
+				const tracked = openclawSessionId && !replayBlocked ? trackedSessions.get(openclawSessionId) : void 0;
+				const stored = openclawSessionId ? replayBlocked ? void 0 : lookupStoredBinding(options?.sessionStore, openclawSessionId) : void 0;
 				const resumableSessionId = tracked && tracked.compatKey === currentCompatKey ? tracked.sdkSessionId : !tracked && stored && stored.compatKey === currentCompatKey ? stored.sdkSessionId : void 0;
 				return runCopilotAttempt(resumableSessionId ? {
 					...params,
@@ -409,14 +453,42 @@ function createCopilotAgentHarness(options) {
 							sessionConfig,
 							...sessionAuthFields(poolAcquire.auth)
 						});
-						if (registerStoredBinding(options?.sessionStore, openclawSessionId, {
+						registerStoredBinding(options?.sessionStore, openclawSessionId, {
 							schemaVersion: 2,
 							sdkSessionId,
 							compatKey: currentCompatKey,
 							compactKey: currentCompactKey,
 							...sessionAuthFields(poolAcquire.auth),
 							updatedAt: Date.now()
-						})) resetBlockedStoredSessions.delete(openclawSessionId);
+						});
+						resetBlockedStoredSessions.delete(openclawSessionId);
+					} : void 0,
+					onDeferredCompaction: openclawSessionId ? ({ abort, cleanup, sdkSessionId }) => {
+						const trackedBinding = trackedSessions.get(openclawSessionId);
+						const storedBinding = lookupStoredBinding(options?.sessionStore, openclawSessionId);
+						const ownsTrackedSession = trackedBinding?.sdkSessionId === sdkSessionId;
+						const ownsStoredSession = storedBinding?.sdkSessionId === sdkSessionId;
+						if (!ownsTrackedSession && !ownsStoredSession) return;
+						trackDeferredCompactionCleanup({
+							abort,
+							cleanup,
+							sessionId: openclawSessionId,
+							sdkSessionId
+						});
+						resetBlockedStoredSessions.add(openclawSessionId);
+						cleanup.then((outcome) => {
+							const currentTracked = trackedSessions.get(openclawSessionId);
+							const currentStored = lookupStoredBinding(options?.sessionStore, openclawSessionId);
+							const stillOwnsTrackedSession = currentTracked?.sdkSessionId === sdkSessionId;
+							const stillOwnsStoredSession = currentStored?.sdkSessionId === sdkSessionId;
+							if (outcome === "completed") {
+								if (stillOwnsTrackedSession || stillOwnsStoredSession) resetBlockedStoredSessions.delete(openclawSessionId);
+								return;
+							}
+							if (stillOwnsTrackedSession) trackedSessions.delete(openclawSessionId);
+							if (stillOwnsStoredSession) deleteStoredBinding(options?.sessionStore, openclawSessionId);
+							if (stillOwnsTrackedSession || stillOwnsStoredSession) resetBlockedStoredSessions.add(openclawSessionId);
+						});
 					} : void 0
 				});
 			})();
@@ -431,10 +503,15 @@ function createCopilotAgentHarness(options) {
 			const openclawSessionId = typeof params.sessionId === "string" ? params.sessionId : void 0;
 			if (!openclawSessionId) return;
 			const tracked = trackedSessions.get(openclawSessionId);
-			if (deleteStoredBinding(options?.sessionStore, openclawSessionId)) resetBlockedStoredSessions.delete(openclawSessionId);
-			else resetBlockedStoredSessions.add(openclawSessionId);
+			const stored = lookupStoredBinding(options?.sessionStore, openclawSessionId);
+			resetBlockedStoredSessions.add(openclawSessionId);
+			await abortDeferredCompactionCleanups(openclawSessionId);
+			const currentStored = lookupStoredBinding(options?.sessionStore, openclawSessionId);
+			if (stored !== void 0 && currentStored?.sdkSessionId === stored.sdkSessionId) {
+				if (deleteStoredBinding(options?.sessionStore, openclawSessionId)) resetBlockedStoredSessions.delete(openclawSessionId);
+			} else resetBlockedStoredSessions.delete(openclawSessionId);
 			if (!tracked) return;
-			trackedSessions.delete(openclawSessionId);
+			if (trackedSessions.get(openclawSessionId)?.sdkSessionId === tracked.sdkSessionId) trackedSessions.delete(openclawSessionId);
 			try {
 				await tracked.client.deleteSession(tracked.sdkSessionId);
 			} catch {}
@@ -446,9 +523,15 @@ function createCopilotAgentHarness(options) {
 				compacted: false,
 				reason: "missing-required-params"
 			};
+			if (hasPendingDeferredCompactionCleanup(openclawSessionId)) return {
+				ok: false,
+				compacted: false,
+				reason: "background-compaction-pending",
+				failure: { reason: "background-compaction-pending" }
+			};
 			const tracked = trackedSessions.get(openclawSessionId);
 			const currentCompactKey = computeSessionCompactKey(params);
-			const { resolvePoolAcquire } = await import("./attempt-BMzeV7AP.js");
+			const { resolvePoolAcquire } = await import("./attempt-BQoxgpM3.js");
 			const resolvedPoolAcquire = resolvePoolAcquire(params);
 			const currentAuth = sessionAuthFields(resolvedPoolAcquire.auth);
 			const compatibleTracked = tracked?.compactKey === currentCompactKey && sessionAuthMatches(tracked, currentAuth) ? tracked : void 0;
@@ -466,11 +549,16 @@ function createCopilotAgentHarness(options) {
 			let handle;
 			let pool;
 			let activeSdkSession;
+			const hookContext = buildCopilotCompactionHookContext(params);
 			try {
 				throwIfAborted(params.abortSignal);
 				pool = await getPool();
 				handle = await pool.acquire(poolAcquire.key, poolAcquire.options);
 				const client = handle.client;
+				await runAgentHarnessBeforeCompactionHook({
+					sessionFile: params.sessionFile,
+					ctx: hookContext
+				});
 				compactResult = await compactWithSafetyTimeout((abortSignal) => compactTrackedSdkSession({
 					abortSignal,
 					client,
@@ -521,6 +609,11 @@ function createCopilotAgentHarness(options) {
 				failure: { reason: "copilot-sdk-history-compact-failed" }
 			};
 			const compacted = compactResult.tokensRemoved > 0 || compactResult.messagesRemoved > 0;
+			if (compacted) await runAgentHarnessAfterCompactionHook({
+				sessionFile: params.sessionFile,
+				compactedCount: compactResult.messagesRemoved,
+				ctx: hookContext
+			});
 			return {
 				ok: true,
 				compacted,
@@ -532,6 +625,8 @@ function createCopilotAgentHarness(options) {
 			disposed = true;
 			disposePromise = (async () => {
 				if (inFlight.size > 0) await Promise.allSettled(inFlight);
+				const cleanupSessionIds = [...deferredCompactionCleanups.keys()];
+				for (const sessionId of cleanupSessionIds) await abortDeferredCompactionCleanups(sessionId);
 				trackedSessions.clear();
 				resetBlockedStoredSessions.clear();
 				if (createdPool) {

package/dist/harness.js

@@ -1,2 +1,2 @@
-import { t as createCopilotAgentHarness } from "./harness-BFRPethX.js";
+import { t as createCopilotAgentHarness } from "./harness-I9ahzRYI.js";
 export { createCopilotAgentHarness };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as createCopilotAgentHarness } from "./harness-BFRPethX.js";
+import { t as createCopilotAgentHarness } from "./harness-I9ahzRYI.js";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 //#region extensions/copilot/index.ts
 function isRecord(value) {

package/dist/{runtime-BUOrFPqD.js → runtime-Bo_ajDXI.js}

@@ -7,7 +7,6 @@ import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 function resolveCopilotSdkFallbackDir(env = process.env) {
 	return path.join(resolveStateDir(env), "npm-runtime", "copilot");
 }
-resolveCopilotSdkFallbackDir();
 const COPILOT_SDK_SPEC = "@github/copilot-sdk@1.0.0-beta.9";
 let cached;
 async function loadCopilotSdk(options = {}) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/copilot",
-  "version": "2026.6.9-beta.1",
+  "version": "2026.6.10-beta.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/copilot",
-      "version": "2026.6.9-beta.1",
+      "version": "2026.6.10-beta.1",
       "dependencies": {
         "@github/copilot-sdk": "1.0.0-beta.9"
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/copilot",
-  "version": "2026.6.9-beta.1",
+  "version": "2026.6.10-beta.1",
   "description": "OpenClaw GitHub Copilot agent runtime plugin (registers a `github-copilot` AgentHarness backed by @github/copilot-sdk over JSON-RPC to the GitHub Copilot CLI)",
   "repository": {
     "type": "git",
@@ -25,10 +25,10 @@
       "minHostVersion": ">=2026.5.28"
     },
     "compat": {
-      "pluginApi": ">=2026.6.9-beta.1"
+      "pluginApi": ">=2026.6.10-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.6.9-beta.1",
+      "openclawVersion": "2026.6.10-beta.1",
       "bundledDist": false
     },
     "release": {
@@ -47,7 +47,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.6.9-beta.1"
+    "openclaw": ">=2026.6.10-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {