@openclaw/acpx 2026.10.5-beta.3 → 2026.10.10-beta.1

package/README.md

@@ -21,10 +21,15 @@ to regenerate wrappers written by an older plugin version.
 ## What it provides
 
 - ACP-backed agent runtime sessions.
+- Built-in ACPX harness targets, including `grok-build` for the Grok Build CLI.
 - Plugin-owned session and transport management.
 - MCP bridge helpers for OpenClaw tools and plugin tools.
 - Static runtime assets used by the ACP process bridge.
 
+If the Gateway restarts before a one-shot session receives its first prompt, ACPX
+reuses the initialized conversation when the agent supports loading or resuming
+sessions. Completed one-shot runs still start a fresh conversation.
+
 ## 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,
@@ -83,6 +88,10 @@ Use the ACP docs for harness-specific setup, permission modes, and model/runtime
 - https://docs.openclaw.ai/tools/acp-agents-setup
 - https://docs.openclaw.ai/tools/acp-agents
 
+`grok-build` is an agent target (`agentId: "grok-build"`), not the xAI model id
+`xai/grok-build-0.1`. The target launches the installed Grok Build CLI through
+`grok agent stdio`.
+
 ## Package
 
 - Plugin id: `acpx`

package/dist/.setup/{harness-attempt-CRe4WIFt.mjs → harness-attempt-lu4_bMfd.mjs}

@@ -1,7 +1,7 @@
-import { createNativeSessionBindingAuthority } from "openclaw/plugin-sdk/agent-harness-session-runtime";
 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 { createNativeSessionBindingScope } from "openclaw/plugin-sdk/agent-harness-session-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";
@@ -299,7 +299,7 @@ async function runAcpHarnessAttempt(params) {
 				...assistant,
 				idempotencyKey: assistantItemId
 			},
-			preparation: { source: createNativeSessionBindingAuthority([], input.hostCapabilities.assertActive).assertLegacyCurrent }
+			preparation: { source: createNativeSessionBindingScope(input.hostCapabilities.assertActive).assertLegacyCurrent }
 		});
 		if (written.kind !== "result") throw new Error("ACP assistant transcript was not committed");
 		assistant = written.result.message;

package/dist/.setup/{pi-session-catalog-runtime-7jc50ZJ4.mjs → pi-session-catalog-runtime-BAM1pEMw.mjs}

@@ -4,22 +4,22 @@ 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 { createSessionCatalogFamily } from "openclaw/plugin-sdk/session-catalog";
 import { resolveAcpSessionAvailability } from "openclaw/plugin-sdk/acp-runtime";
 import process from "node:process";
 import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { createAcpSessionCatalogAdoption, readSessionCatalogJsonlActivity } from "openclaw/plugin-sdk/session-catalog-runtime";
 import { sessionCatalogPaging } from "openclaw/plugin-sdk/session-catalog-paging";
 import { safeParseJson, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import fs$1 from "node:fs/promises";
 import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
-import { isPathStrictlyInside, readFileRangeAsync } from "openclaw/plugin-sdk/file-access-runtime";
+import { isPathStrictlyInside } from "openclaw/plugin-sdk/file-access-runtime";
 //#region extensions/acpx/src/pi-session-store.ts
 const MAX_DISCOVERY_FILES = 1e4;
 const SUMMARY_SCAN_BATCH_SIZE = 100;
 const MAX_SUMMARY_CACHE_ENTRIES = 256;
 const MAX_SESSION_BYTES = 33554432;
 const MAX_SUMMARY_LINE_BYTES = 1048576;
-const APPEND_PROOF_EDGE_BYTES = 65536;
 const IO_CONCURRENCY = 8;
 const PI_FILE_CANDIDATE_CACHE_TTL_MS = 32e3;
 const PI_FILE_CANDIDATE_CACHE_MAX_ENTRIES = 8;
@@ -200,30 +200,6 @@ async function scanSummaryAppend(candidate, start, state) {
 		}
 	}
 }
-async function readAppendProof(file, size) {
-	const length = Math.min(size, APPEND_PROOF_EDGE_BYTES);
-	if (length === 0) return {
-		head: Buffer.alloc(0),
-		tail: Buffer.alloc(0)
-	};
-	const handle = await fs$1.open(file, "r");
-	try {
-		const head = Buffer.alloc(length);
-		const tail = Buffer.alloc(length);
-		const [headRead, tailRead] = await Promise.all([handle.read(head, 0, length, 0), handle.read(tail, 0, length, size - length)]);
-		return {
-			head: head.subarray(0, headRead.bytesRead),
-			tail: tail.subarray(0, tailRead.bytesRead)
-		};
-	} finally {
-		await handle.close();
-	}
-}
-async function cachedPrefixIsUnchanged(candidate, cached) {
-	if (cached.identity !== candidate.identity || cached.size >= candidate.size) return false;
-	const current = await readAppendProof(candidate.file, cached.size);
-	return current.head.equals(cached.appendProof.head) && current.tail.equals(cached.appendProof.tail);
-}
 async function readPiSessionSummary(candidate) {
 	const cached = summaryCache.get(candidate.file);
 	if (cached?.mtimeMs === candidate.mtimeMs && cached.size === candidate.size) {
@@ -236,9 +212,8 @@ async function readPiSessionSummary(candidate) {
 	}
 	let summary;
 	let scanState;
-	let appendProof;
 	try {
-		const resumable = cached && await cachedPrefixIsUnchanged(candidate, cached) ? cached : void 0;
+		const resumable = cached?.identity === candidate.identity && cached.size < candidate.size ? cached : void 0;
 		scanState = resumable ? {
 			...resumable.scanState,
 			pending: Buffer.from(resumable.scanState.pending)
@@ -248,7 +223,6 @@ async function readPiSessionSummary(candidate) {
 			invalid: false
 		};
 		await scanSummaryAppend(candidate, resumable?.size ?? 0, scanState);
-		appendProof = await readAppendProof(candidate.file, candidate.size);
 		const projectedState = {
 			...scanState,
 			pending: Buffer.from(scanState.pending)
@@ -284,8 +258,7 @@ async function readPiSessionSummary(candidate) {
 	cacheSummary(candidate.file, {
 		...candidate,
 		summary,
-		scanState,
-		appendProof
+		scanState
 	});
 	if (summary) threadFileCache.set(threadCacheKey(candidate.storeRoot, summary.threadId), candidate.file);
 	return summary;
@@ -349,24 +322,20 @@ async function readPiSessionFileBaseline(threadId, env) {
 }
 async function readPiSessionById(threadId, env) {
 	const cacheKey = threadCacheKey(piSessionStore(env).root, threadId);
-	let file = threadFileCache.get(cacheKey);
-	for (let attempt = 0; attempt < 2; attempt += 1) {
-		if (!file) file = (await findPiSummary(threadId, env))?.file;
-		if (!file) throw new Error("Pi session was not found");
-		try {
-			const stats = await fs$1.stat(file);
-			if (!stats.isFile()) throw new Error("Pi session is not a file");
-			if (stats.size > MAX_SESSION_BYTES) throw new RangeError("Pi session exceeds the 32 MiB read safety limit");
-			const entries = parsePiJsonLines(await fs$1.readFile(file, "utf8"));
-			if (entries[0]?.type === "session" && entries[0].id === threadId) return entries;
-		} catch (error) {
-			if (error instanceof RangeError) throw error;
-			if (attempt > 0) throw new Error("Pi session is unavailable", { cause: error });
-		}
+	const file = threadFileCache.get(cacheKey) ?? (await findPiSummary(threadId, env))?.file;
+	if (!file) throw new Error("Pi session was not found");
+	try {
+		const stats = await fs$1.stat(file);
+		if (!stats.isFile()) throw new Error("Pi session is not a file");
+		if (stats.size > MAX_SESSION_BYTES) throw new RangeError("Pi session exceeds the 32 MiB read safety limit");
+		const entries = parsePiJsonLines(await fs$1.readFile(file, "utf8"));
+		if (entries[0]?.type !== "session" || entries[0].id !== threadId) throw new Error("Pi session changed during read");
+		return entries;
+	} catch (error) {
 		threadFileCache.delete(cacheKey);
-		file = void 0;
+		if (error instanceof RangeError) throw error;
+		throw new Error("Pi session is unavailable", { cause: error });
 	}
-	throw new Error("Pi session changed during read");
 }
 //#endregion
 //#region extensions/acpx/src/pi-session-catalog.ts
@@ -564,27 +533,6 @@ async function readLocalPiTranscriptPage(value) {
 }
 //#endregion
 //#region extensions/acpx/src/pi-session-upstream-activity.ts
-const MAX_PI_UPSTREAM_SCAN_BYTES = 1048576;
-function parseCompletePiRows(tail) {
-	const entries = [];
-	let lineStart = 0;
-	let classifiedBytes = 0;
-	for (let index = 0; index < tail.length; index += 1) {
-		if (tail[index] !== 10) continue;
-		const line = tail.subarray(lineStart, index).toString("utf8").trim();
-		if (line) {
-			const value = safeParseJson(line);
-			if (!isRecord(value)) break;
-			entries.push(value);
-		}
-		classifiedBytes = index + 1;
-		lineStart = index + 1;
-	}
-	return {
-		entries,
-		classifiedBytes
-	};
-}
 function readFilePath(probe) {
 	return isRecord(probe.upstreamRef) && typeof probe.upstreamRef.filePath === "string" ? probe.upstreamRef.filePath : void 0;
 }
@@ -611,48 +559,20 @@ async function checkPiSessionUpstreamActivity(probe) {
 	const filePath = readFilePath(probe);
 	const markerOffset = readMarkerOffset(probe);
 	if (!filePath || markerOffset === void 0) return;
-	let handle;
-	try {
-		handle = await fs$1.open(filePath, "r");
-	} catch (error) {
-		return isRecord(error) && error.code === "ENOENT" ? {
-			kind: "missing",
-			sessionKey: probe.sessionKey
-		} : void 0;
-	}
-	try {
-		const stat = await handle.stat();
-		if (!stat.isFile()) return {
-			kind: "missing",
-			sessionKey: probe.sessionKey
-		};
-		if (stat.size <= markerOffset) return;
-		const readLength = Math.min(stat.size - markerOffset, MAX_PI_UPSTREAM_SCAN_BYTES);
-		const { entries, classifiedBytes } = parseCompletePiRows(await readFileRangeAsync(handle, markerOffset, readLength));
-		if (classifiedBytes === 0) return;
-		let humanTurns = 0;
-		let occurredAt;
-		for (const entry of entries) {
-			if (entry.type !== "message" || !isRecord(entry.message) || entry.message.role !== "user") continue;
-			const text = piMessageText(entry.message.content);
-			if (!isExternalUserText(probe, text)) continue;
-			humanTurns += 1;
-			occurredAt = Math.max(occurredAt ?? 0, parseDateFirstTimestampMs(entry.message.timestamp) ?? parseDateFirstTimestampMs(entry.timestamp) ?? stat.mtimeMs);
+	return readSessionCatalogJsonlActivity({
+		probe,
+		filePath,
+		offset: markerOffset,
+		classifyLine(line) {
+			const entry = safeParseJson(line);
+			if (!isRecord(entry)) return false;
+			if (entry.type !== "message" || !isRecord(entry.message) || entry.message.role !== "user") return;
+			return {
+				userText: piMessageText(entry.message.content),
+				occurredAt: parseDateFirstTimestampMs(entry.message.timestamp) ?? parseDateFirstTimestampMs(entry.timestamp)
+			};
 		}
-		const nextOffset = markerOffset + classifiedBytes;
-		return {
-			kind: "activity",
-			sessionKey: probe.sessionKey,
-			humanTurns,
-			nextMarker: { offset: nextOffset },
-			...humanTurns > 0 ? {
-				occurredAt: occurredAt ?? stat.mtimeMs,
-				dedupeId: String(nextOffset)
-			} : {}
-		};
-	} finally {
-		await handle.close();
-	}
+	});
 }
 async function checkPiUpstreamActivity(probes) {
 	const outcomes = [];
@@ -677,7 +597,7 @@ async function requireLocalPiSession(threadId) {
 	return session;
 }
 function currentPiCatalogConfig(api) {
-	return api.runtime.config?.current?.() ?? api.config ?? {};
+	return api.runtime.config.current();
 }
 function resolvePiContinuationAvailability(api) {
 	const availability = resolveAcpSessionAvailability({
@@ -695,64 +615,20 @@ function resolvePiContinuationAvailability(api) {
 		message: "Pi CLI is unavailable"
 	};
 }
-function listAdoptedPiSessions(api, agentId, sessionEntries) {
-	return listAdoptedSessionCatalogSessions({
-		...agentId ? { agentId } : {},
-		config: currentPiCatalogConfig(api),
-		pluginId: api.id,
-		runtime: api.runtime,
-		sessionEntries,
-		sourceFromEntry: (entry) => {
-			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: PI_LOCAL_SESSION_HOST_ID,
-				threadId: marker.sourceThreadId
-			} : void 0;
-		}
-	});
-}
-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 ? { displayName: params.session.name } : {},
-		...params.session.cwd ? { spawnedCwd: params.session.cwd } : {},
-		initialEntry: {
-			acpBackendId: ACPX_BACKEND_ID,
-			acpSessionBinding: {
-				acpAgentId: PI_ACP_AGENT_ID,
-				agentSessionId: params.threadId
-			},
-			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 === "gateway" && allowProcessHomeFallback === false && piSessionStore(process.env).usesProcessHomeFallback) throw new Error("local Pi sessions are unavailable in isolated state");
 }
 function createPiSessionCatalogRuntime(api) {
+	const adoption = createAcpSessionCatalogAdoption({
+		api,
+		config: () => currentPiCatalogConfig(api),
+		catalogId: PI_ACP_AGENT_ID,
+		hostId: PI_LOCAL_SESSION_HOST_ID,
+		keyPrefix: PI_ADOPTED_SESSION_KEY_PREFIX,
+		markerPluginId: "acpx",
+		markerKey: "piSessionCatalog",
+		read: readLocalPiTranscriptPage
+	});
 	return createSessionCatalogFamily({
 		runtime: api.runtime,
 		local: {
@@ -821,15 +697,12 @@ function createPiSessionCatalogRuntime(api) {
 				agentId
 			}).sessionAgentId,
 			availability: () => resolvePiContinuationAvailability(api),
-			listAdopted: (agentId, sessionEntries) => listAdoptedPiSessions(api, agentId, sessionEntries),
+			listAdopted: (agentId, sessionEntries) => adoption.listAdopted(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
-			}),
+			create: (params) => adoption.create(params),
 			complete: async (continued, threadId) => await linkContinuedPiSession(continued.sessionKey, threadId),
 			nodeReadOnlyMessage: "paired-node Pi session rows are view-only"
 		},

package/dist/.setup/{register.runtime-DfAHoa8o.mjs → register.runtime-CdG6bROH.mjs}

@@ -53,7 +53,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-De_oVTL3.mjs"));
+const loadServiceModule = createLazyRuntimeModule(() => import("./service-5eVJSjDE.mjs"));
 function unregisterOwnedRuntime(runtime) {
 	if (runtime && getAcpRuntimeBackend(ACPX_BACKEND_ID)?.runtime === runtime) unregisterAcpRuntimeBackend(ACPX_BACKEND_ID);
 }