@ftai/dsh-plugin-acn 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,1377 @@
+import { S as timestampNanos, h as TraceIdSchema, i as effectiveUpdatedAt, l as ClaimIdSchema } from "./claim-DOAGe8ZK.js";
+import { c as TranscriptStore } from "./structured-lyQCK-Zk.js";
+import { n as claimRevision } from "./revision-DeoL_IUN.js";
+import { _ as JobError, c as readYamlOr, l as writeYamlAtomic, n as withFileLock } from "./lock-DbmlKOoX.js";
+import { i as ClaimStore } from "./reported-sets-DdEKdeVb.js";
+import { t as TraceStore } from "./traces-CHBo8y1z.js";
+import { a as disputeVersion, n as PendingUploadsSchema, r as UploadStore } from "./uploads-BCA2p92b.js";
+import { t as DreamStore } from "./checkpoint-RgcdqifN.js";
+import { n as deliveryTarget, t as DeliveryStatusStore } from "./delivery-status-D5m3178s.js";
+import { t as TeamError } from "./errors-pPumDOGD.js";
+import { t as UploadDelivery } from "./deliver-BuYQaPRW.js";
+import { n as agentHomePath, o as invalidStorageName, r as expandHomePath, t as AgentPaths } from "./paths-CDYV5UH9.js";
+import { r as configurationBusy, u as runningConfiguration } from "./session-binding-BQrOGhZI.js";
+import { t as DisputeStore } from "./disputes-ByEmi43j.js";
+import { n as FormationStore } from "./checkpoint-Bmt8q2vB.js";
+import { t as TeamFacade } from "./service-B7AI5jds.js";
+import { t as JobQueue } from "./queue-M917xHPS.js";
+import { c as ConnectionSchema, d as resolveConfig, f as upstreamsOf, l as UpstreamNameSchema, n as teamCredentials, o as resolveUpstream, r as AcnKnowledge, s as ConfigError, t as credentialReference, u as UpstreamSchema } from "./team-credentials-C9xHrPIi.js";
+import { a as messageInfo, n as allActivities, r as MessageInfoSchema, t as activityPage } from "./activities-LRoCwpzw.js";
+import { t as PresentationStore } from "./presentation-BlLjgDjP.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import { access, stat } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { constants } from "node:fs";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { createTypertRemoteInfo } from "@deepseek-ai/dsh-typert-protocol/remote-info";
+import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+//#region src/advanced-configuration.ts
+const seconds = z.number().min(.001).max(Number.MAX_SAFE_INTEGER / 1e3);
+const milliseconds = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+const AdvancedConfigurationSchema = z.strictObject({
+	inboxProcessingStaleAfterSecs: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+	routerQueryTimeoutSecs: seconds,
+	httpTimeoutSecs: seconds,
+	httpRetryCount: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+	httpRetryBaseDelayMs: milliseconds,
+	httpRetryMaxDelayMs: milliseconds
+}).superRefine((value, ctx) => {
+	if (value.httpRetryMaxDelayMs < value.httpRetryBaseDelayMs) ctx.addIssue({
+		code: "custom",
+		path: ["httpRetryMaxDelayMs"],
+		message: "Maximum retry delay must not be smaller than the base delay."
+	});
+});
+function advancedConfiguration(raw) {
+	const config = resolveConfig(raw);
+	return {
+		inboxProcessingStaleAfterSecs: config.inbox.processingStaleAfterSecs,
+		routerQueryTimeoutSecs: config.team.routerTimeoutMs / 1e3,
+		httpTimeoutSecs: config.team.timeoutMs / 1e3,
+		httpRetryCount: config.team.retryCount,
+		httpRetryBaseDelayMs: config.team.retryBaseDelayMs,
+		httpRetryMaxDelayMs: config.team.retryMaxDelayMs
+	};
+}
+//#endregion
+//#region src/configuration.ts
+const ConfigurationValuesSchema = z.strictObject({
+	agentId: z.string().trim(),
+	home: z.string().trim(),
+	provider: z.string().trim(),
+	model: z.string().trim(),
+	mode: z.enum(["solo", "team"]),
+	routerEndpoint: z.string().trim(),
+	maintainerEndpoint: z.string().trim(),
+	keyEnv: z.string().trim(),
+	timeoutMs: z.number(),
+	legacyEnabled: z.boolean().optional(),
+	connections: z.array(ConnectionSchema).optional(),
+	defaultConnection: z.string().optional(),
+	showCompletion: z.boolean().optional(),
+	upstream: z.string().optional(),
+	upstreams: z.record(UpstreamNameSchema, UpstreamSchema).optional(),
+	advanced: AdvancedConfigurationSchema.optional()
+});
+const ModelChoiceSchema = z.strictObject({
+	provider: z.string(),
+	providerName: z.string(),
+	id: z.string(),
+	name: z.string()
+});
+const ConfigurationSnapshotSchema = z.strictObject({
+	revision: z.string(),
+	values: ConfigurationValuesSchema,
+	models: z.array(ModelChoiceSchema),
+	active: z.boolean(),
+	dataDirectory: z.string(),
+	upstreamPending: z.record(z.string(), z.number().int().nonnegative().nullable()).optional()
+});
+const SaveConfigurationSchema = z.strictObject({
+	revision: z.string(),
+	values: ConfigurationValuesSchema
+});
+const ConfigurationResultSchema = z.discriminatedUnion("ok", [z.strictObject({
+	ok: z.literal(true),
+	snapshot: ConfigurationSnapshotSchema
+}), z.strictObject({
+	ok: z.literal(false),
+	code: z.enum([
+		"invalid",
+		"conflict",
+		"unavailable",
+		"persistence",
+		"inactive",
+		"busy"
+	]),
+	fields: z.array(z.string())
+})]);
+function configurationValues(raw) {
+	const config = resolveConfig(raw);
+	return {
+		agentId: config.agentId,
+		home: config.home,
+		provider: config.llm.provider,
+		model: config.llm.model,
+		mode: config.team.routerEndpoint === "" ? "solo" : "team",
+		routerEndpoint: config.team.routerEndpoint,
+		maintainerEndpoint: config.team.maintainerEndpoint,
+		keyEnv: config.team.keyEnv,
+		timeoutMs: config.team.timeoutMs,
+		legacyEnabled: config.legacyEnabled,
+		connections: config.connections,
+		defaultConnection: config.defaultConnection,
+		showCompletion: config.showCompletion,
+		advanced: advancedConfiguration(config),
+		...config.upstreams === void 0 ? {} : {
+			upstreams: config.upstreams,
+			upstream: config.upstream
+		}
+	};
+}
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function mergeConfiguration(raw, values) {
+	if (values.upstreams !== void 0) {
+		const previous = upstreamsOf(resolveConfig(raw));
+		for (const [key, value] of Object.entries(values.upstreams)) if (value.legacyStorage !== previous[key]?.legacyStorage || value.legacyKey !== previous[key]?.legacyKey) throw new ConfigError([
+			"upstreams",
+			key,
+			"legacyStorage"
+		]);
+	}
+	const next = {
+		...raw,
+		agentId: values.agentId,
+		home: values.home,
+		...values.upstreams === void 0 ? {} : {
+			upstreams: values.upstreams,
+			upstream: values.upstream ?? ""
+		},
+		...values.legacyEnabled === void 0 ? {} : { legacyEnabled: values.legacyEnabled },
+		...values.connections === void 0 ? {} : { connections: values.connections },
+		...values.defaultConnection === void 0 ? {} : { defaultConnection: values.defaultConnection },
+		...values.showCompletion === void 0 ? {} : { showCompletion: values.showCompletion },
+		llm: {
+			...record(raw.llm),
+			provider: values.provider,
+			model: values.model
+		},
+		team: {
+			...record(raw.team),
+			timeoutMs: values.timeoutMs,
+			routerEndpoint: values.mode === "team" ? values.routerEndpoint : "",
+			maintainerEndpoint: values.mode === "team" ? values.maintainerEndpoint : "",
+			keyEnv: values.mode === "team" ? values.keyEnv : ""
+		}
+	};
+	delete next["projectUpstreams"];
+	delete next["memory"];
+	const advanced = values.advanced;
+	if (advanced !== void 0) {
+		next["inbox"] = {
+			...record(raw.inbox),
+			processingStaleAfterSecs: advanced.inboxProcessingStaleAfterSecs
+		};
+		const previousTeam = resolveConfig(raw).team;
+		const httpChanged = advanced.httpTimeoutSecs !== previousTeam.timeoutMs / 1e3;
+		const timeoutMs = httpChanged ? Math.round(advanced.httpTimeoutSecs * 1e3) : values.timeoutMs;
+		const routerTimeoutMs = advanced.routerQueryTimeoutSecs === previousTeam.routerTimeoutMs / 1e3 ? previousTeam.routerTimeoutMs : Math.round(advanced.routerQueryTimeoutSecs * 1e3);
+		next["team"] = {
+			...record(next["team"]),
+			timeoutMs,
+			routerTimeoutMs,
+			retryCount: advanced.httpRetryCount,
+			retryBaseDelayMs: advanced.httpRetryBaseDelayMs,
+			retryMaxDelayMs: advanced.httpRetryMaxDelayMs
+		};
+		if (httpChanged && values.upstreams !== void 0) next["upstreams"] = Object.fromEntries(Object.entries(values.upstreams).map(([key, value]) => [key, {
+			...value,
+			timeoutMs
+		}]));
+		if (httpChanged && values.connections !== void 0) next["connections"] = values.connections.map((value) => ({
+			...value,
+			timeoutMs
+		}));
+	}
+	resolveConfig(next);
+	return next;
+}
+//#endregion
+//#region src/interaction.ts
+const RuntimeChoiceSchema = z.object({
+	key: z.string(),
+	name: z.string(),
+	agentId: z.string(),
+	enabled: z.boolean(),
+	mode: z.enum(["solo", "team"])
+});
+const SessionViewSchema = z.object({
+	sessionId: z.string(),
+	key: z.string(),
+	name: z.string(),
+	locked: z.boolean(),
+	available: z.boolean(),
+	phase: z.enum([
+		"ready",
+		"syncing",
+		"failed",
+		"blocked",
+		"unbound"
+	]),
+	message: z.string(),
+	messageInfo: MessageInfoSchema.optional(),
+	defaultConnection: z.string(),
+	needsPreparation: z.boolean().default(false),
+	explicitSelection: z.boolean().default(false),
+	activeMode: z.enum(["solo", "team"]).optional(),
+	configurationChanged: z.boolean().optional(),
+	choices: z.array(RuntimeChoiceSchema),
+	showCompletion: z.boolean()
+});
+const SourceSessionSchema = z.object({
+	id: z.string(),
+	available: z.boolean(),
+	title: z.string().optional()
+});
+const KnowledgeItemSchema = z.object({
+	kind: z.enum([
+		"claim",
+		"dispute",
+		"trace"
+	]),
+	id: z.string(),
+	name: z.string(),
+	status: z.string(),
+	detail: z.string(),
+	summary: z.string().optional(),
+	updatedAt: z.string().optional(),
+	delivery: z.enum([
+		"pending",
+		"synced",
+		"local"
+	]).optional(),
+	sources: z.array(SourceSessionSchema).optional()
+});
+const ActivitySchema = z.object({
+	id: z.string(),
+	kind: z.string(),
+	state: z.string(),
+	attempts: z.number(),
+	updatedAt: z.number(),
+	unseen: z.boolean().default(false),
+	sessionId: z.string().optional(),
+	source: SourceSessionSchema.optional(),
+	summary: z.string(),
+	error: z.string().optional(),
+	summaryInfo: MessageInfoSchema.optional(),
+	errorInfo: MessageInfoSchema.optional(),
+	counts: z.record(z.string(), z.number()).optional(),
+	warnings: z.array(z.string()).optional(),
+	budgetLimited: z.boolean().optional(),
+	requiresAttention: z.boolean().optional(),
+	incompleteCandidates: z.array(z.object({
+		groupId: z.string(),
+		claimIds: z.array(ClaimIdSchema),
+		reason: z.string()
+	})).optional(),
+	entityId: z.string().optional(),
+	retryable: z.boolean().optional(),
+	acknowledged: z.boolean().optional(),
+	reportPath: z.string().optional(),
+	phase: z.enum([
+		"exploration",
+		"wrap_up",
+		"finished"
+	]).optional()
+});
+const KnowledgeViewSchema = z.object({
+	key: z.string(),
+	name: z.string(),
+	items: z.array(KnowledgeItemSchema),
+	omitted: z.number(),
+	activities: z.array(ActivitySchema),
+	activitiesOmitted: z.number().nonnegative().optional(),
+	attentionCount: z.number().nonnegative().optional(),
+	runningCount: z.number().nonnegative().optional(),
+	activityKinds: z.array(z.string()).optional(),
+	activitySources: z.array(z.string()).optional(),
+	pendingClaims: z.number(),
+	pendingDisputes: z.number()
+});
+const ReferenceIdSchema = z.union([ClaimIdSchema, TraceIdSchema]);
+const KnowledgeReferenceSchema = z.object({
+	key: z.string(),
+	id: ReferenceIdSchema,
+	item: KnowledgeItemSchema.optional()
+});
+const TeamConnectionInputSchema = z.union([ConnectionSchema, UpstreamSchema.safeExtend({ id: z.string().optional() })]);
+const ConnectionChecksSchema = z.array(z.object({
+	service: z.enum(["router", "maintainer"]),
+	state: z.enum(["ok", "failed"]),
+	message: z.string()
+}));
+const InteractionRequestSchema = z.discriminatedUnion("action", [
+	z.object({
+		action: z.literal("session"),
+		sessionId: z.string()
+	}),
+	z.object({
+		action: z.literal("select"),
+		sessionId: z.string(),
+		key: z.string()
+	}),
+	z.object({
+		action: z.literal("cancel"),
+		sessionId: z.string()
+	}),
+	z.object({
+		action: z.literal("sync"),
+		sessionId: z.string()
+	}),
+	z.object({
+		action: z.literal("knowledge"),
+		key: z.string(),
+		query: z.string().max(500).default(""),
+		kind: z.enum([
+			"claim",
+			"dispute",
+			"trace"
+		]).default("claim"),
+		status: z.string().max(30).default(""),
+		delivery: z.enum([
+			"all",
+			"pending",
+			"synced",
+			"local"
+		]).default("all"),
+		offset: z.number().int().nonnegative().default(0)
+	}),
+	z.object({
+		action: z.literal("activity"),
+		key: z.string(),
+		attentionOnly: z.boolean().default(false),
+		sourceSession: z.string().default(""),
+		kind: z.string().max(30).default(""),
+		state: z.string().max(30).default(""),
+		offset: z.number().int().nonnegative().default(0)
+	}),
+	z.object({
+		action: z.literal("reference"),
+		key: z.string(),
+		id: ReferenceIdSchema
+	}),
+	z.object({
+		action: z.literal("source_session"),
+		sessionId: z.string().regex(/^[a-zA-Z0-9_-]+$/)
+	}),
+	z.object({
+		action: z.literal("open_directory"),
+		path: z.string().trim().min(1).max(32767)
+	}),
+	z.object({
+		action: z.literal("retry_delivery"),
+		key: z.string()
+	}),
+	z.object({
+		action: z.literal("dream_again"),
+		key: z.string(),
+		id: z.string()
+	}),
+	z.object({
+		action: z.literal("retry"),
+		key: z.string(),
+		id: z.string()
+	}),
+	z.object({
+		action: z.literal("ack"),
+		key: z.string(),
+		id: z.string(),
+		version: z.number().int().nonnegative()
+	}),
+	z.object({
+		action: z.literal("recap"),
+		sessionId: z.string()
+	}),
+	z.object({
+		action: z.literal("check"),
+		connection: TeamConnectionInputSchema
+	}),
+	z.object({
+		action: z.literal("probe"),
+		provider: z.string(),
+		model: z.string()
+	})
+]);
+const InteractionResultSchema = z.object({
+	ok: z.boolean(),
+	message: z.string(),
+	messageInfo: MessageInfoSchema.optional(),
+	serviceAvailable: z.boolean().optional(),
+	session: SessionViewSchema.optional(),
+	knowledge: KnowledgeViewSchema.optional(),
+	reference: KnowledgeReferenceSchema.optional(),
+	sourceSession: SourceSessionSchema.optional(),
+	checks: ConnectionChecksSchema.optional()
+});
+//#endregion
+//#region src/credentials.ts
+const secret = z.string().min(1).max(16384).refine((value) => value.trim().length > 0);
+const CredentialRequestSchema = z.discriminatedUnion("action", [
+	z.strictObject({
+		action: z.literal("describe"),
+		reference: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/)
+	}),
+	z.strictObject({
+		action: z.literal("store"),
+		reference: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/),
+		value: secret
+	}),
+	z.strictObject({
+		action: z.literal("discard"),
+		reference: z.string().regex(/^ACN_TEAM_[0-9A-F]{32}$/)
+	}),
+	z.strictObject({
+		action: z.literal("check"),
+		connection: TeamConnectionInputSchema,
+		value: secret
+	})
+]);
+const CredentialResultSchema = z.strictObject({
+	ok: z.boolean(),
+	message: z.string(),
+	messageInfo: MessageInfoSchema.optional(),
+	configured: z.boolean().optional(),
+	writable: z.boolean().optional(),
+	checks: ConnectionChecksSchema.optional()
+});
+//#endregion
+//#region src/dsh-adapter/configuration-remote.ts
+const request = {
+	mode: "strict",
+	typeSymbol: "@ftai/dsh-plugin-acn#SaveConfiguration",
+	create: () => SaveConfigurationSchema
+};
+const configurationRemote = createTypertRemoteInfo({
+	package: "@ftai/dsh-plugin-acn",
+	methods: {
+		"acnConfiguration/credential": {
+			service: "acnConfiguration",
+			invocation: { kind: "direct" },
+			cancellation: { parameter: "signal" },
+			parameters: [{
+				name: "request",
+				source: "json",
+				codec: {
+					mode: "strict",
+					typeSymbol: "@ftai/dsh-plugin-acn#CredentialRequest",
+					create: () => CredentialRequestSchema
+				},
+				strictCodec: {
+					mode: "strict",
+					typeSymbol: "@ftai/dsh-plugin-acn#CredentialRequest",
+					create: () => CredentialRequestSchema
+				}
+			}],
+			result: {
+				mode: "strict",
+				typeSymbol: "@ftai/dsh-plugin-acn#CredentialResult",
+				create: () => CredentialResultSchema
+			}
+		},
+		"acnConfiguration/interact": {
+			service: "acnConfiguration",
+			invocation: { kind: "direct" },
+			cancellation: { parameter: "signal" },
+			parameters: [{
+				name: "request",
+				source: "json",
+				codec: {
+					mode: "strict",
+					typeSymbol: "@ftai/dsh-plugin-acn#InteractionRequest",
+					create: () => InteractionRequestSchema
+				},
+				strictCodec: {
+					mode: "strict",
+					typeSymbol: "@ftai/dsh-plugin-acn#InteractionRequest",
+					create: () => InteractionRequestSchema
+				}
+			}],
+			result: {
+				mode: "strict",
+				typeSymbol: "@ftai/dsh-plugin-acn#InteractionResult",
+				create: () => InteractionResultSchema
+			}
+		},
+		"acnConfiguration/read": {
+			service: "acnConfiguration",
+			invocation: { kind: "direct" },
+			parameters: [],
+			result: {
+				mode: "strict",
+				typeSymbol: "@ftai/dsh-plugin-acn#ConfigurationSnapshot",
+				create: () => ConfigurationSnapshotSchema
+			}
+		},
+		"acnConfiguration/save": {
+			service: "acnConfiguration",
+			invocation: { kind: "direct" },
+			parameters: [{
+				name: "request",
+				source: "json",
+				codec: request,
+				strictCodec: request
+			}],
+			result: {
+				mode: "strict",
+				typeSymbol: "@ftai/dsh-plugin-acn#ConfigurationResult",
+				create: () => ConfigurationResultSchema
+			}
+		}
+	}
+}, z);
+//#endregion
+//#region src/knowledge/sources.ts
+async function knowledgeSources(context, entityIds) {
+	const wanted = new Set(entityIds);
+	const sources = /* @__PURE__ */ new Map();
+	const add = (ids, session) => {
+		for (const id of ids) if (wanted.has(id)) {
+			const values = sources.get(id) ?? /* @__PURE__ */ new Set();
+			values.add(session);
+			sources.set(id, values);
+		}
+	};
+	if (wanted.size === 0) return /* @__PURE__ */ new Map();
+	const formation = new FormationStore(context);
+	for (const session of await new TranscriptStore(context).sessions()) try {
+		const record = await formation.read(session);
+		if (record?.status === "applied") add([
+			...record.appliedClaims.filter((claim) => claim.holder === context.agentId).map((claim) => claim.id),
+			...record.disputes.filter((dispute) => dispute.reporter_agent_id === context.agentId).map((dispute) => dispute.id),
+			...record.trace?.agent === context.agentId ? [record.trace.id] : []
+		], session);
+	} catch {
+		context.logger.warn("Could not read a knowledge source checkpoint.");
+	}
+	const traces = entityIds.some((id) => id.startsWith("trace_"));
+	const dream = new DreamStore(context);
+	for (const job of await new JobQueue(context).list()) {
+		if (job.sessionId === void 0) continue;
+		const result = z.object({
+			entityIds: z.array(z.string()).default([]),
+			updatedClaimIds: z.array(ClaimIdSchema).default([])
+		}).safeParse(job.result);
+		if (result.success) add([...result.data.entityIds, ...result.data.updatedClaimIds], job.sessionId);
+		if (!traces || job.kind !== "dream") continue;
+		try {
+			const final = await dream.final(job.id);
+			if (final?.applied) add([final.trace_id], job.sessionId);
+			for (const { checkpoint } of await dream.records(job.id)) if (checkpoint.applied) add([checkpoint.trace_id], job.sessionId);
+		} catch {
+			context.logger.warn("Could not read a knowledge source checkpoint.");
+		}
+	}
+	return new Map([...sources].map(([id, sessions]) => [id, [...sessions]]));
+}
+//#endregion
+//#region src/knowledge/ordering.ts
+function knowledgeChangedAt(item) {
+	return "holder" in item ? effectiveUpdatedAt(item) : "reporter_agent_id" in item ? item.resolved_at ?? item.created_at : item.created_at;
+}
+function statusOrder(item) {
+	if ("holder" in item) return {
+		active: 0,
+		stale: 1,
+		deprecated: 2
+	}[item.status];
+	return "reporter_agent_id" in item && item.status === "resolved" ? 1 : 0;
+}
+function recentFirst(left, right) {
+	const a = timestampNanos(left);
+	const b = timestampNanos(right);
+	return a === b ? 0 : a > b ? -1 : 1;
+}
+function compareKnowledge(left, right) {
+	return statusOrder(left) - statusOrder(right) || recentFirst(knowledgeChangedAt(left), knowledgeChangedAt(right)) || recentFirst(left.created_at, right.created_at) || left.id.localeCompare(right.id);
+}
+//#endregion
+//#region src/dsh-adapter/source-sessions.ts
+async function sourceSession(ctx, id, signal) {
+	try {
+		const sessionId = SessionId(id);
+		const live = ctx.sessions.get(sessionId);
+		let events;
+		if (live !== void 0) events = live.snapshotEvents();
+		else {
+			const controller = ctx.get("sessionController");
+			const persistence = ctx.get("sessionPersistence");
+			if (controller !== void 0) events = (await controller.inspect(sessionId, signal)).events;
+			else if (persistence !== void 0) {
+				const handle = await persistence.open(sessionId, "read");
+				try {
+					events = (await handle.read()).events;
+				} finally {
+					await handle.close();
+				}
+			} else return {
+				id,
+				available: false
+			};
+		}
+		signal?.throwIfAborted();
+		const latest = [...events].reverse().find((event) => String(event.type) === "session/title");
+		const title = z.object({ title: z.string() }).safeParse(latest?.data);
+		return {
+			id,
+			available: true,
+			...title.success ? { title: title.data.title } : {}
+		};
+	} catch {
+		return {
+			id,
+			available: false
+		};
+	}
+}
+//#endregion
+//#region src/dsh-adapter/interaction-service.ts
+async function checkTeamConnection(ctx, connection, credential = teamCredentials(ctx), signal) {
+	if (!connection.routerEndpoint || !connection.maintainerEndpoint) return {
+		ok: false,
+		message: "单人配置不需要连接检查；请先填写两个团队地址。"
+	};
+	const config = resolveConfig({
+		agentId: connection.agentId,
+		team: {
+			routerEndpoint: connection.routerEndpoint,
+			maintainerEndpoint: connection.maintainerEndpoint,
+			keyEnv: connection.keyEnv,
+			timeoutMs: connection.timeoutMs,
+			retryCount: 0
+		}
+	});
+	if (config.agentId === "") return {
+		ok: false,
+		message: "请先填写 Agent ID。"
+	};
+	const team = new TeamFacade(config.team, config.agentId, ctx.logger, credential);
+	try {
+		const checks = await Promise.all(["maintainer", "router"].map(async (service) => {
+			const bounded = AbortSignal.any([AbortSignal.timeout(Math.min(config.team.timeoutMs, 15e3)), ...signal === void 0 ? [] : [signal]]);
+			try {
+				await team.request(service, async () => {
+					const health = await team[service].health(bounded);
+					if (health.team_auth_enabled && health.auth_passed !== true) throw new JobError("auth", "认证未通过，请检查团队鉴权密钥。");
+					if (service === "router") await team.router.overview(bounded);
+				});
+				return {
+					service,
+					state: "ok",
+					message: "连接与认证通过"
+				};
+			} catch (error) {
+				const reason = bounded.aborted ? bounded.reason instanceof Error && bounded.reason.name === "TimeoutError" ? "timeout" : "cancelled" : error instanceof TeamError ? error.connectionFailure ?? error.kind : error instanceof JobError ? error.kind : "network";
+				const messages = {
+					retryable: "服务暂时不可用，请检查服务状态后重试。",
+					auth: "认证未通过，请检查 Agent ID 和团队鉴权密钥。",
+					timeout: "连接超时，请检查服务状态和网络后重试。",
+					dns: "无法解析服务域名，请检查地址和网络。",
+					unreachable: "无法连接服务，请检查地址、端口和服务是否已启动。",
+					network: "网络连接失败，请检查网络或代理后重试。",
+					protocol: "服务响应不符合 ACN 协议，请联系团队管理员检查服务版本。",
+					client: "服务拒绝了请求，请检查服务地址和访问权限。",
+					cancelled: "检查已取消。"
+				};
+				return {
+					service,
+					state: "failed",
+					message: messages[reason] ?? messages["network"] ?? ""
+				};
+			}
+		}));
+		return {
+			ok: !signal?.aborted && checks.every((item) => item.state === "ok"),
+			message: signal?.aborted ? "检查已取消。" : checks.every((item) => item.state === "ok") ? "团队连接检查通过。" : "部分团队服务不可用；可保存配置并继续本地工作，团队同步前需恢复连接。",
+			checks
+		};
+	} finally {
+		await team.close();
+	}
+}
+async function readKnowledge(pool, key, kind, query, offset, entities = true, activityOptions = {}, filters = {}) {
+	const config = pool.config(key, true);
+	if (config === void 0 || config.agentId === "") throw new JobError("connection", "请选择可用的知识身份。");
+	const knowledge = pool.isBase(key) ? pool.base : new AcnKnowledge(config, pool.ctx.logger);
+	try {
+		const context = knowledge.context();
+		const values = !entities ? [] : kind === "claim" ? await new ClaimStore(context).list() : kind === "dispute" ? await new DisputeStore(context).list() : await new TraceStore(context).list();
+		const pending = await new UploadStore(context).read();
+		const pendingIds = new Set([...pending.claims, ...pending.disputes].map((item) => item.id));
+		const delivered = (await new DeliveryStatusStore(context).read()).delivered;
+		const target = knowledge.team === null ? "" : deliveryTarget(config.team.maintainerEndpoint);
+		const delivery = (item) => {
+			if (pendingIds.has(item.id)) return "pending";
+			const receipt = delivered[`${kind}-${item.id}`];
+			const version = "statement" in item ? claimRevision(item) : "reporter_agent_id" in item ? disputeVersion(item) : "";
+			return target !== "" && receipt?.target === target && receipt.version === version ? "synced" : "local";
+		};
+		const text = query.toLocaleLowerCase();
+		const matching = values.filter((item) => ("holder" in item ? item.holder === context.agentId : "agent" in item ? item.agent === context.agentId : item.reporter_agent_id === context.agentId) && JSON.stringify(item).toLocaleLowerCase().includes(text) && (!filters.status || "status" in item && item.status === filters.status) && (!filters.delivery || filters.delivery === "all" || delivery(item) === filters.delivery)).sort(compareKnowledge);
+		const rows = await allActivities(knowledge, (kind) => pool.supportsJob(key, kind));
+		const page = activityPage(rows, activityOptions);
+		const sessions = /* @__PURE__ */ new Map();
+		const sessionInfo = (id) => {
+			const current = sessions.get(id) ?? sourceSession(pool.ctx, id);
+			sessions.set(id, current);
+			return current;
+		};
+		const sources = entities ? await knowledgeSources(context, matching.slice(offset, offset + 30).map((item) => item.id)) : /* @__PURE__ */ new Map();
+		const items = await Promise.all(matching.slice(offset, offset + 30).map(async (item) => ({
+			kind,
+			id: item.id,
+			name: item.name,
+			status: "status" in item ? String(item.status) : "",
+			detail: JSON.stringify(item, null, 2),
+			summary: ("statement" in item ? item.statement : "summary" in item ? item.summary : item.task).slice(0, 500),
+			updatedAt: knowledgeChangedAt(item),
+			delivery: delivery(item),
+			sources: await Promise.all((sources.get(item.id) ?? []).map(sessionInfo))
+		})));
+		const activities = await Promise.all(page.activities.map(async (item) => item.sessionId === void 0 ? item : {
+			...item,
+			source: await sessionInfo(item.sessionId)
+		}));
+		const issues = rows.filter((item) => item.kind === "delivery" && item.state === "rejected" && item.requiresAttention).length;
+		const attentionCount = pending.claims.length + pending.disputes.length + issues + rows.filter((item) => item.kind !== "delivery" && item.requiresAttention).length;
+		return {
+			key,
+			name: pool.choices().find((item) => item.key === key)?.name ?? key,
+			items,
+			omitted: Math.max(0, matching.length - offset - 30),
+			...page,
+			activities,
+			activityKinds: [...new Set(rows.map((item) => item.kind))],
+			activitySources: [...new Set(rows.flatMap((item) => item.sessionId === void 0 ? [] : [item.sessionId]))],
+			attentionCount,
+			runningCount: rows.filter((item) => item.kind !== "delivery" && (item.state === "queued" || item.state === "running")).length,
+			pendingClaims: pending.claims.length,
+			pendingDisputes: pending.disputes.length
+		};
+	} finally {
+		if (knowledge !== pool.base) await knowledge.team?.close();
+	}
+}
+async function executeInteraction(ctx, input, runtimePool, signal) {
+	const parsed = InteractionRequestSchema.safeParse(input);
+	if (!parsed.success) return {
+		ok: false,
+		message: "请求字段不合法，请重新加载页面。"
+	};
+	const request = parsed.data;
+	const pool = runtimePool ?? ctx.get("acnRuntime");
+	try {
+		if (request.action === "open_directory") {
+			const controller = ctx.get("sessionController");
+			if (controller === void 0 || !controller.canOpenWorkspacePath()) return {
+				ok: false,
+				message: "当前主机无法打开系统文件管理器。"
+			};
+			const path = resolve(expandHomePath(request.path));
+			try {
+				if (!(await stat(path)).isDirectory()) return {
+					ok: false,
+					message: "请选择已有的目录。"
+				};
+			} catch {
+				return {
+					ok: false,
+					message: "目录不存在或无法访问，请检查路径。"
+				};
+			}
+			await controller.openWorkspacePath({ path }, signal ?? AbortSignal.timeout(15e3));
+			return {
+				ok: true,
+				message: ""
+			};
+		}
+		if (pool === void 0) return {
+			ok: false,
+			serviceAvailable: false,
+			message: "知识组件尚未启用，聊天仍可继续。请在插件管理中启用 ACN 知识组件。"
+		};
+		if (request.action === "source_session") {
+			const source = await sourceSession(ctx, request.sessionId, signal);
+			return {
+				ok: source.available,
+				message: source.available ? "" : "来源会话不可用，可能已删除或无法读取。",
+				sourceSession: source
+			};
+		}
+		if (request.action === "check") return await checkTeamConnection(ctx, request.connection, teamCredentials(ctx), signal);
+		if (request.action === "probe") {
+			if (!request.provider || !request.model) return {
+				ok: true,
+				message: "沿用会话模型；首次同步前请先选择聊天模型。"
+			};
+			const bounded = AbortSignal.any([AbortSignal.timeout(2e4), ...signal === void 0 ? [] : [signal]]);
+			bounded.throwIfAborted();
+			const call = await ctx.llm.prepareCall({
+				provider: request.provider,
+				model: request.model,
+				maxTokens: 1024
+			}, bounded);
+			const assembler = new BlockAssembler();
+			for await (const chunk of call.stream({
+				...call.config,
+				system: "Reply with OK.",
+				messages: [createUserMessage({
+					content: [{
+						type: "text",
+						text: "Connection check."
+					}],
+					source: { kind: "acn-formation" }
+				})],
+				signal: bounded
+			})) assembler.push(chunk);
+			bounded.throwIfAborted();
+			if (assembler.finish.kind !== "stop") return {
+				ok: false,
+				message: "模型未正常完成检查，保留原模型。请检查模型配置或重试。"
+			};
+			return {
+				ok: true,
+				message: "知识模型检查通过。"
+			};
+		}
+		if (request.action === "knowledge") return {
+			ok: true,
+			message: "",
+			knowledge: await readKnowledge(pool, request.key, request.kind, request.query, request.offset, true, {}, request)
+		};
+		if (request.action === "reference") {
+			const config = pool.config(request.key, true);
+			if (config === void 0 || !config.agentId) throw new JobError("connection", "请选择可用的知识身份。");
+			const knowledge = pool.isBase(request.key) ? pool.base : new AcnKnowledge(config, ctx.logger);
+			try {
+				const trace = request.id.startsWith("trace_");
+				const item = (trace ? await new TraceStore(knowledge.context()).list() : await new ClaimStore(knowledge.context()).list()).find((value) => value.id === request.id && ("holder" in value ? value.holder : value.agent) === knowledge.agentId);
+				const origins = item === void 0 ? [] : (await knowledgeSources(knowledge.context(), [item.id])).get(item.id) ?? [];
+				const sources = await Promise.all(origins.map((id) => sourceSession(ctx, id, signal)));
+				return {
+					ok: true,
+					message: "",
+					reference: {
+						key: request.key,
+						id: request.id,
+						...item === void 0 ? {} : { item: {
+							kind: trace ? "trace" : "claim",
+							id: item.id,
+							name: item.name,
+							status: "status" in item ? String(item.status) : "",
+							detail: JSON.stringify(item, null, 2),
+							sources
+						} }
+					}
+				};
+			} finally {
+				if (knowledge !== pool.base) await knowledge.team?.close();
+			}
+		}
+		if (request.action === "activity") return {
+			ok: true,
+			message: "",
+			knowledge: await readKnowledge(pool, request.key, "claim", "", 0, false, request)
+		};
+		if (request.action === "ack") {
+			const config = pool.config(request.key, true);
+			if (config === void 0 || !config.agentId) throw new JobError("connection", "知识身份不可用。");
+			const knowledge = pool.isBase(request.key) ? pool.base : new AcnKnowledge(config, ctx.logger);
+			try {
+				const job = await new JobQueue(knowledge.context()).read(request.id);
+				const rejected = job === null ? (await allActivities(knowledge, (kind) => pool.supportsJob(request.key, kind))).find((item) => item.id === request.id && item.state === "rejected") : void 0;
+				if (rejected !== void 0 && rejected.updatedAt === request.version) {
+					await new PresentationStore(knowledge.context()).acknowledge(rejected.id, request.version);
+					return {
+						ok: true,
+						message: "已标记知悉；该争议仍未成功投递。"
+					};
+				}
+				if (job === null || job.updatedAt !== request.version || !["succeeded", "failed"].includes(job.state)) return {
+					ok: false,
+					message: "任务状态已变化，请重新读取。"
+				};
+				await new PresentationStore(knowledge.context()).acknowledge(job.id, job.updatedAt);
+				return {
+					ok: true,
+					message: ""
+				};
+			} finally {
+				if (knowledge !== pool.base) await knowledge.team?.close();
+			}
+		}
+		if (request.action === "retry_delivery" || request.action === "dream_again") {
+			if (pool.config(request.key) === void 0) throw new JobError("connection", "连接已停用或删除，不能重试。");
+			const knowledge = await pool.activate(request.key);
+			if (request.action === "dream_again") {
+				const previous = await knowledge.jobs?.queue.read(request.id);
+				if (previous?.kind !== "dream" || previous.state !== "succeeded") throw new JobError("validation", "请先等待当前 Dream 结束，再重新整理。");
+				const dream = await pool.dreamService(request.key);
+				if (dream === void 0) throw new JobError("handler_inactive", "Dream 组件未启用，请在插件管理中启用后重试。");
+				await dream.request(typeof previous.payload["workspace_root"] === "string" ? previous.payload["workspace_root"] : void 0, previous.sessionId);
+				return {
+					ok: true,
+					message: "已创建新的 Dream 请求，将重新读取当前知识。"
+				};
+			}
+			if (knowledge.team === null) throw new JobError("connection", "单人配置不投递团队知识，请在设置中恢复团队连接。");
+			const report = await new UploadDelivery(knowledge.context(), knowledge.team).deliver(signal);
+			return {
+				ok: report.warnings.length === 0,
+				message: report.warnings.length > 0 ? "团队投递未全部完成，请查看活动中的具体原因。" : report.pendingClaims + report.pendingDisputes > 0 ? "仍有投递正在进行或等待依赖，待投记录已保留。" : "本轮团队投递已完成。"
+			};
+		}
+		if (request.action === "retry") {
+			if (pool.config(request.key) === void 0) throw new JobError("connection", "连接已停用或删除，不能重试。");
+			const knowledge = await pool.activate(request.key);
+			const job = await knowledge.jobs?.queue.read(request.id);
+			if (job !== null && job !== void 0 && !knowledge.jobs?.supports(job.kind)) throw new JobError("handler_inactive", "对应后台组件未启用，请在插件管理中启用后重试。");
+			if (job?.kind === "dream" && job.payload["paused"] === true) {
+				await knowledge.jobs?.queue.pauseDream(false);
+				knowledge.jobs?.wake(true);
+			} else await knowledge.jobs?.retry(request.id);
+			return {
+				ok: true,
+				message: "任务已重新入队。"
+			};
+		}
+		const id = SessionId(request.sessionId);
+		let session = ctx.sessions.get(id);
+		const controller = ctx.get("sessionController");
+		if (session === void 0 && request.action === "session" && controller !== void 0) {
+			const inspection = await controller.inspect(id);
+			return {
+				ok: true,
+				message: "",
+				session: await pool.sessionView(inspection.meta, inspection.events)
+			};
+		}
+		if (session === void 0 && controller !== void 0) {
+			const resolved = await controller.resolveAgent(id);
+			if ("agent" in resolved) session = resolved.agent.session;
+		}
+		if (session === void 0) return {
+			ok: false,
+			message: "会话不可用，请重新打开或新建会话。"
+		};
+		if (request.action === "session") return {
+			ok: true,
+			message: "",
+			session: await pool.sessionView(session.header)
+		};
+		if (request.action === "select") return {
+			ok: true,
+			message: "",
+			session: await pool.select(session.header, request.key)
+		};
+		if (request.action === "cancel") {
+			await pool.cancel(session.header);
+			return {
+				ok: true,
+				message: "",
+				session: await pool.sessionView(session.header)
+			};
+		}
+		if (request.action === "sync") {
+			await pool.sync(session.header);
+			return {
+				ok: true,
+				message: "",
+				session: await pool.sessionView(session.header)
+			};
+		}
+		const services = await pool.service(session.header);
+		const job = await services.formation?.recap(session.id);
+		return {
+			ok: services.formation !== void 0,
+			message: services.formation === void 0 ? "知识形成组件未启用。" : job == null ? "没有可复盘的新增内容。" : "复盘已入队，可在处理活动中查看。"
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: error instanceof JobError ? error.message : "操作未完成。请检查连接、知识模型和本地存储后重试。",
+			...error instanceof JobError ? { messageInfo: messageInfo(error.message, error.kind) } : {}
+		};
+	}
+}
+//#endregion
+//#region src/dsh-adapter/configuration-service.ts
+function configurationRevision(raw) {
+	return createHash("sha256").update(JSON.stringify(raw)).digest("hex");
+}
+var ConfigurationBusy = class extends Error {
+	kind = "configuration_busy";
+};
+var ConfigurationConflict = class extends Error {
+	kind = "configuration_conflict";
+};
+const activeState = 2;
+function entryConfig(entry) {
+	return entry.options.config ?? {};
+}
+async function checkDirectory(path) {
+	let current = path;
+	for (;;) try {
+		if (!(await stat(current)).isDirectory()) throw new ConfigError(["home"]);
+		await access(current, constants.R_OK | constants.W_OK | constants.X_OK);
+		return;
+	} catch (error) {
+		if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") throw new ConfigError(["home"]);
+		const parent = dirname(current);
+		if (parent === current) throw new ConfigError(["home"]);
+		current = parent;
+	}
+}
+var ConfigurationService = class extends TypertRemoteService {
+	pending = 0;
+	mutationTail = Promise.resolve();
+	stagedCredentials = /* @__PURE__ */ new Set();
+	protectCredentials(raw) {
+		const config = resolveConfig(raw);
+		this.stagedCredentials.delete(config.team.keyEnv);
+		for (const item of Object.values(upstreamsOf(config))) this.stagedCredentials.delete(item.keyEnv);
+	}
+	async serialize(operation) {
+		const previous = this.mutationTail;
+		let release;
+		this.mutationTail = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		try {
+			return await operation();
+		} finally {
+			release?.();
+		}
+	}
+	async credential(request, signal) {
+		const result = request.action !== "check" ? await this.serialize(() => this.credentialOperation(request, signal)) : await this.credentialOperation(request, signal);
+		return {
+			...result,
+			messageInfo: result.messageInfo ?? messageInfo(result.message)
+		};
+	}
+	async credentialOperation(request, signal) {
+		const parsed = CredentialRequestSchema.safeParse(request);
+		if (!parsed.success) return {
+			ok: false,
+			message: "请检查团队配置，并填写有效的鉴权密钥。"
+		};
+		if (parsed.data.action === "check") try {
+			const { connection, value } = parsed.data;
+			return await checkTeamConnection(this.ctx, {
+				...connection,
+				keyEnv: connection.keyEnv || "ACN_TEAM_DRAFT"
+			}, () => Promise.resolve(value), signal);
+		} catch {
+			return {
+				ok: false,
+				message: "检查未完成，请核对团队配置后重试。"
+			};
+		}
+		const provider = this.ctx.get("credentials");
+		if (provider === void 0) return {
+			ok: false,
+			message: "当前 DSH 未提供凭据托管，无法在此页保存新密钥。仍可输入临时密钥检查连接；保存新密钥需使用支持凭据托管的 DSH。已有环境变量引用可继续沿用，高级配置方法见插件配置文档。",
+			writable: false
+		};
+		try {
+			const reference = credentialReference(parsed.data.reference);
+			if (parsed.data.action === "discard") {
+				if (!this.stagedCredentials.has(reference)) return {
+					ok: false,
+					message: "密钥已被配置或会话使用，保留现有凭据。"
+				};
+				const config = this.ctx.get("configEditor") === void 0 ? this.ctx.get("acnRuntime")?.base.config : resolveConfig(entryConfig(this.entry()));
+				if (config !== void 0 && (config.team.keyEnv === reference || Object.values(upstreamsOf(config)).some((item) => item.keyEnv === reference)) || this.ctx.agents.list().some((agent) => runningConfiguration(agent.session.header)?.team.keyEnv === reference)) {
+					this.stagedCredentials.delete(reference);
+					return {
+						ok: false,
+						message: "密钥已被配置或会话使用，保留现有凭据。"
+					};
+				}
+				await provider.unset(reference);
+				this.stagedCredentials.delete(reference);
+				return {
+					ok: true,
+					message: ""
+				};
+			}
+			if (parsed.data.action === "store") {
+				const info = await provider.describe(reference);
+				if (!info.writable) return {
+					ok: false,
+					message: "当前密钥存储只读，无法保存新密钥；仍可检查连接，或留空保留现有密钥。",
+					configured: info.configured,
+					writable: false
+				};
+				if (info.configured) return {
+					ok: false,
+					message: "已有密钥引用不能覆盖，请重新输入并保存为新引用。"
+				};
+				await provider.set(reference, parsed.data.value);
+				this.stagedCredentials.add(reference);
+			}
+			const info = await provider.describe(reference);
+			return {
+				ok: true,
+				message: parsed.data.action === "store" ? "凭据已保存到 DSH 托管存储，完成配置保存后，新启动的会话才会采用；已有会话保留原连接。" : "",
+				configured: info.configured,
+				writable: info.writable
+			};
+		} catch {
+			this.ctx.logger.warn("Team credential operation could not complete.");
+			return {
+				ok: false,
+				message: "凭据操作未完成，请检查宿主凭据服务后重试。"
+			};
+		}
+	}
+	async interact(request, signal) {
+		if (this.pending > 0 && [
+			"select",
+			"sync",
+			"retry",
+			"retry_delivery",
+			"dream_again"
+		].includes(request.action)) return Promise.resolve({
+			ok: false,
+			message: configurationBusy
+		});
+		const pool = this.entry().fiber?.ctx.get("acnRuntime");
+		const result = await executeInteraction(pool?.ctx ?? this.ctx, request, pool, signal);
+		return {
+			...result,
+			messageInfo: result.messageInfo ?? messageInfo(result.message),
+			...result.session === void 0 ? {} : { session: {
+				...result.session,
+				messageInfo: messageInfo(result.session.message)
+			} }
+		};
+	}
+	constructor(ctx) {
+		super(ctx, "acnConfiguration");
+		ctx.on("agent/created", () => {
+			if (this.pending > 0) throw new Error(configurationBusy);
+		});
+		ctx.on("agent/pre-step", async (_event, next) => {
+			if (this.pending > 0) throw new Error(configurationBusy);
+			const decision = await next();
+			if (this.pending > 0) throw new Error(configurationBusy);
+			return decision;
+		});
+		ctx.tools.guard((execution) => this.pending > 0 && ["claim", "consult_router"].includes(execution.name) ? configurationBusy : void 0);
+	}
+	checkIdle() {
+		if (this.ctx.agents.list().some((agent) => agent.status === "running") || this.entry().fiber?.ctx.acnRuntime.preparing) throw new ConfigurationBusy();
+	}
+	entry() {
+		const rows = this.ctx.configEditor.entries().filter((entry) => entry.options.id === "acn-knowledge" && entry.options.name === "@ftai/dsh-plugin-acn/knowledge");
+		const entry = rows.length === 1 ? rows[0] : void 0;
+		if (entry === void 0) throw new ConfigError(["acn-knowledge"]);
+		return entry;
+	}
+	async models() {
+		return (await Promise.all(this.ctx.llm.listProviders().map(async (provider) => {
+			try {
+				return (await this.ctx.llm.listModels(provider.id)).map((model) => ({
+					provider: provider.id,
+					providerName: provider.name,
+					id: model.id,
+					name: model.name
+				}));
+			} catch {
+				return [];
+			}
+		}))).flat();
+	}
+	async read() {
+		const models = await this.models();
+		const entry = this.entry();
+		const raw = entryConfig(entry);
+		const values = configurationValues(raw);
+		const config = resolveConfig(raw);
+		const upstreamPending = {};
+		for (const key of Object.keys(upstreamsOf(config))) try {
+			const selected = resolveUpstream(config, key, true);
+			if (selected === void 0) continue;
+			const path = new AgentPaths(agentHomePath(selected.home, selected.agentId)).pendingUploads;
+			const pending = await readYamlOr(path, PendingUploadsSchema, () => PendingUploadsSchema.parse({}));
+			upstreamPending[key] = pending.claims.length + pending.disputes.length + (pending.consolidations?.length ?? 0) + (pending.acknowledgements?.length ?? 0);
+		} catch {
+			upstreamPending[key] = null;
+			this.ctx.logger.warn("Could not read pending counts for an upstream; configuration remains available.");
+		}
+		let dataDirectory = "";
+		try {
+			const selected = config.upstreams === void 0 ? config : resolveUpstream(config, config.upstream);
+			dataDirectory = selected?.agentId ? agentHomePath(selected.home, selected.agentId) : "";
+		} catch {
+			this.ctx.logger.warn("Could not resolve the selected data directory; configuration remains available.");
+		}
+		return {
+			revision: configurationRevision(raw),
+			values,
+			models,
+			active: entry.fiber?.state === activeState,
+			dataDirectory,
+			upstreamPending
+		};
+	}
+	save(request) {
+		return this.serialize(() => this.saveOperation(request));
+	}
+	async saveOperation(request) {
+		const parsed = SaveConfigurationSchema.safeParse(request);
+		if (!parsed.success) return {
+			ok: false,
+			code: "invalid",
+			fields: [...new Set(parsed.error.issues.map((issue) => issue.path.join(".")))]
+		};
+		const { revision, values } = parsed.data;
+		try {
+			const entry = this.entry();
+			this.protectCredentials(entryConfig(entry));
+			if (configurationRevision(entryConfig(entry)) !== revision) return {
+				ok: false,
+				code: "conflict",
+				fields: []
+			};
+			if (values.upstreams === void 0 && values.agentId === "") throw new ConfigError(["agentId"]);
+			if (values.mode === "team" && (!values.routerEndpoint || !values.maintainerEndpoint)) throw new ConfigError(["team"]);
+			const previous = configurationValues(entryConfig(entry));
+			const candidate = resolveConfig(mergeConfiguration(entryConfig(entry), values));
+			const enabled = Object.entries(upstreamsOf(candidate)).filter(([, item]) => item.enabled);
+			if (enabled.flatMap(([key, item]) => [
+				key,
+				item.agentId,
+				item.legacyKey ?? ""
+			]).some((name) => invalidStorageName(name))) return {
+				ok: false,
+				code: "invalid",
+				fields: ["windowsStorageName"]
+			};
+			await checkDirectory(agentHomePath(candidate.home, "example"));
+			for (const [key] of enabled) {
+				const selected = resolveUpstream(candidate, key);
+				if (selected !== void 0) await checkDirectory(agentHomePath(selected.home, selected.agentId));
+			}
+			if (values.upstreams !== void 0 && previous.upstreams === void 0 && (previous.agentId !== "" || (previous.connections?.length ?? 0) > 0)) {
+				const backup = join(dirname(dirname(agentHomePath(previous.home, "example"))), "upstream-migration-v1.yaml");
+				await withFileLock(`${backup}.lock`, async () => {
+					if (await readYamlOr(backup, z.unknown(), () => null) === null) await writeYamlAtomic(backup, entryConfig(entry), z.unknown(), this.ctx.logger);
+				});
+			}
+			if (values.provider !== "" && !(await this.models()).some((model) => model.provider === values.provider && model.id === values.model)) return {
+				ok: false,
+				code: "unavailable",
+				fields: ["llm"]
+			};
+			this.checkIdle();
+			this.pending += 1;
+			let conflict = false;
+			const identity = (value) => value.upstreams !== void 0 || value.agentId === "" ? "" : agentHomePath(value.home, value.agentId);
+			const epoch = () => Math.max(Date.now(), ...this.ctx.agents.list().map((agent) => agent.session.header.createdAt));
+			try {
+				await this.ctx.configEditor.edit(entry, (current) => {
+					if (configurationRevision(current) !== revision) {
+						if (identity(configurationValues(current)) === identity(previous)) throw new ConfigurationConflict();
+						conflict = true;
+						return {
+							...current,
+							sessionEpoch: epoch()
+						};
+					}
+					this.checkIdle();
+					const next = mergeConfiguration(current, values);
+					this.protectCredentials(next);
+					if (values.upstreams === void 0 && identity(previous) !== identity(values)) next.sessionEpoch = epoch();
+					return next;
+				});
+			} finally {
+				this.pending -= 1;
+			}
+			if (conflict) return {
+				ok: false,
+				code: "conflict",
+				fields: []
+			};
+			if (entry.fiber?.state !== activeState) return {
+				ok: false,
+				code: "inactive",
+				fields: []
+			};
+			return {
+				ok: true,
+				snapshot: await this.read()
+			};
+		} catch (error) {
+			if (error instanceof ConfigurationBusy) return {
+				ok: false,
+				code: "busy",
+				fields: []
+			};
+			if (error instanceof ConfigurationConflict) return {
+				ok: false,
+				code: "conflict",
+				fields: []
+			};
+			if (error instanceof ConfigError) return {
+				ok: false,
+				code: "invalid",
+				fields: [...error.fields]
+			};
+			this.ctx.logger.warn("ACN configuration could not be applied through the profile editor.");
+			return {
+				ok: false,
+				code: "persistence",
+				fields: []
+			};
+		}
+	}
+};
+//#endregion
+//#region src/plugins/configuration.ts
+const name = "acn-configuration";
+function apply(ctx) {
+	ctx.inject([
+		"configEditor",
+		"typert",
+		"llm",
+		"agents",
+		"sessions",
+		"tools"
+	], (child) => {
+		child.effect(() => child.typert.register({
+			package: "@ftai/dsh-plugin-acn",
+			face: "host",
+			schemas: [],
+			model: {
+				services: [],
+				events: [],
+				objects: []
+			},
+			invocations: configurationRemote.descriptors
+		}));
+		child.plugin(ConfigurationService);
+	});
+}
+var configuration_default = {
+	name,
+	apply
+};
+//#endregion
+export { apply, configuration_default as default, name };