@openclaw/acpx 2026.8.1-beta.2 → 2026.9.1-beta.1

package/dist/index.js

@@ -1,14 +1,14 @@
-import { t as createAcpxRuntimeService } from "./register.runtime-C29AY8LI.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-Dj29TKFy.js";
 import "./config-schema-DN_uAi4R.js";
-import { a as PI_SESSION_READ_COMMAND, i as PI_SESSIONS_LIST_COMMAND, o as PI_TERMINAL_RESUME_COMMAND, r as piSessionStoreAvailable } from "./pi-session-paths-DgYt8LUg.js";
+import { a as PI_SESSIONS_CAPABILITY, c as PI_SESSION_READ_COMMAND, l as PI_TERMINAL_RESUME_COMMAND, o as PI_SESSIONS_LIST_COMMAND, r as piSessionStoreAvailable, s as PI_SESSION_ID_PATTERN } from "./pi-session-paths-EMbd4Hkz.js";
 import { tryDispatchAcpReplyHook } from "openclaw/plugin-sdk/acp-runtime-backend";
 import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
 import { createLazyRuntimeModule, createLazyRuntimeSurface } from "openclaw/plugin-sdk/lazy-runtime";
 import { resolveNodeHostExecutable } from "openclaw/plugin-sdk/node-host";
+import { createSessionCatalogNodeHostBindings } from "openclaw/plugin-sdk/session-catalog";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/acpx/src/pi-session-catalog-plugin.ts
-const PI_SESSIONS_CAPABILITY = "pi-sessions";
-const loadPiSessionCatalogModule = createLazyRuntimeModule(() => import("./pi-session-catalog-runtime-BiTQtT7s.js"));
+const loadPiSessionCatalogModule = createLazyRuntimeModule(() => import("./pi-session-catalog-runtime-BIu-8uRZ.js"));
 function fullConfigCatalogEnabled(config) {
 	if (!isRecord(config) || !isRecord(config.plugins) || !isRecord(config.plugins.entries)) return true;
 	const entry = config.plugins.entries.acpx;
@@ -18,54 +18,40 @@ function fullConfigCatalogEnabled(config) {
 function isPiSessionCatalogEnabled(pluginConfig) {
 	return !isRecord(pluginConfig) || !isRecord(pluginConfig.piSessionCatalog) || pluginConfig.piSessionCatalog.enabled !== false;
 }
-function createPiSessionNodeHostCommands() {
+function createPiSessionNodeHostBindings() {
 	const storeAvailable = ({ config, env }) => fullConfigCatalogEnabled(config) && piSessionStoreAvailable(env);
-	return [
-		{
-			command: PI_SESSIONS_LIST_COMMAND,
-			cap: PI_SESSIONS_CAPABILITY,
-			dangerous: false,
-			isAvailable: storeAvailable,
-			handle: async (paramsJSON) => await (await loadPiSessionCatalogModule()).listPiSessions(paramsJSON)
+	return createSessionCatalogNodeHostBindings({
+		capability: PI_SESSIONS_CAPABILITY,
+		listCommand: PI_SESSIONS_LIST_COMMAND,
+		readCommand: PI_SESSION_READ_COMMAND,
+		terminalCommand: PI_TERMINAL_RESUME_COMMAND,
+		sessionIdPattern: PI_SESSION_ID_PATTERN,
+		executable: "pi",
+		args: (threadId) => ["--session", threadId],
+		listAvailable: storeAvailable,
+		terminalAvailable: ({ config, env }) => storeAvailable({
+			config,
+			env
+		}) && Boolean(resolveNodeHostExecutable("pi", {
+			env,
+			pathEnv: env.PATH ?? env.Path ?? "",
+			strategy: "direct"
+		})),
+		parseParams: (paramsJSON) => {
+			if (!paramsJSON) return;
+			try {
+				return JSON.parse(paramsJSON);
+			} catch (error) {
+				throw new Error("Pi session parameters must be valid JSON", { cause: error });
+			}
 		},
-		{
-			command: PI_SESSION_READ_COMMAND,
-			cap: PI_SESSIONS_CAPABILITY,
-			dangerous: false,
-			isAvailable: storeAvailable,
-			handle: async (paramsJSON) => await (await loadPiSessionCatalogModule()).readPiSession(paramsJSON)
-		},
-		{
-			command: PI_TERMINAL_RESUME_COMMAND,
-			cap: PI_SESSIONS_CAPABILITY,
-			dangerous: false,
-			duplex: true,
-			isAvailable: ({ config, env }) => storeAvailable({
-				config,
-				env
-			}) && Boolean(resolveNodeHostExecutable("pi", {
-				env,
-				pathEnv: env.PATH ?? env.Path ?? "",
-				strategy: "direct"
-			})),
-			handle: async (paramsJSON, io) => await (await loadPiSessionCatalogModule()).resumePiSession(paramsJSON, io)
-		}
-	];
-}
-function createPiSessionNodeInvokePolicies() {
-	return [{
-		commands: [
-			PI_SESSIONS_LIST_COMMAND,
-			PI_SESSION_READ_COMMAND,
-			PI_TERMINAL_RESUME_COMMAND
-		],
-		defaultPlatforms: [
-			"macos",
-			"linux",
-			"windows"
-		],
-		handle: (context) => context.command === "acpx.pi.terminal.resume.v1" ? { ok: true } : context.invokeNode()
-	}];
+		list: async (params) => await (await loadPiSessionCatalogModule()).listPiSessions(params),
+		read: async (params) => await (await loadPiSessionCatalogModule()).readPiSession(params),
+		requireSession: async (threadId) => await (await loadPiSessionCatalogModule()).requireLocalPiSession(threadId),
+		terminalIoRequiredMessage: "Pi terminal command requires duplex transport",
+		terminalUnavailableMessage: "Pi CLI is unavailable",
+		invalidThreadIdMessage: "INVALID_REQUEST: threadId is invalid"
+	});
 }
 function registerPiSessionCatalog(api) {
 	if (!isPiSessionCatalogEnabled(api.pluginConfig)) return;
@@ -80,8 +66,9 @@ function registerPiSessionCatalog(api) {
 		checkUpstreamActivity: async (probes, policy) => await (await loadCatalogRuntime()).checkUpstreamActivity(probes, policy),
 		openTerminal: async (request) => await (await loadCatalogRuntime()).openTerminal(request)
 	});
-	for (const command of createPiSessionNodeHostCommands()) api.registerNodeHostCommand(command);
-	for (const policy of createPiSessionNodeInvokePolicies()) api.registerNodeInvokePolicy(policy);
+	const nodeHost = createPiSessionNodeHostBindings();
+	for (const command of nodeHost.commands) api.registerNodeHostCommand(command);
+	for (const policy of nodeHost.policies) api.registerNodeInvokePolicy(policy);
 }
 //#endregion
 //#region extensions/acpx/index.ts

package/dist/{pi-session-catalog-runtime-BiTQtT7s.js → pi-session-catalog-runtime-BIu-8uRZ.js}

@@ -1,15 +1,16 @@
-import { a as PI_SESSION_READ_COMMAND, i as PI_SESSIONS_LIST_COMMAND, n as piSessionStore, o as PI_TERMINAL_RESUME_COMMAND, r as piSessionStoreAvailable, t as piAcpSessionStoreRoot } from "./pi-session-paths-DgYt8LUg.js";
+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.js";
 import { parseDateFirstTimestampMs } from "openclaw/plugin-sdk/number-runtime";
-import { decodeNodePtyResumeParams, resolveNodeHostExecutable, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
+import { resolveNodeHostExecutable } from "openclaw/plugin-sdk/node-host";
+import { createSessionCatalogFamily, importSessionCatalogHistory, isExternalUserText, listAdoptedSessionCatalogSessions, sessionCatalogAdoptedSessionKey, sessionCatalogPaging } from "openclaw/plugin-sdk/session-catalog";
 import { isRecord, normalizeBoundedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createReadStream } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
 import process from "node:process";
 import { resolveAcpSessionAvailability } from "openclaw/plugin-sdk/acp-runtime";
-import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
-import { createSessionCatalogAdoptionCoordinator, importSessionCatalogHistory, isExternalUserText, listAdoptedSessionCatalogSessions, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
+import { resolveSessionAgentIds } from "openclaw/plugin-sdk/agent-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { isPathStrictlyInside } from "openclaw/plugin-sdk/file-access-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) {
@@ -26,7 +27,7 @@ const APPEND_PROOF_EDGE_BYTES = 64 * 1024;
 const IO_CONCURRENCY = 8;
 const PI_FILE_CANDIDATE_CACHE_TTL_MS = 32e3;
 const PI_FILE_CANDIDATE_CACHE_MAX_ENTRIES = 8;
-const SESSION_ID_PATTERN$2 = /^(?!-)[A-Za-z0-9._:-]{1,256}$/u;
+const SESSION_ID_PATTERN = /^(?!-)[A-Za-z0-9._:-]{1,256}$/u;
 const summaryCache = /* @__PURE__ */ new Map();
 const threadFileCache = /* @__PURE__ */ new Map();
 const piFileCandidateCache = /* @__PURE__ */ new Map();
@@ -120,7 +121,7 @@ async function scanPiFileCandidates(env) {
 				identity: `${String(stats.dev)}:${String(stats.ino)}:${String(stats.birthtimeMs)}`,
 				mtimeMs: stats.mtimeMs,
 				size: stats.size,
-				resumable: acpRoot ? pathIsWithin(acpRoot, file) : false
+				resumable: acpRoot ? isPathStrictlyInside(acpRoot, file) : false
 			} : void 0;
 		} catch {
 			return;
@@ -155,10 +156,6 @@ async function piFileCandidates(env) {
 		throw error;
 	}
 }
-function pathIsWithin(root, candidate) {
-	const relative = path.relative(root, candidate);
-	return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
-}
 function parsePiJsonLines(content) {
 	return content.split(/\r?\n/u).flatMap((line) => {
 		if (!line.trim()) return [];
@@ -277,7 +274,7 @@ async function readPiSessionSummary(candidate) {
 		const { header, name, firstMessage } = projectedState;
 		const version = header?.type === "session" && typeof header.version === "number" ? header.version : 1;
 		const threadId = header?.type === "session" ? normalizeBoundedOptionalString(header.id, 256) : void 0;
-		if (header && threadId && SESSION_ID_PATTERN$2.test(threadId)) {
+		if (header && threadId && SESSION_ID_PATTERN.test(threadId)) {
 			const cwd = normalizeBoundedOptionalString(header.cwd, 4096);
 			const createdAt = parsePiSessionTimestampMs(header.timestamp);
 			summary = {
@@ -380,86 +377,8 @@ async function readPiSessionById(threadId, env) {
 }
 //#endregion
 //#region extensions/acpx/src/pi-session-catalog.ts
-const LOCAL_HOST_ID$1 = "gateway";
-const DEFAULT_PAGE_LIMIT = 20;
-const MAX_PAGE_LIMIT$1 = 100;
 const MAX_SEARCH_LENGTH = 500;
-const MAX_CURSOR_LENGTH = 128;
-const MAX_TRANSCRIPT_ITEM_BYTES = 512 * 1024;
-const MAX_TRANSCRIPT_PAGE_BYTES = 20 * 1024 * 1024;
-const SESSION_ID_PATTERN$1 = /^(?!-)[A-Za-z0-9._:-]{1,256}$/u;
-function boundedLimit(value, fallback = DEFAULT_PAGE_LIMIT) {
-	if (value === void 0) return fallback;
-	if (!Number.isInteger(value) || Number(value) < 1 || Number(value) > MAX_PAGE_LIMIT$1) throw new Error(`limit must be an integer between 1 and ${String(MAX_PAGE_LIMIT$1)}`);
-	return Number(value);
-}
-function encodeCursor(offset) {
-	return Buffer.from(JSON.stringify({ offset }), "utf8").toString("base64url");
-}
-function optionalRawCursor(value) {
-	if (value === void 0) return;
-	if (typeof value !== "string" || value.length === 0 || value.length > MAX_CURSOR_LENGTH) throw new Error("cursor is invalid");
-	return value;
-}
-function decodeCursor(value) {
-	const cursor = optionalRawCursor(value);
-	if (cursor === void 0) return 0;
-	try {
-		const bytes = Buffer.from(cursor, "base64url");
-		if (bytes.toString("base64url") !== cursor) throw new Error("non-canonical base64url");
-		const parsed = JSON.parse(bytes.toString("utf8"));
-		if (!isRecord(parsed) || !Number.isSafeInteger(parsed.offset) || Number(parsed.offset) < 0) throw new Error("invalid offset");
-		const offset = Number(parsed.offset);
-		if (encodeCursor(offset) !== cursor) throw new Error("non-canonical cursor payload");
-		return offset;
-	} catch (error) {
-		throw new Error("cursor is invalid", { cause: error });
-	}
-}
-function isExactPiSessionCursor(value) {
-	if (typeof value !== "string") return false;
-	try {
-		decodeCursor(value);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function truncateUtf8(text, maxBytes) {
-	if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
-	let low = 0;
-	let high = text.length;
-	while (low < high) {
-		const middle = Math.ceil((low + high) / 2);
-		if (Buffer.byteLength(text.slice(0, middle), "utf8") <= maxBytes - 3) low = middle;
-		else high = middle - 1;
-	}
-	const end = low > 0 && /[\uD800-\uDBFF]/u.test(text.charAt(low - 1)) ? low - 1 : low;
-	return `${text.slice(0, end)}…`;
-}
-function transcriptPage(items, limit, offset) {
-	const end = Math.max(0, items.length - offset);
-	const start = Math.max(0, end - limit);
-	const page = [];
-	let pageBytes = 2;
-	for (let index = end - 1; index >= start; index -= 1) {
-		const item = items[index];
-		if (!item) continue;
-		const bounded = {
-			...item,
-			text: truncateUtf8(item.text ?? "", MAX_TRANSCRIPT_ITEM_BYTES)
-		};
-		const itemBytes = Buffer.byteLength(JSON.stringify(bounded), "utf8") + 1;
-		if (page.length > 0 && pageBytes + itemBytes > MAX_TRANSCRIPT_PAGE_BYTES) break;
-		page.unshift(bounded);
-		pageBytes += itemBytes;
-	}
-	const consumed = offset + page.length;
-	return {
-		items: page,
-		...consumed < items.length ? { nextCursor: encodeCursor(consumed) } : {}
-	};
-}
+const isExactPiSessionCursor = sessionCatalogPaging.isExactCursor;
 function textFromContent$1(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return "";
@@ -473,44 +392,20 @@ function textFromContent$1(content) {
 		return [];
 	}).join("\n");
 }
-function parseListParams(value) {
-	if (value === void 0 || value === null) return { limit: DEFAULT_PAGE_LIMIT };
-	if (!isRecord(value)) throw new Error("Pi session list parameters must be an object");
-	const unknown = Object.keys(value).find((key) => ![
-		"searchTerm",
-		"limit",
-		"cursor"
-	].includes(key));
-	if (unknown) throw new Error(`unknown Pi session list parameter: ${unknown}`);
-	const searchTerm = normalizeBoundedOptionalString(value.searchTerm, MAX_SEARCH_LENGTH);
-	if (value.searchTerm !== void 0 && !searchTerm) throw new Error("searchTerm is invalid");
-	const cursor = optionalRawCursor(value.cursor);
-	return {
-		limit: boundedLimit(value.limit),
-		...searchTerm ? { searchTerm } : {},
-		...cursor ? { cursor } : {}
-	};
-}
-function parseReadParams(value) {
-	if (!isRecord(value)) throw new Error("Pi session read parameters must be an object");
-	const unknown = Object.keys(value).find((key) => ![
-		"threadId",
-		"limit",
-		"cursor"
-	].includes(key));
-	if (unknown) throw new Error(`unknown Pi session read parameter: ${unknown}`);
-	const threadId = normalizeBoundedOptionalString(value.threadId, 256);
-	if (!threadId || !SESSION_ID_PATTERN$1.test(threadId)) throw new Error("threadId is invalid");
-	const cursor = optionalRawCursor(value.cursor);
-	return {
-		threadId,
-		limit: boundedLimit(value.limit),
-		...cursor ? { cursor } : {}
-	};
-}
+const PI_PARAMETER_MESSAGES = {
+	listNotObject: "Pi session list parameters must be an object",
+	unknownListParameter: (key) => `unknown Pi session list parameter: ${key}`,
+	invalidSearchTerm: "searchTerm is invalid",
+	readNotObject: "Pi session read parameters must be an object",
+	unknownReadParameter: (key) => `unknown Pi session read parameter: ${key}`,
+	invalidThreadId: "threadId is invalid"
+};
 async function listLocalPiSessionPage(value) {
-	const params = parseListParams(value);
-	const offset = decodeCursor(params.cursor);
+	const params = sessionCatalogPaging.parseListParams(value, {
+		searchMaxLength: MAX_SEARCH_LENGTH,
+		messages: PI_PARAMETER_MESSAGES
+	});
+	const offset = sessionCatalogPaging.decodeCursor(params.cursor);
 	const { summaries, hasMore } = await listPiSummaryPage(process.env, {
 		offset,
 		limit: params.limit,
@@ -519,7 +414,7 @@ async function listLocalPiSessionPage(value) {
 	const page = summaries.map(({ file: _file, version: _version, ...session }) => session);
 	return {
 		sessions: page,
-		...hasMore ? { nextCursor: encodeCursor(offset + page.length) } : {}
+		...hasMore ? { nextCursor: sessionCatalogPaging.encodeCursor(offset + page.length) } : {}
 	};
 }
 function isoTimestamp(message, entry) {
@@ -670,11 +565,16 @@ function piTranscriptItems(entries) {
 	});
 }
 async function readLocalPiTranscriptPage(value) {
-	const params = parseReadParams(value);
-	const offset = decodeCursor(params.cursor);
-	const page = transcriptPage(piTranscriptItems(await readPiSessionById(params.threadId, process.env)), params.limit, offset);
+	const params = sessionCatalogPaging.parseReadParams(value, {
+		threadIdMaxLength: 256,
+		threadIdPattern: PI_SESSION_ID_PATTERN,
+		messages: PI_PARAMETER_MESSAGES
+	});
+	const offset = sessionCatalogPaging.decodeCursor(params.cursor);
+	const items = piTranscriptItems(await readPiSessionById(params.threadId, process.env));
+	const page = sessionCatalogPaging.boundTranscriptPage(items, params.limit, offset);
 	return {
-		hostId: LOCAL_HOST_ID$1,
+		hostId: PI_LOCAL_SESSION_HOST_ID,
 		label: "Local Pi",
 		threadId: params.threadId,
 		...page
@@ -798,201 +698,17 @@ async function checkPiUpstreamActivity(probes) {
 }
 //#endregion
 //#region extensions/acpx/src/pi-session-catalog-runtime.ts
-const LOCAL_HOST_ID = "gateway";
-const MAX_PAGE_LIMIT = 100;
-const MAX_HOSTS = 100;
 const NODE_TIMEOUT_MS = 2e4;
-const SESSION_ID_PATTERN = /^(?!-)[A-Za-z0-9._:-]{1,256}$/u;
-const TRANSCRIPT_ITEM_TYPES = /* @__PURE__ */ new Set([
-	"userMessage",
-	"agentMessage",
-	"reasoning",
-	"toolCall",
-	"toolResult",
-	"other"
-]);
 const ACPX_BACKEND_ID = "acpx";
 const PI_ACP_AGENT_ID = "pi";
 const PI_ADOPTED_SESSION_KEY_PREFIX = "plugin:acpx:catalog-adopt:pi:";
-var PiCatalogParamsError = class extends Error {};
-const continueAdoption = createSessionCatalogAdoptionCoordinator();
-function validatePiThreadId(value) {
-	if (typeof value !== "string" || !SESSION_ID_PATTERN.test(value)) throw new Error("INVALID_REQUEST: threadId is invalid");
-	return value;
-}
-function isOptionalString(value) {
-	return value === void 0 || typeof value === "string";
-}
-function isOptionalNumber(value) {
-	return value === void 0 || typeof value === "number";
-}
-function isNodeSession(value) {
-	return isRecord(value) && typeof value.threadId === "string" && SESSION_ID_PATTERN.test(value.threadId) && typeof value.status === "string" && value.status.length > 0 && typeof value.archived === "boolean" && typeof value.canContinue === "boolean" && typeof value.canArchive === "boolean" && isOptionalString(value.name) && isOptionalString(value.cwd) && isOptionalString(value.source) && isOptionalString(value.modelProvider) && isOptionalString(value.cliVersion) && isOptionalString(value.gitBranch) && isOptionalString(value.sessionKey) && isOptionalNumber(value.createdAt) && isOptionalNumber(value.updatedAt) && isOptionalNumber(value.recencyAt);
-}
-function isNodeTranscriptItem(value) {
-	return isRecord(value) && typeof value.type === "string" && TRANSCRIPT_ITEM_TYPES.has(value.type) && isOptionalString(value.id) && isOptionalString(value.text) && isOptionalString(value.timestamp) && isOptionalString(value.model) && (value.truncated === void 0 || typeof value.truncated === "boolean");
-}
-function parseNodeParams(paramsJSON) {
-	if (!paramsJSON) return;
-	try {
-		return JSON.parse(paramsJSON);
-	} catch (error) {
-		throw new Error("Pi session parameters must be valid JSON", { cause: error });
-	}
-}
-function nodeLabel(node) {
-	return node.displayName?.trim() || node.remoteIp?.trim() || node.nodeId;
-}
-function unwrapNodePayload(value) {
-	return isRecord(value) && typeof value.payloadJSON === "string" ? JSON.parse(value.payloadJSON) : value;
-}
-function setCatalogCapabilities(page, capabilities) {
-	for (const session of page.sessions) {
-		session.canContinue = capabilities.canContinue && session.canContinue;
-		session.canOpenTerminal = capabilities.canOpenTerminal;
-	}
-	return page;
-}
-function projectPiAdoptedSessions(page, adopted) {
-	return {
-		...page,
-		sessions: page.sessions.map((session) => {
-			const sessionKey = adopted.get(sessionCatalogAdoptedSourceKey(LOCAL_HOST_ID, session.threadId));
-			return sessionKey ? {
-				...session,
-				sessionKey
-			} : session;
-		})
-	};
-}
-async function listPiNodeHost(runtime, query, node) {
-	const hostId = `node:${node.nodeId}`;
-	const common = {
-		hostId,
-		label: nodeLabel(node),
-		kind: "node",
-		connected: node.connected === true,
-		nodeId: node.nodeId
-	};
-	if (node.connected !== true) return {
-		...common,
-		sessions: [],
-		error: {
-			code: "NODE_OFFLINE",
-			message: "Paired node is offline"
-		}
-	};
-	try {
-		const cursor = query.cursors?.[hostId];
-		if (cursor !== void 0 && !isExactPiSessionCursor(cursor)) throw new Error("cursor is invalid");
-		const page = parseNodeSessionPage(unwrapNodePayload(await runtime.nodes.invoke({
-			nodeId: node.nodeId,
-			command: PI_SESSIONS_LIST_COMMAND,
-			params: {
-				...query.limitPerHost ? { limit: query.limitPerHost } : {},
-				...query.search ? { searchTerm: query.search } : {},
-				...cursor !== void 0 ? { cursor } : {}
-			},
-			timeoutMs: NODE_TIMEOUT_MS,
-			scopes: ["operator.write"]
-		})));
-		const canOpenTerminal = (node.invocableCommands ?? node.commands)?.includes(PI_TERMINAL_RESUME_COMMAND) === true;
-		return {
-			...common,
-			...setCatalogCapabilities(page, {
-				canContinue: false,
-				canOpenTerminal
-			})
-		};
-	} catch {
-		return {
-			...common,
-			sessions: [],
-			error: {
-				code: "NODE_INVOKE_FAILED",
-				message: "Paired node Pi sessions are unavailable"
-			}
-		};
-	}
-}
-function parseNodeSessionPage(value) {
-	if (!isRecord(value) || !Array.isArray(value.sessions) || value.sessions.length > MAX_PAGE_LIMIT) throw new Error("Pi node returned an invalid session page");
-	if (!value.sessions.every(isNodeSession)) throw new Error("Pi node returned an invalid session page");
-	const sessions = value.sessions;
-	const nextCursor = value.nextCursor;
-	if (nextCursor !== void 0 && !isExactPiSessionCursor(nextCursor)) throw new Error("Pi node returned an invalid cursor");
-	return {
-		sessions,
-		...nextCursor !== void 0 ? { nextCursor } : {}
-	};
-}
-function parseNodeTranscriptPage(value, threadId) {
-	if (!isRecord(value) || value.threadId !== threadId || !Array.isArray(value.items) || value.items.length > MAX_PAGE_LIMIT || !value.items.every(isNodeTranscriptItem)) throw new Error("Pi node returned an invalid transcript page");
-	const nextCursor = value.nextCursor;
-	if (nextCursor !== void 0 && !isExactPiSessionCursor(nextCursor)) throw new Error("Pi node returned an invalid cursor");
-	return {
-		hostId: LOCAL_HOST_ID,
-		threadId,
-		items: value.items,
-		...nextCursor !== void 0 ? { nextCursor } : {}
-	};
-}
-async function listPiHosts(api, query) {
-	const runtime = api.runtime;
-	const canContinue = resolvePiContinuationAvailability(api).available;
-	const adopted = query.sessionEntries ? listAdoptedPiSessions(api, query.sessionEntries) : /* @__PURE__ */ new Map();
-	const requested = query.hostIds ? new Set(query.hostIds) : void 0;
-	const hosts = [];
-	const localStore = !requested || requested.has(LOCAL_HOST_ID) ? piSessionStore(process.env) : void 0;
-	if (localStore && (query.allowProcessHomeFallback !== false || !localStore.usesProcessHomeFallback) && piSessionStoreAvailable(process.env, localStore)) try {
-		hosts.push({
-			hostId: LOCAL_HOST_ID,
-			label: "Local Pi",
-			kind: "gateway",
-			connected: true,
-			...await listLocalPiSessionPage({
-				limit: query.limitPerHost,
-				...query.search ? { searchTerm: query.search } : {},
-				cursor: query.cursors?.[LOCAL_HOST_ID]
-			}).then((page) => projectPiAdoptedSessions(setCatalogCapabilities(page, {
-				canContinue,
-				canOpenTerminal: resolveNodeHostExecutable("pi", {
-					env: process.env,
-					pathEnv: process.env.PATH ?? "",
-					strategy: "fallback"
-				}) !== void 0
-			}), adopted))
-		});
-	} catch {
-		hosts.push({
-			hostId: LOCAL_HOST_ID,
-			label: "Local Pi",
-			kind: "gateway",
-			connected: true,
-			sessions: [],
-			error: {
-				code: "LOCAL_READ_FAILED",
-				message: "Local Pi sessions are unavailable"
-			}
-		});
-	}
-	let nodes;
-	try {
-		nodes = (await (query.listNodes?.() ?? runtime.nodes.list())).nodes;
-	} catch {
-		return hosts;
-	}
-	const eligible = nodes.filter((node) => node.commands?.includes("acpx.pi.sessions.list.v1") && (!requested || requested.has(`node:${node.nodeId}`))).toSorted((left, right) => nodeLabel(left).localeCompare(nodeLabel(right))).slice(0, MAX_HOSTS - hosts.length);
-	const nodeHosts = await Promise.all(eligible.map((node) => listPiNodeHost(runtime, query, node)));
-	return [...hosts, ...nodeHosts];
-}
 async function requireLocalPiSession(threadId) {
-	const record = (await listLocalPiSessionPage({
+	const session = (await listLocalPiSessionPage({
 		searchTerm: threadId,
-		limit: MAX_PAGE_LIMIT
-	})).sessions.find((session) => session.threadId === threadId);
-	if (!record) throw new Error("Pi session is unavailable");
-	return record;
+		limit: 100
+	})).sessions.find((candidate) => candidate.threadId === threadId);
+	if (!session) throw new Error("Pi session is unavailable");
+	return session;
 }
 function currentPiCatalogConfig(api) {
 	return api.runtime.config?.current?.() ?? api.config ?? {};
@@ -1013,8 +729,9 @@ function resolvePiContinuationAvailability(api) {
 		message: "Pi CLI is unavailable"
 	};
 }
-function listAdoptedPiSessions(api, sessionEntries) {
+function listAdoptedPiSessions(api, agentId, sessionEntries) {
 	return listAdoptedSessionCatalogSessions({
+		...agentId ? { agentId } : {},
 		config: currentPiCatalogConfig(api),
 		pluginId: api.id,
 		runtime: api.runtime,
@@ -1023,198 +740,148 @@ function listAdoptedPiSessions(api, sessionEntries) {
 			const acpx = isRecord(entry.pluginExtensions?.acpx) ? entry.pluginExtensions.acpx : void 0;
 			const marker = acpx && isRecord(acpx.piSessionCatalog) ? acpx.piSessionCatalog : void 0;
 			return marker && typeof marker.sourceThreadId === "string" ? {
-				hostId: LOCAL_HOST_ID,
+				hostId: PI_LOCAL_SESSION_HOST_ID,
 				threadId: marker.sourceThreadId
 			} : void 0;
 		}
 	});
 }
-async function continuePiSession(api, hostId, threadId) {
-	if (hostId.startsWith("node:")) throw new PiCatalogParamsError("paired-node Pi session rows are view-only");
-	if (hostId !== LOCAL_HOST_ID) throw new PiCatalogParamsError("Pi session catalog hostId is invalid");
-	const availability = resolvePiContinuationAvailability(api);
-	if (!availability.available) throw new PiCatalogParamsError(availability.message);
-	const sourceKey = sessionCatalogAdoptedSourceKey(hostId, threadId);
-	return await continueAdoption({
-		sourceKey,
-		findExisting: () => listAdoptedPiSessions(api).get(sourceKey),
-		create: async () => {
-			const record = await requireLocalPiSession(threadId).catch(() => void 0);
-			if (!record) throw new PiCatalogParamsError("Pi session is unavailable");
-			if (!record.canContinue) throw new PiCatalogParamsError("Pi session is outside the session store supported by pi-acp");
-			const currentAvailability = resolvePiContinuationAvailability(api);
-			if (!currentAvailability.available) throw new PiCatalogParamsError(currentAvailability.message);
-			const config = currentPiCatalogConfig(api);
-			const marker = { sourceThreadId: threadId };
-			return { sessionKey: (await api.runtime.agent.session.createSessionEntry({
-				cfg: config,
-				key: sessionCatalogAdoptedSessionKey(PI_ADOPTED_SESSION_KEY_PREFIX, threadId),
-				agentId: resolveDefaultAgentId(config),
-				recoverMatchingInitialEntry: true,
-				...record.name ? { label: record.name } : {},
-				...record.cwd ? { spawnedCwd: record.cwd } : {},
-				initialEntry: {
-					acpBackendId: ACPX_BACKEND_ID,
-					acpSessionBinding: {
-						acpAgentId: PI_ACP_AGENT_ID,
-						agentSessionId: threadId
-					},
-					pluginExtensions: { acpx: { piSessionCatalog: marker } }
-				},
-				afterCreate: async (entry) => {
-					await importSessionCatalogHistory({
-						catalogId: "pi",
-						threadId,
-						read: async ({ cursor, limit }) => await readPiTranscript(api.runtime, {
-							hostId,
-							threadId,
-							limit,
-							...cursor ? { cursor } : {}
-						}),
-						sessionId: entry.sessionId,
-						sessionKey: entry.key,
-						agentId: entry.agentId,
-						...record.cwd ? { cwd: record.cwd } : {},
-						config
-					});
-					return { pluginExtensions: { acpx: { piSessionCatalog: marker } } };
-				}
-			})).key };
-		},
-		complete: async (continued) => await linkContinuedPiSession(continued.sessionKey, threadId)
-	});
-}
-async function resolveNodePiSession(params) {
-	const record = parseNodeSessionPage(unwrapNodePayload(await params.runtime.nodes.invoke({
-		nodeId: params.nodeId,
-		command: PI_SESSIONS_LIST_COMMAND,
-		params: {
-			searchTerm: params.threadId,
-			limit: MAX_PAGE_LIMIT
-		},
-		timeoutMs: NODE_TIMEOUT_MS,
-		scopes: ["operator.write"]
-	}))).sessions.find((session) => session.threadId === params.threadId);
-	if (!record) throw new Error("Pi session is unavailable");
-	return record;
-}
-async function openPiTerminal(params) {
-	const title = `pi --session ${params.threadId.slice(0, 12)}…`;
-	if (params.hostId === LOCAL_HOST_ID) {
-		const record = await requireLocalPiSession(params.threadId);
-		const resolution = resolveNodeHostExecutable("pi", {
-			env: process.env,
-			pathEnv: process.env.PATH ?? "",
-			strategy: "fallback"
-		});
-		if (!resolution) throw new Error("Pi CLI is unavailable");
-		return {
-			kind: "local",
-			argv: [
-				resolution.executable,
-				"--session",
-				params.threadId
-			],
-			...record.cwd ? { cwd: record.cwd } : {},
-			...resolution.pathEnv ? { pathEnv: resolution.pathEnv } : {},
-			title
-		};
-	}
-	if (!params.hostId.startsWith("node:")) throw new Error("hostId is invalid");
-	const nodeId = params.hostId.slice(5);
-	if (!(await params.runtime.nodes.list()).nodes.find((candidate) => {
-		const commands = candidate.invocableCommands ?? candidate.commands;
-		return candidate.nodeId === nodeId && candidate.connected === true && commands?.includes("acpx.pi.sessions.list.v1") === true && commands.includes("acpx.pi.terminal.resume.v1");
-	})) throw new Error("paired-node Pi terminal is unavailable");
-	const record = await resolveNodePiSession({
-		runtime: params.runtime,
-		nodeId,
-		threadId: params.threadId
-	});
-	return {
-		kind: "node",
-		nodeId,
-		command: PI_TERMINAL_RESUME_COMMAND,
-		paramsJSON: JSON.stringify({ threadId: params.threadId }),
-		...record.cwd ? { cwd: record.cwd } : {},
-		title
-	};
-}
-async function readPiTranscript(runtime, request) {
-	const cursor = request.cursor;
-	if (cursor !== void 0 && !isExactPiSessionCursor(cursor)) throw new Error("cursor is invalid");
-	if (request.hostId === LOCAL_HOST_ID) {
-		assertPiLocalAccess(request.hostId, request.allowProcessHomeFallback);
-		return await readLocalPiTranscriptPage({
-			threadId: request.threadId,
-			...request.limit ? { limit: request.limit } : {},
-			...cursor !== void 0 ? { cursor } : {}
-		});
-	}
-	if (!request.hostId.startsWith("node:")) throw new Error("hostId is invalid");
-	const nodeId = request.hostId.slice(5);
-	const node = (await runtime.nodes.list()).nodes.find((candidate) => candidate.nodeId === nodeId && candidate.connected === true && candidate.commands?.includes("acpx.pi.sessions.read.v1"));
-	if (!node) throw new Error("paired-node Pi session host is unavailable");
-	return {
-		...parseNodeTranscriptPage(unwrapNodePayload(await runtime.nodes.invoke({
-			nodeId,
-			command: PI_SESSION_READ_COMMAND,
-			params: {
-				threadId: request.threadId,
-				...request.limit ? { limit: request.limit } : {},
-				...cursor !== void 0 ? { cursor } : {}
+async function createAdoptedPiSession(params) {
+	const config = currentPiCatalogConfig(params.api);
+	const marker = { sourceThreadId: params.threadId };
+	return { sessionKey: (await params.api.runtime.agent.session.createSessionEntry({
+		cfg: config,
+		key: sessionCatalogAdoptedSessionKey(PI_ADOPTED_SESSION_KEY_PREFIX, params.threadId),
+		agentId: params.agentId,
+		recoverMatchingInitialEntry: true,
+		...params.session.name ? { label: params.session.name } : {},
+		...params.session.cwd ? { spawnedCwd: params.session.cwd } : {},
+		initialEntry: {
+			acpBackendId: ACPX_BACKEND_ID,
+			acpSessionBinding: {
+				acpAgentId: PI_ACP_AGENT_ID,
+				agentSessionId: params.threadId
 			},
-			timeoutMs: NODE_TIMEOUT_MS,
-			scopes: ["operator.write"]
-		})), request.threadId),
-		hostId: request.hostId,
-		label: nodeLabel(node)
-	};
+			pluginExtensions: { acpx: { piSessionCatalog: marker } }
+		},
+		afterCreate: async (entry) => {
+			await importSessionCatalogHistory({
+				catalogId: "pi",
+				threadId: params.threadId,
+				read: async ({ cursor, limit }) => await readLocalPiTranscriptPage({
+					threadId: params.threadId,
+					limit,
+					...cursor ? { cursor } : {}
+				}),
+				sessionId: entry.sessionId,
+				sessionKey: entry.key,
+				agentId: entry.agentId,
+				...params.session.cwd ? { cwd: params.session.cwd } : {},
+				config
+			});
+			return { pluginExtensions: { acpx: { piSessionCatalog: marker } } };
+		}
+	})).key };
 }
 function assertPiLocalAccess(hostId, allowProcessHomeFallback) {
-	if (hostId === LOCAL_HOST_ID && allowProcessHomeFallback === false && piSessionStore(process.env).usesProcessHomeFallback) throw new PiCatalogParamsError("local Pi sessions are unavailable in isolated state");
+	if (hostId === "gateway" && allowProcessHomeFallback === false && piSessionStore(process.env).usesProcessHomeFallback) throw new Error("local Pi sessions are unavailable in isolated state");
 }
-async function listPiSessions(paramsJSON) {
-	return JSON.stringify(await listLocalPiSessionPage(parseNodeParams(paramsJSON)));
+async function listPiSessions(params) {
+	return await listLocalPiSessionPage(params);
 }
-async function readPiSession(paramsJSON) {
-	return JSON.stringify(await readLocalPiTranscriptPage(parseNodeParams(paramsJSON)));
-}
-async function resumePiSession(paramsJSON, io) {
-	if (!io) throw new Error("Pi terminal command requires duplex transport");
-	const params = decodeNodePtyResumeParams(paramsJSON, validatePiThreadId);
-	const record = await requireLocalPiSession(params.threadId);
-	const resolution = resolveNodeHostExecutable("pi", {
-		env: process.env,
-		pathEnv: process.env.PATH ?? process.env.Path ?? "",
-		strategy: "direct"
-	});
-	if (!resolution) throw new Error("Pi CLI is unavailable");
-	return JSON.stringify(await runNodePtyCommand({
-		file: resolution.executable,
-		args: ["--session", params.threadId],
-		cwd: record.cwd,
-		cols: params.cols,
-		rows: params.rows
-	}, io));
+async function readPiSession(params) {
+	return await readLocalPiTranscriptPage(params);
 }
 function createPiSessionCatalogRuntime(api) {
-	return {
-		list: async (query) => await listPiHosts(api, query),
-		read: async (request) => await readPiTranscript(api.runtime, request),
-		continueSession: async (request) => {
-			assertPiLocalAccess(request.hostId, request.allowProcessHomeFallback);
-			return await continuePiSession(api, request.hostId, request.threadId);
+	return createSessionCatalogFamily({
+		runtime: api.runtime,
+		local: {
+			hostId: PI_LOCAL_SESSION_HOST_ID,
+			label: "Local Pi",
+			available: (query) => {
+				const store = piSessionStore(process.env);
+				return (query.allowProcessHomeFallback !== false || !store.usesProcessHomeFallback) && piSessionStoreAvailable(process.env, store);
+			},
+			list: async (query) => await listLocalPiSessionPage({
+				limit: query.limitPerHost,
+				...query.search ? { searchTerm: query.search } : {},
+				cursor: query.cursors?.[PI_LOCAL_SESSION_HOST_ID]
+			}),
+			read: async (request) => await readLocalPiTranscriptPage({
+				threadId: request.threadId,
+				...request.limit ? { limit: request.limit } : {},
+				...request.cursor !== void 0 ? { cursor: request.cursor } : {}
+			}),
+			assertAccess: assertPiLocalAccess
 		},
-		checkUpstreamActivity: (probes, policy) => checkPiUpstreamActivity(probes.filter((probe) => probe.hostId !== LOCAL_HOST_ID || policy?.allowProcessHomeFallback !== false || !piSessionStore(process.env).usesProcessHomeFallback)),
-		openTerminal: async (request) => {
-			assertPiLocalAccess(request.hostId, request.allowProcessHomeFallback);
-			return await openPiTerminal({
-				runtime: api.runtime,
-				...request
-			});
-		}
-	};
+		node: {
+			listCommand: PI_SESSIONS_LIST_COMMAND,
+			readCommand: PI_SESSION_READ_COMMAND,
+			terminalCommand: PI_TERMINAL_RESUME_COMMAND,
+			timeoutMs: NODE_TIMEOUT_MS,
+			maxHosts: 100,
+			maxPageLimit: 100,
+			sessionIdPattern: PI_SESSION_ID_PATTERN
+		},
+		capabilities: {
+			local: () => ({
+				canContinue: resolvePiContinuationAvailability(api).available,
+				canOpenTerminal: resolveNodeHostExecutable("pi", {
+					env: process.env,
+					pathEnv: process.env.PATH ?? "",
+					strategy: "fallback"
+				}) !== void 0
+			}),
+			node: (node) => {
+				return {
+					canContinue: false,
+					canOpenTerminal: (node.invocableCommands ?? node.commands)?.includes(PI_TERMINAL_RESUME_COMMAND) === true
+				};
+			},
+			project: (session, capabilities) => ({
+				...session,
+				canContinue: capabilities.canContinue && session.canContinue,
+				canOpenTerminal: capabilities.canOpenTerminal
+			})
+		},
+		messages: {
+			invalidNodeCursor: "Pi node returned an invalid cursor",
+			invalidNodeSessionPage: "Pi node returned an invalid session page",
+			invalidNodeTranscriptPage: "Pi node returned an invalid transcript page",
+			invalidHostId: "Pi session catalog hostId is invalid",
+			localReadFailed: "Local Pi sessions are unavailable",
+			nodeInvokeFailed: "Paired node Pi sessions are unavailable",
+			nodeReadUnavailable: "paired-node Pi session host is unavailable",
+			nodeTerminalUnavailable: "paired-node Pi terminal is unavailable",
+			sessionUnavailable: "Pi session is unavailable"
+		},
+		continuation: {
+			resolveAgentId: (agentId) => resolveSessionAgentIds({
+				config: api.config,
+				agentId
+			}).sessionAgentId,
+			availability: () => resolvePiContinuationAvailability(api),
+			listAdopted: (agentId, sessionEntries) => listAdoptedPiSessions(api, agentId, sessionEntries),
+			loadSession: requireLocalPiSession,
+			validateSession: (session) => {
+				if (!session.canContinue) throw new Error("Pi session is outside the session store supported by pi-acp");
+			},
+			create: async (params) => await createAdoptedPiSession({
+				api,
+				...params
+			}),
+			complete: async (continued, threadId) => await linkContinuedPiSession(continued.sessionKey, threadId),
+			nodeReadOnlyMessage: "paired-node Pi session rows are view-only"
+		},
+		terminal: {
+			executable: "pi",
+			args: (threadId) => ["--session", threadId],
+			title: (threadId) => `pi --session ${threadId.slice(0, 12)}…`,
+			requireLocalSession: requireLocalPiSession,
+			unavailableMessage: "Pi CLI is unavailable"
+		},
+		checkUpstreamActivity: (probes, policy) => checkPiUpstreamActivity(probes.filter((probe) => probe.hostId !== "gateway" || policy?.allowProcessHomeFallback !== false || !piSessionStore(process.env).usesProcessHomeFallback))
+	}, isExactPiSessionCursor);
 }
 //#endregion
-export { createPiSessionCatalogRuntime, listPiSessions, readPiSession, resumePiSession };
+export { createPiSessionCatalogRuntime, listPiSessions, readPiSession, requireLocalPiSession };

package/dist/{pi-session-paths-DgYt8LUg.js → pi-session-paths-EMbd4Hkz.js}

@@ -6,6 +6,9 @@ import path from "node:path";
 const PI_SESSIONS_LIST_COMMAND = "acpx.pi.sessions.list.v1";
 const PI_SESSION_READ_COMMAND = "acpx.pi.sessions.read.v1";
 const PI_TERMINAL_RESUME_COMMAND = "acpx.pi.terminal.resume.v1";
+const PI_SESSIONS_CAPABILITY = "pi-sessions";
+const PI_LOCAL_SESSION_HOST_ID = "gateway";
+const PI_SESSION_ID_PATTERN = /^(?!-)[A-Za-z0-9._:-]{1,256}$/u;
 //#endregion
 //#region extensions/acpx/src/pi-session-paths.ts
 function piHome(env) {
@@ -78,4 +81,4 @@ function piSessionStoreAvailable(env, store) {
 	}
 }
 //#endregion
-export { PI_SESSION_READ_COMMAND as a, PI_SESSIONS_LIST_COMMAND as i, piSessionStore as n, PI_TERMINAL_RESUME_COMMAND as o, piSessionStoreAvailable as r, piAcpSessionStoreRoot as t };
+export { PI_SESSIONS_CAPABILITY as a, PI_SESSION_READ_COMMAND as c, PI_LOCAL_SESSION_HOST_ID as i, PI_TERMINAL_RESUME_COMMAND as l, piSessionStore as n, PI_SESSIONS_LIST_COMMAND as o, piSessionStoreAvailable as r, PI_SESSION_ID_PATTERN as s, piAcpSessionStoreRoot as t };

package/dist/{process-reaper-DzVuCxl3.js → process-reaper-DduWm_7N.js}

@@ -1,12 +1,12 @@
 import { t as AcpxPluginConfigSchema } from "./config-schema-DN_uAi4R.js";
 import { u as readAcpxProcessLeaseIdentity, v as splitCommandParts } from "./process-lease-Cwvj7WGe.js";
 import { createRequire } from "node:module";
-import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs";
 import path from "node:path";
-import { runExec } from "openclaw/plugin-sdk/process-runtime";
+import { isPidAlive, runExec } from "openclaw/plugin-sdk/process-runtime";
 import { fileURLToPath } from "node:url";
+import { formatPluginConfigIssue } from "openclaw/plugin-sdk/extension-shared";
 //#region extensions/acpx/src/codex-adapter.ts
 const CODEX_ACP_PACKAGE = "@agentclientprotocol/codex-acp";
 const CODEX_ACP_BIN = "codex-acp";
@@ -355,14 +355,6 @@ function collectProcessTree(processes, rootPid) {
 function uniquePids(processes) {
 	return Array.from(new Set(processes.map((processInfo) => processInfo.pid).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid)));
 }
-function isProcessAlive(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
 async function terminatePids(pids, deps) {
 	const killProcess = deps?.killProcess ?? ((pid, signal) => process.kill(pid, signal));
 	const sleep = deps?.sleep ?? ((ms) => new Promise((resolve) => {
@@ -375,7 +367,7 @@ async function terminatePids(pids, deps) {
 	} catch {}
 	if (terminated.length === 0) return terminated;
 	await sleep(750);
-	for (const pid of terminated) if (deps?.killProcess || isProcessAlive(pid)) try {
+	for (const pid of terminated) if (deps?.killProcess || isPidAlive(pid)) try {
 		killProcess(pid, "SIGKILL");
 	} catch {}
 	return terminated;

package/dist/{register.runtime-C29AY8LI.js → register.runtime-Dj29TKFy.js}

@@ -1,137 +1,14 @@
 import { getAcpRuntimeBackend, registerAcpRuntimeBackend, unregisterAcpRuntimeBackend } from "openclaw/plugin-sdk/acp-runtime-backend";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
-import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
-//#region extensions/acpx/src/runtime-turn.ts
-/**
-* ACPX turn adapters. Modern runtimes can expose startTurn directly; legacy
-* runtimes that only stream runTurn events are adapted to the newer contract.
-*/
-function isCancellationStopReason(stopReason) {
-	return stopReason === "cancel" || stopReason === "cancelled" || stopReason === "manual-cancel";
-}
-var LegacyRunTurnEventQueue = class {
-	constructor() {
-		this.items = [];
-		this.waits = [];
-		this.closed = false;
-	}
-	push(item) {
-		if (this.closed) return;
-		const waiter = this.waits.shift();
-		if (waiter) {
-			waiter.resolve(item);
-			return;
-		}
-		this.items.push(item);
-	}
-	clear() {
-		this.items.length = 0;
-	}
-	close() {
-		if (this.closed) return;
-		this.closed = true;
-		for (const waiter of this.waits.splice(0)) waiter.resolve(null);
-	}
-	fail(error) {
-		if (this.closed) return;
-		this.error = error;
-		this.closed = true;
-		for (const waiter of this.waits.splice(0)) waiter.reject(error);
-	}
-	async next() {
-		const item = this.items.shift();
-		if (item) return item;
-		if (this.error) throw toErrorObject(this.error, "Non-Error thrown");
-		if (this.closed) return null;
-		return await new Promise((resolve, reject) => {
-			this.waits.push({
-				resolve,
-				reject
-			});
-		});
-	}
-	async *iterate() {
-		for (;;) {
-			const item = await this.next();
-			if (!item) return;
-			yield item;
-		}
-	}
-};
-function legacyRunTurnAsStartTurn(runtime, input) {
-	const result = createDeferred();
-	result.promise.catch(() => {});
-	const queue = new LegacyRunTurnEventQueue();
-	let resultSettled = false;
-	const settleResult = (next) => {
-		if (resultSettled) return;
-		resultSettled = true;
-		result.resolve(next);
-	};
-	(async () => {
-		try {
-			for await (const event of runtime.runTurn(input)) {
-				if (event.type === "done") {
-					settleResult({
-						status: event.status ?? (isCancellationStopReason(event.stopReason) ? "cancelled" : "completed"),
-						...event.stopReason ? { stopReason: event.stopReason } : {}
-					});
-					continue;
-				}
-				if (event.type === "error") {
-					settleResult({
-						status: "failed",
-						error: {
-							message: event.message,
-							...event.code ? { code: event.code } : {},
-							...event.detailCode ? { detailCode: event.detailCode } : {},
-							...event.retryable === void 0 ? {} : { retryable: event.retryable }
-						}
-					});
-					continue;
-				}
-				queue.push(event);
-			}
-			settleResult({
-				status: "failed",
-				error: {
-					code: "ACP_TURN_FAILED",
-					message: "ACP turn ended without a terminal done event."
-				}
-			});
-		} catch (error) {
-			result.reject(error);
-			queue.fail(error);
-			return;
-		}
-		queue.close();
-	})();
-	return {
-		requestId: input.requestId,
-		events: queue.iterate(),
-		result: result.promise,
-		async cancel(inputArgs) {
-			await runtime.cancel({
-				handle: input.handle,
-				reason: inputArgs?.reason
-			});
-		},
-		async closeStream() {
-			queue.clear();
-			queue.close();
-		}
-	};
-}
-/** Start an ACP turn, adapting legacy runTurn-only runtimes when needed. */
-function startRuntimeTurn(runtime, input) {
-	return runtime.startTurn?.(input) ?? legacyRunTurnAsStartTurn(runtime, input);
-}
-/** Start an ACP turn through a lazy runtime resolver. */
+//#region extensions/acpx/src/runtime-proxy.ts
+/** Start an ACP turn through a lazy runtime resolver without awaiting resolution up front. */
 function lazyStartRuntimeTurn(resolveRuntime, input) {
-	const turnPromise = resolveRuntime().then((runtime) => startRuntimeTurn(runtime, input));
+	const turnPromise = resolveRuntime().then((runtime) => runtime.startTurn(input));
 	return {
 		requestId: input.requestId,
+		get promptStarted() {
+			return turnPromise.then((turn) => turn.promptStarted);
+		},
 		events: { async *[Symbol.asyncIterator]() {
 			yield* (await turnPromise).events;
 		} },
@@ -144,8 +21,6 @@ function lazyStartRuntimeTurn(resolveRuntime, input) {
 		}
 	};
 }
-//#endregion
-//#region extensions/acpx/src/runtime-proxy.ts
 /** Create an ACP runtime facade backed by an async runtime resolver. */
 function createLazyAcpRuntimeProxy(resolveRuntime) {
 	return {
@@ -159,25 +34,22 @@ function createLazyAcpRuntimeProxy(resolveRuntime) {
 			yield* (await resolveRuntime()).runTurn(input);
 		},
 		async getCapabilities(input) {
-			return await (await resolveRuntime()).getCapabilities?.(input) ?? { controls: [] };
+			return await (await resolveRuntime()).getCapabilities(input);
 		},
 		async getStatus(input) {
-			return await (await resolveRuntime()).getStatus?.(input) ?? {};
+			return await (await resolveRuntime()).getStatus(input);
 		},
 		async setMode(input) {
-			await (await resolveRuntime()).setMode?.(input);
+			await (await resolveRuntime()).setMode(input);
 		},
 		async setConfigOption(input) {
-			await (await resolveRuntime()).setConfigOption?.(input);
+			await (await resolveRuntime()).setConfigOption(input);
 		},
 		async doctor() {
-			return await (await resolveRuntime()).doctor?.() ?? {
-				ok: true,
-				message: "ok"
-			};
+			return await (await resolveRuntime()).doctor();
 		},
 		async prepareFreshSession(input) {
-			await (await resolveRuntime()).prepareFreshSession?.(input);
+			await (await resolveRuntime()).prepareFreshSession(input);
 		},
 		async cancel(input) {
 			await (await resolveRuntime()).cancel(input);
@@ -194,7 +66,7 @@ function createLazyAcpRuntimeProxy(resolveRuntime) {
 * immediately, then imports the heavier service only when a session needs it.
 */
 const ACPX_BACKEND_ID = "acpx";
-const loadServiceModule = createLazyRuntimeModule(() => import("./service-LTeZyc7q.js"));
+const loadServiceModule = createLazyRuntimeModule(() => import("./service-PRlUtXMf.js"));
 function unregisterOwnedRuntime(runtime) {
 	if (runtime && getAcpRuntimeBackend(ACPX_BACKEND_ID)?.runtime === runtime) unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
 }

package/dist/register.runtime.js

@@ -1,2 +1,2 @@
-import { t as createAcpxRuntimeService } from "./register.runtime-C29AY8LI.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-Dj29TKFy.js";
 export { createAcpxRuntimeService };

package/dist/{runtime-BmzHUTK8.js → runtime-BmOxa15I.js}

@@ -1,6 +1,6 @@
 import { d as withAcpxLeaseEnvironment, i as createAcpxProcessLeaseId, o as hashAcpxProcessCommand, t as ACPX_PROBE_LEASE_SESSION_KEY, u as readAcpxProcessLeaseIdentity, v as splitCommandParts } from "./process-lease-Cwvj7WGe.js";
 import { AcpRuntimeError } from "./runtime-api.js";
-import { d as OPENCLAW_CODEX_CONFIG_ARG, l as CODEX_ACP_PACKAGE, n as cleanupOpenClawOwnedAcpxProcessTree, r as isOpenClawLeaseAwareAcpxProcessCommand, t as cleanupOpenClawOwnedAcpxPendingLease } from "./process-reaper-DzVuCxl3.js";
+import { d as OPENCLAW_CODEX_CONFIG_ARG, l as CODEX_ACP_PACKAGE, n as cleanupOpenClawOwnedAcpxProcessTree, r as isOpenClawLeaseAwareAcpxProcessCommand, t as cleanupOpenClawOwnedAcpxPendingLease } from "./process-reaper-DduWm_7N.js";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import path, { resolve } from "node:path";
@@ -940,6 +940,9 @@ var AcpxRuntime = class {
 		});
 		return {
 			requestId: input.requestId,
+			get promptStarted() {
+				return turnPromise.then(({ turn }) => turn.promptStarted);
+			},
 			events: { async *[Symbol.asyncIterator]() {
 				const { command, turn } = await turnPromise;
 				try {

package/dist/{service-LTeZyc7q.js → service-PRlUtXMf.js}

@@ -1,11 +1,10 @@
-import { n as createLazyAcpRuntimeProxy } from "./register.runtime-C29AY8LI.js";
+import { n as createLazyAcpRuntimeProxy } from "./register.runtime-Dj29TKFy.js";
 import "./config-schema-DN_uAi4R.js";
 import { _ as quoteCommandPart, a as createAcpxProcessLeaseStore, f as ACPX_GATEWAY_INSTANCE_KEY, g as normalizeAcpxGatewayInstanceRecord, l as openAcpxProcessLeaseStateStore, n as OPENCLAW_ACPX_LEASE_ID_ARG, p as ACPX_GATEWAY_INSTANCE_NAMESPACE, r as OPENCLAW_GATEWAY_INSTANCE_ID_ARG, v as splitCommandParts } from "./process-lease-Cwvj7WGe.js";
-import { a as resolveAcpxPluginConfig, c as CODEX_ACP_BIN, d as OPENCLAW_CODEX_CONFIG_ARG, i as reapStaleOpenClawOwnedAcpxOrphans, l as CODEX_ACP_PACKAGE, n as cleanupOpenClawOwnedAcpxProcessTree, o as resolveAcpxPluginRoot, s as toAcpMcpServers, t as cleanupOpenClawOwnedAcpxPendingLease, u as LEGACY_CODEX_ACP_PACKAGE } from "./process-reaper-DzVuCxl3.js";
+import { a as resolveAcpxPluginConfig, c as CODEX_ACP_BIN, d as OPENCLAW_CODEX_CONFIG_ARG, i as reapStaleOpenClawOwnedAcpxOrphans, l as CODEX_ACP_PACKAGE, n as cleanupOpenClawOwnedAcpxProcessTree, o as resolveAcpxPluginRoot, s as toAcpMcpServers, t as cleanupOpenClawOwnedAcpxPendingLease, u as LEGACY_CODEX_ACP_PACKAGE } from "./process-reaper-DduWm_7N.js";
 import { createRequire } from "node:module";
 import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { isRecord, normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import fs from "node:fs";
 import os from "node:os";
@@ -13,6 +12,7 @@ import path from "node:path";
 import fs$1 from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { inspect } from "node:util";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
 import { parse, stringify } from "smol-toml";
 //#region extensions/acpx/src/codex-trust-config.ts
@@ -1021,7 +1021,7 @@ async function prepareAcpxCodexAuthConfig(params) {
 */
 const ENABLE_STARTUP_PROBE_ENV = "OPENCLAW_ACPX_RUNTIME_STARTUP_PROBE";
 const SKIP_RUNTIME_PROBE_ENV = "OPENCLAW_SKIP_ACPX_RUNTIME_PROBE";
-const loadRuntimeModule = createLazyRuntimeModule(() => import("./runtime-BmzHUTK8.js"));
+const loadRuntimeModule = createLazyRuntimeModule(() => import("./runtime-BmOxa15I.js"));
 /** Convert ACPX timeout seconds into timer-safe milliseconds. */
 function resolveAcpxTimerTimeoutMs(timeoutSeconds) {
 	if (timeoutSeconds === void 0) return;
@@ -1046,6 +1046,7 @@ function createLazyDefaultRuntime(params) {
 				openclawToolsMcpBridgeEnabled: params.pluginConfig.openClawToolsMcpBridge,
 				permissionMode: params.pluginConfig.permissionMode,
 				nonInteractivePermissions: params.pluginConfig.nonInteractivePermissions,
+				elicitationModes: ["form", "url"],
 				timeoutMs: resolveAcpxTimerTimeoutMs(params.pluginConfig.timeoutSeconds)
 			});
 			return runtime;
@@ -1260,7 +1261,7 @@ function createAcpxRuntimeService(params) {
 					ctx.logger.info("embedded acpx runtime backend ready");
 					return;
 				}
-				const doctorReport = await measureAcpxStartup(ctx, "probe.doctor", () => startedRuntime.doctor?.());
+				const doctorReport = await measureAcpxStartup(ctx, "probe.doctor", () => startedRuntime.doctor());
 				if (currentRevision !== lifecycleRevision) return;
 				detailAcpxStartup(ctx, "probe.result", [["healthyCount", 0]]);
 				ctx.logger.warn(`embedded acpx runtime backend probe failed: ${doctorReport ? formatDoctorFailureMessage(doctorReport) : "backend remained unhealthy after probe"}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/acpx",
-  "version": "2026.8.1-beta.2",
+  "version": "2026.9.1-beta.1",
   "description": "OpenClaw ACP runtime backend with plugin-owned session and transport management.",
   "repository": {
     "type": "git",
@@ -8,10 +8,10 @@
   },
   "type": "module",
   "dependencies": {
-    "@agentclientprotocol/claude-agent-acp": "0.62.0",
-    "@agentclientprotocol/codex-acp": "1.1.7",
-    "acpx": "0.13.0",
-    "smol-toml": "1.7.1",
+    "@agentclientprotocol/claude-agent-acp": "0.70.0",
+    "@agentclientprotocol/codex-acp": "1.6.0",
+    "acpx": "0.13.1",
+    "smol-toml": "1.8.0",
     "zod": "4.4.3"
   },
   "devDependencies": {
@@ -43,10 +43,10 @@
       ]
     },
     "compat": {
-      "pluginApi": ">=2026.8.1-beta.2"
+      "pluginApi": ">=2026.9.1-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.8.1-beta.2",
+      "openclawVersion": "2026.9.1-beta.1",
       "staticAssets": [
         {
           "source": "./src/runtime-internals/mcp-proxy.mjs",
@@ -74,7 +74,7 @@
     "skills/**"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.8.1-beta.2"
+    "openclaw": ">=2026.9.1-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/skills/acp-router/SKILL.md

@@ -209,8 +209,8 @@ ${ACPX_CMD} codex sessions close oc-codex-<conversationId>
 Defaults are:
 
 - `openclaw -> openclaw acp`
-- `claude -> bundled @agentclientprotocol/claude-agent-acp@0.55.0`
-- `codex -> bundled @agentclientprotocol/codex-acp@1.1.2 through OpenClaw's isolated CODEX_HOME wrapper`
+- `claude -> bundled @agentclientprotocol/claude-agent-acp@0.70.0`
+- `codex -> bundled @agentclientprotocol/codex-acp@1.6.0 through OpenClaw's isolated CODEX_HOME wrapper`
 - `copilot -> copilot --acp --stdio`
 - `cursor -> cursor-agent acp`
 - `droid -> droid exec --output-format acp`