@openclaw/acpx 2026.7.2-beta.4 → 2026.7.2-beta.7

package/dist/doctor-contract-api.js

@@ -1,4 +1,4 @@
-import { c as openAcpxProcessLeaseStateStore, d as ACPX_GATEWAY_INSTANCE_NAMESPACE, f as ACPX_LEGACY_GATEWAY_INSTANCE_FILE, m as normalizeAcpxGatewayInstanceRecord, o as normalizeAcpxProcessLease, p as ACPX_LEGACY_PROCESS_LEASE_FILE, s as normalizeAcpxProcessLeaseFile, u as ACPX_GATEWAY_INSTANCE_KEY } from "./process-lease-CU1cFI4I.js";
+import { c as openAcpxProcessLeaseStateStore, d as ACPX_GATEWAY_INSTANCE_KEY, f as ACPX_GATEWAY_INSTANCE_NAMESPACE, h as normalizeAcpxGatewayInstanceRecord, m as ACPX_LEGACY_PROCESS_LEASE_FILE, o as normalizeAcpxProcessLease, p as ACPX_LEGACY_GATEWAY_INSTANCE_FILE, s as normalizeAcpxProcessLeaseFile } from "./process-lease-DSLDgiNl.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { archiveLegacyStateSource } from "openclaw/plugin-sdk/runtime-doctor";

package/dist/index.js

@@ -1,9 +1,12 @@
-import { t as createAcpxRuntimeService } from "./register.runtime-Dajn8myc.js";
+import { t as createAcpxRuntimeService } from "./register.runtime-BbS2JTTv.js";
 import "./config-schema-lrk5nlcV.js";
 import { tryDispatchAcpReplyHook } from "openclaw/plugin-sdk/acp-runtime-backend";
 import { finiteSecondsToTimerSafeMilliseconds } from "openclaw/plugin-sdk/number-runtime";
 import process$1 from "node:process";
+import { resolveAcpSessionAvailability } from "openclaw/plugin-sdk/acp-runtime";
+import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
 import { decodeNodePtyResumeParams, resolveNodeHostExecutable, runNodePtyCommand } from "openclaw/plugin-sdk/node-host";
+import { createSessionCatalogAdoptionCoordinator, importSessionCatalogHistory, isExternalUserText, listAdoptedSessionCatalogSessions, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createReadStream, readFileSync, statSync } from "node:fs";
@@ -67,6 +70,13 @@ function piSessionStore(env, cwd = process.cwd()) {
 		flat: false
 	};
 }
+/** Store root scanned by pi-acp@0.0.26 when resolving a native session id. */
+function piAcpSessionStoreRoot(env) {
+	const configuredAgentDir = env.PI_CODING_AGENT_DIR?.trim();
+	if (configuredAgentDir && !isPiSessionCatalogPathAbsolute(configuredAgentDir)) return;
+	const agentDir = configuredAgentDir ? path.resolve(configuredAgentDir) : path.join(piHome(env), ".pi", "agent");
+	return path.join(agentDir, "sessions");
+}
 function piSessionStoreAvailable(env) {
 	try {
 		return statSync(piSessionStore(env).root).isDirectory();
@@ -83,9 +93,12 @@ const MAX_SESSION_BYTES = 32 * 1024 * 1024;
 const MAX_SUMMARY_LINE_BYTES = 1024 * 1024;
 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 summaryCache = /* @__PURE__ */ new Map();
 const threadFileCache = /* @__PURE__ */ new Map();
+const piFileCandidateCache = /* @__PURE__ */ new Map();
 function threadCacheKey(storeRoot, threadId) {
 	return `${storeRoot}\0${threadId}`;
 }
@@ -114,9 +127,10 @@ function optionalString(value, maxLength) {
 }
 async function discoverPiSessionFiles(env) {
 	const store = piSessionStore(env);
+	const resolvedRoot = await realpathOrResolve(store.root);
 	let entries;
 	try {
-		entries = await fs$1.readdir(store.root, { withFileTypes: true });
+		entries = await fs$1.readdir(resolvedRoot, { withFileTypes: true });
 	} catch {
 		return {
 			root: store.root,
@@ -125,12 +139,12 @@ async function discoverPiSessionFiles(env) {
 	}
 	if (store.flat) return {
 		root: store.root,
-		files: entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).slice(0, MAX_DISCOVERY_FILES).map((entry) => path.join(store.root, entry.name))
+		files: entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).slice(0, MAX_DISCOVERY_FILES).map((entry) => path.join(resolvedRoot, entry.name))
 	};
 	const files = [];
 	for (const entry of entries) {
 		if (!entry.isDirectory() || files.length >= MAX_DISCOVERY_FILES) continue;
-		const directory = path.join(store.root, entry.name);
+		const directory = path.join(resolvedRoot, entry.name);
 		let children;
 		try {
 			children = await fs$1.readdir(directory, { withFileTypes: true });
@@ -147,6 +161,13 @@ async function discoverPiSessionFiles(env) {
 		files
 	};
 }
+async function realpathOrResolve(value) {
+	try {
+		return await fs$1.realpath(value);
+	} catch {
+		return path.resolve(value);
+	}
+}
 async function mapConcurrent(values, limit, mapper) {
 	const results = [];
 	results.length = values.length;
@@ -160,8 +181,10 @@ async function mapConcurrent(values, limit, mapper) {
 	await Promise.all(workers);
 	return results;
 }
-async function piFileCandidates(env) {
+async function scanPiFileCandidates(env) {
 	const { root, files } = await discoverPiSessionFiles(env);
+	const configuredAcpRoot = piAcpSessionStoreRoot(env);
+	const acpRoot = configuredAcpRoot ? await realpathOrResolve(configuredAcpRoot) : void 0;
 	return (await mapConcurrent(files, IO_CONCURRENCY, async (file) => {
 		try {
 			const stats = await fs$1.stat(file);
@@ -170,13 +193,46 @@ async function piFileCandidates(env) {
 				storeRoot: root,
 				identity: `${String(stats.dev)}:${String(stats.ino)}:${String(stats.birthtimeMs)}`,
 				mtimeMs: stats.mtimeMs,
-				size: stats.size
+				size: stats.size,
+				resumable: acpRoot ? pathIsWithin(acpRoot, file) : false
 			} : void 0;
 		} catch {
 			return;
 		}
 	})).filter((candidate) => candidate !== void 0).toSorted((left, right) => right.mtimeMs - left.mtimeMs);
 }
+async function piFileCandidates(env) {
+	const store = piSessionStore(env);
+	const key = `${store.root}\0${store.flat}\0${piAcpSessionStoreRoot(env) ?? ""}`;
+	const cached = piFileCandidateCache.get(key);
+	if (cached && cached.expiresAt > Date.now()) {
+		piFileCandidateCache.delete(key);
+		piFileCandidateCache.set(key, cached);
+		return await cached.candidates;
+	}
+	if (cached) piFileCandidateCache.delete(key);
+	const candidates = scanPiFileCandidates(env);
+	const entry = {
+		expiresAt: Date.now() + PI_FILE_CANDIDATE_CACHE_TTL_MS,
+		candidates
+	};
+	piFileCandidateCache.set(key, entry);
+	while (piFileCandidateCache.size > PI_FILE_CANDIDATE_CACHE_MAX_ENTRIES) {
+		const oldest = piFileCandidateCache.keys().next();
+		if (oldest.done) break;
+		piFileCandidateCache.delete(oldest.value);
+	}
+	try {
+		return await candidates;
+	} catch (error) {
+		if (piFileCandidateCache.get(key) === entry) piFileCandidateCache.delete(key);
+		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 [];
@@ -188,12 +244,12 @@ function parsePiJsonLines(content) {
 		}
 	});
 }
-function textFromContent$1(content) {
+function textFromContent$2(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return "";
 	return content.flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n");
 }
-function timestampMs$1(value) {
+function timestampMs$2(value) {
 	if (typeof value === "number" && Number.isFinite(value)) return value;
 	if (typeof value === "string") {
 		const parsed = Date.parse(value);
@@ -212,7 +268,7 @@ function processSummaryLine(state, line) {
 		return;
 	}
 	if (entry.type === "session_info") state.name = optionalString(entry.name, 1e3);
-	else if (!state.firstMessage && entry.type === "message" && isRecord(entry.message) && entry.message.role === "user") state.firstMessage = optionalString(textFromContent$1(entry.message.content), 1e3);
+	else if (!state.firstMessage && entry.type === "message" && isRecord(entry.message) && entry.message.role === "user") state.firstMessage = optionalString(textFromContent$2(entry.message.content), 1e3);
 }
 function appendSummaryBytes(state, bytes) {
 	if (state.discarding || bytes.length === 0) return;
@@ -274,7 +330,10 @@ async function readPiSessionSummary(candidate) {
 	if (cached?.mtimeMs === candidate.mtimeMs && cached.size === candidate.size) {
 		summaryCache.delete(candidate.file);
 		summaryCache.set(candidate.file, cached);
-		return cached.summary;
+		return cached.summary ? {
+			...cached.summary,
+			canContinue: candidate.resumable
+		} : cached.summary;
 	}
 	let summary;
 	let scanState;
@@ -297,12 +356,14 @@ async function readPiSessionSummary(candidate) {
 		};
 		if (!projectedState.discarding && projectedState.pending.length > 0) processSummaryLine(projectedState, projectedState.pending);
 		const { header, name, firstMessage } = projectedState;
+		const version = header?.type === "session" && typeof header.version === "number" ? header.version : 1;
 		const threadId = header?.type === "session" ? optionalString(header.id, 256) : void 0;
 		if (header && threadId && SESSION_ID_PATTERN$2.test(threadId)) {
 			const cwd = optionalString(header.cwd, 4096);
-			const createdAt = timestampMs$1(header.timestamp);
+			const createdAt = timestampMs$2(header.timestamp);
 			summary = {
 				file: candidate.file,
+				version,
 				threadId,
 				...name || firstMessage ? { name: name ?? firstMessage } : {},
 				...cwd ? { cwd } : {},
@@ -313,7 +374,7 @@ async function readPiSessionSummary(candidate) {
 				source: "pi-cli",
 				modelProvider: "pi",
 				archived: false,
-				canContinue: false,
+				canContinue: candidate.resumable,
 				canArchive: false
 			};
 		}
@@ -364,6 +425,19 @@ async function findPiSummary(threadId, env) {
 		if (match) return match;
 	}
 }
+async function readPiSessionFileBaseline(threadId, env) {
+	const summary = await findPiSummary(threadId, env);
+	if (!summary?.canContinue || summary.version < 3) return;
+	try {
+		const stats = await fs$1.stat(summary.file);
+		return stats.isFile() ? {
+			filePath: summary.file,
+			offset: stats.size
+		} : void 0;
+	} catch {
+		return;
+	}
+}
 async function readPiSessionById(threadId, env) {
 	const cacheKey = threadCacheKey(piSessionStore(env).root, threadId);
 	let file = threadFileCache.get(cacheKey);
@@ -472,7 +546,7 @@ function transcriptPage(items, limit, offset) {
 		...consumed < items.length ? { nextCursor: encodeCursor(consumed) } : {}
 	};
 }
-function textFromContent(content) {
+function textFromContent$1(content) {
 	if (typeof content === "string") return content;
 	if (!Array.isArray(content)) return "";
 	return content.flatMap((part) => {
@@ -485,7 +559,7 @@ function textFromContent(content) {
 		return [];
 	}).join("\n");
 }
-function timestampMs(value) {
+function timestampMs$1(value) {
 	if (typeof value === "number" && Number.isFinite(value)) return value;
 	if (typeof value === "string") {
 		const parsed = Date.parse(value);
@@ -535,14 +609,14 @@ async function listLocalPiSessionPage(value) {
 		limit: params.limit,
 		...params.searchTerm ? { searchTerm: params.searchTerm } : {}
 	});
-	const page = summaries.map(({ file: _file, ...session }) => session);
+	const page = summaries.map(({ file: _file, version: _version, ...session }) => session);
 	return {
 		sessions: page,
 		...hasMore ? { nextCursor: encodeCursor(offset + page.length) } : {}
 	};
 }
 function isoTimestamp(message, entry) {
-	const value = timestampMs(message.timestamp) ?? timestampMs(entry.timestamp);
+	const value = timestampMs$1(message.timestamp) ?? timestampMs$1(entry.timestamp);
 	if (value === void 0) return;
 	const date = new Date(value);
 	return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
@@ -588,7 +662,7 @@ function piMessageItems(entry) {
 		...modelRef ? { model: modelRef } : {}
 	};
 	if (role === "user") {
-		const text = textFromContent(message.content);
+		const text = textFromContent$1(message.content);
 		return text ? [{
 			...common,
 			type: "userMessage",
@@ -597,7 +671,7 @@ function piMessageItems(entry) {
 	}
 	if (role === "toolResult") {
 		const toolName = optionalPiString(message.toolName, 256);
-		const text = textFromContent(message.content);
+		const text = textFromContent$1(message.content);
 		return [{
 			...common,
 			type: "toolResult",
@@ -622,7 +696,7 @@ function piMessageItems(entry) {
 	if (role === "custom" || role === "hookMessage") {
 		if (message.display !== true) return [];
 		const customType = optionalPiString(message.customType, 256);
-		const text = textFromContent(message.content);
+		const text = textFromContent$1(message.content);
 		return text ? [{
 			...common,
 			type: "other",
@@ -678,7 +752,7 @@ function piTranscriptItems(entries) {
 			text: entry.summary
 		}];
 		if (entry.type === "custom_message" && entry.display === true) {
-			const text = textFromContent(entry.content);
+			const text = textFromContent$1(entry.content);
 			return text ? [{
 				...common,
 				type: "other",
@@ -700,6 +774,121 @@ async function readLocalPiTranscriptPage(value) {
 	};
 }
 //#endregion
+//#region extensions/acpx/src/pi-session-upstream-activity.ts
+const MAX_PI_UPSTREAM_SCAN_BYTES = 1024 * 1024;
+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) try {
+			const value = JSON.parse(line);
+			if (!isRecord(value)) break;
+			entries.push(value);
+		} catch {
+			break;
+		}
+		classifiedBytes = index + 1;
+		lineStart = index + 1;
+	}
+	return {
+		entries,
+		classifiedBytes
+	};
+}
+function textFromContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return;
+	return content.flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : []).join("\n") || void 0;
+}
+function timestampMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string") {
+		const parsed = Date.parse(value);
+		return Number.isNaN(parsed) ? void 0 : parsed;
+	}
+}
+function readFilePath(probe) {
+	return isRecord(probe.upstreamRef) && typeof probe.upstreamRef.filePath === "string" ? probe.upstreamRef.filePath : void 0;
+}
+function readMarkerOffset(probe) {
+	return isRecord(probe.marker) && Number.isSafeInteger(probe.marker.offset) && Number(probe.marker.offset) >= 0 ? Number(probe.marker.offset) : void 0;
+}
+async function linkContinuedPiSession(sessionKey, threadId) {
+	try {
+		const baseline = await readPiSessionFileBaseline(threadId, process$1.env);
+		return baseline ? {
+			sessionKey,
+			upstream: {
+				kind: "pi-cli",
+				ref: { filePath: baseline.filePath },
+				marker: { offset: baseline.offset }
+			}
+		} : { sessionKey };
+	} catch {
+		return { sessionKey };
+	}
+}
+async function checkPiSessionUpstreamActivity(probe) {
+	if (probe.hostId !== "gateway" || probe.upstreamKind !== "pi-cli") return;
+	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 buffer = Buffer.allocUnsafe(readLength);
+		const { bytesRead } = await handle.read(buffer, 0, buffer.length, markerOffset);
+		const { entries, classifiedBytes } = parseCompletePiRows(buffer.subarray(0, bytesRead));
+		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;
+			if (!isExternalUserText(probe, textFromContent(entry.message.content))) continue;
+			humanTurns += 1;
+			occurredAt = Math.max(occurredAt ?? 0, timestampMs(entry.message.timestamp) ?? timestampMs(entry.timestamp) ?? stat.mtimeMs);
+		}
+		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 = [];
+	for (const probe of probes) try {
+		const outcome = await checkPiSessionUpstreamActivity(probe);
+		if (outcome) outcomes.push(outcome);
+	} catch {}
+	return outcomes;
+}
+//#endregion
 //#region extensions/acpx/src/pi-session-catalog-plugin.ts
 const PI_SESSIONS_LIST_COMMAND = "acpx.pi.sessions.list.v1";
 const PI_SESSION_READ_COMMAND = "acpx.pi.sessions.read.v1";
@@ -718,6 +907,11 @@ const TRANSCRIPT_ITEM_TYPES = /* @__PURE__ */ new Set([
 	"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;
@@ -823,8 +1017,11 @@ function nodeLabel(node) {
 function unwrapNodePayload(value) {
 	return isRecord(value) && typeof value.payloadJSON === "string" ? JSON.parse(value.payloadJSON) : value;
 }
-function setTerminalCapability(page, canOpenTerminal) {
-	for (const session of page.sessions) session.canOpenTerminal = canOpenTerminal;
+function setCatalogCapabilities(page, capabilities) {
+	for (const session of page.sessions) {
+		session.canContinue = capabilities.canContinue && session.canContinue;
+		session.canOpenTerminal = capabilities.canOpenTerminal;
+	}
 	return page;
 }
 async function listPiNodeHost(runtime, query, node) {
@@ -861,7 +1058,10 @@ async function listPiNodeHost(runtime, query, node) {
 		const canOpenTerminal = (node.invocableCommands ?? node.commands)?.includes(PI_TERMINAL_RESUME_COMMAND) === true;
 		return {
 			...common,
-			...setTerminalCapability(page, canOpenTerminal)
+			...setCatalogCapabilities(page, {
+				canContinue: false,
+				canOpenTerminal
+			})
 		};
 	} catch {
 		return {
@@ -896,7 +1096,9 @@ function parseNodeTranscriptPage(value, threadId) {
 		...nextCursor !== void 0 ? { nextCursor } : {}
 	};
 }
-async function listPiHosts(runtime, query) {
+async function listPiHosts(api, query) {
+	const runtime = api.runtime;
+	const canContinue = resolvePiContinuationAvailability(api).available;
 	const requested = query.hostIds ? new Set(query.hostIds) : void 0;
 	const hosts = [];
 	if ((!requested || requested.has(LOCAL_HOST_ID)) && piSessionStoreAvailable(process$1.env)) try {
@@ -909,11 +1111,14 @@ async function listPiHosts(runtime, query) {
 				limit: query.limitPerHost,
 				...query.search ? { searchTerm: query.search } : {},
 				cursor: query.cursors?.[LOCAL_HOST_ID]
-			}).then((page) => setTerminalCapability(page, resolveNodeHostExecutable("pi", {
-				env: process$1.env,
-				pathEnv: process$1.env.PATH ?? "",
-				strategy: "fallback"
-			}) !== void 0))
+			}).then((page) => setCatalogCapabilities(page, {
+				canContinue,
+				canOpenTerminal: resolveNodeHostExecutable("pi", {
+					env: process$1.env,
+					pathEnv: process$1.env.PATH ?? "",
+					strategy: "fallback"
+				}) !== void 0
+			}))
 		});
 	} catch {
 		hosts.push({
@@ -930,7 +1135,7 @@ async function listPiHosts(runtime, query) {
 	}
 	let nodes;
 	try {
-		nodes = (await runtime.nodes.list()).nodes;
+		nodes = (await (query.listNodes?.() ?? runtime.nodes.list())).nodes;
 	} catch {
 		return hosts;
 	}
@@ -946,6 +1151,95 @@ async function requireLocalPiSession(threadId) {
 	if (!record) throw new Error("Pi session is unavailable");
 	return record;
 }
+function currentPiCatalogConfig(api) {
+	return api.runtime.config?.current?.() ?? api.config ?? {};
+}
+function resolvePiContinuationAvailability(api) {
+	const availability = resolveAcpSessionAvailability({
+		config: currentPiCatalogConfig(api),
+		backendId: ACPX_BACKEND_ID,
+		agentId: PI_ACP_AGENT_ID
+	});
+	if (!availability.available) return availability;
+	return resolveNodeHostExecutable("pi", {
+		env: process$1.env,
+		pathEnv: process$1.env.PATH ?? "",
+		strategy: "fallback"
+	}) ? { available: true } : {
+		available: false,
+		message: "Pi CLI is unavailable"
+	};
+}
+function listAdoptedPiSessions(api) {
+	return listAdoptedSessionCatalogSessions({
+		config: currentPiCatalogConfig(api),
+		pluginId: api.id,
+		runtime: api.runtime,
+		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: LOCAL_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,
@@ -1035,8 +1329,10 @@ function registerPiSessionCatalog(api) {
 	api.registerSessionCatalog({
 		id: "pi",
 		label: "Pi",
-		list: async (query) => await listPiHosts(api.runtime, query),
+		list: async (query) => await listPiHosts(api, query),
 		read: async (request) => await readPiTranscript(api.runtime, request),
+		continueSession: async (request) => await continuePiSession(api, request.hostId, request.threadId),
+		checkUpstreamActivity: checkPiUpstreamActivity,
 		openTerminal: async (request) => await openPiTerminal({
 			runtime: api.runtime,
 			...request

package/dist/{process-lease-CU1cFI4I.js → process-lease-DSLDgiNl.js}

@@ -1,4 +1,52 @@
 import { createHash, randomUUID } from "node:crypto";
+//#region extensions/acpx/src/command-line.ts
+/**
+* Small shell-command helpers for ACPX-launched processes. Splitting supports
+* simple quoted command strings from config without invoking a shell parser.
+*/
+/** Quote one command argument for display or config serialization. */
+function quoteCommandPart(value) {
+	return JSON.stringify(value);
+}
+/** Split a command string into argv-like parts using simple quote/backslash rules. */
+function splitCommandParts(value) {
+	const parts = [];
+	let current = "";
+	let quote = null;
+	let escaping = false;
+	for (const ch of value) {
+		if (escaping) {
+			current += ch;
+			escaping = false;
+			continue;
+		}
+		if (ch === "\\" && quote !== "'") {
+			escaping = true;
+			continue;
+		}
+		if (quote) {
+			if (ch === quote) quote = null;
+			else current += ch;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			quote = ch;
+			continue;
+		}
+		if (/\s/.test(ch)) {
+			if (current) {
+				parts.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += ch;
+	}
+	if (escaping) current += "\\";
+	if (current) parts.push(current);
+	return parts;
+}
+//#endregion
 //#region extensions/acpx/src/state.ts
 const ACPX_PROCESS_LEASE_NAMESPACE = "process-leases";
 const ACPX_PROCESS_LEASE_MAX_ENTRIES = 4096;
@@ -26,6 +74,19 @@ function normalizeAcpxGatewayInstanceRecord(value) {
 const OPENCLAW_ACPX_LEASE_ID_ARG = "--openclaw-acpx-lease-id";
 /** CLI argument carrying the owning gateway instance id. */
 const OPENCLAW_GATEWAY_INSTANCE_ID_ARG = "--openclaw-gateway-instance-id";
+/** Read OpenClaw lease identity from a generated wrapper command. */
+function readAcpxProcessLeaseIdentity(command) {
+	const parts = splitCommandParts(command?.trim() ?? "");
+	const leaseIndex = parts.lastIndexOf(OPENCLAW_ACPX_LEASE_ID_ARG);
+	const gatewayIndex = parts.lastIndexOf(OPENCLAW_GATEWAY_INSTANCE_ID_ARG);
+	const leaseId = leaseIndex >= 0 ? parts[leaseIndex + 1]?.trim() : "";
+	const gatewayInstanceId = gatewayIndex >= 0 ? parts[gatewayIndex + 1]?.trim() : "";
+	if (!leaseId || !gatewayInstanceId) return;
+	return {
+		leaseId,
+		gatewayInstanceId
+	};
+}
 function normalizeAcpxProcessLease(value) {
 	if (typeof value !== "object" || value === null) return;
 	const record = value;
@@ -128,4 +189,4 @@ function withAcpxLeaseEnvironment(params) {
 	return appendAcpxLeaseArgs(params);
 }
 //#endregion
-export { hashAcpxProcessCommand as a, openAcpxProcessLeaseStateStore as c, ACPX_GATEWAY_INSTANCE_NAMESPACE as d, ACPX_LEGACY_GATEWAY_INSTANCE_FILE as f, createAcpxProcessLeaseStore as i, withAcpxLeaseEnvironment as l, normalizeAcpxGatewayInstanceRecord as m, OPENCLAW_GATEWAY_INSTANCE_ID_ARG as n, normalizeAcpxProcessLease as o, ACPX_LEGACY_PROCESS_LEASE_FILE as p, createAcpxProcessLeaseId as r, normalizeAcpxProcessLeaseFile as s, OPENCLAW_ACPX_LEASE_ID_ARG as t, ACPX_GATEWAY_INSTANCE_KEY as u };
+export { splitCommandParts as _, hashAcpxProcessCommand as a, openAcpxProcessLeaseStateStore as c, ACPX_GATEWAY_INSTANCE_KEY as d, ACPX_GATEWAY_INSTANCE_NAMESPACE as f, quoteCommandPart as g, normalizeAcpxGatewayInstanceRecord as h, createAcpxProcessLeaseStore as i, readAcpxProcessLeaseIdentity as l, ACPX_LEGACY_PROCESS_LEASE_FILE as m, OPENCLAW_GATEWAY_INSTANCE_ID_ARG as n, normalizeAcpxProcessLease as o, ACPX_LEGACY_GATEWAY_INSTANCE_FILE as p, createAcpxProcessLeaseId as r, normalizeAcpxProcessLeaseFile as s, OPENCLAW_ACPX_LEASE_ID_ARG as t, withAcpxLeaseEnvironment as u };