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

package/lib/service-BQaszW_v.js

@@ -0,0 +1,344 @@
+import { t as ClaimSchema, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { t as abortable } from "./structured-C9byFuzm.js";
+import { n as validateAgentReport } from "./dispute-CtrInHzf.js";
+import { t as TeamError } from "./errors-pPumDOGD.js";
+import { n as InboxMessageSchema, t as InboxAckRequestSchema } from "./inbox-DFtE2fOp.js";
+import { a as AgentQuerySchema, c as RouterQueryResultSchema, r as HealthResponseSchema, u as ScopesOverviewSnapshotSchema } from "./auth-DFI9yowX.js";
+import { z } from "zod";
+import { setTimeout } from "node:timers/promises";
+import { promisify } from "node:util";
+import { BlockList, isIP } from "node:net";
+import { Agent, EnvHttpProxyAgent, ProxyAgent, fetch } from "undici";
+import { execFile } from "node:child_process";
+//#region src/team/system-proxy.ts
+const run = promisify(execFile);
+const empty = () => ({ exceptions: [] });
+function proxyUrl(host, port) {
+	if (!host || port !== void 0 && (!/^\d+$/.test(port) || Number(port) < 1 || Number(port) > 65535)) return void 0;
+	try {
+		const address = port === void 0 ? host : `${host.includes(":") && !host.startsWith("[") ? `[${host}]` : host}:${port}`;
+		const url = new URL(address.includes("://") ? address : `http://${address}`);
+		return (url.protocol === "http:" || url.protocol === "https:") && url.hostname && !url.username && !url.password ? url.origin : void 0;
+	} catch {
+		return;
+	}
+}
+function parseMacProxy(output) {
+	const values = /* @__PURE__ */ new Map();
+	const exceptions = [];
+	let inExceptions = false;
+	for (const raw of output.split(/\r?\n/)) {
+		const line = raw.trim();
+		if (inExceptions) {
+			if (line === "}") inExceptions = false;
+			else {
+				const m = /^\d+\s*:\s*(.+)$/.exec(line);
+				if (m?.[1]) exceptions.push(m[1].trim());
+			}
+			continue;
+		}
+		if (/^ExceptionsList\s*:\s*<array>\s*\{$/.test(line)) {
+			inExceptions = true;
+			continue;
+		}
+		const pair = /^(\w+)\s*:\s*(.*)$/.exec(line);
+		if (pair?.[1] && pair[2] !== void 0) values.set(pair[1], pair[2].trim());
+	}
+	if (values.get("ProxyAutoConfigEnable") === "1" || values.get("ProxyAutoDiscoveryEnable") === "1") return empty();
+	if (values.get("ExcludeSimpleHostnames") === "1") exceptions.push("<local>");
+	const http = values.get("HTTPEnable") === "1" ? proxyUrl(values.get("HTTPProxy"), values.get("HTTPPort")) : void 0;
+	const https = values.get("HTTPSEnable") === "1" ? proxyUrl(values.get("HTTPSProxy"), values.get("HTTPSPort")) : void 0;
+	return {
+		...http ? { http } : {},
+		...https ? { https } : {},
+		exceptions
+	};
+}
+function parseWindowsProxy(output) {
+	const values = /* @__PURE__ */ new Map();
+	for (const line of output.split(/\r?\n/)) {
+		const m = /^\s*(\w+)\s+REG_\w+\s+(.*)$/.exec(line);
+		if (m?.[1] && m[2] !== void 0) values.set(m[1].toLowerCase(), m[2].trim());
+	}
+	if (values.get("autoconfigurl") || Number(values.get("proxyenable")) !== 1) return empty();
+	const server = values.get("proxyserver") ?? "";
+	let http;
+	let https;
+	if (server.includes("=")) for (const entry of server.split(";")) {
+		const [protocol, address] = entry.split("=", 2).map((part) => part.trim());
+		if (protocol?.toLowerCase() === "http") http = proxyUrl(address);
+		if (protocol?.toLowerCase() === "https") https = proxyUrl(address);
+	}
+	else http = https = proxyUrl(server);
+	return {
+		...http ? { http } : {},
+		...https ? { https } : {},
+		exceptions: (values.get("proxyoverride") ?? "").split(";").filter(Boolean)
+	};
+}
+function bypassSystemProxy(endpoint, exceptions) {
+	const host = endpoint.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+	const port = endpoint.port || (endpoint.protocol === "https:" ? "443" : "80");
+	return exceptions.flatMap((rule) => rule.split(/[,;\s]+/)).some((raw) => {
+		const rule = raw.toLowerCase();
+		if (!rule) return false;
+		if (rule === "*") return true;
+		if (rule === "<local>") return isIP(host) === 0 && !host.includes(".");
+		if (rule.includes("/")) {
+			const [network, prefix] = rule.split("/");
+			if (!network || !prefix) return false;
+			const family = isIP(host);
+			const parts = network.split(".");
+			if (family === 4) while (parts.length < 4) parts.push("0");
+			const address = family === 4 ? parts.join(".") : network;
+			const bits = Number(prefix);
+			if (!family || isIP(address) !== family || !Number.isInteger(bits) || bits < 0 || bits > (family === 4 ? 32 : 128)) return false;
+			const block = new BlockList();
+			const type = family === 4 ? "ipv4" : "ipv6";
+			block.addSubnet(address, bits, type);
+			return block.check(host, type);
+		}
+		const m = /^(\[[^\]]+\]|[^:]+)(?::(\d+))?$/.exec(rule);
+		if (!m?.[1] || m[2] && m[2] !== port) return false;
+		const pattern = m[1].replace(/^\[|\]$/g, "").replace(/^\*?\./, "");
+		if (pattern.includes("*")) return new RegExp(`^${pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`).test(host);
+		return host === pattern || isIP(host) === 0 && host.endsWith(`.${pattern}`);
+	});
+}
+async function systemProxyFor(endpoint) {
+	try {
+		let proxy;
+		if (process.platform === "darwin") proxy = parseMacProxy((await run("/usr/sbin/scutil", ["--proxy"], { timeout: 5e3 })).stdout);
+		else if (process.platform === "win32") proxy = parseWindowsProxy((await run("reg", ["query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"], {
+			timeout: 5e3,
+			windowsHide: true
+		})).stdout);
+		else return void 0;
+		const url = new URL(endpoint);
+		if (bypassSystemProxy(url, [...proxy.exceptions, process.env["no_proxy"] ?? process.env["NO_PROXY"] ?? ""])) return void 0;
+		return url.protocol === "https:" ? proxy.https : proxy.http;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/team/http.ts
+const environmentCredential = (reference) => Promise.resolve(process.env[reference]);
+function connectionFailure(error, timedOut) {
+	if (timedOut) return "timeout";
+	const cause = error instanceof Error && error.cause instanceof Error ? error.cause : error;
+	const code = cause !== null && typeof cause === "object" && "code" in cause ? cause.code : void 0;
+	return code === "ENOTFOUND" || code === "EAI_AGAIN" ? "dns" : code === "ECONNREFUSED" || code === "ENETUNREACH" || code === "EHOSTUNREACH" ? "unreachable" : "network";
+}
+function bypassProxy(endpoint) {
+	const host = new URL(endpoint).hostname.toLowerCase().replace(/^\[|\]$/g, "");
+	return host === "localhost" || host.endsWith(".localhost") || host === "::1" || isIP(host) === 4 && host.startsWith("127.");
+}
+function teamUrl(endpoint, path) {
+	const url = new URL(endpoint);
+	url.pathname = `${url.pathname.replace(/\/+$/, "")}${path}`;
+	url.search = "";
+	url.hash = "";
+	return url.href;
+}
+var TeamHttp = class {
+	service;
+	endpoint;
+	agentId;
+	config;
+	credential;
+	dispatcher;
+	stop = new AbortController();
+	constructor(service, endpoint, agentId, config, credential = environmentCredential) {
+		this.service = service;
+		this.endpoint = endpoint;
+		this.agentId = agentId;
+		this.config = config;
+		this.credential = credential;
+		const hasEnvironmentProxy = [
+			"http_proxy",
+			"HTTP_PROXY",
+			"https_proxy",
+			"HTTPS_PROXY",
+			"all_proxy",
+			"ALL_PROXY"
+		].some((name) => Boolean(process.env[name]?.trim()));
+		const fallback = process.env["all_proxy"] || process.env["ALL_PROXY"];
+		const environment = fallback ? {
+			httpProxy: process.env["http_proxy"] || process.env["HTTP_PROXY"] || fallback,
+			httpsProxy: process.env["https_proxy"] || process.env["HTTPS_PROXY"] || fallback
+		} : {};
+		this.dispatcher = bypassProxy(endpoint) ? Promise.resolve(new Agent()) : hasEnvironmentProxy ? Promise.resolve(new EnvHttpProxyAgent(environment)) : systemProxyFor(endpoint).then((proxy) => proxy ? new ProxyAgent(proxy) : new Agent());
+	}
+	async credentialConfigured() {
+		return this.config.keyEnv !== "" && Boolean(await this.credential(this.config.keyEnv));
+	}
+	async post(path, data, schema, signal) {
+		const operation = `POST ${path}`;
+		for (let attempt = 0;; attempt += 1) {
+			const timeout = AbortSignal.timeout(Math.min(this.config.timeoutMs, 2147483647));
+			const combined = AbortSignal.any([
+				this.stop.signal,
+				timeout,
+				...signal === void 0 ? [] : [signal]
+			]);
+			let failure;
+			try {
+				if (combined.aborted) throw new TeamError(timeout.aborted ? "retryable" : "cancelled", this.service, operation);
+				const key = this.config.keyEnv ? await abortable(this.credential(this.config.keyEnv), combined) ?? "" : "";
+				const response = await fetch(teamUrl(this.endpoint, path), {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					dispatcher: await abortable(this.dispatcher, combined),
+					redirect: "error",
+					signal: combined,
+					body: JSON.stringify({
+						auth: {
+							agent_id: this.agentId,
+							acn_key: key
+						},
+						data
+					})
+				});
+				if (response.ok) {
+					if (schema === void 0) {
+						await response.body?.cancel();
+						return;
+					}
+					let body;
+					try {
+						body = await response.json();
+					} catch (error) {
+						throw new TeamError(error instanceof SyntaxError ? "protocol" : "retryable", this.service, operation, response.status);
+					}
+					const parsed = schema.safeParse(body);
+					if (!parsed.success) throw new TeamError("protocol", this.service, operation, response.status);
+					return parsed.data;
+				}
+				await response.body?.cancel();
+				const status = response.status;
+				failure = new TeamError(status === 401 || this.service === "router" && status === 403 ? "auth" : path === "/inbox/ack" && (status === 404 || status === 405) ? "legacy_route" : status === 408 || status === 429 || status >= 500 ? "retryable" : "client", this.service, operation, status);
+			} catch (error) {
+				if (signal?.aborted && signal.reason instanceof Error && signal.reason.name === "TimeoutError") throw new TeamError("retryable", this.service, operation, void 0, "timeout");
+				if (signal?.aborted || this.stop.signal.aborted) throw new TeamError("cancelled", this.service, operation);
+				failure = error instanceof TeamError ? error : new TeamError("retryable", this.service, operation, void 0, connectionFailure(error, timeout.aborted));
+			}
+			if (failure.kind !== "retryable" || attempt >= this.config.retryCount) throw failure;
+			const backoff = Math.min(this.config.retryMaxDelayMs, this.config.retryBaseDelayMs * 2 ** Math.min(attempt, 16));
+			try {
+				await setTimeout(Math.max(1, Math.min(this.config.retryMaxDelayMs, Math.round(backoff * (.8 + Math.random() * .4)))), void 0, { signal: AbortSignal.any([this.stop.signal, ...signal === void 0 ? [] : [signal]]) });
+			} catch {
+				if (signal?.aborted && signal.reason instanceof Error && signal.reason.name === "TimeoutError") throw new TeamError("retryable", this.service, operation, void 0, "timeout");
+				throw new TeamError("cancelled", this.service, operation);
+			}
+		}
+	}
+	async close() {
+		this.stop.abort();
+		await (await this.dispatcher).destroy();
+	}
+};
+//#endregion
+//#region src/team/router-client.ts
+var RouterClient = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	bounded(signal) {
+		return AbortSignal.any([AbortSignal.timeout(Math.min(this.http.config.routerTimeoutMs, 2147483647)), ...signal === void 0 ? [] : [signal]]);
+	}
+	query(query, signal) {
+		return this.http.post("/claims/query", AgentQuerySchema.parse(query), RouterQueryResultSchema, this.bounded(signal));
+	}
+	overview(signal) {
+		return this.http.post("/claims/scopes/overview", {}, ScopesOverviewSnapshotSchema, this.bounded(signal));
+	}
+	health(signal) {
+		return this.http.post("/health", {}, HealthResponseSchema, signal);
+	}
+};
+//#endregion
+//#region src/team/maintainer-client.ts
+var MaintainerClient = class {
+	http;
+	constructor(http) {
+		this.http = http;
+	}
+	pull(signal) {
+		return this.http.post("/inbox/pull", { agent_id: this.http.agentId }, z.array(InboxMessageSchema), signal);
+	}
+	ack(ids, signal) {
+		return this.http.post("/inbox/ack", InboxAckRequestSchema.parse({
+			agent_id: this.http.agentId,
+			inbox_ids: ids
+		}), void 0, signal);
+	}
+	upload(claim, signal) {
+		return this.http.post("/claims/upload", ClaimSchema.parse(claim), void 0, signal);
+	}
+	report(dispute, signal) {
+		return this.http.post("/disputes/report", validateAgentReport(dispute), void 0, signal);
+	}
+	health(signal) {
+		return this.http.post("/health", {}, HealthResponseSchema, signal);
+	}
+};
+//#endregion
+//#region src/team/service.ts
+var TeamFacade = class {
+	logger;
+	router;
+	maintainer;
+	states = {
+		mode: "team",
+		router: { state: "unknown" },
+		maintainer: { state: "unknown" }
+	};
+	warned = /* @__PURE__ */ new Set();
+	constructor(config, agentId, logger, credential) {
+		this.logger = logger;
+		this.router = new RouterClient(new TeamHttp("router", config.routerEndpoint, agentId, config, credential));
+		this.maintainer = new MaintainerClient(new TeamHttp("maintainer", config.maintainerEndpoint, agentId, config, credential));
+	}
+	status() {
+		return structuredClone(this.states);
+	}
+	async request(service, action) {
+		try {
+			const result = await action();
+			this.states[service] = {
+				state: "ok",
+				at: nowSeconds()
+			};
+			return result;
+		} catch (error) {
+			if (!(error instanceof TeamError)) throw error;
+			if (error.kind === "cancelled") throw error;
+			this.states[service] = {
+				state: "failed",
+				at: nowSeconds(),
+				error: error.message
+			};
+			const warning = error.kind === "auth" ? "auth" : `${service}:${error.kind}`;
+			if (!this.warned.has(warning)) {
+				this.warned.add(warning);
+				this.logger.warn(error.message);
+			}
+			throw error;
+		}
+	}
+	async health(signal) {
+		await Promise.allSettled(["router", "maintainer"].map((service) => this.request(service, async () => {
+			const result = await this[service].health(signal);
+			if (result.team_auth_enabled && result.auth_passed === void 0) throw new TeamError("protocol", service, "POST /health");
+			if (result.team_auth_enabled && result.auth_passed === false) throw new TeamError("auth", service, "POST /health", 401);
+			return result;
+		})));
+	}
+	async close() {
+		await Promise.all([this.router.http.close(), this.maintainer.http.close()]);
+	}
+};
+//#endregion
+export { bypassProxy as a, TeamHttp as i, MaintainerClient as n, teamUrl as o, RouterClient as r, TeamFacade as t };

package/lib/service-BhniAHLo.js

@@ -0,0 +1,305 @@
+import { i as effectiveUpdatedAt, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { d as RecapOutputSchema, n as resolveRoute, r as structuredCall, u as FormationValidationError } from "./structured-C9byFuzm.js";
+import { R as nextClaimUpdateAt } from "./evidence-store-DW7kj20i.js";
+import { _ as JobError } from "./lock-DbmlKOoX.js";
+import { s as ensureKnowledgeReady } from "./alignment-CwH0nBf-.js";
+import { t as TeamError } from "./errors-pPumDOGD.js";
+import { t as UploadDelivery } from "./deliver-C-dmhkfm.js";
+import { t as prepareFormation } from "./prepare-CGXwBEcu.js";
+import { s as DisputeResolutionSchema } from "./inbox-DFtE2fOp.js";
+import { t as InboxStore } from "./inbox-2CugZZQm.js";
+import { n as InboxEffectStore } from "./effects-DX1iy6FM.js";
+//#region src/inbox/prepare.ts
+const InternalizeOutputSchema = RecapOutputSchema.omit({ used_claim_ids: true });
+function valid(condition, message) {
+	if (!condition) throw new FormationValidationError(message);
+}
+const sameSet = (a, b) => new Set(a).size === new Set(b).size && a.every((id) => b.includes(id));
+const resolutionOf = (message) => message.message_type === "claim_attribute_update" ? message.arbitration_resolution : void 0;
+function validateArbitration(message) {
+	const resolution = resolutionOf(message);
+	if (resolution === void 0) return;
+	valid(resolution.dispute_id === resolution.dispute_snapshot.id, "仲裁 dispute_id 与冻结 Dispute 不一致。");
+	valid(resolution.resolution_type !== "unresolved" && resolution.resolution_basis !== "insufficient_evidence", "未解决或证据不足的仲裁不能内化。");
+	const direct = resolution.direct_claim_snapshots.map((claim) => claim.id);
+	const disputed = resolution.dispute_snapshot.claims;
+	valid(new Set(direct).size === direct.length && new Set(disputed).size === disputed.length && sameSet(direct, disputed), "仲裁直接 Claim 快照必须唯一且完整覆盖 Dispute。");
+	const assessed = resolution.claim_assessments?.map((item) => item.claim_id) ?? [];
+	valid(assessed.length === 0 || new Set(assessed).size === assessed.length && sameSet(assessed, direct), "仲裁 assessment 必须唯一且完整覆盖直接 Claim。");
+}
+function inboxContext(agentId, messages, local) {
+	valid(messages.length > 0, "内化批次不能为空。");
+	valid(local.every((claim) => claim.holder === agentId) && new Set(local.map((claim) => claim.id)).size === local.length, "本地 Claim 持有权或 ID 不合法。");
+	for (const message of messages) validateArbitration(message);
+	const first = messages[0];
+	valid(first !== void 0 && messages.every((message) => message.message_type === first.message_type && !(message.message_type === "policy_update" && message.policy.status === "deprecated")), "内化批次类型不一致或含待确定性处理的废弃 Policy。");
+	const directClaims = messages.flatMap((message) => resolutionOf(message)?.direct_claim_snapshots ?? []);
+	const directIds = new Set(directClaims.map((claim) => claim.id));
+	const editable = local.filter((claim) => claim.status !== "deprecated" || directIds.has(claim.id));
+	return {
+		input: first.message_type === "policy_update" ? {
+			agent_id: agentId,
+			inbox_messages: messages,
+			local_claims: editable
+		} : {
+			agent_id: agentId,
+			claim_attribute_updates: messages.map((message) => {
+				const context = resolutionOf(message);
+				if (context === void 0) return {
+					claim_attribute_update: message,
+					conclusion: message.policy.statement,
+					direct_claims: []
+				};
+				return {
+					claim_attribute_update: message,
+					conclusion: context.conclusion,
+					resolution: DisputeResolutionSchema.parse(context),
+					dispute: context.dispute_snapshot,
+					direct_claims: context.direct_claim_snapshots
+				};
+			}),
+			local_claims: editable
+		},
+		editable,
+		directClaims,
+		directIds
+	};
+}
+function semantics(claim) {
+	return JSON.stringify({
+		id: claim.id,
+		name: claim.name,
+		statement: claim.statement,
+		scope: claim.scope,
+		holder: claim.holder,
+		confidence: claim.confidence,
+		status: claim.status,
+		evidence_summary: claim.evidence_summary,
+		source_claim_ids: [...new Set(claim.source_claim_ids)].sort()
+	});
+}
+function repeatsResolved(dispute, messages, local, targets) {
+	return messages.some((message) => {
+		const context = resolutionOf(message);
+		if (context === void 0 || !sameSet(dispute.claims, context.dispute_snapshot.claims)) return false;
+		return context.direct_claim_snapshots.every((before) => {
+			return semantics(targets.find((claim) => claim.id === before.id) ?? local.find((claim) => claim.id === before.id) ?? before) === semantics(before);
+		});
+	});
+}
+function prepareInbox(raw, agentId, messages, local, now = nowSeconds()) {
+	const context = inboxContext(agentId, messages, local);
+	const output = InternalizeOutputSchema.parse(raw);
+	const policyIds = [...new Set(messages.map((message) => message.policy.id))];
+	if (messages[0]?.message_type === "claim_attribute_update") for (const draft of [...output.new_claims, ...output.updated_claims]) {
+		if (policyIds.length === 1 && policyIds[0] !== void 0 && !draft.source_claim_ids.some((source) => policyIds.some((id) => id === source))) draft.source_claim_ids.push(policyIds[0]);
+		valid(draft.source_claim_ids.some((source) => policyIds.some((id) => id === source)), "每条 CAU 变更必须引用真正相关的本批 Policy；多 Policy 批次不能自动归因。");
+	}
+	const prepared = prepareFormation({
+		...output,
+		used_claim_ids: []
+	}, agentId, context.editable, policyIds, now, {
+		directClaims: context.directClaims,
+		editableDeprecatedIds: context.directIds
+	});
+	const final = new Map([
+		...context.directClaims,
+		...local,
+		...prepared.claims
+	].map((claim) => [claim.id, claim]));
+	valid(prepared.disputes.every((dispute) => dispute.claims.every((id) => final.get(id)?.status !== "deprecated")), "新 Dispute 不得引用本批最终状态为 deprecated 的 Claim。");
+	prepared.disputes = prepared.disputes.filter((dispute) => !repeatsResolved(dispute, messages, local, prepared.claims));
+	return prepared;
+}
+//#endregion
+//#region src/inbox/cascade.ts
+function deprecatePolicyClaims(policyId, local, now = nowSeconds()) {
+	return local.filter((claim) => claim.source_claim_ids.includes(policyId)).map((claim) => claim.status === "deprecated" ? claim : {
+		...claim,
+		status: "deprecated",
+		updated_at: nextClaimUpdateAt(now, effectiveUpdatedAt(claim))
+	});
+}
+//#endregion
+//#region src/inbox/sync.ts
+async function syncInbox(context, team, signal) {
+	const report = {
+		pulled: 0,
+		accepted: 0,
+		acknowledged: 0,
+		warnings: []
+	};
+	if (context.mode === "solo" || team === null) return report;
+	let messages;
+	try {
+		messages = await team.request("maintainer", () => team.maintainer.pull(signal));
+	} catch (error) {
+		if (!(error instanceof TeamError)) throw error;
+		report.warnings.push(error.message);
+		return report;
+	}
+	report.pulled = messages.length;
+	const store = new InboxStore(context);
+	const accepted = [];
+	for (const message of messages) {
+		signal?.throwIfAborted();
+		try {
+			await store.acceptPulled(message);
+			if (!accepted.includes(message.id)) accepted.push(message.id);
+		} catch {
+			report.warnings.push("Inbox 快照持久化失败；已保存的前缀仍会确认并处理。");
+			break;
+		}
+	}
+	report.accepted = accepted.length;
+	if (accepted.length > 0) try {
+		await team.request("maintainer", () => team.maintainer.ack(accepted, signal));
+		report.acknowledged = accepted.length;
+	} catch (error) {
+		if (!(error instanceof TeamError)) throw error;
+		report.warnings.push(error.message);
+	}
+	return report;
+}
+//#endregion
+//#region src/inbox/service.ts
+var AcnInbox = class {
+	knowledge;
+	backend;
+	render;
+	unregister;
+	stopping = new AbortController();
+	active = /* @__PURE__ */ new Set();
+	constructor(knowledge, backend, render) {
+		this.knowledge = knowledge;
+		this.backend = backend;
+		this.render = render;
+		if (knowledge.jobs === null) throw new JobError("unconfigured", "请先配置 agentId。");
+		this.unregister = knowledge.jobs.register("inbox", (job, control) => this.track(() => this.run(job, {
+			...control,
+			signal: AbortSignal.any([control.signal, this.stopping.signal])
+		})));
+	}
+	async track(operation) {
+		this.stopping.signal.throwIfAborted();
+		const pending = operation();
+		this.active.add(pending);
+		try {
+			return await pending;
+		} finally {
+			this.active.delete(pending);
+		}
+	}
+	enqueue(synchronize = true, sessionId) {
+		this.stopping.signal.throwIfAborted();
+		if (this.knowledge.jobs === null) throw new JobError("unconfigured", "请先配置 agentId。");
+		return this.knowledge.jobs.enqueue("inbox", { synchronize }, sessionId);
+	}
+	async request(signal, sessionId) {
+		return this.track(async () => {
+			const report = await syncInbox(this.knowledge.context(), this.knowledge.team, signal === void 0 ? this.stopping.signal : AbortSignal.any([signal, this.stopping.signal]));
+			const job = await this.enqueue(false, sessionId);
+			return {
+				...report,
+				pending: (await new InboxStore(this.knowledge.context()).listPending()).length,
+				jobId: job.id
+			};
+		});
+	}
+	async start() {
+		await new InboxEffectStore(this.knowledge.context()).recover();
+		if (await new InboxStore(this.knowledge.context()).hasUnfinished()) await this.enqueue();
+	}
+	async prepare(messages, analysisClaims, job, control) {
+		const first = messages[0];
+		if (first === void 0) throw new JobError("validation", "Inbox 批次为空。");
+		if (first.message_type === "policy_update" && first.policy.status === "deprecated") {
+			const syncClaims = deprecatePolicyClaims(first.policy.id, analysisClaims);
+			return {
+				claims: syncClaims.filter((target) => analysisClaims.some((before) => before.id === target.id && before.status !== "deprecated")),
+				syncClaims,
+				disputes: [],
+				usedClaimIds: [],
+				warnings: []
+			};
+		}
+		const context = inboxContext(this.knowledge.context().agentId, messages, analysisClaims);
+		const route = await resolveRoute(this.knowledge.config.llm, this.knowledge.context());
+		return structuredCall({
+			backend: this.backend,
+			context: this.knowledge.context(),
+			config: this.knowledge.config.llm,
+			route,
+			jobId: job.id,
+			system: this.render(first.message_type === "policy_update" ? "inbox_policy_update_internalize.j2" : "inbox_claim_attribute_update_internalize.j2", {}),
+			input: JSON.stringify(context.input),
+			schema: InternalizeOutputSchema,
+			parse: (value) => prepareInbox(value, this.knowledge.context().agentId, messages, analysisClaims),
+			signal: control.signal
+		});
+	}
+	async run(job, control) {
+		const context = this.knowledge.context();
+		await ensureKnowledgeReady(context.paths.root);
+		await new InboxEffectStore(context).recover();
+		control.signal.throwIfAborted();
+		const sync = job.payload["synchronize"] === false ? {
+			pulled: 0,
+			accepted: 0,
+			acknowledged: 0,
+			warnings: []
+		} : await syncInbox(context, this.knowledge.team, control.signal);
+		await ensureKnowledgeReady(context.paths.root);
+		const store = new InboxStore(context, this.knowledge.config.inbox.processingStaleAfterSecs);
+		await store.recoverOrphans();
+		const claimed = await store.claimPending();
+		let applied = 0;
+		let handled = 0;
+		const entityIds = /* @__PURE__ */ new Set();
+		try {
+			for (let offset = 0; offset < claimed.length;) {
+				const first = claimed[offset];
+				if (first === void 0) break;
+				const batch = [first];
+				offset += 1;
+				if (!(first.message.message_type === "policy_update" && first.message.policy.status === "deprecated")) while (offset < claimed.length) {
+					const next = claimed[offset];
+					if (next === void 0 || next.message.message_type !== first.message.message_type || next.message.message_type === "policy_update" && next.message.policy.status === "deprecated") break;
+					batch.push(next);
+					offset += 1;
+				}
+				control.signal.throwIfAborted();
+				const analysisClaims = (await this.knowledge.snapshot()).claims;
+				const messages = batch.map((item) => item.message);
+				const prepared = await this.prepare(messages, analysisClaims, job, control);
+				const result = await this.knowledge.applyInboxEffect(messages, analysisClaims, prepared, control);
+				control.committed?.();
+				applied += result.applied;
+				handled += messages.length;
+				for (const id of result.entityIds ?? []) entityIds.add(id);
+				control.signal.throwIfAborted();
+			}
+		} finally {
+			for (const item of claimed) await store.release(item);
+		}
+		control.signal.throwIfAborted();
+		const delivery = await new UploadDelivery(context, this.knowledge.team).deliver(control.signal);
+		if ((await store.listPending()).length > 0) await this.enqueue();
+		return {
+			...sync,
+			applied,
+			handled,
+			entityIds: [...entityIds],
+			uploadedClaims: delivery.deliveredClaims,
+			reportedDisputes: delivery.deliveredDisputes,
+			warnings: [...sync.warnings, ...delivery.warnings]
+		};
+	}
+	async close() {
+		this.stopping.abort(new JobError("suspended", "Inbox 已暂停，未完成消息保留。"));
+		this.unregister();
+		await Promise.allSettled([...this.active]);
+	}
+};
+//#endregion
+export { inboxContext as a, InternalizeOutputSchema as i, syncInbox as n, prepareInbox as o, deprecatePolicyClaims as r, validateArbitration as s, AcnInbox as t };