@openclaw/copilot 2026.6.10 → 2026.6.11

package/README.md

@@ -16,7 +16,7 @@ on a model or provider entry; `auto` never picks it. PI remains the default
 embedded runtime.
 
 See [GitHub Copilot agent runtime](../../docs/plugins/copilot.md) for
-configuration, doctor probes, transcript mirroring, compaction, side
+configuration, the doctor contract, transcript mirroring, compaction, side
 questions, replay, and the supported-surface contract.
 See [qa/copilot-capabilities.md](../../qa/copilot-capabilities.md)
 for the SDK capability inventory the harness is pinned to.

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

@@ -1,8 +1,11 @@
-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 { n as resolveCopilotAuth } from "./harness-D-3KWchY.js";
+import { applyEmbeddedAttemptToolsAllow, awaitAgentEndSideEffects, buildAgentHarnessUserInputAnswers, buildAgentHookContextChannelFields, buildEmbeddedAttemptToolRunContext, clearActiveEmbeddedRun, deliverAgentHarnessUserInputPrompt, detectAndLoadAgentHarnessPromptImages, embeddedAgentLog, extractToolErrorMessage, getPluginToolMeta, isSubagentSessionKey, isToolResultError, resolveAgentHarnessBeforePromptBuildResult, resolveAttemptFsWorkspaceOnly, resolveAttemptSpawnWorkspaceDir, resolveBootstrapContextForRun, resolveCompactionTimeoutMs, resolveEmbeddedAttemptToolConstructionPlan, resolveModelAuthMode, resolveSandboxContext, resolveSessionAgentIds, resolveUserPath, runAgentEndSideEffects, runAgentHarnessAfterCompactionHook, runAgentHarnessAfterToolCallHook, runAgentHarnessBeforeCompactionHook, runAgentHarnessBeforeMessageWriteHook, runAgentHarnessLlmInputHook, runAgentHarnessLlmOutputHook, sanitizeToolResult, setActiveEmbeddedRun } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash } from "node:crypto";
 import path from "node:path";
 import fsp from "node:fs/promises";
+import { publishSessionTranscriptUpdateByIdentity, withSessionTranscriptWriteLock } from "openclaw/plugin-sdk/session-transcript-runtime";
+import { createAgentHarnessTaskRuntime } from "openclaw/plugin-sdk/agent-harness-task-runtime";
+import { createAgentHarnessToolSurfaceRuntime } from "openclaw/plugin-sdk/agent-harness-tool-runtime";
 //#region extensions/copilot/src/compaction-bridge.ts
 /**
 * Shape an `InfiniteSessionConfig` for `SessionConfig.infiniteSessions`.
@@ -95,12 +98,13 @@ function buildMirrorDedupeIdentity(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);
+	const transcriptTarget = resolveCopilotMirrorTranscriptTarget(params);
+	if (await withSessionTranscriptWriteLock({
+		...transcriptTarget,
+		config: params.config
+	}, async (transcript) => {
+		let didAppendMessage = false;
+		const existingIdempotencyKeys = readTranscriptIdempotencyKeys(await transcript.readEvents());
 		for (const message of messages) {
 			const dedupeIdentity = buildMirrorDedupeIdentity(message);
 			const idempotencyKey = params.idempotencyScope ? `${params.idempotencyScope}:${dedupeIdentity}` : void 0;
@@ -118,39 +122,35 @@ async function mirrorCopilotTranscript(params) {
 				...nextMessage,
 				idempotencyKey
 			} : nextMessage;
-			await appendSessionTranscriptMessage({
-				transcriptPath: params.sessionFile,
+			if (!await transcript.appendMessage({
 				message: messageToAppend,
-				config: params.config
-			});
+				idempotencyLookup: idempotencyKey ? "caller-checked" : "scan"
+			})) continue;
+			didAppendMessage = true;
 			if (idempotencyKey) existingIdempotencyKeys.add(idempotencyKey);
 		}
-	} finally {
-		await lock.release();
-	}
-	if (params.sessionKey) emitSessionTranscriptUpdate({
-		sessionFile: params.sessionFile,
-		sessionKey: params.sessionKey
+		return didAppendMessage;
+	})) await publishSessionTranscriptUpdateByIdentity({
+		...transcriptTarget,
+		update: params.sessionKey ? { sessionKey: params.sessionKey } : void 0
 	});
-	else emitSessionTranscriptUpdate(params.sessionFile);
 }
-async function readTranscriptIdempotencyKeys(sessionFile) {
+function resolveCopilotMirrorTranscriptTarget(params) {
+	const sessionFile = params.sessionFile.trim();
+	if (!sessionFile) throw new Error("Copilot transcript mirror requires a sessionFile target");
+	return {
+		...params.agentId ? { agentId: params.agentId } : {},
+		sessionFile,
+		sessionId: params.sessionId,
+		sessionKey: params.sessionKey ?? ""
+	};
+}
+function readTranscriptIdempotencyKeys(events) {
 	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;
-		}
+	for (const event of events) {
+		if (!event || typeof event !== "object" || Array.isArray(event)) continue;
+		const parsed = event;
+		if (typeof parsed.message?.idempotencyKey === "string") keys.add(parsed.message.idempotencyKey);
 	}
 	return keys;
 }
@@ -229,6 +229,7 @@ function attachEventBridge(session, options) {
 	let observedCompaction = false;
 	let deltaQueue = Promise.resolve();
 	let deltaChain = Promise.resolve();
+	let agentEventChain = Promise.resolve();
 	let compactionChain = Promise.resolve();
 	let compactionIdle = Promise.resolve();
 	let resolveCompactionIdle;
@@ -294,6 +295,44 @@ function attachEventBridge(session, options) {
 			toolName
 		});
 	});
+	registerListener(session, unsubscribeFns, "session.plan_changed", (event) => {
+		enqueueAgentEvent({
+			stream: "plan",
+			data: {
+				phase: "update",
+				title: "Plan updated",
+				source: "copilot-sdk",
+				operation: event.data.operation,
+				...event.agentId ? { agentId: event.agentId } : {}
+			}
+		});
+	});
+	registerListener(session, unsubscribeFns, "exit_plan_mode.requested", (event) => {
+		const steps = splitPlanText(event.data.planContent);
+		enqueueAgentEvent({
+			stream: "plan",
+			data: {
+				phase: "update",
+				title: "Plan updated",
+				source: "copilot-sdk",
+				...event.data.summary ? { explanation: event.data.summary } : {},
+				...steps.length > 0 ? { steps } : {},
+				...event.data.actions.length > 0 ? { actions: event.data.actions } : {},
+				...event.data.requestId ? { requestId: event.data.requestId } : {},
+				...event.data.recommendedAction ? { recommendedAction: event.data.recommendedAction } : {},
+				...event.agentId ? { agentId: event.agentId } : {}
+			}
+		});
+	});
+	registerListener(session, unsubscribeFns, "subagent.started", (event) => {
+		forwardNativeSubagentEvent(event);
+	});
+	registerListener(session, unsubscribeFns, "subagent.completed", (event) => {
+		forwardNativeSubagentEvent(event);
+	});
+	registerListener(session, unsubscribeFns, "subagent.failed", (event) => {
+		forwardNativeSubagentEvent(event);
+	});
 	registerListener(session, unsubscribeFns, "session.compaction_start", (event) => {
 		if (!isRootCompactionEvent(event)) return;
 		observedCompaction = true;
@@ -350,6 +389,9 @@ function attachEventBridge(session, options) {
 		awaitDeltaChain() {
 			return deltaChain;
 		},
+		awaitAgentEventChain() {
+			return agentEventChain;
+		},
 		hasObservedCompaction() {
 			return observedCompaction;
 		},
@@ -397,6 +439,17 @@ function attachEventBridge(session, options) {
 		if (!callback) return;
 		compactionChain = compactionChain.then(callback, callback).catch(() => void 0);
 	}
+	function enqueueAgentEvent(event) {
+		const callback = options.onAgentEvent;
+		if (!callback) return;
+		const invoke = () => callback(event);
+		agentEventChain = agentEventChain.then(invoke, invoke).catch(() => void 0);
+	}
+	function forwardNativeSubagentEvent(event) {
+		try {
+			options.onNativeSubagentEvent?.(event);
+		} catch {}
+	}
 	async function awaitStableCompaction() {
 		const idle = activeCompactionCount > 0 ? compactionIdle : void 0;
 		if (idle) await idle;
@@ -473,6 +526,9 @@ function isRootCompactionEvent(event) {
 function joinReasoning(order, reasoningById) {
 	return order.map((reasoningId) => reasoningById.get(reasoningId) ?? "").join("");
 }
+function splitPlanText(text) {
+	return (text ?? "").split(/\r?\n/).map((line) => line.trim().replace(/^[-*]\s+/, "")).filter((line) => line.length > 0);
+}
 function readString$2(value) {
 	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -561,6 +617,130 @@ function createHooksBridge(config, options) {
 	return Object.keys(hooks).length > 0 ? hooks : void 0;
 }
 //#endregion
+//#region extensions/copilot/src/native-subagent-task-mirror.ts
+const COPILOT_NATIVE_SUBAGENT_TASK_KIND = "copilot-native";
+const COPILOT_NATIVE_SUBAGENT_RUN_ID_PREFIX = "copilot-agent:";
+function createCopilotNativeSubagentTaskMirror(params) {
+	if (!params.scope) return;
+	return new CopilotNativeSubagentTaskMirror({
+		agentId: params.agentId,
+		now: params.now
+	}, createAgentHarnessTaskRuntime({
+		runtime: "subagent",
+		taskKind: COPILOT_NATIVE_SUBAGENT_TASK_KIND,
+		scope: params.scope,
+		runIdPrefix: COPILOT_NATIVE_SUBAGENT_RUN_ID_PREFIX
+	}));
+}
+var CopilotNativeSubagentTaskMirror = class {
+	constructor(params, runtime) {
+		this.params = params;
+		this.runtime = runtime;
+		this.runIdByAgentId = /* @__PURE__ */ new Map();
+		this.runIdByToolCallId = /* @__PURE__ */ new Map();
+		this.terminalRunIds = /* @__PURE__ */ new Set();
+		this.activeRunIds = /* @__PURE__ */ new Set();
+		this.now = params.now ?? Date.now;
+	}
+	handleEvent(event) {
+		const toolCallId = event.data.toolCallId.trim();
+		if (!toolCallId) return;
+		const runId = this.resolveRunId(event);
+		if (event.type === "subagent.started") {
+			this.handleStarted(event, runId, toolCallId);
+			return;
+		}
+		if (event.type === "subagent.completed") {
+			this.handleCompleted(event, runId);
+			return;
+		}
+		this.handleFailed(event, runId);
+	}
+	finalizeActiveRuns() {
+		const eventAt = this.now();
+		for (const runId of this.activeRunIds) {
+			this.terminalRunIds.add(runId);
+			this.runtime.finalizeTaskRunByRunId({
+				runId,
+				status: "cancelled",
+				endedAt: eventAt,
+				lastEventAt: eventAt,
+				error: "Copilot native subagent ended with its parent attempt.",
+				progressSummary: "Copilot native subagent cancelled with its parent attempt.",
+				terminalSummary: "Copilot native subagent cancelled."
+			});
+		}
+		this.activeRunIds.clear();
+	}
+	handleStarted(event, runId, toolCallId) {
+		const agentId = event.agentId?.trim();
+		if (agentId ? this.runIdByAgentId.get(agentId) : this.runIdByToolCallId.get(toolCallId)) return;
+		const eventAt = this.now();
+		const label = event.data.agentDisplayName.trim() || event.data.agentName.trim();
+		const task = event.data.agentDescription.trim() || `Copilot native subagent ${label}`;
+		if (!this.runtime.tryCreateRunningTaskRun({
+			sourceId: toolCallId,
+			agentId: this.params.agentId,
+			runId,
+			label: label || "Copilot subagent",
+			task,
+			notifyPolicy: "silent",
+			deliveryStatus: "not_applicable",
+			preferMetadata: true,
+			startedAt: eventAt,
+			lastEventAt: eventAt,
+			progressSummary: "Copilot native subagent started."
+		})) return;
+		if (agentId) this.runIdByAgentId.set(agentId, runId);
+		else this.runIdByToolCallId.set(toolCallId, runId);
+		this.terminalRunIds.delete(runId);
+		this.activeRunIds.add(runId);
+	}
+	handleCompleted(event, runId) {
+		if (this.terminalRunIds.has(runId)) return;
+		const eventAt = this.now();
+		this.terminalRunIds.add(runId);
+		this.activeRunIds.delete(runId);
+		this.runtime.finalizeTaskRunByRunId({
+			runId,
+			status: "succeeded",
+			endedAt: eventAt,
+			lastEventAt: eventAt,
+			progressSummary: "Copilot native subagent completed.",
+			terminalSummary: buildCompletionSummary(event)
+		});
+	}
+	handleFailed(event, runId) {
+		if (this.terminalRunIds.has(runId)) return;
+		const eventAt = this.now();
+		this.terminalRunIds.add(runId);
+		this.activeRunIds.delete(runId);
+		this.runtime.finalizeTaskRunByRunId({
+			runId,
+			status: "failed",
+			endedAt: eventAt,
+			lastEventAt: eventAt,
+			error: event.data.error,
+			progressSummary: "Copilot native subagent failed.",
+			terminalSummary: "Copilot native subagent failed."
+		});
+	}
+	resolveRunId(event) {
+		const agentId = event.agentId?.trim();
+		if (agentId) {
+			const existing = this.runIdByAgentId.get(agentId);
+			if (existing) return existing;
+		}
+		const existing = this.runIdByToolCallId.get(event.data.toolCallId);
+		if (existing) return existing;
+		return `${COPILOT_NATIVE_SUBAGENT_RUN_ID_PREFIX}${agentId || event.data.toolCallId.trim()}`;
+	}
+};
+function buildCompletionSummary(event) {
+	const details = [event.data.totalToolCalls !== void 0 ? `${event.data.totalToolCalls} tool calls` : void 0, event.data.totalTokens !== void 0 ? `${event.data.totalTokens} tokens` : void 0].filter((value) => value !== void 0);
+	return details.length > 0 ? `Copilot native subagent completed (${details.join(", ")}).` : "Copilot native subagent completed.";
+}
+//#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)";
@@ -812,7 +992,27 @@ async function createCopilotToolBridge(input) {
 		sourceTools: []
 	};
 	const createOpenClawCodingTools = input.createOpenClawCodingTools ?? (await import("openclaw/plugin-sdk/agent-harness")).createOpenClawCodingTools;
-	const toolOptions = buildOpenClawCodingToolsOptions(input, effectiveToolPlan);
+	const toolSurfaceRuntime = createAgentHarnessToolSurfaceRuntime({
+		abortSignal: input.abortSignal,
+		agentId: input.agentId,
+		config: attemptParams.config,
+		disableTools: attemptParams.disableTools,
+		executeTool: (toolParams) => executeCatalogTool(input, toolParams),
+		forceMessageTool: shouldForceCopilotMessageTool(attemptParams),
+		isRawModelRun: isCopilotRawModelRun(attemptParams),
+		modelToolsEnabled: true,
+		prompt: attemptParams.prompt,
+		runId: attemptParams.runId,
+		runtimeToolAllowlist: effectiveToolPlan.runtimeToolAllowlist,
+		sessionId: input.sessionId,
+		sessionKey: attemptParams.sandboxSessionKey ?? attemptParams.sessionKey ?? input.sessionKey,
+		sourceReplyDeliveryMode: attemptParams.sourceReplyDeliveryMode,
+		toolsAllow: attemptParams.toolsAllow
+	});
+	const toolOptions = buildOpenClawCodingToolsOptions(input, {
+		...effectiveToolPlan,
+		runtimeToolAllowlist: toolSurfaceRuntime.runtimeToolAllowlist
+	}, toolSurfaceRuntime);
 	let sourceTools;
 	try {
 		sourceTools = await createOpenClawCodingTools(toolOptions);
@@ -820,10 +1020,12 @@ async function createCopilotToolBridge(input) {
 		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 allowedSourceTools = filterCopilotToolsForAllowlist(sourceTools, toolSurfaceRuntime.runtimeToolAllowlist);
+	const filteredTools = filterCopilotToolsForAllowlist(filterCopilotToolsForConstructionPlan(toolSurfaceRuntime.compactTools(allowedSourceTools).tools, effectiveToolPlan.codingToolConstructionPlan, { preserveToolNames: toolSurfaceRuntime.runtimeToolAllowlist }), toolSurfaceRuntime.runtimeToolAllowlist);
 	const duplicateNames = findDuplicateToolNames(filteredTools);
 	if (duplicateNames.length > 0) throw new Error(`[copilot-tool-bridge] duplicate tool names: ${duplicateNames.join(", ")}`);
 	return {
+		cleanup: toolSurfaceRuntime.cleanup,
 		sdkTools: filteredTools.map((sourceTool) => convertOpenClawToolToSdkTool(sourceTool, {
 			abortSignal: input.abortSignal,
 			beforeExecute: input.beforeExecute,
@@ -855,7 +1057,7 @@ async function createCopilotToolBridge(input) {
 * {@link CopilotToolBridgeInput}; callers resolve it via
 * `resolveSandboxContext` before constructing the bridge.
 */
-function buildOpenClawCodingToolsOptions(input, toolPlan) {
+function buildOpenClawCodingToolsOptions(input, toolPlan, toolSurfaceRuntime) {
 	const a = input.attemptParams ?? {};
 	const sandboxSessionKey = a.sandboxSessionKey?.trim() || a.sessionKey?.trim() || input.sessionKey || input.sessionId;
 	const liveSessionKey = a.sessionKey ?? input.sessionKey;
@@ -907,11 +1109,14 @@ function buildOpenClawCodingToolsOptions(input, toolPlan) {
 		cwd,
 		sandbox,
 		spawnWorkspaceDir,
-		config: a.config,
+		config: toolSurfaceRuntime?.config ?? a.config,
 		abortSignal: input.abortSignal,
 		modelProvider: input.modelProvider,
 		modelId: input.modelId,
 		includeCoreTools: toolPlan.includeCoreTools,
+		includeToolSearchControls: toolSurfaceRuntime?.includeToolSearchControls,
+		toolSearchCatalogRef: toolSurfaceRuntime?.toolSearchCatalogRef,
+		toolSearchCatalogExecutor: toolSurfaceRuntime?.toolSearchCatalogExecutor,
 		runtimeToolAllowlist: toolPlan.runtimeToolAllowlist,
 		toolConstructionPlan: toolPlan.codingToolConstructionPlan,
 		modelCompat,
@@ -1046,6 +1251,56 @@ function convertOpenClawToolToSdkTool(sourceTool, ctx) {
 		skipPermission: true
 	};
 }
+async function executeCatalogTool(input, params) {
+	const sourceTool = params.tool;
+	const startedAt = Date.now();
+	let preparedArgs = params.input;
+	try {
+		preparedArgs = sourceTool.prepareArguments ? sourceTool.prepareArguments(params.input) : params.input;
+		const result = await sourceTool.execute(params.toolCallId, preparedArgs, params.signal ?? input.abortSignal, params.onUpdate);
+		const sanitizedResult = sanitizeToolResult(result);
+		const isError = isToolResultError(sanitizedResult);
+		input.attemptParams?.onAgentToolResult?.({
+			toolName: params.toolName,
+			result: sanitizedResult,
+			isError
+		});
+		await input.onToolCompleted?.({
+			toolName: params.toolName,
+			toolCallId: params.toolCallId,
+			args: toToolStartArgs(preparedArgs),
+			result: sanitizedResult,
+			...isError ? { error: extractToolErrorMessage(sanitizedResult) ?? "tool returned an error" } : {},
+			startedAt
+		});
+		return result;
+	} catch (error) {
+		const message = toError$1(error).message;
+		const failure = sanitizeToolResult({
+			content: [{
+				type: "text",
+				text: message
+			}],
+			details: {
+				status: "failed",
+				error: message
+			}
+		});
+		input.attemptParams?.onAgentToolResult?.({
+			toolName: params.toolName,
+			result: failure,
+			isError: true
+		});
+		await input.onToolCompleted?.({
+			toolName: params.toolName,
+			toolCallId: params.toolCallId,
+			args: toToolStartArgs(preparedArgs),
+			error: message,
+			startedAt
+		});
+		throw error;
+	}
+}
 function toToolStartArgs(args) {
 	return args && typeof args === "object" && !Array.isArray(args) ? args : { value: args };
 }
@@ -1139,9 +1394,11 @@ function shouldForceCopilotMessageTool(params) {
 function filterCopilotToolsForAllowlist(tools, toolsAllow) {
 	return applyEmbeddedAttemptToolsAllow(tools, toolsAllow, { toolMeta: (tool) => getPluginToolMeta(tool) ?? readInlinePluginToolMeta(tool) });
 }
-function filterCopilotToolsForConstructionPlan(tools, plan) {
+function filterCopilotToolsForConstructionPlan(tools, plan, options = {}) {
 	if (plan.includeBaseCodingTools && plan.includeShellTools) return tools;
+	const preserveToolNames = new Set(options.preserveToolNames);
 	return tools.filter((tool) => {
+		if (preserveToolNames.has(tool.name)) return true;
 		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;
@@ -1173,6 +1430,97 @@ function toError$1(error) {
 	return error instanceof Error ? error : new Error(String(error));
 }
 //#endregion
+//#region extensions/copilot/src/user-input-bridge.ts
+const COPILOT_USER_INPUT_QUESTION_ID = "answer";
+function createCopilotUserInputBridge(params) {
+	let pending;
+	const resolvePending = (value) => {
+		const current = pending;
+		if (!current) return;
+		pending = void 0;
+		current.cleanup();
+		current.resolve(value);
+	};
+	return {
+		onUserInputRequest(request) {
+			const question = toQuestion(request);
+			resolvePending(emptyCopilotUserInputResponse());
+			return new Promise((resolve) => {
+				const abortListener = () => resolvePending(emptyCopilotUserInputResponse());
+				const cleanup = () => params.signal?.removeEventListener("abort", abortListener);
+				pending = {
+					question,
+					resolve,
+					cleanup
+				};
+				params.signal?.addEventListener("abort", abortListener, { once: true });
+				if (params.signal?.aborted) {
+					resolvePending(emptyCopilotUserInputResponse());
+					return;
+				}
+				deliverAgentHarnessUserInputPrompt(params.paramsForRun, [question], {
+					intro: "Copilot needs input:",
+					formatText: formatCopilotDisplayText
+				}).catch((error) => {
+					embeddedAgentLog.warn("failed to deliver copilot user input prompt", { error });
+				});
+			});
+		},
+		handleQueuedMessage(text) {
+			const current = pending;
+			if (!current) return false;
+			resolvePending(buildCopilotUserInputResponse(current.question, text));
+			return true;
+		},
+		cancelPending() {
+			resolvePending(emptyCopilotUserInputResponse());
+		}
+	};
+}
+function toQuestion(request) {
+	return {
+		id: COPILOT_USER_INPUT_QUESTION_ID,
+		header: "Copilot needs input",
+		question: request.question,
+		isOther: request.allowFreeform !== false,
+		isSecret: false,
+		options: request.choices && request.choices.length > 0 ? request.choices.map((choice) => ({ label: choice })) : null
+	};
+}
+function buildCopilotUserInputResponse(question, inputText) {
+	const selected = buildAgentHarnessUserInputAnswers([question], inputText).answers[COPILOT_USER_INPUT_QUESTION_ID]?.answers[0] ?? "";
+	return {
+		answer: selected,
+		wasFreeform: !isChoiceAnswer(question, selected)
+	};
+}
+function emptyCopilotUserInputResponse() {
+	return {
+		answer: "",
+		wasFreeform: true
+	};
+}
+function isChoiceAnswer(question, answer) {
+	return Boolean(answer && question.options?.some((option) => option.label.toLowerCase() === answer.toLowerCase()));
+}
+function formatCopilotDisplayText(value) {
+	return escapeCopilotChatText(sanitizeCopilotDisplayText(value).trim() || "<unknown>");
+}
+function sanitizeCopilotDisplayText(value) {
+	let safe = "";
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		safe += codePoint != null && isUnsafeDisplayCodePoint(codePoint) ? "?" : character;
+	}
+	return safe;
+}
+function escapeCopilotChatText(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("@", "＠").replaceAll("`", "｀").replaceAll("[", "［").replaceAll("]", "］").replaceAll("(", "（").replaceAll(")", "）").replaceAll("*", "∗").replaceAll("_", "＿").replaceAll("~", "～").replaceAll("|", "｜");
+}
+function isUnsafeDisplayCodePoint(codePoint) {
+	return codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint === 173 || codePoint === 1564 || codePoint === 6158 || codePoint >= 8203 && codePoint <= 8207 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8288 && codePoint <= 8303 || codePoint === 65279 || codePoint >= 65529 && codePoint <= 65531 || codePoint >= 917504 && codePoint <= 917631;
+}
+//#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([
@@ -1325,6 +1673,7 @@ function readResolvedWorkspacePath(value) {
 //#region extensions/copilot/src/attempt.ts
 const SUPPORTED_PROVIDERS = new Set(["github-copilot"]);
 const BACKGROUND_COMPACTION_CANCEL_TIMEOUT_MS = 5e3;
+const COPILOT_ASK_USER_AVAILABLE_TOOLS = ["builtin:ask_user"];
 async function runCopilotAgentEndHook(params, hookParams) {
 	if (!params.messageChannel && !params.messageProvider) {
 		await awaitAgentEndSideEffects(hookParams);
@@ -1380,10 +1729,12 @@ function deferBackgroundCompactionCleanup(params) {
 				await cancelBackgroundCompactionBeforeTeardown(params.session);
 				params.bridge.settleCompactionWait();
 			}
+			params.finalizeNativeSubagents?.();
 			params.bridge.detach();
 			try {
 				await params.session.disconnect();
 			} catch {}
+			params.cleanupToolBridge?.();
 			if (outcome !== "completed" && params.sdkSessionId) try {
 				await params.handle.client.deleteSession(params.sdkSessionId);
 			} catch {}
@@ -1482,17 +1833,31 @@ async function runCopilotAttempt(params, deps) {
 	let handle;
 	let session;
 	let bridge;
+	const nativeSubagentTaskMirror = createCopilotNativeSubagentTaskMirror({
+		agentId: sessionAgentId,
+		now,
+		scope: input.agentHarnessTaskRuntimeScope
+	});
+	let activeRunHandleRef;
+	let userInputBridgeRef;
+	let cleanupToolBridge;
 	let releaseError;
 	let downgradedFromResume = false;
 	let resumeFailureRecovered = false;
 	let yieldDetected = false;
-	const onAbort = () => {
+	const markExternalAbort = () => {
 		abortRequested = true;
 		externalAbort = true;
 		aborted = true;
+	};
+	const abortActiveSession = () => {
+		markExternalAbort();
 		if (settled || !sentTurnStarted || !session) return;
 		session.abort().catch(() => void 0);
 	};
+	const onAbort = () => {
+		abortActiveSession();
+	};
 	params.abortSignal?.addEventListener("abort", onAbort, { once: true });
 	const resolveSandbox = deps.resolveSandboxContextOverride ?? resolveSandboxContext;
 	let sandbox = null;
@@ -1552,7 +1917,7 @@ async function runCopilotAttempt(params, deps) {
 	try {
 		let sdkTools;
 		try {
-			sdkTools = (await createToolBridge({
+			const toolBridge = await createToolBridge({
 				modelProvider: modelRef.provider,
 				modelId: modelRef.id,
 				agentId: readString(params.agentId) ?? "copilot",
@@ -1582,7 +1947,9 @@ async function runCopilotAttempt(params, deps) {
 					...error ? { error } : {},
 					startedAt
 				})
-			})).sdkTools;
+			});
+			cleanupToolBridge = toolBridge.cleanup;
+			sdkTools = toolBridge.sdkTools;
 		} catch (error) {
 			return finishAttempt(createResult(input, {
 				messagesSnapshot: messages,
@@ -1631,7 +1998,12 @@ async function runCopilotAttempt(params, deps) {
 			});
 		};
 		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 userInputBridge = createCopilotUserInputBridge({
+			paramsForRun: attemptInput,
+			signal: params.abortSignal
+		});
+		userInputBridgeRef = userInputBridge;
+		const sessionConfig = createSessionConfig(attemptInput, modelRef.id, sdkTools, poolAcquire.auth, promptBuild.developerInstructions || void 0, effectiveWorkspaceDir, effectiveCwd, userInputBridge.onUserInputRequest, hasNativePromptHook ? { onUserPromptSubmitted: ({ additionalContext, prompt }) => emitLlmInput(prompt, additionalContext) } : void 0);
 		const replayDecision = decideReplayAction({
 			sdkSessionId: input.initialReplayState?.sdkSessionId,
 			replayInvalid: input.initialReplayState?.replayInvalid
@@ -1661,6 +2033,8 @@ async function runCopilotAttempt(params, deps) {
 		} catch {}
 		bridge = attachEventBridge(session, {
 			onAssistantDelta: input.onAssistantDelta,
+			onAgentEvent: input.onAgentEvent,
+			onNativeSubagentEvent: (event) => nativeSubagentTaskMirror?.handleEvent(event),
 			onCompactionStart: async () => {
 				const sessionFile = readString(input.sessionFile);
 				if (!sessionFile) return;
@@ -1681,6 +2055,26 @@ async function runCopilotAttempt(params, deps) {
 			getSdkSessionId: () => sdkSessionId,
 			isAborted: () => aborted
 		});
+		const activeRunHandle = {
+			kind: "embedded",
+			queueMessage: async (text) => {
+				if (userInputBridge.handleQueuedMessage(text)) return;
+				throw new Error("Copilot runtime is not waiting for user input.");
+			},
+			isStreaming: () => !settled && !aborted,
+			isCompacting: () => bridge?.isCompacting() ?? false,
+			sourceReplyDeliveryMode: input.sourceReplyDeliveryMode,
+			cancel: () => {
+				userInputBridge.cancelPending();
+				abortActiveSession();
+			},
+			abort: () => {
+				userInputBridge.cancelPending();
+				abortActiveSession();
+			}
+		};
+		setActiveEmbeddedRun(input.sessionId, activeRunHandle, input.sessionKey, input.sessionFile);
+		activeRunHandleRef = activeRunHandle;
 		const messageOptions = await createMessageOptions(attemptInput, {
 			effectiveCwd,
 			effectiveWorkspaceDir,
@@ -1696,6 +2090,7 @@ async function runCopilotAttempt(params, deps) {
 			if (!hasNativePromptHook) emitLlmInput(attemptInput.prompt);
 			const result = await session.sendAndWait(messageOptions, input.timeoutMs);
 			await bridge.awaitDeltaChain();
+			await bridge.awaitAgentEventChain();
 			if (!bridge.recordSendResult(result) && !aborted) {
 				timedOut = true;
 				timedOutDuringCompaction = bridge.isCompacting();
@@ -1710,9 +2105,12 @@ async function runCopilotAttempt(params, deps) {
 			try {
 				await bridge?.awaitDeltaChain();
 			} catch {}
+			await bridge?.awaitAgentEventChain();
 		} else promptError = toError(error);
 	} finally {
 		settled = true;
+		userInputBridgeRef?.cancelPending();
+		if (activeRunHandleRef) clearActiveEmbeddedRun(input.sessionId, activeRunHandleRef, input.sessionKey, input.sessionFile);
 		if ((bridge?.hasObservedCompaction() || timedOut && bridge?.hasObservedSessionIdle() === false) && bridge && session && handle) {
 			const cleanupAbort = new AbortController();
 			const abortCleanup = () => cleanupAbort.abort();
@@ -1722,6 +2120,8 @@ async function runCopilotAttempt(params, deps) {
 				abortSignal: cleanupAbort.signal,
 				awaitSessionIdle: !bridge.hasObservedSessionIdle(),
 				bridge,
+				cleanupToolBridge,
+				finalizeNativeSubagents: () => nativeSubagentTaskMirror?.finalizeActiveRuns(),
 				handle,
 				pool: deps.pool,
 				sdkSessionId,
@@ -1741,6 +2141,9 @@ async function runCopilotAttempt(params, deps) {
 			params.abortSignal?.removeEventListener("abort", onAbort);
 		} else {
 			await bridge?.awaitCompactionChain();
+			await bridge?.awaitAgentEventChain();
+			nativeSubagentTaskMirror?.finalizeActiveRuns();
+			cleanupToolBridge?.();
 			bridge?.detach();
 			params.abortSignal?.removeEventListener("abort", onAbort);
 			if (session) try {
@@ -1778,19 +2181,21 @@ async function runCopilotAttempt(params, deps) {
 		...taggedLastAssistant ? [taggedLastAssistant] : []
 	];
 	const sessionFileForMirror = readString(input.sessionFile);
-	const sessionIdForScope = sessionIdUsed ?? readString(input.sessionId);
-	if (sessionFileForMirror && messagesSnapshot.length > 0) {
+	const openClawSessionIdForMirror = readString(input.sessionId);
+	const mirrorScopeSessionId = sessionIdUsed ?? openClawSessionIdForMirror;
+	if (sessionFileForMirror && openClawSessionIdForMirror && 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}`);
+			return attachCopilotMirrorIdentity(message, `${sdkSessionId ?? mirrorScopeSessionId ?? "attempt"}:${message.role}:${index}`);
 		});
 		await dualWriteCopilotTranscriptBestEffort({
 			sessionFile: sessionFileForMirror,
+			sessionId: openClawSessionIdForMirror,
 			sessionKey: readString(input.sessionKey),
 			agentId: readString(input.agentId),
 			messages: taggedMessages,
-			idempotencyScope: sessionIdForScope ? `copilot:${sessionIdForScope}` : void 0,
+			idempotencyScope: mirrorScopeSessionId ? `copilot:${mirrorScopeSessionId}` : void 0,
 			config: input.config
 		}).catch((mirrorError) => {
 			console.warn("[copilot-attempt] dual-write transcript wrapper rejected unexpectedly", mirrorError);
@@ -1894,19 +2299,20 @@ function createPromptError(code, message, cause) {
 	if (cause !== void 0) error.cause = cause;
 	return error;
 }
-function createSessionConfig(params, sdkModelId, sdkTools, resolvedAuth, systemMessageContent, effectiveWorkspaceDir, effectiveCwd, hooksBridgeOptions) {
+function createSessionConfig(params, sdkModelId, sdkTools, resolvedAuth, systemMessageContent, effectiveWorkspaceDir, effectiveCwd, onUserInputRequest, hooksBridgeOptions) {
 	const permissionPolicy = params.permissionPolicy ?? rejectAllPolicy;
 	const hooks = createHooksBridge(params.hooksConfig, hooksBridgeOptions);
 	const infiniteSessions = createInfiniteSessionConfig(params.infiniteSessionConfig);
 	return {
 		model: sdkModelId,
 		onPermissionRequest: createPermissionBridge(permissionPolicy),
+		onUserInputRequest,
 		...hooks ? { hooks } : {},
 		...typeof params.enableSessionTelemetry === "boolean" ? { enableSessionTelemetry: params.enableSessionTelemetry } : {},
 		...infiniteSessions ? { infiniteSessions } : {},
 		reasoningEffort: params.reasoningEffort,
 		tools: sdkTools,
-		availableTools: sdkTools.map((tool) => tool.name),
+		availableTools: buildCopilotAvailableTools(sdkTools),
 		workingDirectory: effectiveCwd ?? effectiveWorkspaceDir ?? readResolvedAttemptPath(params.workspaceDir),
 		...effectiveWorkspaceDir && effectiveCwd && effectiveCwd !== effectiveWorkspaceDir ? { instructionDirectories: [effectiveWorkspaceDir] } : {},
 		...resolvedAuth.authMode === "gitHubToken" && resolvedAuth.gitHubToken ? { gitHubToken: resolvedAuth.gitHubToken } : {},
@@ -1916,6 +2322,9 @@ function createSessionConfig(params, sdkModelId, sdkTools, resolvedAuth, systemM
 		} } : {}
 	};
 }
+function buildCopilotAvailableTools(sdkTools) {
+	return [...new Set([...sdkTools.map((tool) => tool.name), ...COPILOT_ASK_USER_AVAILABLE_TOOLS])];
+}
 async function createMessageOptions(params, context) {
 	const attachments = createPromptImageAttachments(await resolvePromptImages(params, context));
 	return attachments.length > 0 ? {

package/dist/{harness-I9ahzRYI.js → harness-D-3KWchY.js}

@@ -421,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-BQoxgpM3.js");
+				const { resolvePoolAcquire, runCopilotAttempt } = await import("./attempt-ArBh6GPT.js");
 				if (disposed) throw new Error("[copilot] harness was disposed while starting an attempt");
 				const poolAcquire = resolvePoolAcquire(params);
 				const pool = await getPool();
@@ -531,7 +531,7 @@ function createCopilotAgentHarness(options) {
 			};
 			const tracked = trackedSessions.get(openclawSessionId);
 			const currentCompactKey = computeSessionCompactKey(params);
-			const { resolvePoolAcquire } = await import("./attempt-BQoxgpM3.js");
+			const { resolvePoolAcquire } = await import("./attempt-ArBh6GPT.js");
 			const resolvedPoolAcquire = resolvePoolAcquire(params);
 			const currentAuth = sessionAuthFields(resolvedPoolAcquire.auth);
 			const compatibleTracked = tracked?.compactKey === currentCompactKey && sessionAuthMatches(tracked, currentAuth) ? tracked : void 0;
@@ -617,7 +617,16 @@ function createCopilotAgentHarness(options) {
 			return {
 				ok: true,
 				compacted,
-				reason: compacted ? "copilot-sdk-history-compacted" : "already under target"
+				reason: compacted ? "copilot-sdk-history-compacted" : "already under target",
+				...compacted ? { result: {
+					summary: compactResult.summaryContent ?? "",
+					firstKeptEntryId: "",
+					tokensBefore: params.currentTokenCount ?? (compactResult.contextWindow?.currentTokens ?? 0) + compactResult.tokensRemoved,
+					tokensAfter: compactResult.contextWindow?.currentTokens,
+					details: compactResult,
+					sessionId: params.sessionId,
+					sessionFile: params.sessionFile
+				} } : {}
 			};
 		},
 		async dispose() {

package/dist/harness.js

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

package/dist/index.js

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

package/npm-shrinkwrap.json

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

package/openclaw.plugin.json

@@ -2,6 +2,7 @@
   "id": "copilot",
   "name": "GitHub Copilot agent runtime",
   "description": "Registers the GitHub Copilot agent runtime.",
+  "icon": "https://cdn.simpleicons.org/githubcopilot",
   "version": "2026.6.2",
   "activation": {
     "onStartup": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/copilot",
-  "version": "2026.6.10",
+  "version": "2026.6.11",
   "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.10"
+      "pluginApi": ">=2026.6.11"
     },
     "build": {
-      "openclawVersion": "2026.6.10",
+      "openclawVersion": "2026.6.11",
       "bundledDist": false
     },
     "release": {
@@ -47,7 +47,7 @@
     "README.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.6.10"
+    "openclaw": ">=2026.6.11"
   },
   "peerDependenciesMeta": {
     "openclaw": {