vora-ai 0.1.26 → 0.1.28

package/dist/.buildstamp

@@ -1 +1 @@
-{"builtAt":1775223093739,"head":"809127927c36d52125a491485e706e10be30d557"}
+{"builtAt":1776317543592,"head":"1faf2041d7bd987e79822f1292b887409901c756"}

package/dist/abort-CnLcEeXq.js

@@ -0,0 +1,194 @@
+import { r as logVerbose } from "./globals-qRkgzlvg.js";
+import { w as parseAgentSessionKey } from "./session-key-DlUf34JW.js";
+import { h as resolveSessionAgentId } from "./agent-scope-Dka5AEcV.js";
+import { a as resolveSessionStoreEntry, c as updateSessionStore, t as loadSessionStore } from "./store-B1qasysN.js";
+import "./sessions-DJIHfetj.js";
+import { l as resolveStorePath } from "./paths-D0AqgX8k.js";
+import { Cn as resolveInternalSessionKey, Qt as abortEmbeddedPiRun, St as markSubagentRunTerminated, _t as getLatestSubagentRunByChildSessionKey, bt as listSubagentRunsForController, wn as resolveMainSessionAlias } from "./vora-embedded-runner-CiuvE9Ko.js";
+import { u as clearSessionQueues } from "./content-blocks-CAWxYwhb.js";
+import { c as getAcpSessionManager } from "./vora-embedded-block-chunker-Bv4wrk09.js";
+import { i as setAbortMemory, n as isAbortRequestText } from "./abort-primitives-CJw9W5kU.js";
+import { a as stripMentions, o as stripStructuralPrefixes } from "./mentions-Ba5tN8AJ.js";
+import { t as resolveCommandAuthorization } from "./command-auth-CtHZculb.js";
+import { a as shouldPersistAbortCutoff, i as resolveAbortCutoffFromContext, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-DKLdsZAp.js";
+const abortDeps = {
+	getAcpSessionManager,
+	abortEmbeddedPiRun,
+	getLatestSubagentRunByChildSessionKey,
+	listSubagentRunsForController,
+	markSubagentRunTerminated
+};
+function formatAbortReplyText(stoppedSubagents) {
+	if (typeof stoppedSubagents !== "number" || stoppedSubagents <= 0) return "⚙️ Agent was aborted.";
+	return `⚙️ Agent was aborted. Stopped ${stoppedSubagents} ${stoppedSubagents === 1 ? "sub-agent" : "sub-agents"}.`;
+}
+function resolveSessionEntryForKey(store, sessionKey) {
+	if (!store || !sessionKey) return {};
+	const resolved = resolveSessionStoreEntry({
+		store,
+		sessionKey
+	});
+	if (resolved.existing) return resolved.legacyKeys.length > 0 ? {
+		entry: resolved.existing,
+		key: resolved.normalizedKey,
+		legacyKeys: resolved.legacyKeys
+	} : {
+		entry: resolved.existing,
+		key: resolved.normalizedKey
+	};
+	return {};
+}
+function resolveAbortTargetKey(ctx) {
+	const target = ctx.CommandTargetSessionKey?.trim();
+	if (target) return target;
+	return ctx.SessionKey?.trim() || void 0;
+}
+function normalizeRequesterSessionKey(cfg, key) {
+	const cleaned = key?.trim();
+	if (!cleaned) return;
+	const { mainKey, alias } = resolveMainSessionAlias(cfg);
+	return resolveInternalSessionKey({
+		key: cleaned,
+		alias,
+		mainKey
+	});
+}
+function stopSubagentsForRequester(params) {
+	const requesterKey = normalizeRequesterSessionKey(params.cfg, params.requesterSessionKey);
+	if (!requesterKey) return { stopped: 0 };
+	const dedupedRunsByChildKey = /* @__PURE__ */ new Map();
+	for (const run of abortDeps.listSubagentRunsForController(requesterKey)) {
+		const childKey = run.childSessionKey?.trim();
+		if (!childKey) continue;
+		const latest = abortDeps.getLatestSubagentRunByChildSessionKey(childKey);
+		const latestControllerSessionKey = latest?.controllerSessionKey?.trim() || latest?.requesterSessionKey?.trim();
+		if (!latest || latest.runId !== run.runId || latestControllerSessionKey !== requesterKey) continue;
+		const existing = dedupedRunsByChildKey.get(childKey);
+		if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
+	}
+	const runs = Array.from(dedupedRunsByChildKey.values());
+	if (runs.length === 0) return { stopped: 0 };
+	const storeCache = /* @__PURE__ */ new Map();
+	const seenChildKeys = /* @__PURE__ */ new Set();
+	let stopped = 0;
+	for (const run of runs) {
+		const childKey = run.childSessionKey?.trim();
+		if (!childKey || seenChildKeys.has(childKey)) continue;
+		seenChildKeys.add(childKey);
+		if (!run.endedAt) {
+			const cleared = clearSessionQueues([childKey]);
+			const parsed = parseAgentSessionKey(childKey);
+			const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId });
+			let store = storeCache.get(storePath);
+			if (!store) {
+				store = loadSessionStore(storePath);
+				storeCache.set(storePath, store);
+			}
+			const sessionId = store[childKey]?.sessionId;
+			const aborted = sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false;
+			if (abortDeps.markSubagentRunTerminated({
+				runId: run.runId,
+				childSessionKey: childKey,
+				reason: "killed"
+			}) > 0 || aborted || cleared.followupCleared > 0 || cleared.laneCleared > 0) stopped += 1;
+		}
+		const cascadeResult = stopSubagentsForRequester({
+			cfg: params.cfg,
+			requesterSessionKey: childKey
+		});
+		stopped += cascadeResult.stopped;
+	}
+	if (stopped > 0) logVerbose(`abort: stopped ${stopped} subagent run(s) for ${requesterKey}`);
+	return { stopped };
+}
+async function tryFastAbortFromMessage(params) {
+	const { ctx, cfg } = params;
+	const targetKey = resolveAbortTargetKey(ctx);
+	const agentId = resolveSessionAgentId({
+		sessionKey: targetKey ?? ctx.SessionKey ?? "",
+		config: cfg
+	});
+	const raw = stripStructuralPrefixes(ctx.CommandBody ?? ctx.RawBody ?? ctx.Body ?? "");
+	if (!isAbortRequestText(ctx.ChatType?.trim().toLowerCase() === "group" ? stripMentions(raw, ctx, cfg, agentId) : raw)) return {
+		handled: false,
+		aborted: false
+	};
+	const commandAuthorized = ctx.CommandAuthorized;
+	const auth = resolveCommandAuthorization({
+		ctx,
+		cfg,
+		commandAuthorized
+	});
+	if (!auth.isAuthorizedSender) return {
+		handled: false,
+		aborted: false
+	};
+	const abortKey = targetKey ?? auth.from ?? auth.to;
+	const requesterSessionKey = targetKey ?? ctx.SessionKey ?? abortKey;
+	if (targetKey) {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		const store = loadSessionStore(storePath);
+		const { entry, key, legacyKeys } = resolveSessionEntryForKey(store, targetKey);
+		const resolvedTargetKey = key ?? targetKey;
+		const acpManager = abortDeps.getAcpSessionManager();
+		if (acpManager) {
+			if (acpManager.resolveSession({
+				cfg,
+				sessionKey: resolvedTargetKey
+			}).kind !== "none") try {
+				await acpManager.cancelSession({
+					cfg,
+					sessionKey: resolvedTargetKey,
+					reason: "fast-abort"
+				});
+			} catch (error) {
+				logVerbose(`abort: ACP cancel failed for ${resolvedTargetKey}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		const sessionId = entry?.sessionId;
+		const aborted = sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false;
+		const cleared = clearSessionQueues([resolvedTargetKey, sessionId]);
+		if (cleared.followupCleared > 0 || cleared.laneCleared > 0) logVerbose(`abort: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
+		const abortCutoff = shouldPersistAbortCutoff({
+			commandSessionKey: ctx.SessionKey,
+			targetSessionKey: resolvedTargetKey
+		}) ? resolveAbortCutoffFromContext(ctx) : void 0;
+		if (entry && key) {
+			entry.abortedLastRun = true;
+			applyAbortCutoffToSessionEntry(entry, abortCutoff);
+			entry.updatedAt = Date.now();
+			store[key] = entry;
+			for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete store[legacyKey];
+			await updateSessionStore(storePath, (nextStore) => {
+				const nextEntry = nextStore[key] ?? entry;
+				if (!nextEntry) return;
+				nextEntry.abortedLastRun = true;
+				applyAbortCutoffToSessionEntry(nextEntry, abortCutoff);
+				nextEntry.updatedAt = Date.now();
+				nextStore[key] = nextEntry;
+				for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete nextStore[legacyKey];
+			});
+		} else if (abortKey) setAbortMemory(abortKey, true);
+		const { stopped } = stopSubagentsForRequester({
+			cfg,
+			requesterSessionKey
+		});
+		return {
+			handled: true,
+			aborted,
+			stoppedSubagents: stopped
+		};
+	}
+	if (abortKey) setAbortMemory(abortKey, true);
+	const { stopped } = stopSubagentsForRequester({
+		cfg,
+		requesterSessionKey
+	});
+	return {
+		handled: true,
+		aborted: false,
+		stoppedSubagents: stopped
+	};
+}
+//#endregion
+export { tryFastAbortFromMessage as i, resolveSessionEntryForKey as n, stopSubagentsForRequester as r, formatAbortReplyText as t };

package/dist/abort-cutoff.runtime-BrlNp5Yd.js

@@ -0,0 +1,20 @@
+import { c as updateSessionStore } from "./store-B1qasysN.js";
+import { n as hasAbortCutoff, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-DKLdsZAp.js";
+//#region src/auto-reply/reply/abort-cutoff.runtime.ts
+async function clearAbortCutoffInSessionRuntime(params) {
+	const { sessionEntry, sessionStore, sessionKey, storePath } = params;
+	if (!sessionEntry || !sessionStore || !sessionKey || !hasAbortCutoff(sessionEntry)) return false;
+	applyAbortCutoffToSessionEntry(sessionEntry, void 0);
+	sessionEntry.updatedAt = Date.now();
+	sessionStore[sessionKey] = sessionEntry;
+	if (storePath) await updateSessionStore(storePath, (store) => {
+		const existing = store[sessionKey] ?? sessionEntry;
+		if (!existing) return;
+		applyAbortCutoffToSessionEntry(existing, void 0);
+		existing.updatedAt = Date.now();
+		store[sessionKey] = existing;
+	});
+	return true;
+}
+//#endregion
+export { clearAbortCutoffInSessionRuntime };

package/dist/abort-cutoff.runtime.js

@@ -1 +1 @@
-export * from "./abort-cutoff.runtime-CsdWnPMq.js";
+export * from "./abort-cutoff.runtime-BrlNp5Yd.js";

package/dist/abort-primitives-CJw9W5kU.js

@@ -0,0 +1,92 @@
+import { a as normalizeCommandBody } from "./commands-registry-DTpHDw8u.js";
+//#region src/auto-reply/reply/abort-primitives.ts
+const ABORT_TRIGGERS = new Set([
+	"stop",
+	"esc",
+	"abort",
+	"wait",
+	"exit",
+	"interrupt",
+	"detente",
+	"deten",
+	"detén",
+	"arrete",
+	"arrête",
+	"停止",
+	"やめて",
+	"止めて",
+	"रुको",
+	"توقف",
+	"стоп",
+	"остановись",
+	"останови",
+	"остановить",
+	"прекрати",
+	"halt",
+	"anhalten",
+	"aufhören",
+	"hoer auf",
+	"stopp",
+	"pare",
+	"stop vora",
+	"vora stop",
+	"stop action",
+	"stop current action",
+	"stop run",
+	"stop current run",
+	"stop agent",
+	"stop the agent",
+	"stop don't do anything",
+	"stop dont do anything",
+	"stop do not do anything",
+	"stop doing anything",
+	"do not do that",
+	"please stop",
+	"stop please"
+]);
+const ABORT_MEMORY = /* @__PURE__ */ new Map();
+const ABORT_MEMORY_MAX = 2e3;
+const TRAILING_ABORT_PUNCTUATION_RE = /[.!?…,，。;；:：'"’”)\]}]+$/u;
+function normalizeAbortTriggerText(text) {
+	return text.trim().toLowerCase().replace(/[’`]/g, "'").replace(/\s+/g, " ").replace(TRAILING_ABORT_PUNCTUATION_RE, "").trim();
+}
+function isAbortTrigger(text) {
+	if (!text) return false;
+	const normalized = normalizeAbortTriggerText(text);
+	return ABORT_TRIGGERS.has(normalized);
+}
+function isAbortRequestText(text, options) {
+	if (!text) return false;
+	const normalized = normalizeCommandBody(text, options).trim();
+	if (!normalized) return false;
+	const normalizedLower = normalized.toLowerCase();
+	return normalizedLower === "/stop" || normalizeAbortTriggerText(normalizedLower) === "/stop" || isAbortTrigger(normalizedLower);
+}
+function getAbortMemory(key) {
+	const normalized = key.trim();
+	if (!normalized) return;
+	return ABORT_MEMORY.get(normalized);
+}
+function pruneAbortMemory() {
+	if (ABORT_MEMORY.size <= ABORT_MEMORY_MAX) return;
+	const excess = ABORT_MEMORY.size - ABORT_MEMORY_MAX;
+	let removed = 0;
+	for (const entryKey of ABORT_MEMORY.keys()) {
+		ABORT_MEMORY.delete(entryKey);
+		removed += 1;
+		if (removed >= excess) break;
+	}
+}
+function setAbortMemory(key, value) {
+	const normalized = key.trim();
+	if (!normalized) return;
+	if (!value) {
+		ABORT_MEMORY.delete(normalized);
+		return;
+	}
+	if (ABORT_MEMORY.has(normalized)) ABORT_MEMORY.delete(normalized);
+	ABORT_MEMORY.set(normalized, true);
+	pruneAbortMemory();
+}
+//#endregion
+export { setAbortMemory as i, isAbortRequestText as n, isAbortTrigger as r, getAbortMemory as t };

package/dist/abort.runtime-D8E2OPP1.js

@@ -0,0 +1,2 @@
+import { i as tryFastAbortFromMessage, t as formatAbortReplyText } from "./abort-CnLcEeXq.js";
+export { formatAbortReplyText, tryFastAbortFromMessage };

package/dist/abort.runtime.js

@@ -1 +1 @@
-export * from "./abort.runtime-B2L0T4xX.js";
+export * from "./abort.runtime-D8E2OPP1.js";

package/dist/account-core-DRNmhPrG.js

@@ -0,0 +1,26 @@
+import "./utils-BOp-NlYr.js";
+//#region src/plugin-sdk/account-core.ts
+/** Resolve an account by id, then fall back to the default account when the primary lacks credentials. */
+function resolveAccountWithDefaultFallback(params) {
+	const hasExplicitAccountId = Boolean(params.accountId?.trim());
+	const normalizedAccountId = params.normalizeAccountId(params.accountId);
+	const primary = params.resolvePrimary(normalizedAccountId);
+	if (hasExplicitAccountId || params.hasCredential(primary)) return primary;
+	const fallbackId = params.resolveDefaultAccountId();
+	if (fallbackId === normalizedAccountId) return primary;
+	const fallback = params.resolvePrimary(fallbackId);
+	if (!params.hasCredential(fallback)) return primary;
+	return fallback;
+}
+/** List normalized configured account ids from a raw channel account record map. */
+function listConfiguredAccountIds(params) {
+	if (!params.accounts) return [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(params.accounts)) {
+		if (!key) continue;
+		ids.add(params.normalizeAccountId(key));
+	}
+	return [...ids];
+}
+//#endregion
+export { resolveAccountWithDefaultFallback as n, listConfiguredAccountIds as t };

package/dist/account-helpers-DHGlHJbT.js

@@ -0,0 +1,20 @@
+import { h as normalizeAccountId, m as DEFAULT_ACCOUNT_ID } from "./session-key-DlUf34JW.js";
+//#region src/channels/plugins/account-helpers.ts
+function listCombinedAccountIds(params) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const id of params.configuredAccountIds) if (id) ids.add(id);
+	for (const id of params.additionalAccountIds ?? []) if (id) ids.add(id);
+	if (params.implicitAccountId) ids.add(params.implicitAccountId);
+	if (ids.size === 0 && params.fallbackAccountIdWhenEmpty) return [params.fallbackAccountIdWhenEmpty];
+	return [...ids].toSorted((a, b) => a.localeCompare(b));
+}
+function resolveListedDefaultAccountId(params) {
+	const preferred = params.configuredDefaultAccountId;
+	const normalizeListedAccountId = params.normalizeListedAccountId ?? normalizeAccountId;
+	if (preferred && (params.allowUnlistedDefaultAccount || params.accountIds.some((accountId) => normalizeListedAccountId(accountId) === preferred))) return preferred;
+	if (params.accountIds.includes("default")) return DEFAULT_ACCOUNT_ID;
+	if (params.ambiguousFallbackAccountId && params.accountIds.length > 1) return params.ambiguousFallbackAccountId;
+	return params.accountIds[0] ?? "default";
+}
+//#endregion
+export { resolveListedDefaultAccountId as n, listCombinedAccountIds as t };

package/dist/account-snapshot-fields-BhdiFHk1.js

@@ -0,0 +1,106 @@
+//#region src/shared/net/url-userinfo.ts
+function stripUrlUserInfo(value) {
+	try {
+		const parsed = new URL(value);
+		if (!parsed.username && !parsed.password) return value;
+		parsed.username = "";
+		parsed.password = "";
+		return parsed.toString();
+	} catch {
+		return value;
+	}
+}
+//#endregion
+//#region src/channels/account-snapshot-fields.ts
+const CREDENTIAL_STATUS_KEYS = [
+	"tokenStatus",
+	"botTokenStatus",
+	"appTokenStatus",
+	"signingSecretStatus",
+	"userTokenStatus"
+];
+function asRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	return value;
+}
+function readTrimmedString(record, key) {
+	const value = record[key];
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function readBoolean(record, key) {
+	return typeof record[key] === "boolean" ? record[key] : void 0;
+}
+function readNumber(record, key) {
+	const value = record[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readStringArray(record, key) {
+	const value = record[key];
+	if (!Array.isArray(value)) return;
+	const normalized = value.map((entry) => typeof entry === "string" || typeof entry === "number" ? String(entry) : "").map((entry) => entry.trim()).filter(Boolean);
+	return normalized.length > 0 ? normalized : void 0;
+}
+function readCredentialStatus(record, key) {
+	const value = record[key];
+	return value === "available" || value === "configured_unavailable" || value === "missing" ? value : void 0;
+}
+function hasConfiguredUnavailableCredentialStatus(account) {
+	const record = asRecord(account);
+	if (!record) return false;
+	return CREDENTIAL_STATUS_KEYS.some((key) => readCredentialStatus(record, key) === "configured_unavailable");
+}
+function hasResolvedCredentialValue(account) {
+	const record = asRecord(account);
+	if (!record) return false;
+	return [
+		"token",
+		"botToken",
+		"appToken",
+		"signingSecret",
+		"userToken"
+	].some((key) => {
+		const value = record[key];
+		return typeof value === "string" && value.trim().length > 0;
+	}) || CREDENTIAL_STATUS_KEYS.some((key) => readCredentialStatus(record, key) === "available");
+}
+function projectCredentialSnapshotFields(account) {
+	const record = asRecord(account);
+	if (!record) return {};
+	return {
+		...readTrimmedString(record, "tokenSource") ? { tokenSource: readTrimmedString(record, "tokenSource") } : {},
+		...readTrimmedString(record, "botTokenSource") ? { botTokenSource: readTrimmedString(record, "botTokenSource") } : {},
+		...readTrimmedString(record, "appTokenSource") ? { appTokenSource: readTrimmedString(record, "appTokenSource") } : {},
+		...readTrimmedString(record, "signingSecretSource") ? { signingSecretSource: readTrimmedString(record, "signingSecretSource") } : {},
+		...readCredentialStatus(record, "tokenStatus") ? { tokenStatus: readCredentialStatus(record, "tokenStatus") } : {},
+		...readCredentialStatus(record, "botTokenStatus") ? { botTokenStatus: readCredentialStatus(record, "botTokenStatus") } : {},
+		...readCredentialStatus(record, "appTokenStatus") ? { appTokenStatus: readCredentialStatus(record, "appTokenStatus") } : {},
+		...readCredentialStatus(record, "signingSecretStatus") ? { signingSecretStatus: readCredentialStatus(record, "signingSecretStatus") } : {},
+		...readCredentialStatus(record, "userTokenStatus") ? { userTokenStatus: readCredentialStatus(record, "userTokenStatus") } : {}
+	};
+}
+function projectSafeChannelAccountSnapshotFields(account) {
+	const record = asRecord(account);
+	if (!record) return {};
+	return {
+		...readTrimmedString(record, "name") ? { name: readTrimmedString(record, "name") } : {},
+		...readBoolean(record, "linked") !== void 0 ? { linked: readBoolean(record, "linked") } : {},
+		...readBoolean(record, "running") !== void 0 ? { running: readBoolean(record, "running") } : {},
+		...readBoolean(record, "connected") !== void 0 ? { connected: readBoolean(record, "connected") } : {},
+		...readNumber(record, "reconnectAttempts") !== void 0 ? { reconnectAttempts: readNumber(record, "reconnectAttempts") } : {},
+		...readNumber(record, "lastInboundAt") !== void 0 ? { lastInboundAt: readNumber(record, "lastInboundAt") } : {},
+		...readTrimmedString(record, "healthState") ? { healthState: readTrimmedString(record, "healthState") } : {},
+		...readTrimmedString(record, "mode") ? { mode: readTrimmedString(record, "mode") } : {},
+		...readTrimmedString(record, "dmPolicy") ? { dmPolicy: readTrimmedString(record, "dmPolicy") } : {},
+		...readStringArray(record, "allowFrom") ? { allowFrom: readStringArray(record, "allowFrom") } : {},
+		...projectCredentialSnapshotFields(account),
+		...readTrimmedString(record, "baseUrl") ? { baseUrl: stripUrlUserInfo(readTrimmedString(record, "baseUrl")) } : {},
+		...readBoolean(record, "allowUnmentionedGroups") !== void 0 ? { allowUnmentionedGroups: readBoolean(record, "allowUnmentionedGroups") } : {},
+		...readTrimmedString(record, "cliPath") ? { cliPath: readTrimmedString(record, "cliPath") } : {},
+		...readTrimmedString(record, "dbPath") ? { dbPath: readTrimmedString(record, "dbPath") } : {},
+		...readNumber(record, "port") !== void 0 ? { port: readNumber(record, "port") } : {}
+	};
+}
+//#endregion
+export { hasResolvedCredentialValue as n, projectSafeChannelAccountSnapshotFields as r, hasConfiguredUnavailableCredentialStatus as t };

package/dist/account-summary-BeXZKUZA.js

@@ -0,0 +1,36 @@
+import { r as normalizeStringEntries } from "./string-normalization-C4lqTvFU.js";
+import { r as projectSafeChannelAccountSnapshotFields } from "./account-snapshot-fields-BhdiFHk1.js";
+//#region src/channels/account-summary.ts
+function buildChannelAccountSnapshot(params) {
+	const described = params.plugin.config.describeAccount?.(params.account, params.cfg);
+	return {
+		enabled: params.enabled,
+		configured: params.configured,
+		...projectSafeChannelAccountSnapshotFields(params.account),
+		...described,
+		accountId: params.accountId
+	};
+}
+function formatChannelAllowFrom(params) {
+	if (params.plugin.config.formatAllowFrom) return params.plugin.config.formatAllowFrom({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		allowFrom: params.allowFrom
+	});
+	return normalizeStringEntries(params.allowFrom);
+}
+function asRecord(value) {
+	if (!value || typeof value !== "object") return;
+	return value;
+}
+function resolveChannelAccountEnabled(params) {
+	if (params.plugin.config.isEnabled) return params.plugin.config.isEnabled(params.account, params.cfg);
+	return asRecord(params.account)?.enabled !== false;
+}
+async function resolveChannelAccountConfigured(params) {
+	if (params.plugin.config.isConfigured) return await params.plugin.config.isConfigured(params.account, params.cfg);
+	if (params.readAccountConfiguredField) return asRecord(params.account)?.configured !== false;
+	return true;
+}
+//#endregion
+export { resolveChannelAccountEnabled as i, formatChannelAllowFrom as n, resolveChannelAccountConfigured as r, buildChannelAccountSnapshot as t };

package/dist/acp-cli-C5EV1u56.js

@@ -0,0 +1,88 @@
+import { n as defaultRuntime } from "./runtime-COo8Py6Q.js";
+import { t as formatDocsLink } from "./links-BUljfMHZ.js";
+import { r as theme } from "./theme-Cf3aCnEp.js";
+import { n as inheritOptionFromParent } from "./command-options-Bgh1wKGB.js";
+import { t as readSecretFromFile } from "./secret-file-B-66fayX.js";
+//#region src/acp/client.ts
+async function runAcpClientInteractive() {
+	throw new Error("ACP is disabled in VORA V1");
+}
+//#endregion
+//#region src/acp/server.ts
+async function serveAcpGateway() {
+	throw new Error("ACP is disabled in VORA V1");
+}
+//#endregion
+//#region src/acp/types.ts
+function normalizeAcpProvenanceMode() {
+	return "none";
+}
+//#endregion
+//#region src/cli/acp-cli.ts
+function resolveSecretOption(params) {
+	const direct = params.direct?.trim();
+	const file = params.file?.trim();
+	if (direct && file) throw new Error(`Use either ${params.directFlag} or ${params.fileFlag} for ${params.label}.`);
+	if (file) return /* @__PURE__ */ readSecretFromFile(file, params.label);
+	return direct || void 0;
+}
+function warnSecretCliFlag(flag) {
+	defaultRuntime.error(`Warning: ${flag} can be exposed via process listings. Prefer ${flag}-file or environment variables.`);
+}
+function registerAcpCli(program) {
+	const acp = program.command("acp").description("Run an ACP bridge backed by the Gateway");
+	acp.option("--url <url>", "Gateway WebSocket URL (defaults to gateway.remote.url when configured)").option("--token <token>", "Gateway token (if required)").option("--token-file <path>", "Read gateway token from file").option("--password <password>", "Gateway password (if required)").option("--password-file <path>", "Read gateway password from file").option("--session <key>", "Default session key (e.g. agent:main:main)").option("--session-label <label>", "Default session label to resolve").option("--require-existing", "Fail if the session key/label does not exist", false).option("--reset-session", "Reset the session key before first use", false).option("--no-prefix-cwd", "Do not prefix prompts with the working directory", false).option("--provenance <mode>", "ACP provenance mode: off, meta, or meta+receipt").option("-v, --verbose", "Verbose logging to stderr", false).addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/acp", "docs.vora.ai/cli/acp")}\n`).action(async (opts) => {
+		try {
+			const gatewayToken = resolveSecretOption({
+				direct: opts.token,
+				file: opts.tokenFile,
+				directFlag: "--token",
+				fileFlag: "--token-file",
+				label: "Gateway token"
+			});
+			const gatewayPassword = resolveSecretOption({
+				direct: opts.password,
+				file: opts.passwordFile,
+				directFlag: "--password",
+				fileFlag: "--password-file",
+				label: "Gateway password"
+			});
+			if (opts.token) warnSecretCliFlag("--token");
+			if (opts.password) warnSecretCliFlag("--password");
+			const provenanceMode = normalizeAcpProvenanceMode(opts.provenance);
+			if (opts.provenance && !provenanceMode) throw new Error("Invalid --provenance value. Use off, meta, or meta+receipt.");
+			await serveAcpGateway({
+				gatewayUrl: opts.url,
+				gatewayToken,
+				gatewayPassword,
+				defaultSessionKey: opts.session,
+				defaultSessionLabel: opts.sessionLabel,
+				requireExistingSession: Boolean(opts.requireExisting),
+				resetSession: Boolean(opts.resetSession),
+				prefixCwd: !opts.noPrefixCwd,
+				provenanceMode,
+				verbose: Boolean(opts.verbose)
+			});
+		} catch (err) {
+			defaultRuntime.error(String(err));
+			defaultRuntime.exit(1);
+		}
+	});
+	acp.command("client").description("Run an interactive ACP client against the local ACP bridge").option("--cwd <dir>", "Working directory for the ACP session").option("--server <command>", "ACP server command (default: vora)").option("--server-args <args...>", "Extra arguments for the ACP server").option("--server-verbose", "Enable verbose logging on the ACP server", false).option("-v, --verbose", "Verbose client logging", false).action(async (opts, command) => {
+		const inheritedVerbose = inheritOptionFromParent(command, "verbose");
+		try {
+			await runAcpClientInteractive({
+				cwd: opts.cwd,
+				serverCommand: opts.server,
+				serverArgs: opts.serverArgs,
+				serverVerbose: Boolean(opts.serverVerbose),
+				verbose: Boolean(opts.verbose || inheritedVerbose)
+			});
+		} catch (err) {
+			defaultRuntime.error(String(err));
+			defaultRuntime.exit(1);
+		}
+	});
+}
+//#endregion
+export { registerAcpCli };

package/dist/acp-stateful-target-driver-DXsrjXo5.js

@@ -0,0 +1,67 @@
+import { t as readAcpSessionEntry } from "./session-meta-gAQN0gYD.js";
+import { r as resolveConfiguredAcpBindingSpecFromRecord } from "./persistent-bindings.types-BSE9BJzY.js";
+//#region src/acp/persistent-bindings.lifecycle.ts
+async function ensureConfiguredAcpBindingReady() {}
+//#endregion
+//#region src/acp/persistent-bindings.resolve.ts
+function resolveConfiguredAcpBindingSpecBySessionKey() {
+	return null;
+}
+//#endregion
+//#region src/channels/plugins/acp-stateful-target-driver.ts
+function toAcpStatefulBindingTargetDescriptor(params) {
+	const metaAgentId = (readAcpSessionEntry(params)?.acp)?.agent?.trim();
+	if (metaAgentId) return {
+		kind: "stateful",
+		driverId: "acp",
+		sessionKey: params.sessionKey,
+		agentId: metaAgentId
+	};
+	const spec = resolveConfiguredAcpBindingSpecBySessionKey(params);
+	if (!spec) return null;
+	return {
+		kind: "stateful",
+		driverId: "acp",
+		sessionKey: params.sessionKey,
+		agentId: spec.agentId,
+		...spec.label ? { label: spec.label } : {}
+	};
+}
+async function ensureAcpTargetReady(params) {
+	const configuredBinding = resolveConfiguredAcpBindingSpecFromRecord(params.bindingResolution.record);
+	if (!configuredBinding) return {
+		ok: false,
+		error: "Configured ACP binding unavailable"
+	};
+	return await ensureConfiguredAcpBindingReady({
+		cfg: params.cfg,
+		configuredBinding: {
+			spec: configuredBinding,
+			record: params.bindingResolution.record
+		}
+	});
+}
+async function ensureAcpTargetSession(params) {
+	const spec = resolveConfiguredAcpBindingSpecFromRecord(params.bindingResolution.record);
+	if (!spec) return {
+		ok: false,
+		sessionKey: params.bindingResolution.statefulTarget.sessionKey,
+		error: "Configured ACP binding unavailable"
+	};
+	return await ensureConfiguredAcpBindingSession({
+		cfg: params.cfg,
+		spec
+	});
+}
+async function resetAcpTargetInPlace(params) {
+	return await resetAcpSessionInPlace(params);
+}
+const acpStatefulBindingTargetDriver = {
+	id: "acp",
+	ensureReady: ensureAcpTargetReady,
+	ensureSession: ensureAcpTargetSession,
+	resolveTargetBySessionKey: toAcpStatefulBindingTargetDescriptor,
+	resetInPlace: resetAcpTargetInPlace
+};
+//#endregion
+export { acpStatefulBindingTargetDriver };