@openclaw/acpx 2026.9.5 → 2026.9.6

package/README.md

@@ -19,6 +19,57 @@ Restart the Gateway after installing or updating the plugin.
 - MCP bridge helpers for OpenClaw tools and plugin tools.
 - Static runtime assets used by the ACP process bridge.
 
+## Native agents in the model picker
+
+Install GitHub Copilot CLI, Kilo Code, OpenCode, Pi ACP, or Qwen Code and complete its login on the Gateway host,
+then refresh the model catalog. Choose one of its models to use that agent in ordinary chat.
+The agent owns its credentials; OpenClaw keeps the conversation transcript and asks for approval
+when the agent requests permission. Pi does not request tool approval unless an extension adds it.
+The same selection works in the web app and channels.
+
+The runtime and provider IDs are `acp-copilot`, `acp-kilocode`, `acp-opencode`, `acp-pi`, and `acp-qwen`.
+Each model keeps its native ID, including any slashes. Configured ACP agent commands take
+precedence over installed defaults. Catalog refresh uses installed commands and does not install
+missing agents. Explicit ACP commands and bindings keep their existing agent names.
+
+Models settings lists detected agents on the Gateway machine. Turn each native agent on or off
+there, or set `plugins.entries.acpx.config.nativeAgents.<id>` to `false` (`copilot`, `kilocode`,
+`opencode`, `pi`, or `qwen`). Missing flags are enabled. Disabling an agent prevents new native turns
+and catalog discovery without interrupting a running turn or deleting history. Classic ACP
+commands and `acp.allowedAgents` keep their existing behavior. Detection checks installed
+executables; it does not prove that an agent is logged in or can serve a model.
+
+For GitHub Copilot CLI, run `copilot login` under the Gateway's OS account before refreshing
+the catalog. Copilot owns GitHub authentication, model access, and plan usage. Its explicitly
+configured BYOK providers remain CLI-owned and can incur separate API charges; OpenClaw does
+not select a BYOK route for it. See the
+[Copilot setup and billing notes](https://docs.openclaw.ai/tools/acp-agents-setup#github-copilot-cli-in-native-chat).
+
+Native picker runtimes run on the Gateway host and use the native app's permissions.
+OpenClaw checks that execution choice before dispatching a chat turn; ACP runners do not
+implement OpenClaw sandboxing or workspace-only filesystem confinement.
+
+When optional chat restrictions cannot be enforced, an administrator can choose
+**Continue for this chat** to use the native app's permissions. This grants Full Access
+and turns off optional sandboxing for that chat only; agent-wide and global settings
+stay unchanged. After a refused message, confirmation retries that message once.
+Confirming a model selection without a pending message does not send anything.
+
+A creator-role-required sandbox cannot be removed, and remote execution placement
+is not supported. Choose a compatible runtime when those boundaries must remain.
+OpenClaw's Read Only, Guarded, and Workspace permission modes are not supported
+by these native runtimes.
+
+Native tool permission requests still require their one-shot approval. Once approved,
+delegated filesystem writes do not encounter a second ACPX terminal approval gate.
+Classic ACP sessions keep their configured `permissionMode`. The ACP client's
+delegated filesystem remains rooted at its session cwd; this is not a sandbox for
+the native process's own filesystem access.
+
+Catalog refresh closes its local connection. The native agent owns any history it creates.
+Reset and deletion close the local session and prevent its reuse, including after a Gateway restart.
+Native history stays with the agent; these operations do not delete it.
+
 ## Configure
 
 Use the ACP docs for harness-specific setup, permission modes, and model/runtime selection:

package/dist/.setup/command-line-CPBLOiZM.mjs

@@ -0,0 +1,138 @@
+//#region extensions/acpx/src/codex-adapter.ts
+const CODEX_ACP_PACKAGE = "@agentclientprotocol/codex-acp";
+const CODEX_ACP_BIN = "codex-acp";
+const LEGACY_CODEX_ACP_PACKAGE = "@zed-industries/codex-acp";
+const OPENCLAW_CODEX_CONFIG_ARG = "--openclaw-codex-config";
+//#endregion
+//#region extensions/acpx/src/command-line.ts
+/** Match ACPX's persisted argv identity; scalar records keep their original bytes. */
+function renderAgentCommand(command) {
+	return typeof command === "string" ? command : command.map((part) => /^[A-Za-z0-9_@%+=:,./^~-]+$/.test(part) ? part : JSON.stringify(part)).join(" ");
+}
+/** Split a command string into argv-like parts using simple quote/backslash rules. */
+function splitCommandParts(value) {
+	if (Array.isArray(value)) return value;
+	const windows = process.platform === "win32";
+	const parts = [];
+	let current = "";
+	let quote = null;
+	let escaping = false;
+	let hasPart = false;
+	for (const ch of value) {
+		if (escaping) {
+			current += ch;
+			escaping = false;
+			hasPart = true;
+			continue;
+		}
+		if (ch === "\\" && quote !== "'" && !windows) {
+			escaping = true;
+			hasPart = true;
+			continue;
+		}
+		if (windows && ch === "\"" && quote !== "'") {
+			const backslashes = current.match(/\\+$/)?.[0].length ?? 0;
+			current = current.slice(0, current.length - backslashes) + "\\".repeat(Math.floor(backslashes / 2));
+			if (backslashes % 2 === 1) {
+				current += "\"";
+				continue;
+			}
+		}
+		if (quote) {
+			if (ch === quote) quote = null;
+			else current += ch;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = ch;
+			hasPart = true;
+			continue;
+		}
+		if (/\s/.test(ch)) {
+			if (hasPart) {
+				parts.push(current);
+				current = "";
+				hasPart = false;
+			}
+			continue;
+		}
+		current += ch;
+		hasPart = true;
+	}
+	if (escaping) current += "\\";
+	if (quote) throw new Error("Invalid agent command: unterminated quote");
+	if (hasPart) parts.push(current);
+	return parts;
+}
+const OPENCLAW_BRIDGE_EXECUTABLE = "openclaw";
+const OPENCLAW_BRIDGE_SUBCOMMAND = "acp";
+function normalizeAgentName(value) {
+	const normalized = value?.trim().toLowerCase();
+	return normalized ? normalized : void 0;
+}
+function basename(value) {
+	return value.split(/[\\/]/).pop() ?? value;
+}
+function isEnvAssignment(value) {
+	return /^[A-Za-z_][A-Za-z0-9_]*=/.test(value);
+}
+function unwrapEnvCommand(parts) {
+	const command = parts.at(0);
+	if (!command || basename(command) !== "env") return parts;
+	let index = 1;
+	while (true) {
+		const part = parts.at(index);
+		if (!part || !isEnvAssignment(part)) break;
+		index += 1;
+	}
+	return parts.slice(index);
+}
+function matchesExecutableName(value, executableName) {
+	const normalized = basename(value).toLowerCase();
+	return normalized === executableName || normalized === `${executableName}.exe`;
+}
+function matchesPackageSpec(value, packageName) {
+	const normalized = value.trim().toLowerCase();
+	return normalized === packageName || normalized.startsWith(`${packageName}@`);
+}
+function stripModuleExtension(value) {
+	return value.replace(/\.[cm]?js$/i, "").toLowerCase();
+}
+function isAcpCommand(command, params) {
+	if (!command) return false;
+	const parts = unwrapEnvCommand(splitCommandParts(command));
+	if (!parts.length) return false;
+	if (parts.some((part) => matchesPackageSpec(part, params.packageName))) return true;
+	const commandName = basename(parts[0] ?? "");
+	if (matchesExecutableName(commandName, params.executableName)) return true;
+	if (!matchesExecutableName(commandName, "node")) return false;
+	const scriptName = stripModuleExtension(basename(parts[1] ?? ""));
+	return scriptName === params.executableName || scriptName === `${params.executableName}-wrapper`;
+}
+function isOpenClawBridgeCommand(command) {
+	if (!command) return false;
+	const parts = unwrapEnvCommand(splitCommandParts(command));
+	if (basename(parts[0] ?? "") === OPENCLAW_BRIDGE_EXECUTABLE) return parts[1] === OPENCLAW_BRIDGE_SUBCOMMAND;
+	if (basename(parts[0] ?? "") !== "node") return false;
+	const scriptName = basename(parts[1] ?? "");
+	return /^openclaw(?:\.[cm]?js)?$/i.test(scriptName) && parts[2] === OPENCLAW_BRIDGE_SUBCOMMAND;
+}
+function isCodexAcpCommand(command) {
+	return isAcpCommand(command, {
+		packageName: CODEX_ACP_PACKAGE,
+		executableName: "codex-acp"
+	});
+}
+function isClaudeAcpCommand(command) {
+	return isAcpCommand(command, {
+		packageName: "@agentclientprotocol/claude-agent-acp",
+		executableName: "claude-agent-acp"
+	});
+}
+function resolveAgentCommand(params) {
+	const normalizedAgentName = normalizeAgentName(params.agentName);
+	if (!normalizedAgentName) return;
+	return splitCommandParts(params.agentRegistry.resolve(normalizedAgentName));
+}
+//#endregion
+export { renderAgentCommand as a, CODEX_ACP_BIN as c, OPENCLAW_CODEX_CONFIG_ARG as d, normalizeAgentName as i, CODEX_ACP_PACKAGE as l, isCodexAcpCommand as n, resolveAgentCommand as o, isOpenClawBridgeCommand as r, splitCommandParts as s, isClaudeAcpCommand as t, LEGACY_CODEX_ACP_PACKAGE as u };

package/dist/.setup/{config-DvCm0_Dp.mjs → config-CdPsIued.mjs}

@@ -1,16 +1,30 @@
-import { _ as splitCommandParts } from "./process-lease-B83BGiLj.mjs";
+import { s as splitCommandParts } from "./command-line-CPBLOiZM.mjs";
 import { createRequire } from "node:module";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { z } from "zod";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
-import { z } from "zod";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/acpx/src/config-schema.ts
 /**
 * ACPX plugin configuration schema and public config types. Runtime setup uses
 * this file as the single source of truth for validation and defaulting.
 */
+const ACPX_NATIVE_AGENT_IDS = [
+	"opencode",
+	"qwen",
+	"pi",
+	"kilocode",
+	"copilot"
+];
+const AcpxNativeAgentsSchema = z.strictObject({
+	opencode: z.boolean().optional(),
+	qwen: z.boolean().optional(),
+	pi: z.boolean().optional(),
+	kilocode: z.boolean().optional(),
+	copilot: z.boolean().optional()
+}).optional();
 const ACPX_PERMISSION_MODES = [
 	"approve-all",
 	"approve-reads",
@@ -25,6 +39,7 @@ const McpServerConfigSchema = z.object({
 });
 /** Zod schema for validating raw ACPX plugin config from OpenClaw config. */
 const AcpxPluginConfigSchema = z.strictObject({
+	nativeAgents: AcpxNativeAgentsSchema,
 	cwd: nonEmptyTrimmedString("cwd must be a non-empty string").optional(),
 	stateDir: nonEmptyTrimmedString("stateDir must be a non-empty string").optional(),
 	probeAgent: nonEmptyTrimmedString("probeAgent must be a non-empty string").optional(),
@@ -181,4 +196,4 @@ function resolveAcpxPluginConfig(params) {
 	};
 }
 //#endregion
-export { toAcpMcpServers as i, resolveAcpxPluginRoot as n, resolveOpenClawRoot as r, resolveAcpxPluginConfig as t };
+export { ACPX_NATIVE_AGENT_IDS as a, toAcpMcpServers as i, resolveAcpxPluginRoot as n, AcpxNativeAgentsSchema as o, resolveOpenClawRoot as r, resolveAcpxPluginConfig as t };

package/dist/.setup/harness-attempt-CDXMeP5Z.mjs

@@ -0,0 +1,369 @@
+import { randomUUID } from "node:crypto";
+import { consumeAcpTurnStream } from "openclaw/plugin-sdk/acp-runtime";
+import { clearActiveEmbeddedRun, emitAgentEvent, resolveAgentHarnessBeforePromptBuildResult, resolveBootstrapContextForRun, setActiveEmbeddedRun } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { SessionManager, buildSessionContext } from "openclaw/plugin-sdk/agent-sessions";
+import { DEFAULT_PLUGIN_APPROVAL_TIMEOUT_MS } from "openclaw/plugin-sdk/approval-runtime";
+import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import { resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { appendSessionTranscriptMessageByIdentityStrict } from "openclaw/plugin-sdk/session-transcript-runtime";
+//#region extensions/acpx/src/harness-attempt.ts
+async function runAcpHarnessAttempt(params) {
+	const { input, runtime } = params;
+	if (!input.agentId || !input.sessionKey) throw new Error("ACP chat requires an owned OpenClaw session");
+	const agentId = input.agentId;
+	const sessionKey = input.sessionKey;
+	const controller = new AbortController();
+	const signal = AbortSignal.any([
+		controller.signal,
+		params.generationSignal,
+		...input.abortSignal ? [input.abortSignal] : []
+	]);
+	const eventGate = { open: !signal.aborted };
+	const stopDelivery = () => {
+		eventGate.open = false;
+	};
+	const assertActive = () => {
+		signal.throwIfAborted();
+		input.hostCapabilities.assertActive();
+	};
+	const transcript = {
+		agentId,
+		sessionKey,
+		sessionId: input.sessionId,
+		storePath: resolveStorePath(input.config?.session?.store, { agentId })
+	};
+	const recorder = input.userTurnTranscriptRecorder;
+	if (!recorder) throw new Error("ACP chat requires its admitted transcript recorder");
+	let handle;
+	let text = "";
+	let reasoning = "";
+	let started = false;
+	let settled = false;
+	let timedOut = false;
+	let denied = false;
+	let approvalFailure;
+	let failure;
+	let cancelled = false;
+	let terminalAnchor;
+	let assistant;
+	let assistantIdempotencyKey;
+	const toolMetas = [];
+	let messages = [];
+	const activeRun = {
+		kind: "embedded",
+		runId: input.runId,
+		toolAuthorityFingerprint: input.toolAuthorityFingerprint,
+		queueMessage: async () => {
+			throw new Error(`${params.label} does not support live message injection`);
+		},
+		isStreaming: () => started && !settled,
+		isAborted: () => signal.aborted,
+		isCompacting: () => false,
+		cancel: () => controller.abort(),
+		abort: () => controller.abort(),
+		sourceReplyDeliveryMode: input.sourceReplyDeliveryMode
+	};
+	let activeRegistered = false;
+	let timer;
+	assertActive();
+	try {
+		setActiveEmbeddedRun(input.sessionId, activeRun, sessionKey, input.sessionFile, agentId);
+		activeRegistered = true;
+		input.replyOperation?.attachBackend(activeRun);
+		signal.addEventListener("abort", stopDelivery, { once: true });
+		timer = setTimeout(() => {
+			timedOut = true;
+			input.onAttemptTimeout?.(/* @__PURE__ */ new Error("ACP turn timed out"));
+			controller.abort();
+		}, input.timeoutMs);
+		timer.unref();
+		const sessionContext = await SessionManager.openModelContextAsync(transcript, {
+			cwd: input.workspaceDir,
+			signal
+		});
+		const entries = sessionContext.getBranch();
+		messages = sessionContext.buildSessionContext().messages;
+		assertActive();
+		const target = {
+			agentId,
+			sessionKey: `agent:${agentId}:harness:${params.harnessId}:${input.sessionId}`,
+			agent: params.agent,
+			agentCommand: params.command,
+			mode: "persistent",
+			bridgeSession: {
+				agentId,
+				sessionKey,
+				native: true
+			},
+			cwd: input.workspaceDir
+		};
+		handle = await runtime.ensureSession(target);
+		assertActive();
+		const status = await runtime.getStatus({ handle });
+		assertActive();
+		if (status.models?.currentModelId !== input.modelId) await runtime.setModel({
+			handle,
+			model: input.modelId,
+			signal,
+			assertActive
+		});
+		assertActive();
+		const lastRequestId = status.lastRequestId;
+		const previousAssistantIndex = lastRequestId ? entries.findLastIndex((entry) => entry.type === "message" && "idempotencyKey" in entry.message && entry.message.idempotencyKey === `${lastRequestId}:acp:assistant`) : -1;
+		const previousUserIndex = lastRequestId && previousAssistantIndex < 0 ? entries.findLastIndex((entry) => entry.type === "message" && entry.message.role === "user" && (entry.id === lastRequestId || lastRequestId.startsWith(`${entry.id}:acp:`))) : -1;
+		if (lastRequestId && previousAssistantIndex < 0 && previousUserIndex < 0) throw new Error("ACP conversation history cannot be reconciled; reset this session before continuing");
+		await recorder.persistApproved({ expectedSessionId: input.sessionId });
+		assertActive();
+		const admission = recorder.getAdmissionReceipt();
+		if (recorder.isBlocked() || !recorder.hasPersisted() || !admission) throw new Error("ACP input was not admitted to its transcript");
+		const previousIndex = previousAssistantIndex >= 0 ? previousAssistantIndex : previousUserIndex;
+		const previous = buildSessionContext(entries.slice(previousIndex + 1).filter((entry) => entry.id !== admission.entryId)).messages;
+		const bootstrap = !lastRequestId ? await resolveBootstrapContextForRun({
+			workspaceDir: input.workspaceDir,
+			config: input.config,
+			sessionKey,
+			sessionId: input.sessionId,
+			agentId,
+			chatType: input.chatType,
+			contextMode: input.bootstrapContextMode,
+			runKind: input.bootstrapContextRunKind
+		}) : void 0;
+		const built = await resolveAgentHarnessBeforePromptBuildResult({
+			prompt: input.prompt,
+			currentInboundContext: input.currentInboundContext,
+			messages,
+			developerInstructions: [...bootstrap?.contextFiles.map((file) => `${file.path}\n${file.content}`) ?? [], input.extraSystemPrompt].filter(Boolean).join("\n\n"),
+			ctx: {
+				runId: input.runId,
+				agentId,
+				sessionId: input.sessionId,
+				sessionKey,
+				workspaceDir: input.workspaceDir,
+				config: input.config,
+				trigger: input.trigger,
+				modelProviderId: input.provider,
+				modelId: input.modelId
+			},
+			bootstrapContextRunKind: input.bootstrapContextRunKind
+		});
+		if (built.toolsAllow) throw new Error("ACP cannot enforce this prompt-hook tool restriction");
+		const onPermissionRequest = async (request, context) => {
+			try {
+				assertActive();
+				const approvalSignal = AbortSignal.any([signal, context.signal]);
+				const detail = JSON.stringify(request.raw.toolCall);
+				const supportsAllowOnce = request.raw.options.some((option) => option.kind === "allow_once");
+				const requestResult = await input.hostCapabilities.requestApproval({
+					title: `${params.label} permission request`,
+					description: request.raw.toolCall.title ?? "Native tool action",
+					detail,
+					signal: approvalSignal,
+					severity: "warning",
+					toolName: request.inferredKind ?? "other",
+					toolCallId: request.raw.toolCall.toolCallId,
+					allowedDecisions: supportsAllowOnce ? ["allow-once", "deny"] : ["deny"],
+					timeoutMs: DEFAULT_PLUGIN_APPROVAL_TIMEOUT_MS,
+					transportTimeoutMs: DEFAULT_PLUGIN_APPROVAL_TIMEOUT_MS + 1e4
+				});
+				const result = requestResult?.id ? await input.hostCapabilities.waitForApproval({
+					approvalId: requestResult.id,
+					timeoutMs: DEFAULT_PLUGIN_APPROVAL_TIMEOUT_MS,
+					transportTimeoutMs: DEFAULT_PLUGIN_APPROVAL_TIMEOUT_MS + 1e4,
+					signal: approvalSignal
+				}) : void 0;
+				assertActive();
+				approvalSignal.throwIfAborted();
+				const allowed = supportsAllowOnce && result?.decision === "allow-once";
+				denied ||= !allowed;
+				return { outcome: allowed ? "allow_once" : "reject_once" };
+			} catch (error) {
+				if (!signal.aborted && !context.signal.aborted) approvalFailure = toErrorObject(error, "Native approval request failed");
+				denied = true;
+				return { outcome: "cancel" };
+			}
+		};
+		const requestId = `${admission.entryId}:acp:${randomUUID()}`;
+		const turn = {
+			handle,
+			text: [
+				built.developerInstructions ? `Conversation instructions:\n${built.developerInstructions}` : void 0,
+				previous.length ? `Conversation context before this turn:\n${JSON.stringify(previous)}` : void 0,
+				`Current turn:\n${built.prompt}`
+			].filter(Boolean).join("\n\n"),
+			mode: "prompt",
+			requestId,
+			signal,
+			assertActive,
+			onPermissionRequest,
+			...input.images?.length ? { attachments: input.images.map((image) => ({
+				data: image.data,
+				mediaType: image.mimeType
+			})) } : {}
+		};
+		const outcome = await consumeAcpTurnStream({
+			runtime,
+			turn,
+			eventGate,
+			onBeforePrompt: assertActive,
+			onPromptStarted: () => {
+				started = true;
+				recorder.markSentToProvider?.();
+				input.onExecutionStarted?.();
+			},
+			onOutputEvent: async (event) => {
+				assertActive();
+				if (event.type === "text_delta") {
+					if (event.stream === "thought") {
+						reasoning += event.text;
+						await input.onReasoningStream?.({ text: reasoning });
+					} else {
+						if (!text) {
+							await input.onAssistantMessageStart?.();
+							assertActive();
+						}
+						text += event.text;
+						const update = {
+							stream: "assistant",
+							data: {
+								text,
+								delta: event.text
+							}
+						};
+						emitAgentEvent({
+							runId: input.runId,
+							sessionKey,
+							sessionId: input.sessionId,
+							...update
+						});
+						await input.onAgentEvent?.(update);
+						assertActive();
+						await input.onPartialReply?.({ text });
+					}
+				} else {
+					const existing = event.toolCallId ? toolMetas.find((tool) => tool.toolCallId === event.toolCallId) : void 0;
+					const metadata = {
+						toolName: event.title ?? event.kind ?? "tool",
+						toolCallId: event.toolCallId,
+						meta: event.text,
+						isError: event.status === "failed"
+					};
+					if (existing) Object.assign(existing, metadata);
+					else toolMetas.push(metadata);
+					await input.onToolResult?.({ text: event.text });
+				}
+			}
+		});
+		if (approvalFailure) throw approvalFailure;
+		cancelled = outcome.terminalStatus === "cancelled";
+		if (!text.trim() && denied) text = `${params.label} could not complete this turn because permission was not granted.`;
+		else if (!text.trim() && toolMetas.some((tool) => tool.isError)) text = `${params.label} reported a failed tool operation and did not return an answer.`;
+		const usage = (await runtime.getStatus({ handle })).usage?.perRequest?.[requestId];
+		assistant = {
+			role: "assistant",
+			provider: input.provider,
+			model: input.modelId,
+			api: input.model.api,
+			content: [...reasoning ? [{
+				type: "thinking",
+				thinking: reasoning
+			}] : [], ...text ? [{
+				type: "text",
+				text
+			}] : []],
+			stopReason: cancelled ? "aborted" : "stop",
+			timestamp: Date.now(),
+			usage: {
+				input: usage?.inputTokens ?? 0,
+				output: usage?.outputTokens ?? 0,
+				cacheRead: usage?.cachedReadTokens ?? 0,
+				cacheWrite: usage?.cachedWriteTokens ?? 0,
+				totalTokens: usage?.totalTokens ?? 0,
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					total: 0
+				}
+			}
+		};
+		const key = `${requestId}:acp:assistant`;
+		const written = await appendSessionTranscriptMessageByIdentityStrict({
+			...transcript,
+			config: input.config,
+			runId: input.runId,
+			updateMode: "inline",
+			message: {
+				...assistant,
+				idempotencyKey: key
+			},
+			prepareMessageAfterIdempotencyCheck: (message) => {
+				input.hostCapabilities.assertActive();
+				return message;
+			}
+		});
+		if (written.kind !== "result") throw new Error("ACP assistant transcript was not committed");
+		assistant = written.result.message;
+		assistantIdempotencyKey = key;
+		terminalAnchor = written.result.anchor;
+		messages = (await SessionManager.openModelContextAsync(transcript, {
+			cwd: input.workspaceDir,
+			through: written.result.anchor
+		})).buildSessionContext().messages;
+	} catch (error) {
+		failure = error;
+	} finally {
+		settled = true;
+		clearTimeout(timer);
+		signal.removeEventListener("abort", stopDelivery);
+		if (activeRegistered) clearActiveEmbeddedRun(input.sessionId, activeRun, sessionKey, input.sessionFile);
+	}
+	return {
+		terminal: timedOut ? {
+			kind: "timeout",
+			phase: "prompt",
+			source: "runtime",
+			aborted: true
+		} : signal.aborted || cancelled ? {
+			kind: "aborted",
+			source: "external"
+		} : failure ? {
+			kind: "failed",
+			source: "prompt",
+			error: failure
+		} : { kind: "ok" },
+		sessionIdUsed: input.sessionId,
+		sessionFileUsed: input.sessionFile,
+		agentHarnessId: params.harnessId,
+		runtimeModelSelection: {
+			provider: input.provider,
+			model: input.modelId
+		},
+		messagesSnapshot: messages,
+		assistantTexts: text ? [text] : [],
+		lastAssistant: assistant,
+		currentAttemptAssistant: assistant,
+		...assistantIdempotencyKey ? {
+			assistantTranscriptOwned: true,
+			assistantTranscriptIdempotencyKey: assistantIdempotencyKey,
+			contextEngineTerminalAnchor: terminalAnchor
+		} : {},
+		toolMetas,
+		didSendViaMessagingTool: false,
+		messagingToolSentTexts: [],
+		messagingToolSentMediaUrls: [],
+		messagingToolSentTargets: [],
+		cloudCodeAssistFormatError: false,
+		replayMetadata: {
+			hadPotentialSideEffects: toolMetas.length > 0,
+			replaySafe: !started
+		},
+		itemLifecycle: {
+			startedCount: toolMetas.length,
+			completedCount: failure ? 0 : toolMetas.length,
+			activeCount: 0
+		}
+	};
+}
+//#endregion
+export { runAcpHarnessAttempt };

package/dist/.setup/{pi-session-catalog-runtime-CbLyvshh.mjs → pi-session-catalog-runtime-UhiQSaDw.mjs}

@@ -1,18 +1,18 @@
-import { c as PI_SESSION_READ_COMMAND, i as PI_LOCAL_SESSION_HOST_ID, l as PI_TERMINAL_RESUME_COMMAND, n as piSessionStore, o as PI_SESSIONS_LIST_COMMAND, r as piSessionStoreAvailable, s as PI_SESSION_ID_PATTERN, t as piAcpSessionStoreRoot } from "./pi-session-paths-EMbd4Hkz.mjs";
-import { resolveNodeHostExecutable } from "openclaw/plugin-sdk/node-host";
-import { createSessionCatalogFamily, importSessionCatalogHistory, isExternalUserText, listAdoptedSessionCatalogSessions, sessionCatalogAdoptedSessionKey } from "openclaw/plugin-sdk/session-catalog";
-import { isRecord, normalizeBoundedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { c as PI_SESSION_READ_COMMAND, i as PI_LOCAL_SESSION_HOST_ID, l as PI_TERMINAL_RESUME_COMMAND, n as piSessionStore, o as PI_SESSIONS_LIST_COMMAND, r as piSessionStoreAvailable, s as PI_SESSION_ID_PATTERN, t as piAcpSessionStoreRoot } from "./pi-session-paths-CIvyk6KB.mjs";
+import { parseDateFirstTimestampMs } from "openclaw/plugin-sdk/number-runtime";
 import { createReadStream } from "node:fs";
 import path from "node:path";
+import { isRecord, normalizeBoundedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveNodeHostExecutable } from "openclaw/plugin-sdk/node-host";
+import { createSessionCatalogFamily, importSessionCatalogHistory, isExternalUserText, listAdoptedSessionCatalogSessions, sessionCatalogAdoptedSessionKey } from "openclaw/plugin-sdk/session-catalog";
 import fs$1 from "node:fs/promises";
-import process from "node:process";
 import { resolveAcpSessionAvailability } from "openclaw/plugin-sdk/acp-runtime";
+import process from "node:process";
 import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 import { sessionCatalogPaging } from "openclaw/plugin-sdk/session-catalog-paging";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 import { isPathStrictlyInside, readFileRangeAsync } from "openclaw/plugin-sdk/file-access-runtime";
-import { parseDateFirstTimestampMs } from "openclaw/plugin-sdk/number-runtime";
 //#region extensions/acpx/src/pi-session-timestamp.ts
 /** Preserve Pi JSONL's date-first string contract while accepting numeric millisecond values. */
 function parsePiSessionTimestampMs(value) {