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

package/lib/plugins/prompt.js

@@ -0,0 +1,102 @@
+import { d as sessionAllowed } from "../session-binding-BQrOGhZI.js";
+import { t as loadPromptRenderer } from "../render-CJaVcKKC.js";
+import { t as isEvidenceAgent } from "../subagent-yJsFxHmH.js";
+import { t as KnowledgeSessions } from "../sessions-C2xuPFQv.js";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+//#region src/plugins/prompt.ts
+const name = "acn-prompt";
+const inject = [
+	"acnKnowledge",
+	"acnRuntime",
+	"systemPrompt",
+	"agents",
+	"sessions"
+];
+async function apply(ctx) {
+	const knowledge = ctx.acnKnowledge;
+	ctx.effect(() => ctx.acnRuntime.component("prompt"));
+	if (!knowledge.configured || knowledge.config.upstreams !== void 0) return;
+	if (!knowledge.active) return;
+	const render = await loadPromptRenderer();
+	const sessions = new KnowledgeSessions(knowledge);
+	const pending = /* @__PURE__ */ new Map();
+	ctx.systemPrompt.section({
+		name: "acn:knowledge",
+		order: 700,
+		interpolate: false,
+		text: ({ agent }) => agent !== void 0 && !sessionAllowed(ctx, knowledge.config, agent.session.header) ? "" : render("knowledge.j2", {
+			agent_id: knowledge.agentId,
+			team: knowledge.mode === "team"
+		})
+	});
+	ctx.systemPrompt.section({
+		name: "acn:claim-catalog",
+		order: 710,
+		interpolate: false,
+		text: ({ agent }) => agent === void 0 || !sessionAllowed(ctx, knowledge.config, agent.session.header) ? "" : sessions.catalog(agent.session.id)
+	});
+	ctx.effect(() => ctx.acnRuntime.registerBaseline((id, fetchOverview) => sessions.freeze(id, "clear", void 0, fetchOverview), (header) => sessionAllowed(ctx, knowledge.config, header) ? {
+		"acn:knowledge": render("knowledge.j2", {
+			agent_id: knowledge.agentId,
+			team: knowledge.mode === "team"
+		}),
+		"acn:claim-catalog": sessions.catalog(header.id)
+	} : {
+		"acn:knowledge": "",
+		"acn:claim-catalog": ""
+	}));
+	ctx.on("agent/created", async ({ agent, source, signal }) => {
+		if (!sessionAllowed(ctx, knowledge.config, agent.session.header) || isEvidenceAgent(agent.session.header)) return;
+		await sessions.freeze(agent.session.id, source, agent.session.header.parentSession, true, signal);
+	});
+	ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
+		if (isEvidenceAgent(agent.session.header) || !sessionAllowed(ctx, knowledge.config, agent.session.header)) return next();
+		const decision = await next();
+		if (decision.kind === "reject") return decision;
+		signal.throwIfAborted();
+		const notice = await sessions.prepare(agent.session.id, signal);
+		signal.throwIfAborted();
+		if (notice === null) return decision;
+		const message = createUserMessage({
+			content: [{
+				type: "text",
+				text: notice.text
+			}],
+			source: { kind: "acn-claim-changes" }
+		});
+		pending.set(message.id, {
+			sessionId: agent.session.id,
+			notice
+		});
+		return {
+			...decision,
+			messages: [...decision.messages, message]
+		};
+	});
+	ctx.on("session/event", (session, event) => {
+		if (event.type !== "user/message" || event.data.source.kind !== "acn-claim-changes") return;
+		const admission = pending.get(event.data.id);
+		if (admission?.sessionId !== session.id) return;
+		pending.delete(event.data.id);
+		sessions.admitted(session.id, admission.notice);
+	});
+	ctx.on("agent/status", ({ agent, status }) => {
+		if (status === "idle") {
+			for (const [id, admission] of pending) if (admission.sessionId === agent.session.id) pending.delete(id);
+		}
+	});
+	ctx.on("agent/disposed", ({ agent }) => {
+		sessions.forget(agent.session.id).catch(() => {
+			knowledge.logger.warn("Could not finish session Claim state cleanup.");
+		});
+	});
+	for (const agent of ctx.agents.list()) if (sessionAllowed(ctx, knowledge.config, agent.session.header) && !isEvidenceAgent(agent.session.header)) await sessions.freeze(agent.session.id, "resume", agent.session.header.parentSession);
+	ctx.effect(() => () => sessions.flush());
+}
+var prompt_default = {
+	name,
+	inject,
+	apply
+};
+//#endregion
+export { apply, prompt_default as default, inject, name };

package/lib/plugins/tools.js

@@ -0,0 +1,280 @@
+import { h as TraceIdSchema, l as ClaimIdSchema, n as ClaimStatusSchema, r as ConfidenceSchema } from "../claim-DOAGe8ZK.js";
+import { n as RevisionConflict, t as KnowledgeError } from "../errors-Bp_2WXBr.js";
+import { S as LockTimeoutError } from "../lock-DbmlKOoX.js";
+import { r as KnowledgeBusy } from "../alignment-CwH0nBf-.js";
+import { t as SessionStateStore } from "../session-state-CYqUhC95.js";
+import { t as TeamError } from "../errors-pPumDOGD.js";
+import { u as runningConfiguration } from "../session-binding-BQrOGhZI.js";
+import { t as toolParameters } from "../tool-schema-3b4gH1zf.js";
+import { n as isSubagent } from "../subagent-yJsFxHmH.js";
+import { t as ClaimUpdateSchema } from "../types-C2ST2Zdg.js";
+import { z } from "zod";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region src/tools/validation.ts
+function validationMessage(error) {
+	return error.issues.slice(0, 8).map((issue) => {
+		return `${issue.path.map(String).filter((part) => /^[a-zA-Z_][a-zA-Z0-9_]{0,63}$|^[0-9]+$/.test(part)).join(".") || "$"}: ${issue.code === "invalid_type" ? `expected ${issue.expected}` : issue.code === "too_small" ? `minimum ${String(issue.minimum)}` : issue.code === "too_big" ? `maximum ${String(issue.maximum)}` : issue.code === "invalid_value" ? `expected ${issue.values.map(String).join(" | ")}` : issue.code === "unrecognized_keys" ? "unexpected fields; use only fields for the selected action" : issue.code === "invalid_format" ? `invalid ${issue.format} format` : "does not match the required action or field rule"}`;
+	}).join("; ");
+}
+//#endregion
+//#region src/tools/claim.ts
+const text = z.string();
+const id = text.describe("claim id for read/update, or trace id for read_trace");
+const offset = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional().describe("list/traces result offset");
+const limit = z.number().int().min(1).max(100).optional().describe("list/traces maximum results").meta({ default: 20 });
+const editableText = text.optional().describe("update only");
+const ClaimToolArgsSchema = z.discriminatedUnion("action", [
+	z.strictObject({
+		action: z.literal("list"),
+		query: text.optional().describe("list only: case-insensitive substring search across name, scope, and statement"),
+		include_deprecated: z.boolean().optional().describe("list only: include deprecated claims so they can be inspected or restored").meta({ default: false }),
+		offset,
+		limit
+	}),
+	z.strictObject({
+		action: z.literal("read"),
+		id
+	}),
+	z.strictObject({
+		action: z.literal("update"),
+		id,
+		expected_revision: text.describe("Required for update; use the exact revision returned by read"),
+		name: editableText,
+		statement: editableText,
+		scope: editableText,
+		evidence_summary: editableText,
+		confidence: ConfidenceSchema.optional().describe("update only"),
+		status: ClaimStatusSchema.optional().describe("update only")
+	}),
+	z.strictObject({
+		action: z.literal("traces"),
+		claim_id: text.optional().describe("traces only: return traces whose inputs or outputs reference this claim"),
+		offset,
+		limit
+	}),
+	z.strictObject({
+		action: z.literal("read_trace"),
+		id,
+		task_offset: offset.describe("read_trace only: character offset into task text"),
+		task_limit: z.number().int().min(1).max(16e3).optional().describe("read_trace only: maximum task characters").meta({ default: 4e3 })
+	})
+]);
+const CLAIM_DESCRIPTION = "List, search, read, or CAS-update this agent's own claims, and inspect the original task traces connected to them. Updates require the revision returned by read and preserve claim identity, holder, creation time, and sources.";
+const optionalFields = /* @__PURE__ */ new Set([
+	"query",
+	"include_deprecated",
+	"offset",
+	"limit",
+	"name",
+	"statement",
+	"scope",
+	"evidence_summary",
+	"confidence",
+	"status",
+	"claim_id",
+	"task_offset",
+	"task_limit"
+]);
+async function executeClaim(knowledge, input, signal) {
+	try {
+		signal?.throwIfAborted();
+		const normalized = typeof input === "object" && input !== null && !Array.isArray(input) ? Object.fromEntries(Object.entries(input).map(([key, value]) => [key, value === null && optionalFields.has(key) ? void 0 : value])) : input;
+		const args = ClaimToolArgsSchema.parse(normalized);
+		switch (args.action) {
+			case "list": return await knowledge.listClaims({
+				...args.query === void 0 ? {} : { query: args.query },
+				...args.include_deprecated === void 0 ? {} : { includeDeprecated: args.include_deprecated },
+				...args.offset === void 0 ? {} : { offset: args.offset },
+				...args.limit === void 0 ? {} : { limit: args.limit }
+			}, signal);
+			case "read": return await knowledge.readClaim(z.object({ id: ClaimIdSchema }).parse({ id: args.id }).id, signal);
+			case "update": {
+				const update = ClaimUpdateSchema.parse(Object.fromEntries(Object.entries(args).filter(([key]) => key !== "action")));
+				return await knowledge.updateClaim(update, signal);
+			}
+			case "traces": return await knowledge.listTraces({
+				...args.claim_id === void 0 ? {} : { claimId: ClaimIdSchema.parse(args.claim_id) },
+				...args.offset === void 0 ? {} : { offset: args.offset },
+				...args.limit === void 0 ? {} : { limit: args.limit }
+			}, signal);
+			case "read_trace": return await knowledge.readTrace(z.object({ id: TraceIdSchema }).parse({ id: args.id }).id, {
+				...args.task_offset === void 0 ? {} : { taskOffset: args.task_offset },
+				...args.task_limit === void 0 ? {} : { taskLimit: args.task_limit }
+			}, signal);
+		}
+	} catch (error) {
+		signal?.throwIfAborted();
+		if (error instanceof KnowledgeBusy || error instanceof LockTimeoutError) return { error: {
+			kind: "knowledge_busy",
+			message: "知识库暂时忙碌，请稍后重试当前知识操作。",
+			retryable: true
+		} };
+		if (error instanceof RevisionConflict) return {
+			conflict: true,
+			current_revision: error.currentRevision
+		};
+		if (error instanceof KnowledgeError) return { error: {
+			kind: error.kind,
+			message: error.message
+		} };
+		if (error instanceof z.ZodError) return { error: {
+			kind: "validation",
+			message: validationMessage(error)
+		} };
+		throw error;
+	}
+}
+//#endregion
+//#region src/tools/consult-router.ts
+const CONSULT_ROUTER_DESCRIPTION = "Consult the team router. Use mode='overview' to list available team claim scopes before choosing a query boundary. Use mode='query' with a non-empty scope to retrieve candidate claims and related disputes. Overview is only a map of available scopes; query returns concrete claim content.";
+const ConsultRouterArgsSchema = z.discriminatedUnion("mode", [z.strictObject({ mode: z.literal("overview") }), z.strictObject({
+	mode: z.literal("query"),
+	scope: z.string().trim().min(1),
+	semantic_query: z.string().trim().nullish()
+})]);
+async function executeConsultRouter(knowledge, args, sessionId, signal) {
+	const parsed = ConsultRouterArgsSchema.safeParse(args);
+	if (!parsed.success) return { error: {
+		kind: "validation",
+		message: validationMessage(parsed.error)
+	} };
+	const team = knowledge.team;
+	if (team === null) return { error: {
+		kind: "unconfigured",
+		message: "Team router is not configured."
+	} };
+	try {
+		if (parsed.data.mode === "overview") return {
+			mode: "overview",
+			available: true,
+			scopes: (await team.request("router", () => team.router.overview(signal))).scopes
+		};
+		const { scope, semantic_query } = parsed.data;
+		const result = await team.request("router", () => team.router.query({
+			scope,
+			semantic_query: semantic_query || null
+		}, signal));
+		signal?.throwIfAborted();
+		const ids = result.candidate_claims.map((claim) => claim.id);
+		await new SessionStateStore(knowledge.context()).update(sessionId, (current) => {
+			const seen = z.array(z.string()).parse(current?.["seenSourceIds"] ?? []);
+			return {
+				...current,
+				schemaVersion: 1,
+				seenSourceIds: [.../* @__PURE__ */ new Set([...seen, ...ids])]
+			};
+		});
+		return {
+			mode: "query",
+			available: true,
+			candidate_claims: result.candidate_claims,
+			disputes: result.disputes
+		};
+	} catch (error) {
+		if (!(error instanceof TeamError)) throw error;
+		return {
+			mode: parsed.data.mode,
+			available: false,
+			error: {
+				kind: error.kind,
+				message: error.message
+			}
+		};
+	}
+}
+//#endregion
+//#region src/dsh-adapter/tools.ts
+function claimTool(knowledge, resolve) {
+	return {
+		...defineTool({
+			name: "claim",
+			description: CLAIM_DESCRIPTION,
+			parameters: { action: {
+				type: "string",
+				required: true,
+				enum: [
+					"list",
+					"read",
+					"update",
+					"traces",
+					"read_trace"
+				]
+			} },
+			output: {
+				schema: { type: "json" },
+				render: (_args, value) => [{
+					type: "text",
+					text: JSON.stringify(value, null, 2)
+				}]
+			},
+			async execute(args, exec) {
+				if (resolve !== void 0 && exec.agent === void 0) return { error: {
+					kind: "ownership",
+					message: "Claim requires an agent session."
+				} };
+				const result = await executeClaim(resolve === void 0 || exec.agent === void 0 ? knowledge : await resolve(exec.agent.session.header), args, exec.signal);
+				const json = JSON.parse(JSON.stringify(result));
+				return z.json().parse(json);
+			}
+		}),
+		parameters: toolParameters(ClaimToolArgsSchema)
+	};
+}
+function consultRouterTool(knowledge, resolve) {
+	return {
+		...defineTool({
+			name: "consult_router",
+			description: CONSULT_ROUTER_DESCRIPTION,
+			parameters: { mode: {
+				type: "string",
+				enum: ["overview", "query"],
+				required: true
+			} },
+			output: {
+				schema: { type: "json" },
+				render: (_args, value) => [{
+					type: "text",
+					text: JSON.stringify(value, null, 2)
+				}]
+			},
+			async execute(args, exec) {
+				if (exec.agent === void 0) throw new Error("consult_router requires an agent session.");
+				const result = await executeConsultRouter(resolve === void 0 ? knowledge : await resolve(exec.agent.session.header), args, exec.agent.session.id, exec.signal);
+				return z.json().parse(JSON.parse(JSON.stringify(result)));
+			}
+		}),
+		parameters: toolParameters(ConsultRouterArgsSchema)
+	};
+}
+//#endregion
+//#region src/plugins/tools.ts
+const name = "acn-tools";
+const inject = [
+	"acnKnowledge",
+	"acnRuntime",
+	"tools"
+];
+function apply(ctx) {
+	if (!ctx.acnKnowledge.configured && ctx.acnKnowledge.config.upstreams === void 0) return;
+	const denied = (exec) => {
+		const args = exec.arguments;
+		return exec.name === "claim" && typeof args === "object" && args !== null && "action" in args && args.action === "update" && exec.agent !== void 0 && isSubagent(exec.agent.session.header) ? "Subagents cannot modify ACN knowledge." : void 0;
+	};
+	ctx.on("tools/pre-execute", (exec, next) => {
+		const reason = denied(exec);
+		return reason === void 0 ? next() : Promise.resolve({
+			kind: "deny",
+			reason
+		});
+	});
+	ctx.tools.guard(denied);
+	ctx.tools.register(claimTool(ctx.acnKnowledge, (header) => ctx.acnRuntime.knowledge(header)));
+	if ((ctx.get("agents")?.list().some((agent) => Boolean(runningConfiguration(agent.session.header)?.team.routerEndpoint)) ?? false) || Object.values(ctx.acnKnowledge.config.upstreams ?? {}).some((item) => item.enabled && item.routerEndpoint) || ctx.acnKnowledge.team !== null || ctx.acnKnowledge.config.connections.some((connection) => connection.enabled)) ctx.tools.register(consultRouterTool(ctx.acnKnowledge, (header) => ctx.acnRuntime.knowledge(header)));
+}
+var tools_default = {
+	name,
+	inject,
+	apply
+};
+//#endregion
+export { apply, tools_default as default, inject, name };

package/lib/policy-DnyHh7Bl.js

@@ -0,0 +1,16 @@
+import { a as TextSchema, c as AgentIdSchema, f as PolicyIdSchema, o as optional, y as TimestampSchema } from "./claim-DOAGe8ZK.js";
+import { z } from "zod";
+//#region src/protocol/policy.ts
+const PolicySchema = z.object({
+	id: PolicyIdSchema,
+	message_type: z.enum(["policy_update", "claim_attribute_update"]).default("policy_update"),
+	name: TextSchema,
+	statement: TextSchema,
+	scope: TextSchema,
+	status: z.enum(["active", "deprecated"]),
+	created_at: TimestampSchema,
+	updated_at: optional(TimestampSchema),
+	target_agents: optional(z.array(AgentIdSchema))
+});
+//#endregion
+export { PolicySchema as t };

package/lib/prepare-DwHZudbA.js

@@ -0,0 +1,134 @@
+import { _ as deriveDisputeId, g as deriveClaimId, i as effectiveUpdatedAt, l as ClaimIdSchema, m as SourceIdSchema, u as DisputeIdSchema, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { d as RecapOutputSchema, u as FormationValidationError } from "./structured-lyQCK-Zk.js";
+import { R as nextClaimUpdateAt } from "./evidence-store-DLFvSuNa.js";
+import { n as validateClaimText } from "./regular-file-BFpqMoub.js";
+//#region src/formation/prepare.ts
+function requireValid(condition, message) {
+	if (!condition) throw new FormationValidationError(message);
+}
+function recapClaimIds(texts) {
+	return [...new Set(texts.flatMap((text) => [...text.matchAll(/(?<![A-Za-z0-9_])claim_[0-9a-f]{8}(?![A-Za-z0-9_])/g)].map((match) => ClaimIdSchema.parse(match[0]))))];
+}
+function prepareFormation(raw, agentId, local, seenSourceIds, now = nowSeconds(), visibility = {}) {
+	const output = RecapOutputSchema.parse(raw);
+	const placeholders = /* @__PURE__ */ new Map();
+	const occupied = new Set([...local, ...visibility.directClaims ?? []].map((claim) => String(claim.id)));
+	function reserve(make) {
+		for (let attempt = 0; attempt < 8; attempt += 1) {
+			const id = make();
+			if (!occupied.has(id)) {
+				occupied.add(id);
+				return id;
+			}
+		}
+		throw new FormationValidationError("生成 ID 冲突，请重试本批复盘。");
+	}
+	output.new_claims.forEach((draft, index) => {
+		requireValid(draft.id === `$new_claim_${index}$`, "new_claims.id 必须是按数组位置递增的占位符。");
+		placeholders.set(draft.id, reserve(() => deriveClaimId(now, draft.name, draft.scope)));
+	});
+	output.new_disputes.forEach((draft, index) => {
+		requireValid(draft.id === `$new_dispute_${index}$`, "new_disputes.id 必须是按数组位置递增的占位符。");
+		placeholders.set(draft.id, reserve(() => deriveDisputeId(now, draft.name, draft.claims, draft.summary)));
+	});
+	const replace = (value) => value.replace(/\$new_(?:claim|dispute)_\d+\$/g, (token) => {
+		const id = placeholders.get(token);
+		requireValid(id !== void 0, "输出含未声明的占位符。");
+		return id;
+	});
+	const resolved = RecapOutputSchema.parse(JSON.parse(JSON.stringify(output), (_key, value) => typeof value === "string" ? replace(value) : value));
+	const visibleClaims = new Set(local.filter((claim) => claim.status !== "deprecated").map((claim) => claim.id));
+	for (const claim of visibility.directClaims ?? []) visibleClaims.add(claim.id);
+	for (const id of visibility.editableDeprecatedIds ?? []) visibleClaims.add(id);
+	const policies = /* @__PURE__ */ new Set();
+	for (const source of seenSourceIds) if (ClaimIdSchema.safeParse(source).success) visibleClaims.add(source);
+	else if (SourceIdSchema.safeParse(source).success) policies.add(source);
+	const sourceClaims = new Set(visibleClaims);
+	for (const claim of [...local.filter((claim) => visibleClaims.has(claim.id)), ...visibility.directClaims ?? []]) for (const source of claim.source_claim_ids) if (source.startsWith("policy_")) policies.add(source);
+	else sourceClaims.add(source);
+	const disputeClaims = new Set(visibleClaims);
+	for (const claim of resolved.new_claims) {
+		sourceClaims.add(claim.id);
+		disputeClaims.add(claim.id);
+	}
+	const warnings = [];
+	const usedClaimIds = [];
+	for (const raw of resolved.used_claim_ids) {
+		const id = ClaimIdSchema.safeParse(raw);
+		requireValid(id.success && visibleClaims.has(id.data), "used_claim_ids 包含不在本次上下文中的合法 Claim ID；请核对来源后重试整批。");
+		if (!usedClaimIds.includes(id.data)) usedClaimIds.push(id.data);
+	}
+	function sources(values, self) {
+		return [...new Set(values.map((value) => {
+			const parsed = SourceIdSchema.safeParse(value);
+			requireValid(parsed.success, "source_claim_ids 必须是合法 Claim 或 Policy ID。");
+			requireValid(value !== self, "source_claim_ids 不得引用自身。");
+			requireValid(value.startsWith("policy_") ? policies.has(value) : sourceClaims.has(value), "source_claim_ids 引用了本轮不可见的来源。");
+			return parsed.data;
+		}))];
+	}
+	const claims = resolved.new_claims.map(({ id: rawId, source_claim_ids, ...draft }) => {
+		validateClaimText({
+			name: draft.name,
+			statement: draft.statement,
+			scope: draft.scope,
+			evidence_summary: draft.evidence_summary
+		});
+		const id = ClaimIdSchema.parse(rawId);
+		return {
+			...draft,
+			id,
+			holder: agentId,
+			status: "active",
+			created_at: now,
+			source_claim_ids: sources(source_claim_ids, id)
+		};
+	});
+	const updated = /* @__PURE__ */ new Set();
+	for (const { id: rawId, source_claim_ids, ...draft } of resolved.updated_claims) {
+		const existing = local.find((claim) => claim.id === rawId);
+		requireValid(existing !== void 0 && existing.holder === agentId && (existing.status !== "deprecated" || visibility.editableDeprecatedIds?.has(existing.id) === true), "updated_claims 只能更新本轮可见且由当前 agent 持有的 Claim。");
+		requireValid(!updated.has(rawId), "updated_claims 含重复 ID。");
+		updated.add(rawId);
+		validateClaimText({
+			name: draft.name,
+			statement: draft.statement,
+			scope: draft.scope,
+			evidence_summary: draft.evidence_summary
+		});
+		claims.push({
+			...existing,
+			...draft,
+			source_claim_ids: sources(source_claim_ids, rawId),
+			updated_at: nextClaimUpdateAt(now, effectiveUpdatedAt(existing))
+		});
+		if (!usedClaimIds.includes(existing.id)) usedClaimIds.push(existing.id);
+	}
+	return {
+		claims,
+		disputes: resolved.new_disputes.map((draft) => {
+			validateClaimText({
+				name: draft.name,
+				summary: draft.summary
+			});
+			const ids = draft.claims.map((raw) => {
+				const id = ClaimIdSchema.safeParse(raw);
+				requireValid(id.success && disputeClaims.has(raw), "Dispute 引用了本轮不可见的 Claim。");
+				return id.data;
+			});
+			requireValid(new Set(ids).size === ids.length, "Dispute 至少引用两条不同的 Claim。");
+			return {
+				...draft,
+				id: DisputeIdSchema.parse(draft.id),
+				claims: ids,
+				reporter_agent_id: agentId,
+				status: "open",
+				created_at: now
+			};
+		}),
+		usedClaimIds,
+		warnings
+	};
+}
+//#endregion
+export { recapClaimIds as n, prepareFormation as t };

package/lib/presentation-BlLjgDjP.js

@@ -0,0 +1,47 @@
+import { c as readYamlOr, l as writeYamlAtomic, n as withFileLock } from "./lock-DbmlKOoX.js";
+import { z } from "zod";
+import { join } from "node:path";
+//#region src/store/presentation.ts
+const Schema = z.object({
+	schemaVersion: z.literal(1),
+	baselineAt: z.number(),
+	seen: z.record(z.string(), z.number())
+});
+var PresentationStore = class {
+	context;
+	path;
+	constructor(context) {
+		this.context = context;
+		this.path = join(context.paths.root, "presentation.yaml");
+	}
+	read() {
+		return readYamlOr(this.path, Schema, () => null);
+	}
+	async initialize() {
+		await withFileLock(`${this.path}.lock`, async () => {
+			if (await this.read() === null) await writeYamlAtomic(this.path, {
+				schemaVersion: 1,
+				baselineAt: Date.now(),
+				seen: {}
+			}, Schema, this.context.logger);
+		});
+	}
+	async acknowledge(id, version) {
+		await withFileLock(`${this.path}.lock`, async () => {
+			const current = await this.read() ?? {
+				schemaVersion: 1,
+				baselineAt: Date.now(),
+				seen: {}
+			};
+			await writeYamlAtomic(this.path, {
+				...current,
+				seen: {
+					...current.seen,
+					[id]: Math.max(version, current.seen[id] ?? 0)
+				}
+			}, Schema, this.context.logger);
+		});
+	}
+};
+//#endregion
+export { PresentationStore as t };

package/lib/protocol.js

@@ -0,0 +1,8 @@
+import { S as timestampNanos, _ as deriveDisputeId, b as normalizeTimestamp, c as AgentIdSchema, d as InboxIdSchema, f as PolicyIdSchema, g as deriveClaimId, h as TraceIdSchema, i as effectiveUpdatedAt, l as ClaimIdSchema, m as SourceIdSchema, n as ClaimStatusSchema, p as ResolutionIdSchema, r as ConfidenceSchema, t as ClaimSchema, u as DisputeIdSchema, v as deriveTraceId, x as nowSeconds, y as TimestampSchema } from "./claim-DOAGe8ZK.js";
+import { n as claimRevision, t as canonicalJson } from "./revision-DeoL_IUN.js";
+import { t as TraceSchema } from "./trace-Da0RnL5R.js";
+import { n as validateAgentReport, t as DisputeSchema } from "./dispute-CtrInHzf.js";
+import { t as PolicySchema } from "./policy-DnyHh7Bl.js";
+import { a as ArbitrationResolutionContextSchema, i as inboxEventAt, n as InboxMessageSchema, o as ClaimAssessmentSchema, r as InboxPullRequestSchema, s as DisputeResolutionSchema, t as InboxAckRequestSchema } from "./inbox-DFtE2fOp.js";
+import { a as AgentQuerySchema, c as RouterQueryResultSchema, i as authRequestSchema, l as ScopeOverviewItemSchema, n as HealthRequestSchema, o as CandidateClaimSchema, r as HealthResponseSchema, s as DisputeRefSchema, t as AuthEnvelopeSchema, u as ScopesOverviewSnapshotSchema } from "./auth-DFI9yowX.js";
+export { AgentIdSchema, AgentQuerySchema, ArbitrationResolutionContextSchema, AuthEnvelopeSchema, CandidateClaimSchema, ClaimAssessmentSchema, ClaimIdSchema, ClaimSchema, ClaimStatusSchema, ConfidenceSchema, DisputeIdSchema, DisputeRefSchema, DisputeResolutionSchema, DisputeSchema, HealthRequestSchema, HealthResponseSchema, InboxAckRequestSchema, InboxIdSchema, InboxMessageSchema, InboxPullRequestSchema, PolicyIdSchema, PolicySchema, ResolutionIdSchema, RouterQueryResultSchema, ScopeOverviewItemSchema, ScopesOverviewSnapshotSchema, SourceIdSchema, TimestampSchema, TraceIdSchema, TraceSchema, authRequestSchema, canonicalJson, claimRevision, deriveClaimId, deriveDisputeId, deriveTraceId, effectiveUpdatedAt, inboxEventAt, normalizeTimestamp, nowSeconds, timestampNanos, validateAgentReport };