@openclaw/nextcloud-talk 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/api.js

@@ -1,2 +1,2 @@
-import { t as nextcloudTalkPlugin } from "./channel-BSnehBf6.js";
+import { t as nextcloudTalkPlugin } from "./channel-DtnECxVM.js";
 export { nextcloudTalkPlugin };

package/dist/{channel-BSnehBf6.js → channel-DtnECxVM.js}

@@ -6,7 +6,7 @@ import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
 import { createLoggedPairingApprovalNotifier, createPairingPrefixStripper } from "openclaw/plugin-sdk/channel-pairing";
 import { createAllowlistProviderRouteAllowlistWarningCollector, resolveScopeRequireMention, resolveScopeToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
 import { buildWebhookChannelStatusSummary, createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
-import { convertMarkdownTables, sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
+import { convertMarkdownTables, renderMarkdownWithMarkers, sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { createChannelApprovalAuth } from "openclaw/plugin-sdk/approval-auth-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId, resolveAccountWithDefaultFallback, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-core";
@@ -15,7 +15,8 @@ import { buildSecretInputSchema, hasConfiguredSecretInput, normalizeResolvedSecr
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { parseStrictNonNegativeInteger, parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
 import { readProviderJsonResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
-import { createAccountStatusSink, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
+import { buildChannelInboundEventContext, resolveChannelInboundRouteEnvelope } from "openclaw/plugin-sdk/channel-inbound";
+import { bindIngressLifecycleToReplyOptions, createAccountStatusSink, createChannelIngressMonitor, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, resolveChannelStreamingBlockEnabled, runPassiveAccountLifecycle } from "openclaw/plugin-sdk/channel-outbound";
 import { ssrfPolicyFromPrivateNetworkOptIn, ssrfPolicyFromPrivateNetworkOptIn as ssrfPolicyFromPrivateNetworkOptIn$1 } from "openclaw/plugin-sdk/ssrf-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
@@ -24,16 +25,15 @@ import { fileExists, safeEqualSecret } from "openclaw/plugin-sdk/security-runtim
 import { clearAccountEntryFields } from "openclaw/plugin-sdk/channel-plugin-common";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2 } from "openclaw/plugin-sdk/account-id";
 import { DmPolicySchema, GroupPolicySchema, MarkdownConfigSchema, ReplyRuntimeConfigSchemaShape, buildChannelConfigSchema, buildGroupEntrySchema, buildMultiAccountChannelSchema, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
-import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
+import { formatAllowFromLowercase, resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
-import { requireChannelOpenAllowFrom, resolveLoggerBackedRuntime, runStoppablePassiveMonitor, safeParseJsonWithSchema } from "openclaw/plugin-sdk/extension-shared";
+import { requireChannelOpenAllowFrom, resolveLoggerBackedRuntime } from "openclaw/plugin-sdk/extension-shared";
 import { z } from "zod";
 import os from "node:os";
 import path from "node:path";
-import { createChannelReplayGuard, migratePersistentDedupeLegacyJsonFile } from "openclaw/plugin-sdk/persistent-dedupe";
+import { migratePersistentDedupeLegacyJsonFile, resolvePersistentDedupePluginStateNamespace } from "openclaw/plugin-sdk/persistent-dedupe";
 import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 import { channelIngressRoutes, resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { resolveInboundRouteEnvelopeBuilderWithRuntime } from "openclaw/plugin-sdk/inbound-envelope";
 import { buildChannelKeyCandidates, normalizeChannelSlug, resolveChannelEntryMatchWithFallback } from "openclaw/plugin-sdk/channel-targets";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -41,9 +41,41 @@ import { createServer } from "node:http";
 import { WEBHOOK_RATE_LIMIT_DEFAULTS, createAuthRateLimiter, isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText } from "openclaw/plugin-sdk/webhook-ingress";
 import { jsonResult, readStringParam, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, buildOutboundBaseSessionKey, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/routing";
+import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
 import { applyAccountNameToChannelSection, baseUrlTextInput, createSetupTranslator, createStandardChannelSetupStatus, defineTokenCredential, formatDocsLink, patchScopedAccountConfig, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
 import { createSetupInputPresenceValidator, createSetupTranslator as createSetupTranslator$1, mergeAllowFromEntries, promptParsedAllowFromForAccount, resolveSetupAccountId } from "openclaw/plugin-sdk/setup-runtime";
 import { formatDocsLink as formatDocsLink$1 } from "openclaw/plugin-sdk/setup-tools";
+//#region extensions/nextcloud-talk/src/api-credentials.ts
+function resolveNextcloudTalkApiCredentialsResult(params) {
+	const apiUser = params.apiUser?.trim();
+	if (!apiUser) return { status: "missing" };
+	const inlinePassword = normalizeResolvedSecretInputString({
+		value: params.apiPassword,
+		path: "channels.nextcloud-talk.apiPassword"
+	});
+	if (inlinePassword) return {
+		status: "available",
+		value: {
+			apiUser,
+			apiPassword: inlinePassword
+		}
+	};
+	if (!params.apiPasswordFile?.trim()) return { status: "missing" };
+	const result = tryReadSecretFileSync(params.apiPasswordFile, "Nextcloud Talk API password", { rejectHardlinks: false }, { configPath: params.configPath ?? "channels.nextcloud-talk.apiPasswordFile" });
+	if (result.status === "available") return result.value ? {
+		status: "available",
+		value: {
+			apiUser,
+			apiPassword: result.value
+		}
+	} : { status: "missing" };
+	return result;
+}
+function resolveNextcloudTalkApiCredentials(params) {
+	const result = resolveNextcloudTalkApiCredentialsResult(params);
+	return result.status === "available" ? result.value : void 0;
+}
+//#endregion
 //#region extensions/nextcloud-talk/src/accounts.ts
 function isTruthyEnvValue(value) {
 	const normalized = normalizeLowercaseStringOrEmpty(value);
@@ -79,13 +111,21 @@ function resolveNextcloudTalkSecret(cfg, opts) {
 	const envSecret = normalizeOptionalString(process.env.NEXTCLOUD_TALK_BOT_SECRET);
 	if (envSecret && resolvedAccountId === DEFAULT_ACCOUNT_ID) return {
 		secret: envSecret,
-		source: "env"
+		source: "env",
+		status: "available"
 	};
-	if (merged.botSecretFile) {
-		const fileSecret = tryReadSecretFileSync(merged.botSecretFile, "Nextcloud Talk bot secret file", { rejectSymlink: true });
-		if (fileSecret) return {
-			secret: fileSecret,
-			source: "secretFile"
+	const botSecretFile = normalizeOptionalString(merged.botSecretFile);
+	if (botSecretFile) {
+		const result = tryReadSecretFileSync(botSecretFile, "Nextcloud Talk bot secret file", { rejectSymlink: true }, { configPath: `channels.nextcloud-talk.accounts.${resolvedAccountId}.botSecretFile` });
+		return result.status === "available" ? {
+			secret: result.value,
+			source: "secretFile",
+			status: "available"
+		} : {
+			secret: "",
+			source: "secretFile",
+			status: "configured_unavailable",
+			diagnostic: result.diagnostic
 		};
 	}
 	const inlineSecret = normalizeResolvedSecretInputString({
@@ -94,11 +134,13 @@ function resolveNextcloudTalkSecret(cfg, opts) {
 	});
 	if (inlineSecret) return {
 		secret: inlineSecret,
-		source: "config"
+		source: "config",
+		status: "available"
 	};
 	return {
 		secret: "",
-		source: "none"
+		source: "none",
+		status: "missing"
 	};
 }
 function resolveNextcloudTalkAccount(params) {
@@ -109,6 +151,13 @@ function resolveNextcloudTalkAccount(params) {
 		const accountEnabled = merged.enabled !== false;
 		const enabled = baseEnabled && accountEnabled;
 		const secretResolution = resolveNextcloudTalkSecret(params.cfg, { accountId });
+		const apiCredentialResolution = resolveNextcloudTalkApiCredentialsResult({
+			apiUser: merged.apiUser,
+			apiPassword: merged.apiPassword,
+			apiPasswordFile: merged.apiPasswordFile,
+			configPath: `channels.nextcloud-talk.accounts.${accountId}.apiPasswordFile`
+		});
+		const diagnostics = [secretResolution.diagnostic, apiCredentialResolution.status === "configured_unavailable" ? apiCredentialResolution.diagnostic : void 0].filter((diagnostic) => Boolean(diagnostic));
 		const baseUrl = merged.baseUrl?.trim()?.replace(/\/$/, "") ?? "";
 		debugAccounts("resolve", {
 			accountId,
@@ -123,6 +172,9 @@ function resolveNextcloudTalkAccount(params) {
 			baseUrl,
 			secret: secretResolution.secret,
 			secretSource: secretResolution.source,
+			tokenStatus: secretResolution.status,
+			apiCredentialStatus: apiCredentialResolution.status,
+			...diagnostics.length > 0 ? { credentialDiagnostics: diagnostics } : {},
 			config: merged
 		};
 	};
@@ -130,7 +182,7 @@ function resolveNextcloudTalkAccount(params) {
 		accountId: resolvedAccountId,
 		normalizeAccountId,
 		resolvePrimary: resolve,
-		hasCredential: (account) => account.secretSource !== "none",
+		hasCredential: (account) => account.tokenStatus !== "missing",
 		resolveDefaultAccountId: () => resolveDefaultNextcloudTalkAccountId(params.cfg)
 	});
 }
@@ -150,28 +202,10 @@ const nextcloudTalkApprovalAuth = createChannelApprovalAuth({
 	normalizeApprover: normalizeNextcloudTalkApproverId
 }).approvalAuth;
 //#endregion
-//#region extensions/nextcloud-talk/src/api-credentials.ts
-function resolveNextcloudTalkApiCredentials(params) {
-	const apiUser = params.apiUser?.trim();
-	if (!apiUser) return;
-	const inlinePassword = normalizeResolvedSecretInputString({
-		value: params.apiPassword,
-		path: "channels.nextcloud-talk.apiPassword"
-	});
-	if (inlinePassword) return {
-		apiUser,
-		apiPassword: inlinePassword
-	};
-	if (!params.apiPasswordFile) return;
-	try {
-		const fileValue = tryReadSecretFileSync(params.apiPasswordFile, "Nextcloud Talk API password", { rejectHardlinks: false });
-		return fileValue ? {
-			apiUser,
-			apiPassword: fileValue
-		} : void 0;
-	} catch {
-		return;
-	}
+//#region extensions/nextcloud-talk/src/guarded-response.ts
+async function releaseNextcloudTalkGuardedResponse(params) {
+	if (!params.response.bodyUsed) await params.response.body?.cancel().catch(() => void 0);
+	await params.release();
 }
 //#endregion
 //#region extensions/nextcloud-talk/src/signature.ts
@@ -317,7 +351,10 @@ async function probeNextcloudTalkBotResponseFeature(params) {
 				message: `Nextcloud Talk bot "${bot.name ?? bot.id ?? "matching bot"}" has the response feature.`
 			};
 		} finally {
-			await release();
+			await releaseNextcloudTalkGuardedResponse({
+				response,
+				release
+			});
 		}
 	} catch (error) {
 		return {
@@ -399,44 +436,13 @@ const NextcloudTalkConfigSchema = buildMultiAccountChannelSchema(z.object({
 	}
 });
 //#endregion
-//#region extensions/nextcloud-talk/src/replay-guard.ts
+//#region extensions/nextcloud-talk/src/replay-migration-contract.ts
 const NEXTCLOUD_TALK_PLUGIN_ID = "nextcloud-talk";
 const NEXTCLOUD_TALK_REPLAY_DEDUPE_NAMESPACE_PREFIX = "replay-dedupe";
-const DEFAULT_REPLAY_TTL_MS = 1440 * 60 * 1e3;
-const DEFAULT_MEMORY_MAX_SIZE = 1e3;
-const DEFAULT_STATE_MAX_ENTRIES = 1e4;
-function buildNextcloudTalkReplayKey(params) {
-	const roomToken = params.roomToken.trim();
-	const messageId = params.messageId.trim();
-	if (!roomToken || !messageId) return null;
-	return `${roomToken}:${messageId}`;
-}
-function createNextcloudTalkReplayGuard(options) {
-	const stateDir = options.stateDir?.trim();
-	const baseOptions = {
-		ttlMs: options.ttlMs ?? DEFAULT_REPLAY_TTL_MS,
-		memoryMaxSize: options.memoryMaxSize ?? DEFAULT_MEMORY_MAX_SIZE
-	};
-	return createChannelReplayGuard({
-		dedupe: stateDir ? {
-			...baseOptions,
-			pluginId: NEXTCLOUD_TALK_PLUGIN_ID,
-			namespacePrefix: NEXTCLOUD_TALK_REPLAY_DEDUPE_NAMESPACE_PREFIX,
-			stateMaxEntries: options.stateMaxEntries ?? options.fileMaxEntries ?? DEFAULT_STATE_MAX_ENTRIES,
-			env: {
-				...process.env,
-				OPENCLAW_STATE_DIR: stateDir
-			},
-			onDiskError: options.onDiskError
-		} : baseOptions,
-		buildReplayKey: buildNextcloudTalkReplayKey,
-		namespace: (event) => event.accountId
-	});
-}
+const NEXTCLOUD_TALK_REPLAY_DEDUPE_TTL_MS = 1440 * 60 * 1e3;
+const NEXTCLOUD_TALK_REPLAY_DEDUPE_MAX_ENTRIES = 1e4;
 //#endregion
 //#region extensions/nextcloud-talk/src/doctor.ts
-const REPLAY_DEDUPE_TTL_MS = 1440 * 60 * 1e3;
-const REPLAY_DEDUPE_MAX_ENTRIES = 1e4;
 function sanitizeLegacyReplaySegment(value) {
 	const trimmed = value.trim();
 	if (!trimmed) return "default";
@@ -471,11 +477,11 @@ async function repairNextcloudTalkReplayDedupeState(params) {
 			const result = await migratePersistentDedupeLegacyJsonFile({
 				filePath: legacyPath,
 				namespace: accountId,
-				ttlMs: REPLAY_DEDUPE_TTL_MS,
+				ttlMs: NEXTCLOUD_TALK_REPLAY_DEDUPE_TTL_MS,
 				memoryMaxSize: 0,
 				pluginId: NEXTCLOUD_TALK_PLUGIN_ID,
 				namespacePrefix: NEXTCLOUD_TALK_REPLAY_DEDUPE_NAMESPACE_PREFIX,
-				stateMaxEntries: REPLAY_DEDUPE_MAX_ENTRIES,
+				stateMaxEntries: NEXTCLOUD_TALK_REPLAY_DEDUPE_MAX_ENTRIES,
 				env
 			});
 			changes.push(`Migrated Nextcloud Talk replay dedupe cache for account "${accountId}" to SQLite (${result.imported} imported, ${result.skippedExpired} expired, ${result.skippedExisting} already current).`);
@@ -513,19 +519,13 @@ function normalizeNextcloudTalkAllowlist(values) {
 	return (values ?? []).map((value) => normalizeNextcloudTalkAllowEntry(String(value))).filter(Boolean);
 }
 function resolveNextcloudTalkAllowlistMatch(params) {
-	const allowFrom = normalizeNextcloudTalkAllowlist(params.allowFrom);
-	if (allowFrom.length === 0) return { allowed: false };
-	if (allowFrom.includes("*")) return {
-		allowed: true,
-		matchKey: "*",
-		matchSource: "wildcard"
-	};
-	const senderId = normalizeNextcloudTalkAllowEntry(params.senderId);
-	return allowFrom.includes(senderId) ? {
-		allowed: true,
-		matchKey: senderId,
-		matchSource: "id"
-	} : { allowed: false };
+	return resolveAllowlistMatchByCandidates({
+		allowList: normalizeNextcloudTalkAllowlist(params.allowFrom),
+		candidates: [{
+			value: normalizeNextcloudTalkAllowEntry(params.senderId),
+			source: "id"
+		}]
+	});
 }
 function resolveNextcloudTalkRoomMatch(params) {
 	const rooms = params.rooms ?? {};
@@ -664,7 +664,10 @@ async function resolveNextcloudTalkRoomKind(params) {
 			});
 			return kind;
 		} finally {
-			await release();
+			await releaseNextcloudTalkGuardedResponse({
+				response,
+				release
+			});
 		}
 	} catch (err) {
 		cacheRoomInfo(key, {
@@ -703,6 +706,43 @@ function looksLikeNextcloudTalkTargetId(raw) {
 const NEXTCLOUD_TALK_ERROR_SNIPPET_MAX_BYTES = 8 * 1024;
 const NEXTCLOUD_TALK_ERROR_SNIPPET_MAX_CHARS = 200;
 const NEXTCLOUD_TALK_SEND_TIMEOUT_MS = 3e4;
+const NEXTCLOUD_TALK_FORMAT_PROFILE = {
+	mechanism: "markdown",
+	constructs: {
+		bold: "native",
+		italic: "native",
+		underline: "native",
+		strikethrough: "native",
+		spoiler: "native",
+		codeInline: "native",
+		codeBlock: "native",
+		codeLanguage: "native",
+		linkLabel: "native",
+		heading: "native",
+		bulletList: "native",
+		orderedList: "native",
+		taskList: "native",
+		table: "native",
+		blockquote: "native",
+		image: "native",
+		mention: "native"
+	},
+	chunk: {
+		limit: 4e3,
+		unit: "chars",
+		hardCap: 32e3
+	}
+};
+function renderNextcloudTalkMarkdown(markdown) {
+	return renderMarkdownWithMarkers({
+		text: markdown,
+		styles: [],
+		links: []
+	}, {
+		styleMarkers: {},
+		escapeText: (text) => text
+	}, NEXTCLOUD_TALK_FORMAT_PROFILE);
+}
 /** Collapses whitespace and caps an error-body prefix to a short, log-safe snippet. */
 function collapseErrorSnippet(text) {
 	const collapsed = text.replace(/\s+/g, " ").trim();
@@ -781,7 +821,7 @@ async function sendMessageNextcloudTalk(to, text, opts) {
 		channel: "nextcloud-talk",
 		accountId: account.accountId
 	});
-	const message = convertMarkdownTables(text.trim(), tableMode);
+	const message = convertMarkdownTables(renderNextcloudTalkMarkdown(text.trim()), tableMode);
 	const body = { message };
 	if (opts.replyTo) body.replyTo = opts.replyTo;
 	const bodyStr = JSON.stringify(body);
@@ -837,7 +877,10 @@ async function sendMessageNextcloudTalk(to, text, opts) {
 			timestamp
 		};
 	} finally {
-		await release();
+		await releaseNextcloudTalkGuardedResponse({
+			response,
+			release
+		});
 	}
 }
 async function sendReactionNextcloudTalk(roomToken, messageId, reaction, opts) {
@@ -871,7 +914,10 @@ async function sendReactionNextcloudTalk(roomToken, messageId, reaction, opts) {
 		}
 		return { ok: true };
 	} finally {
-		await release();
+		await releaseNextcloudTalkGuardedResponse({
+			response,
+			release
+		});
 	}
 }
 //#endregion
@@ -1077,19 +1123,17 @@ async function handleNextcloudTalkInbound(params) {
 		runtime.log?.(`nextcloud-talk: drop room ${roomToken} (no mention)`);
 		return;
 	}
-	const { route, buildEnvelope } = resolveInboundRouteEnvelopeBuilderWithRuntime({
+	const { route, buildEnvelope } = resolveChannelInboundRouteEnvelope({
 		cfg: config,
 		channel: CHANNEL_ID,
 		accountId: account.accountId,
 		peer: {
 			kind: isGroup ? "group" : "direct",
 			id: isGroup ? roomToken : senderId
-		},
-		runtime: core.channel,
-		sessionStore: config.session?.store
+		}
 	});
 	const fromLabel = isGroup ? `room:${roomName || roomToken}` : senderName || `user:${senderId}`;
-	const { storePath, body } = buildEnvelope({
+	const body = buildEnvelope({
 		channel: "Nextcloud Talk",
 		from: fromLabel,
 		timestamp: message.timestamp,
@@ -1097,40 +1141,58 @@ async function handleNextcloudTalkInbound(params) {
 	});
 	const groupSystemPrompt = normalizeOptionalString(roomConfig?.systemPrompt);
 	const blockStreamingEnabled = resolveChannelStreamingBlockEnabled(account.config);
-	const ctxPayload = core.channel.reply.finalizeInboundContext({
-		Body: body,
-		BodyForAgent: rawBody,
-		RawBody: rawBody,
-		CommandBody: rawBody,
-		From: isGroup ? `nextcloud-talk:room:${roomToken}` : `nextcloud-talk:${senderId}`,
-		To: `nextcloud-talk:${roomToken}`,
-		SessionKey: route.sessionKey,
-		AccountId: route.accountId,
-		ChatType: isGroup ? "group" : "direct",
-		ConversationLabel: fromLabel,
-		SenderName: senderName || void 0,
-		SenderId: senderId,
-		GroupSubject: isGroup ? roomName || roomToken : void 0,
-		GroupSystemPrompt: isGroup ? groupSystemPrompt : void 0,
-		Provider: CHANNEL_ID,
-		Surface: CHANNEL_ID,
-		WasMentioned: isGroup ? wasMentioned : void 0,
-		MessageSid: message.messageId,
-		Timestamp: message.timestamp,
-		OriginatingChannel: CHANNEL_ID,
-		OriginatingTo: `nextcloud-talk:${roomToken}`,
-		CommandAuthorized: commandAuthorized
+	const ctxPayload = buildChannelInboundEventContext({
+		channel: CHANNEL_ID,
+		accountId: route.accountId,
+		messageId: message.messageId,
+		timestamp: message.timestamp,
+		from: isGroup ? `nextcloud-talk:room:${roomToken}` : `nextcloud-talk:${senderId}`,
+		sender: {
+			id: senderId,
+			name: senderName || void 0
+		},
+		conversation: {
+			kind: isGroup ? "group" : "direct",
+			id: roomToken,
+			label: fromLabel
+		},
+		route: {
+			agentId: route.agentId,
+			dmScope: route.dmScope,
+			accountId: route.accountId,
+			routeSessionKey: route.sessionKey
+		},
+		reply: {
+			to: `nextcloud-talk:${roomToken}`,
+			originatingTo: `nextcloud-talk:${roomToken}`
+		},
+		message: {
+			body,
+			bodyForAgent: rawBody,
+			rawBody,
+			commandBody: rawBody
+		},
+		access: {
+			commands: { authorized: commandAuthorized },
+			mentions: {
+				canDetectMention: isGroup,
+				wasMentioned: isGroup && wasMentioned
+			}
+		},
+		extra: {
+			GroupSubject: isGroup ? roomName || roomToken : void 0,
+			GroupSystemPrompt: isGroup ? groupSystemPrompt : void 0
+		}
 	});
-	await core.channel.inbound.dispatchReply({
+	await core.channel.inbound.dispatch({
 		cfg: config,
 		channel: CHANNEL_ID,
 		accountId: account.accountId,
-		agentId: route.agentId,
-		routeSessionKey: route.sessionKey,
-		storePath,
+		route: {
+			agentId: route.agentId,
+			sessionKey: route.sessionKey
+		},
 		ctxPayload,
-		recordInboundSession: core.channel.session.recordInboundSession,
-		dispatchReplyWithBufferedBlockDispatcher: core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 		delivery: {
 			preparePayload: (payload) => payload.text === void 0 ? payload : {
 				...payload,
@@ -1151,6 +1213,7 @@ async function handleNextcloudTalkInbound(params) {
 		},
 		replyPipeline: {},
 		replyOptions: {
+			...params.turnAdoptionLifecycle ? bindIngressLifecycleToReplyOptions(params.turnAdoptionLifecycle) : {},
 			skillFilter: roomConfig?.skills,
 			disableBlockStreaming: typeof blockStreamingEnabled === "boolean" ? !blockStreamingEnabled : void 0
 		},
@@ -1159,6 +1222,74 @@ async function handleNextcloudTalkInbound(params) {
 		} }
 	});
 }
+var NextcloudTalkWebhookPayloadError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "NextcloudTalkWebhookPayloadError";
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseRawObject(rawEvent) {
+	let parsed;
+	try {
+		parsed = JSON.parse(rawEvent);
+	} catch (error) {
+		throw new NextcloudTalkWebhookPayloadError("Nextcloud Talk webhook contains invalid JSON.", { cause: error });
+	}
+	if (!isRecord(parsed)) throw new NextcloudTalkWebhookPayloadError("Nextcloud Talk webhook must be a JSON object.");
+	return parsed;
+}
+function requiredString(value, field) {
+	if (typeof value === "string" && value.trim()) return value.trim();
+	throw new NextcloudTalkWebhookPayloadError(`Nextcloud Talk webhook is missing ${field}.`);
+}
+function inspectNextcloudTalkWebhookEnvelope(rawEvent) {
+	const envelope = parseRawObject(rawEvent);
+	if (envelope.type !== "Create") return null;
+	const object = isRecord(envelope.object) ? envelope.object : null;
+	if (object?.type !== void 0 && object.type !== "Note") return null;
+	if (!object) throw new NextcloudTalkWebhookPayloadError("Nextcloud Talk webhook is missing object.");
+	const target = isRecord(envelope.target) ? envelope.target : null;
+	return {
+		eventId: requiredString(object.id, "object.id"),
+		laneKey: `room:${requiredString(target?.id, "target.id")}`
+	};
+}
+function parseLegacyReplayKey(key) {
+	const separator = key.lastIndexOf(":");
+	const roomId = key.slice(0, separator).trim();
+	const messageId = key.slice(separator + 1).trim();
+	return separator > 0 && roomId && messageId ? {
+		messageId,
+		roomId
+	} : null;
+}
+/** Convert the shipped replay guard's live window into durable completion tombstones. */
+async function migrateNextcloudTalkLegacyReplayState(params) {
+	const entries = await params.store.entries();
+	let migrated = 0;
+	for (const entry of entries) {
+		const identity = parseLegacyReplayKey(entry.value.key);
+		if (!identity || !Number.isFinite(entry.value.seenAt)) continue;
+		const marker = {
+			version: 1,
+			receivedAt: entry.value.seenAt,
+			rawEvent: ""
+		};
+		const result = await params.queue.enqueue(identity.messageId, marker, {
+			receivedAt: entry.value.seenAt,
+			laneKey: `room:${identity.roomId}`
+		});
+		if (result.kind === "accepted" || result.kind === "pending" && result.record.payload.rawEvent === "") {
+			if (!await params.queue.complete(identity.messageId, { completedAt: entry.value.seenAt })) throw new Error(`Failed to migrate Nextcloud Talk replay key ${entry.value.key}.`);
+		}
+		migrated += 1;
+	}
+	await params.store.clear();
+	return migrated;
+}
 //#endregion
 //#region extensions/nextcloud-talk/src/monitor.ts
 const DEFAULT_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
@@ -1166,34 +1297,6 @@ const PREAUTH_WEBHOOK_MAX_BODY_BYTES = 64 * 1024;
 const PREAUTH_WEBHOOK_BODY_TIMEOUT_MS = 5e3;
 const HEALTH_PATH = "/healthz";
 const WEBHOOK_AUTH_RATE_LIMIT_SCOPE = "nextcloud-talk-webhook-auth";
-const NextcloudTalkWebhookPayloadSchema = z.object({
-	type: z.enum([
-		"Create",
-		"Update",
-		"Delete"
-	]),
-	actor: z.object({
-		type: z.literal("Person"),
-		id: z.string().min(1),
-		name: z.string()
-	}),
-	object: z.object({
-		type: z.literal("Note"),
-		id: z.string().min(1),
-		name: z.string(),
-		content: z.string(),
-		mediaType: z.string()
-	}),
-	target: z.object({
-		type: z.literal("Collection"),
-		id: z.string().min(1),
-		name: z.string()
-	})
-});
-const NextcloudTalkWebhookEnvelopeSchema = z.object({
-	type: z.string().min(1),
-	object: z.object({ type: z.string().min(1).optional() }).passthrough().optional()
-});
 const WEBHOOK_ERRORS = {
 	missingSignatureHeaders: "Missing signature headers",
 	invalidBackend: "Invalid backend",
@@ -1202,20 +1305,10 @@ const WEBHOOK_ERRORS = {
 	payloadTooLarge: "Payload too large",
 	internalServerError: "Internal server error"
 };
-async function processNextcloudTalkReplayGuardedMessage(params) {
-	return (await params.replayGuard.processGuarded({
-		accountId: params.accountId,
-		roomToken: params.message.roomToken,
-		messageId: params.message.messageId
-	}, params.handleMessage, { onError: "commit" })).kind === "processed" ? "processed" : "duplicate";
-}
 function formatError(err) {
 	if (err instanceof Error) return err.message;
 	return typeof err === "string" ? err : JSON.stringify(err);
 }
-function parseWebhookPayload(body) {
-	return safeParseJsonWithSchema(NextcloudTalkWebhookPayloadSchema, body);
-}
 function writeJsonResponse(res, status, body) {
 	if (body) {
 		res.writeHead(status, { "Content-Type": "application/json" });
@@ -1255,37 +1348,6 @@ function verifyWebhookSignature(params) {
 	params.authRateLimiter.reset(params.clientIp, WEBHOOK_AUTH_RATE_LIMIT_SCOPE);
 	return true;
 }
-function decodeWebhookCreateMessage(params) {
-	const envelope = safeParseJsonWithSchema(NextcloudTalkWebhookEnvelopeSchema, params.body);
-	if (!envelope) {
-		writeWebhookError(params.res, 400, WEBHOOK_ERRORS.invalidPayloadFormat);
-		return { kind: "invalid" };
-	}
-	if (envelope.type !== "Create") return { kind: "ignore" };
-	if (envelope.object?.type && envelope.object.type !== "Note") return { kind: "ignore" };
-	const payload = parseWebhookPayload(params.body);
-	if (!payload) {
-		writeWebhookError(params.res, 400, WEBHOOK_ERRORS.invalidPayloadFormat);
-		return { kind: "invalid" };
-	}
-	return {
-		kind: "message",
-		message: payloadToInboundMessage(payload)
-	};
-}
-function payloadToInboundMessage(payload) {
-	return {
-		messageId: payload.object.id,
-		roomToken: payload.target.id,
-		roomName: payload.target.name,
-		senderId: payload.actor.id,
-		senderName: payload.actor.name ?? "",
-		text: payload.object.content || payload.object.name || "",
-		mediaType: payload.object.mediaType || "text/plain",
-		timestamp: Date.now(),
-		isGroupChat: true
-	};
-}
 function readNextcloudTalkWebhookBody(req, maxBodyBytes) {
 	return readRequestBodyWithLimit(req, {
 		maxBytes: Math.min(maxBodyBytes, PREAUTH_WEBHOOK_MAX_BODY_BYTES),
@@ -1293,12 +1355,10 @@ function readNextcloudTalkWebhookBody(req, maxBodyBytes) {
 	});
 }
 function createNextcloudTalkWebhookServer(opts) {
-	const { port, host, path, secret, onMessage, onError, abortSignal } = opts;
+	const { port, host, path, secret, onWebhook, onError, abortSignal } = opts;
 	const maxBodyBytes = typeof opts.maxBodyBytes === "number" && Number.isFinite(opts.maxBodyBytes) && opts.maxBodyBytes > 0 ? Math.floor(opts.maxBodyBytes) : DEFAULT_WEBHOOK_MAX_BODY_BYTES;
 	const readBody = opts.readBody ?? readNextcloudTalkWebhookBody;
 	const isBackendAllowed = opts.isBackendAllowed;
-	const shouldProcessMessage = opts.shouldProcessMessage;
-	const processMessage = opts.processMessage;
 	const authRateLimitMaxRequests = typeof opts.authRateLimit?.maxRequests === "number" ? opts.authRateLimit.maxRequests : WEBHOOK_RATE_LIMIT_DEFAULTS.maxRequests;
 	const authRateLimitWindowMs = typeof opts.authRateLimit?.windowMs === "number" ? opts.authRateLimit.windowMs : WEBHOOK_RATE_LIMIT_DEFAULTS.windowMs;
 	const webhookAuthRateLimiter = createAuthRateLimiter({
@@ -1342,37 +1402,8 @@ function createNextcloudTalkWebhookServer(opts) {
 					clientIp,
 					authRateLimiter: webhookAuthRateLimiter
 				})) return;
-				const decoded = decodeWebhookCreateMessage({
-					body,
-					res
-				});
-				if (decoded.kind === "invalid") return;
-				if (decoded.kind === "ignore") {
-					writeJsonResponse(res, 200);
-					return;
-				}
-				const message = decoded.message;
-				if (processMessage) {
-					writeJsonResponse(res, 200);
-					try {
-						await processMessage(message);
-					} catch (err) {
-						onError?.(err instanceof Error ? err : new Error(formatError(err)));
-					}
-					return;
-				}
-				if (shouldProcessMessage) {
-					if (!await shouldProcessMessage(message)) {
-						writeJsonResponse(res, 200);
-						return;
-					}
-				}
+				await onWebhook(body);
 				writeJsonResponse(res, 200);
-				try {
-					await onMessage(message);
-				} catch (err) {
-					onError?.(err instanceof Error ? err : new Error(formatError(err)));
-				}
 			} catch (err) {
 				if (isRequestBodyLimitError(err, "PAYLOAD_TOO_LARGE")) {
 					writeWebhookError(res, 413, WEBHOOK_ERRORS.payloadTooLarge);
@@ -1382,27 +1413,48 @@ function createNextcloudTalkWebhookServer(opts) {
 					writeWebhookError(res, 408, requestBodyErrorToText("REQUEST_BODY_TIMEOUT"));
 					return;
 				}
+				if (err instanceof NextcloudTalkWebhookPayloadError) {
+					writeWebhookError(res, 400, WEBHOOK_ERRORS.invalidPayloadFormat);
+					return;
+				}
 				const error = err instanceof Error ? err : new Error(formatError(err));
 				onError?.(error);
 				writeWebhookError(res, 500, WEBHOOK_ERRORS.internalServerError);
 			}
 		})();
 	});
-	const start = () => {
-		return new Promise((resolve) => {
-			server.listen(port, host, () => resolve());
+	let stopRequested = false;
+	let closePromise;
+	const closeIfListening = () => {
+		if (closePromise) return closePromise;
+		if (!server.listening) return Promise.resolve();
+		closePromise = new Promise((resolve) => {
+			server.close(() => resolve());
+		}).finally(() => {
+			closePromise = void 0;
 		});
+		return closePromise;
 	};
-	let stopped = false;
-	const stop = () => {
-		if (stopped) return;
-		stopped = true;
-		try {
-			server.close();
-		} catch {}
+	const stop = async () => {
+		stopRequested = true;
+		await closeIfListening();
+	};
+	const start = () => {
+		if (stopRequested) return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			const onListenError = (error) => reject(error);
+			server.once("error", onListenError);
+			server.listen(port, host, () => {
+				server.off("error", onListenError);
+				(async () => {
+					if (stopRequested) await closeIfListening();
+					resolve();
+				})().catch(reject);
+			});
+		});
 	};
 	if (abortSignal) if (abortSignal.aborted) stop();
-	else abortSignal.addEventListener("abort", stop, { once: true });
+	else abortSignal.addEventListener("abort", () => void stop(), { once: true });
 	return {
 		server,
 		start,
@@ -1410,6 +1462,164 @@ function createNextcloudTalkWebhookServer(opts) {
 	};
 }
 //#endregion
+//#region extensions/nextcloud-talk/src/webhook-spool.ts
+const NEXTCLOUD_TALK_INGRESS_POLL_INTERVAL_MS = 500;
+const NEXTCLOUD_TALK_INGRESS_PRUNE_INTERVAL_MS = 3600 * 1e3;
+const NEXTCLOUD_TALK_INGRESS_COMPLETED_TTL_MS = 720 * 60 * 60 * 1e3;
+const NEXTCLOUD_TALK_INGRESS_COMPLETED_MAX_ENTRIES = 1e4;
+const NEXTCLOUD_TALK_INGRESS_FAILED_TTL_MS = 720 * 60 * 60 * 1e3;
+const NEXTCLOUD_TALK_INGRESS_FAILED_MAX_ENTRIES = 1e4;
+const NextcloudTalkWebhookPayloadSchema = z.object({
+	type: z.enum([
+		"Create",
+		"Update",
+		"Delete"
+	]),
+	actor: z.object({
+		type: z.literal("Person"),
+		id: z.string().min(1),
+		name: z.string()
+	}),
+	object: z.object({
+		type: z.literal("Note"),
+		id: z.string().min(1),
+		name: z.string(),
+		content: z.string(),
+		mediaType: z.string()
+	}),
+	target: z.object({
+		type: z.literal("Collection"),
+		id: z.string().min(1),
+		name: z.string()
+	})
+});
+function parseClaimedMessage(payload, claimedId, claimedLaneKey) {
+	if (payload.version !== 1) throw new NextcloudTalkWebhookPayloadError(`Nextcloud Talk ingress row ${claimedId} has an unsupported version.`);
+	const result = NextcloudTalkWebhookPayloadSchema.safeParse(parseRawObject(payload.rawEvent));
+	if (!result.success || result.data.type !== "Create" || result.data.object.id !== claimedId) throw new NextcloudTalkWebhookPayloadError(`Nextcloud Talk ingress row ${claimedId} has invalid message identity.`);
+	const webhook = result.data;
+	const roomId = requiredString(webhook.target.id, "target.id");
+	if (claimedLaneKey !== `room:${roomId}`) throw new NextcloudTalkWebhookPayloadError(`Nextcloud Talk ingress row ${claimedId} changed room identity.`);
+	return {
+		messageId: webhook.object.id,
+		roomToken: roomId,
+		roomName: webhook.target.name,
+		senderId: webhook.actor.id,
+		senderName: webhook.actor.name,
+		text: webhook.object.content || webhook.object.name,
+		mediaType: webhook.object.mediaType || "text/plain",
+		timestamp: payload.receivedAt,
+		isGroupChat: true
+	};
+}
+function resolveNonRetryableFailure(error) {
+	if (error instanceof NextcloudTalkWebhookPayloadError) return {
+		reason: "invalid-event",
+		message: error.message
+	};
+	const message = formatErrorMessage(error);
+	if (message.includes("Nextcloud Talk: bot send was rejected") || message.includes("Nextcloud Talk: forbidden")) return {
+		reason: "nextcloud-talk-auth",
+		message
+	};
+	return null;
+}
+function createNextcloudTalkWebhookSpool(options) {
+	let queue = options.queue;
+	const getQueue = () => {
+		queue ??= getNextcloudTalkRuntime().state.openChannelIngressQueue({ accountId: options.accountId });
+		return queue;
+	};
+	const legacyReplayStore = options.legacyReplayStore === null ? null : options.legacyReplayStore ?? getNextcloudTalkRuntime().state.openKeyedStore({
+		namespace: resolvePersistentDedupePluginStateNamespace({
+			namespace: options.accountId,
+			namespacePrefix: "replay-dedupe"
+		}),
+		maxEntries: 1e4,
+		defaultTtlMs: 864e5
+	});
+	const legacyMigration = legacyReplayStore ? migrateNextcloudTalkLegacyReplayState({
+		queue: getQueue(),
+		store: legacyReplayStore
+	}) : Promise.resolve();
+	const monitor = createChannelIngressMonitor({
+		queue: getQueue,
+		inspect: (rawEvent) => inspectNextcloudTalkWebhookEnvelope(rawEvent),
+		payload: {
+			version: 1,
+			serialize: (rawEvent, { receivedAt }) => ({
+				receivedAt,
+				rawEvent
+			}),
+			deserialize: (body) => body.rawEvent,
+			encode: ({ body }) => ({
+				version: 1,
+				...body
+			}),
+			decode: (payload) => ({
+				version: payload.version,
+				body: {
+					receivedAt: payload.receivedAt,
+					rawEvent: payload.rawEvent
+				}
+			}),
+			createClaimError: (kind, claim) => new NextcloudTalkWebhookPayloadError(kind === "invalid-version" ? `Nextcloud Talk ingress row ${claim.id} has an unsupported version.` : `Nextcloud Talk ingress row ${claim.id} has invalid message identity.`)
+		},
+		deliver: async (_rawEvent, lifecycle, claim) => {
+			const message = parseClaimedMessage(claim.payload, claim.id, claim.laneKey);
+			await options.deliver(message, lifecycle);
+		},
+		pollIntervalMs: options.pollIntervalMs ?? NEXTCLOUD_TALK_INGRESS_POLL_INTERVAL_MS,
+		waitForDeliveryIdleBeforeRepump: true,
+		retention: {
+			pruneIntervalMs: NEXTCLOUD_TALK_INGRESS_PRUNE_INTERVAL_MS,
+			completedTtlMs: NEXTCLOUD_TALK_INGRESS_COMPLETED_TTL_MS,
+			completedMaxEntries: NEXTCLOUD_TALK_INGRESS_COMPLETED_MAX_ENTRIES,
+			failedTtlMs: NEXTCLOUD_TALK_INGRESS_FAILED_TTL_MS,
+			failedMaxEntries: NEXTCLOUD_TALK_INGRESS_FAILED_MAX_ENTRIES
+		},
+		drain: {
+			resolveNonRetryableFailure,
+			...options.adoptionStallTimeoutMs === void 0 ? {} : { adoptionStallTimeoutMs: options.adoptionStallTimeoutMs },
+			onLog: (message) => options.runtime.log?.(`nextcloud-talk ${message}`)
+		},
+		...options.abortSignal ? { abortSignal: options.abortSignal } : {},
+		createStoppedError: () => /* @__PURE__ */ new Error("Nextcloud Talk ingress stopped"),
+		onError: (error) => options.runtime.error?.(`nextcloud-talk ingress drain failed: ${formatErrorMessage(error)}`)
+	});
+	let stopping = false;
+	const inFlightReceives = /* @__PURE__ */ new Set();
+	const startAfterMigration = legacyMigration.then(() => {
+		if (!stopping) monitor.start();
+	});
+	return {
+		ready: async () => await startAfterMigration,
+		receive: (rawEvent) => {
+			if (stopping) return Promise.reject(/* @__PURE__ */ new Error("Nextcloud Talk ingress stopped"));
+			const receiveTask = (async () => {
+				await startAfterMigration;
+				return (await monitor.admit(rawEvent)).kind === "ignored" ? "ignored" : "accepted";
+			})();
+			inFlightReceives.add(receiveTask);
+			receiveTask.then(() => inFlightReceives.delete(receiveTask), () => inFlightReceives.delete(receiveTask));
+			return receiveTask;
+		},
+		stop: async () => {
+			stopping = true;
+			const pendingReceives = [...inFlightReceives];
+			const pauseTask = monitor.pause();
+			await startAfterMigration.catch(() => void 0);
+			await Promise.allSettled(pendingReceives);
+			await monitor.stop();
+			await pauseTask;
+		},
+		waitForIdle: async () => {
+			await startAfterMigration.catch(() => void 0);
+			await monitor.waitForIdle();
+		}
+	};
+}
+//#endregion
 //#region extensions/nextcloud-talk/src/monitor-runtime.ts
 const DEFAULT_WEBHOOK_PORT = 8788;
 const DEFAULT_WEBHOOK_HOST = "0.0.0.0";
@@ -1438,13 +1648,29 @@ async function monitorNextcloudTalkProvider(opts) {
 		accountId: account.accountId
 	});
 	const expectedBackendOrigin = normalizeOrigin(account.baseUrl);
-	const replayGuard = createNextcloudTalkReplayGuard({
-		stateDir: core.state.resolveStateDir(process.env, os.homedir),
-		onDiskError: (error) => {
-			logger.warn(`[nextcloud-talk:${account.accountId}] replay guard disk error: ${String(error)}`);
+	const spool = (opts.createSpool ?? createNextcloudTalkWebhookSpool)({
+		accountId: account.accountId,
+		runtime,
+		abortSignal: opts.abortSignal,
+		deliver: async (message, lifecycle) => {
+			core.channel.activity.record({
+				channel: "nextcloud-talk",
+				accountId: account.accountId,
+				direction: "inbound",
+				at: message.timestamp
+			});
+			if (opts.onMessage) await opts.onMessage(message, lifecycle);
+			else await handleNextcloudTalkInbound({
+				message,
+				account,
+				config: cfg,
+				runtime,
+				statusSink: opts.statusSink,
+				turnAdoptionLifecycle: lifecycle
+			});
 		}
 	});
-	const { start, stop } = createNextcloudTalkWebhookServer({
+	const server = (opts.createServer ?? createNextcloudTalkWebhookServer)({
 		port,
 		host,
 		path,
@@ -1453,39 +1679,34 @@ async function monitorNextcloudTalkProvider(opts) {
 			if (!expectedBackendOrigin) return true;
 			return normalizeOrigin(backend) === expectedBackendOrigin;
 		},
-		processMessage: async (message) => {
-			if (await processNextcloudTalkReplayGuardedMessage({
-				replayGuard,
-				accountId: account.accountId,
-				message,
-				handleMessage: async () => {
-					core.channel.activity.record({
-						channel: "nextcloud-talk",
-						accountId: account.accountId,
-						direction: "inbound",
-						at: message.timestamp
-					});
-					if (opts.onMessage) await opts.onMessage(message);
-					else await handleNextcloudTalkInbound({
-						message,
-						account,
-						config: cfg,
-						runtime,
-						statusSink: opts.statusSink
-					});
-				}
-			}) === "duplicate") logger.warn(`[nextcloud-talk:${account.accountId}] replayed webhook ignored room=${message.roomToken} messageId=${message.messageId}`);
-		},
-		onMessage: async () => {},
+		onWebhook: spool.receive,
 		onError: (error) => {
 			logger.error(`[nextcloud-talk:${account.accountId}] webhook error: ${error.message}`);
 		},
 		abortSignal: opts.abortSignal
 	});
-	if (opts.abortSignal?.aborted) return { stop };
-	await start();
+	let stopPromise;
+	const stop = () => {
+		stopPromise ??= (async () => {
+			await server.stop();
+			await spool.stop();
+		})();
+		return stopPromise;
+	};
+	if (opts.abortSignal && !opts.abortSignal.aborted) opts.abortSignal.addEventListener("abort", () => void stop(), { once: true });
 	if (opts.abortSignal?.aborted) {
-		stop();
+		await stop();
+		return { stop };
+	}
+	try {
+		await spool.ready();
+		await server.start();
+	} catch (error) {
+		await stop();
+		throw error;
+	}
+	if (opts.abortSignal?.aborted) {
+		await stop();
 		return { stop };
 	}
 	const publicUrl = account.config.webhookPublicUrl ?? `http://${host === "0.0.0.0" ? "localhost" : host}:${port}${path}`;
@@ -1503,7 +1724,7 @@ const nextcloudTalkGatewayAdapter = {
 			accountId: ctx.accountId,
 			setStatus: ctx.setStatus
 		});
-		await runStoppablePassiveMonitor({
+		await runPassiveAccountLifecycle({
 			abortSignal: ctx.abortSignal,
 			start: async () => await monitorNextcloudTalkProvider({
 				accountId: account.accountId,
@@ -1511,7 +1732,10 @@ const nextcloudTalkGatewayAdapter = {
 				runtime: ctx.runtime,
 				abortSignal: ctx.abortSignal,
 				statusSink
-			})
+			}),
+			stop: async (monitor) => {
+				await monitor.stop();
+			}
 		});
 	},
 	logoutAccount: async ({ accountId, cfg }) => {
@@ -1665,6 +1889,9 @@ function resolveNextcloudTalkOutboundSessionRoute(params) {
 //#region extensions/nextcloud-talk/src/setup-core.ts
 const t$1 = createSetupTranslator$1();
 const channel$1 = "nextcloud-talk";
+function readOptionalString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 function addWildcardAllowFrom(allowFrom) {
 	return mergeAllowFromEntries(allowFrom, ["*"]);
 }
@@ -1783,7 +2010,17 @@ const nextcloudTalkDmPolicy = {
 	promptAllowFrom: promptNextcloudTalkAllowFromForAccount
 };
 const nextcloudTalkSetupAdapter = {
+	singleAccountKeysToMove: ["rooms"],
 	resolveAccountId: ({ accountId }) => normalizeAccountId$1(accountId),
+	prepareAccountConfigInput: ({ input }) => {
+		const setupInput = input;
+		return {
+			...setupInput,
+			baseUrl: setupInput.baseUrl ?? readOptionalString(setupInput.url),
+			secret: setupInput.secret ?? readOptionalString(setupInput.token) ?? readOptionalString(setupInput.password),
+			secretFile: setupInput.secretFile ?? readOptionalString(setupInput.tokenFile)
+		};
+	},
 	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
 		cfg,
 		channelKey: channel$1,
@@ -1813,6 +2050,72 @@ const nextcloudTalkSetupAdapter = {
 		});
 	}
 };
+const nextcloudTalkSetupContract = defineChannelSetupContract({
+	fields: {
+		baseUrl: {
+			kind: "string",
+			cli: {
+				flags: "--base-url <url>",
+				description: "Nextcloud base URL"
+			}
+		},
+		url: {
+			kind: "string",
+			cli: {
+				flags: "--url <url>",
+				description: "Legacy Nextcloud base URL alias"
+			}
+		},
+		secret: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--secret <secret>",
+				description: "Nextcloud Talk bot secret"
+			}
+		},
+		token: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--token <secret>",
+				description: "Legacy Nextcloud bot secret alias"
+			}
+		},
+		password: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--password <secret>",
+				description: "Legacy Nextcloud bot secret alias"
+			}
+		},
+		secretFile: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--secret-file <path>",
+				description: "Nextcloud Talk bot secret file"
+			}
+		},
+		tokenFile: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--token-file <path>",
+				description: "Legacy Nextcloud bot secret file alias"
+			}
+		},
+		useEnv: {
+			kind: "boolean",
+			cli: {
+				flags: "--use-env",
+				description: "Use Nextcloud Talk environment credentials"
+			}
+		}
+	},
+	legacyAdapter: nextcloudTalkSetupAdapter
+});
 //#endregion
 //#region extensions/nextcloud-talk/src/setup-surface.ts
 const t = createSetupTranslator();
@@ -1992,12 +2295,14 @@ const nextcloudTalkPlugin = createChatChannelPlugin({
 		configSchema: buildChannelConfigSchema(NextcloudTalkConfigSchema),
 		config: {
 			...nextcloudTalkConfigAdapter,
-			isConfigured: (account) => Boolean(account.secret?.trim() && account.baseUrl?.trim()),
+			isConfigured: (account) => Boolean(account.tokenStatus !== "missing" && account.baseUrl?.trim()),
 			describeAccount: (account) => describeWebhookAccountSnapshot({
 				account,
-				configured: Boolean(account.secret?.trim() && account.baseUrl?.trim()),
+				configured: Boolean(account.tokenStatus !== "missing" && account.baseUrl?.trim()),
 				extra: {
 					secretSource: account.secretSource,
+					tokenStatus: account.tokenStatus,
+					apiCredentialStatus: account.apiCredentialStatus,
 					baseUrl: account.baseUrl ? "[set]" : "[missing]"
 				}
 			})
@@ -2026,6 +2331,7 @@ const nextcloudTalkPlugin = createChatChannelPlugin({
 			collectRuntimeConfigAssignments
 		},
 		setup: nextcloudTalkSetupAdapter,
+		setupContract: nextcloudTalkSetupContract,
 		status: createComputedAccountStatusAdapter({
 			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID$2),
 			buildChannelSummary: ({ snapshot }) => buildWebhookChannelStatusSummary(snapshot, { secretSource: snapshot.secretSource ?? "none" }),
@@ -2048,9 +2354,11 @@ const nextcloudTalkPlugin = createChatChannelPlugin({
 				accountId: account.accountId,
 				name: account.name,
 				enabled: account.enabled,
-				configured: Boolean(account.secret?.trim() && account.baseUrl?.trim()),
+				configured: Boolean(account.tokenStatus !== "missing" && account.baseUrl?.trim()),
 				extra: {
 					secretSource: account.secretSource,
+					tokenStatus: account.tokenStatus,
+					apiCredentialStatus: account.apiCredentialStatus,
 					baseUrl: account.baseUrl ? "[set]" : "[missing]",
 					mode: "webhook"
 				}

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as nextcloudTalkPlugin } from "./channel-BSnehBf6.js";
+import { t as nextcloudTalkPlugin } from "./channel-DtnECxVM.js";
 export { nextcloudTalkPlugin };

package/npm-shrinkwrap.json

@@ -1,17 +1,17 @@
 {
   "name": "@openclaw/nextcloud-talk",
-  "version": "2026.7.2-beta.2",
+  "version": "2026.7.2-beta.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/nextcloud-talk",
-      "version": "2026.7.2-beta.2",
+      "version": "2026.7.2-beta.4",
       "dependencies": {
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.7.2-beta.2"
+        "openclaw": ">=2026.7.2-beta.4"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/openclaw.plugin.json

@@ -9,12 +9,6 @@
   "channels": [
     "nextcloud-talk"
   ],
-  "channelEnvVars": {
-    "nextcloud-talk": [
-      "NEXTCLOUD_TALK_BOT_SECRET",
-      "NEXTCLOUD_TALK_API_PASSWORD"
-    ]
-  },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/nextcloud-talk",
-  "version": "2026.7.2-beta.2",
+  "version": "2026.7.2-beta.4",
   "description": "OpenClaw Nextcloud Talk channel plugin for conversations.",
   "repository": {
     "type": "git",
@@ -8,7 +8,7 @@
   },
   "type": "module",
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.2"
+    "openclaw": ">=2026.7.2-beta.4"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -20,8 +20,19 @@
       "./index.ts"
     ],
     "setupEntry": "./dist/setup-entry.js",
+    "setupFeatures": {
+      "configPromotion": true
+    },
     "channel": {
       "id": "nextcloud-talk",
+      "configuredState": {
+        "env": {
+          "anyOf": [
+            "NEXTCLOUD_TALK_BOT_SECRET",
+            "NEXTCLOUD_TALK_API_PASSWORD"
+          ]
+        }
+      },
       "label": "Nextcloud Talk",
       "selectionLabel": "Nextcloud Talk (self-hosted)",
       "docsPath": "/channels/nextcloud-talk",
@@ -32,7 +43,80 @@
         "nc"
       ],
       "order": 65,
-      "quickstartAllowFrom": true
+      "quickstartAllowFrom": true,
+      "setup": {
+        "fields": [
+          {
+            "key": "baseUrl",
+            "kind": "string",
+            "cli": {
+              "flags": "--base-url <url>",
+              "description": "Nextcloud base URL"
+            }
+          },
+          {
+            "key": "url",
+            "kind": "string",
+            "cli": {
+              "flags": "--url <url>",
+              "description": "Legacy Nextcloud base URL alias"
+            }
+          },
+          {
+            "key": "secret",
+            "kind": "string",
+            "sensitive": true,
+            "cli": {
+              "flags": "--secret <secret>",
+              "description": "Nextcloud Talk bot secret"
+            }
+          },
+          {
+            "key": "token",
+            "kind": "string",
+            "sensitive": true,
+            "cli": {
+              "flags": "--token <secret>",
+              "description": "Legacy Nextcloud bot secret alias"
+            }
+          },
+          {
+            "key": "password",
+            "kind": "string",
+            "sensitive": true,
+            "cli": {
+              "flags": "--password <secret>",
+              "description": "Legacy Nextcloud bot secret alias"
+            }
+          },
+          {
+            "key": "secretFile",
+            "kind": "string",
+            "sensitive": true,
+            "cli": {
+              "flags": "--secret-file <path>",
+              "description": "Nextcloud Talk bot secret file"
+            }
+          },
+          {
+            "key": "tokenFile",
+            "kind": "string",
+            "sensitive": true,
+            "cli": {
+              "flags": "--token-file <path>",
+              "description": "Legacy Nextcloud bot secret file alias"
+            }
+          },
+          {
+            "key": "useEnv",
+            "kind": "boolean",
+            "cli": {
+              "flags": "--use-env",
+              "description": "Use Nextcloud Talk environment credentials"
+            }
+          }
+        ]
+      }
     },
     "install": {
       "npmSpec": "@openclaw/nextcloud-talk",
@@ -40,10 +124,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.2"
+      "pluginApi": ">=2026.7.2-beta.4"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.2"
+      "openclawVersion": "2026.7.2-beta.4"
     },
     "release": {
       "publishToClawHub": true,