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

package/lib/formation-D4LO31WW.js

@@ -0,0 +1,187 @@
+import { t as ClaimSchema } from "./claim-DOAGe8ZK.js";
+import { _ as JobError } from "./lock-DbmlKOoX.js";
+import { t as PolicySchema } from "./policy-DnyHh7Bl.js";
+import { z } from "zod";
+import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
+//#region src/llm/response.ts
+function structuredResponseText(text) {
+	const trimmed = text.trim();
+	if (/^(?:\{|\[|```)/u.test(trimmed)) return text;
+	const end = trimmed.indexOf("</think>");
+	if (end < 0) return text;
+	const candidate = trimmed.slice(end + 8).trim().replace(/^```(?:json)?\s*\n?([\s\S]*?)\n?```$/iu, "$1");
+	try {
+		const value = JSON.parse(candidate);
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) return candidate;
+	} catch {}
+	return text;
+}
+//#endregion
+//#region src/dsh-adapter/llm.ts
+function structuredBackend(ctx) {
+	return async (route, system, input, maxTokens, signal) => {
+		signal.throwIfAborted();
+		const call = await ctx.llm.prepareCall({
+			...route,
+			maxTokens
+		}, signal);
+		const assembler = new BlockAssembler();
+		for await (const chunk of call.stream({
+			...call.config,
+			messages: [createUserMessage({
+				content: [{
+					type: "text",
+					text: input
+				}],
+				source: { kind: "acn-formation" }
+			})],
+			system,
+			signal
+		})) {
+			signal.throwIfAborted();
+			assembler.push(chunk);
+		}
+		signal.throwIfAborted();
+		const finish = assembler.finish;
+		if (finish.kind === "error" || finish.kind === "aborted") {
+			const error = /* @__PURE__ */ new Error("Auxiliary model stream failed.");
+			error.code = finish.failure.code;
+			if (finish.failure.status !== void 0) error.status = finish.failure.status;
+			if (finish.failure.providerRetryAfterMs !== void 0) error.providerRetryAfterMs = finish.failure.providerRetryAfterMs;
+			throw error;
+		}
+		if (finish.kind === "max-tokens") throw new JobError("structured_output_limit", "后台模型输出达到 token 上限（MAX_TOKENS），JSON 可能被截断；请精简输出或提高输出上限。");
+		const blocks = assembler.blocks();
+		if (blocks.some((block) => block.type === "tool-call" || block.type === "image")) throw new JobError("structured_output_content", "后台模型应返回 JSON 文本，不应调用工具或返回附件。");
+		if (finish.kind !== "stop") throw new JobError("structured_output", "后台模型输出未完整结束；请重新提交完整 JSON 对象。");
+		return {
+			text: structuredResponseText(blocks.filter((block) => block.type === "text").map((block) => block.text).join("")),
+			...assembler.usage === void 0 ? {} : { usage: assembler.usage }
+		};
+	};
+}
+//#endregion
+//#region src/dsh-adapter/formation.ts
+function text(blocks) {
+	return blocks.map((block) => block.type === "text" ? block.text : `[${block.type}]`).join("\n");
+}
+function projectedResult(seq, content) {
+	const chars = Array.from(content);
+	return {
+		seq,
+		type: "tool_result",
+		text: content,
+		projection: {
+			truncated: false,
+			original_chars: chars.length,
+			retained_chars: chars.length
+		}
+	};
+}
+function bodySources(value) {
+	if (Array.isArray(value)) return value.flatMap((item) => bodySources(item));
+	if (typeof value !== "object" || value === null) return [];
+	const claim = ClaimSchema.safeParse(value);
+	if (claim.success) return [claim.data.id];
+	const policy = PolicySchema.safeParse(value);
+	if (policy.success) return [policy.data.id];
+	return Object.values(value).flatMap((item) => bodySources(item));
+}
+function projectContent(event) {
+	switch (event.type) {
+		case "request/header": return { route: {
+			provider: event.data.header.config.provider,
+			model: event.data.header.config.model
+		} };
+		case "user/message":
+			if (event.data.source.kind === "acn-claim-changes" || event.surfaceOp !== "append" || "form" in event.data.source && (event.data.source.form === "instructions" || event.data.source.form === "catalog")) return {};
+			return { entry: {
+				seq: event.seq,
+				type: "user",
+				text: text(event.data.content)
+			} };
+		case "assistant/message": return { entry: {
+			seq: event.seq,
+			type: "assistant",
+			text: text(event.data.message.content.filter((block) => block.type === "text"))
+		} };
+		case "tool/call":
+			if (event.data.name.toLowerCase().includes("memory") || event.data.name === "run_code") return { privateCallId: event.data.callId };
+			return { entry: {
+				seq: event.seq,
+				type: "tool_call",
+				text: JSON.stringify({
+					name: event.data.name,
+					arguments: event.data.arguments
+				})
+			} };
+		case "tool/ptc-dispatch-start":
+			if (event.data.name.toLowerCase().includes("memory") || event.data.name === "run_code") return {};
+			return { entry: {
+				seq: event.seq,
+				type: "tool_call",
+				text: JSON.stringify({
+					name: event.data.name,
+					arguments: event.data.arguments
+				})
+			} };
+		case "tool/ptc-dispatch": {
+			if (event.data.name.toLowerCase().includes("memory") || event.data.name === "run_code") return {};
+			const content = text(event.data.content);
+			let seenSourceIds = [];
+			try {
+				seenSourceIds = bodySources(JSON.parse(content));
+			} catch {}
+			return {
+				seenSourceIds,
+				entry: projectedResult(event.seq, content)
+			};
+		}
+		case "tool/result": {
+			const content = text(event.data.message.content);
+			let seenSourceIds = [];
+			try {
+				seenSourceIds = bodySources(JSON.parse(content));
+			} catch {}
+			return {
+				resultCallId: event.data.message.toolCallId,
+				seenSourceIds,
+				entry: projectedResult(event.seq, content)
+			};
+		}
+		default: return {};
+	}
+}
+function projectEvent(event) {
+	const projection = projectContent(event);
+	if (event.type === "turn/start" || event.type === "turn/end") return {
+		...projection,
+		activity: {
+			seq: event.seq,
+			at: event.time,
+			turn: event.type === "turn/start" ? "start" : event.data.reason.kind === "completed" ? "completed" : "ended"
+		}
+	};
+	if (projection.entry !== void 0) return {
+		...projection,
+		activity: {
+			seq: event.seq,
+			at: event.time,
+			...event.type === "user/message" && event.data.source.kind === "user" && event.surfaceOp === "append" ? { human: true } : {}
+		}
+	};
+	return projection;
+}
+const compactionSchema = z.object({
+	type: z.literal("compaction/summary"),
+	data: z.object({
+		shadowedRange: z.object({ end: z.number().int().nonnegative() }),
+		shadowedSeqs: z.array(z.number().int().nonnegative()).optional()
+	})
+});
+function compactionEnd(event) {
+	const parsed = compactionSchema.safeParse(event);
+	return parsed.success ? Math.max(parsed.data.data.shadowedRange.end, ...parsed.data.data.shadowedSeqs ?? []) : void 0;
+}
+//#endregion
+export { projectEvent as n, structuredBackend as r, compactionEnd as t };

package/lib/formation-replay-Bf4TSBiz.js

@@ -0,0 +1,87 @@
+import { _ as JobError } from "./lock-DbmlKOoX.js";
+import { d as sessionAllowed, l as restoreSessionBinding } from "./session-binding-zCSuizHs.js";
+import { n as projectEvent } from "./formation-D4LO31WW.js";
+import { n as isSubagent } from "./subagent-yJsFxHmH.js";
+import { SessionId, pluginRecordOf } from "@deepseek-ai/dsh-session";
+//#region src/dsh-adapter/formation-archive.ts
+async function connectArchives(ctx, formation, owns) {
+	const registry = ctx.workspaceRegistry;
+	const original = registry.archiveSession.bind(registry);
+	const own = Object.getOwnPropertyDescriptor(registry, "archiveSession");
+	const wrapped = async (id, options) => {
+		if (registry.archivedSessionIds.includes(id)) return original.call(registry, id, options);
+		if (owns !== void 0 && !await owns(id)) return original.call(registry, id, options);
+		const session = ctx.sessions.get(id);
+		const upper = session === void 0 ? void 0 : session.seq - 1;
+		const frozen = await formation.beginArchive(id, upper);
+		try {
+			await original.call(registry, id, options);
+		} catch (error) {
+			if (frozen !== null) await formation.cancelArchive(id);
+			throw error;
+		}
+		if (frozen !== null) await formation.archived(id, frozen);
+	};
+	Object.defineProperty(registry, "archiveSession", {
+		configurable: true,
+		writable: true,
+		value: wrapped
+	});
+	ctx.effect(() => () => {
+		if (Object.getOwnPropertyDescriptor(registry, "archiveSession")?.value !== wrapped) return;
+		if (own === void 0) Reflect.deleteProperty(registry, "archiveSession");
+		else Object.defineProperty(registry, "archiveSession", own);
+	});
+	await formation.reconcileArchives(new Set(registry.archivedSessionIds));
+}
+//#endregion
+//#region src/dsh-adapter/formation-replay.ts
+async function readSession(ctx, id) {
+	const sessionId = SessionId(id);
+	const live = ctx.sessions.get(sessionId);
+	if (live !== void 0) return {
+		header: live.header,
+		events: live.snapshotEvents()
+	};
+	const persistence = ctx.get("sessionPersistence");
+	if (persistence === void 0 || await persistence.stat(sessionId) === void 0) return;
+	const handle = await persistence.open(sessionId, "read");
+	try {
+		return {
+			header: handle.header,
+			events: (await handle.read()).events
+		};
+	} finally {
+		await handle.close();
+	}
+}
+function owned(ctx, config, source) {
+	restoreSessionBinding(source.header, source.events);
+	return !isSubagent(source.header) && sessionAllowed(ctx, config, source.header);
+}
+function formationOwnership(ctx, config) {
+	return async (id) => {
+		const source = await readSession(ctx, id);
+		return source !== void 0 && owned(ctx, config, source);
+	};
+}
+function formationReplay(ctx, config) {
+	return async (id) => {
+		const source = await readSession(ctx, id);
+		if (source === void 0) throw new JobError("transcript_source", "Original session storage is unavailable.");
+		if (!owned(ctx, config, source)) throw new JobError("transcript_source", "Original session ownership does not match.");
+		const { events } = source;
+		const binding = events.find((event) => {
+			const record = pluginRecordOf(event);
+			return record?.type === "plugin:acn/session-binding" || record?.type === "plugin:acn/team-selection";
+		});
+		if (binding === void 0) throw new JobError("transcript_source", "Original session ownership is missing.");
+		const workspace = ctx.get("workspaceRegistry");
+		return [...events.filter((event) => event.seq >= binding.seq).map(projectEvent).filter((projection) => Object.keys(projection).length > 0), {
+			sourceSeq: events.at(-1)?.seq ?? -1,
+			...workspace === void 0 ? {} : { sourceArchived: workspace.archivedSessionIds.includes(SessionId(id)) }
+		}];
+	};
+}
+//#endregion
+export { formationReplay as n, connectArchives as r, formationOwnership as t };

package/lib/formation.js

@@ -0,0 +1,9 @@
+import { a as FormationStateSchema, c as TranscriptStore, d as RecapOutputSchema, i as transportError, l as processedThrough, n as resolveRoute, o as RouteSchema, r as structuredCall, s as TranscriptEntrySchema, t as abortable, u as FormationValidationError } from "./structured-C9byFuzm.js";
+import { _ as JobError, b as Preempted, g as DreamYield, h as DreamStopped, v as JobKindSchema, x as jobPriority, y as JobSchema } from "./lock-DbmlKOoX.js";
+import { a as analysisIsStale, c as observeApplied, i as STALE_PLAN_WARNING, l as sameClaim, n as AnalysisReadBoundary, o as claimChanges, r as KnowledgeBusy, s as ensureKnowledgeReady, t as AnalysisChanged } from "./alignment-CwH0nBf-.js";
+import { n as recapClaimIds, t as prepareFormation } from "./prepare-CGXwBEcu.js";
+import { n as FormationStore, t as CheckpointSchema } from "./checkpoint-CPFPOxBM.js";
+import { n as runnableJob, t as JobQueue } from "./queue-M917xHPS.js";
+import { t as DurableWorker } from "./worker-HMGzJFWd.js";
+import { t as AcnFormation } from "./service-C2lXoygJ.js";
+export { AcnFormation, AnalysisChanged, AnalysisReadBoundary, CheckpointSchema, DreamStopped, DreamYield, DurableWorker, FormationStateSchema, FormationStore, FormationValidationError, JobError, JobKindSchema, JobQueue, JobSchema, KnowledgeBusy, Preempted, RecapOutputSchema, RouteSchema, STALE_PLAN_WARNING, TranscriptEntrySchema, TranscriptStore, abortable, analysisIsStale, claimChanges, ensureKnowledgeReady, jobPriority, observeApplied, prepareFormation, processedThrough, recapClaimIds, resolveRoute, runnableJob, sameClaim, structuredCall, transportError };

package/lib/history-DPMHX3ZE.js

@@ -0,0 +1,214 @@
+import { o as optional, t as ClaimSchema } from "./claim-DOAGe8ZK.js";
+import { c as readYamlOr, l as writeYamlAtomic, n as withFileLock, w as hasCode } from "./lock-DbmlKOoX.js";
+import { t as TraceSchema } from "./trace-Da0RnL5R.js";
+import { t as DisputeSchema } from "./dispute-CtrInHzf.js";
+import { z } from "zod";
+import fs from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { parse } from "yaml";
+//#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
+//#region src/store/history.ts
+const Session = z.string().regex(/^[a-zA-Z0-9_-]+$/);
+const Application = z.object({
+	schema_version: z.literal(1),
+	state: z.enum([
+		"prepared",
+		"applied",
+		"cancelled"
+	]),
+	application: z.object({
+		id: z.string().uuid(),
+		agent: z.string(),
+		knowledge: z.object({
+			claims: z.array(ClaimSchema),
+			disputes: z.array(DisputeSchema)
+		}),
+		trace: optional(TraceSchema)
+	})
+});
+const Journal = z.object({
+	schemaVersion: z.literal(1),
+	scope: z.object({
+		upstreamId: z.string(),
+		sessionId: Session
+	}),
+	jobs: z.array(z.object({
+		id: z.string().uuid(),
+		applicationId: z.string().uuid().nullable(),
+		work: z.object({ agentId: z.string() }).nullable(),
+		trigger: z.string(),
+		attempts: z.number().int().nonnegative(),
+		queuedAtMicros: z.number().nonnegative()
+	})),
+	presentationTimes: z.record(z.string(), z.number().nonnegative()).default({})
+});
+const Entity = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("claim"),
+	value: ClaimSchema
+}), z.object({
+	kind: z.literal("dispute"),
+	value: DisputeSchema
+})]);
+const Ledger = z.object({
+	schemaVersion: z.literal(1),
+	scope: z.object({
+		upstream: z.string(),
+		agent: z.string()
+	}),
+	batches: z.array(z.object({
+		applicationId: z.string().uuid(),
+		owner: z.object({ sourceSession: Session }),
+		items: z.array(z.object({
+			entity: Entity,
+			state: z.string(),
+			lastConnectionRevision: optional(z.string()),
+			presentationAtMicros: z.number().nonnegative().default(0)
+		}))
+	}))
+});
+const ConnectionIndex = z.object({ upstreams: z.array(z.object({
+	summary: z.object({
+		id: z.string(),
+		agentId: z.string(),
+		maintainerEndpoint: z.string()
+	}),
+	maintainerRevision: z.string().optional()
+})) });
+async function documents(directory, schema, context) {
+	let names;
+	try {
+		names = await fs.readdir(directory);
+	} catch (error) {
+		if (hasCode(error, "ENOENT")) return [];
+		throw error;
+	}
+	const result = [];
+	for (const name of names.sort()) {
+		if (!name.endsWith(".yaml") || name.includes(".tmp.")) continue;
+		try {
+			const value = schema.safeParse(parse(await fs.readFile(join(directory, name), "utf8")));
+			if (value.success) result.push(value.data);
+			else context.logger.warn("Skipped an invalid historical knowledge record.");
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) continue;
+			context.logger.warn("Could not read a historical knowledge record.");
+		}
+	}
+	return result;
+}
+async function historicalKnowledge(context) {
+	const result = {
+		applications: [],
+		sources: /* @__PURE__ */ new Map(),
+		deliveries: []
+	};
+	const upstreamRoot = dirname(dirname(context.paths.root));
+	const upstreamId = basename(upstreamRoot);
+	const add = (ids, session) => {
+		for (const id of ids) {
+			const sessions = result.sources.get(id) ?? /* @__PURE__ */ new Set();
+			sessions.add(session);
+			result.sources.set(id, sessions);
+		}
+	};
+	const origins = /* @__PURE__ */ new Map();
+	for (const journal of await documents(join(upstreamRoot, "supervisor", "journals"), Journal, context)) {
+		if (journal.scope.upstreamId !== upstreamId) continue;
+		for (const job of journal.jobs) if (job.applicationId !== null && job.work?.agentId === context.agentId) origins.set(job.applicationId, {
+			sessionId: journal.scope.sessionId,
+			trigger: job.trigger,
+			attempts: job.attempts,
+			updatedAt: (journal.presentationTimes[job.id] ?? job.queuedAtMicros) / 1e3
+		});
+	}
+	for (const record of await documents(join(context.paths.root, "applications"), Application, context)) {
+		const { application } = record;
+		if (application.agent !== context.agentId || application.knowledge.claims.some((claim) => claim.holder !== context.agentId) || application.knowledge.disputes.some((dispute) => dispute.reporter_agent_id !== context.agentId) || application.trace && application.trace.agent !== context.agentId) continue;
+		const origin = origins.get(application.id);
+		const entityIds = [
+			...application.knowledge.claims.map((item) => item.id),
+			...application.knowledge.disputes.map((item) => item.id),
+			...application.trace ? [application.trace.id] : []
+		];
+		const times = [
+			...application.knowledge.claims.map((item) => item.updated_at ?? item.created_at),
+			...application.knowledge.disputes.map((item) => item.created_at),
+			...application.trace ? [application.trace.created_at] : []
+		].map(Date.parse);
+		result.applications.push({
+			id: application.id,
+			state: record.state,
+			kind: origin?.trigger === "archive" ? "finalize" : origin === void 0 ? "history" : "recap",
+			attempts: origin?.attempts ?? 0,
+			updatedAt: origin?.updatedAt ?? Math.max(0, ...times),
+			entityIds,
+			claimCount: application.knowledge.claims.length,
+			disputeCount: application.knowledge.disputes.length,
+			traceCount: Number(application.trace !== void 0),
+			...origin === void 0 ? {} : { sessionId: origin.sessionId }
+		});
+		if (origin !== void 0 && record.state === "applied") add(entityIds, origin.sessionId);
+	}
+	try {
+		const connection = ConnectionIndex.parse(JSON.parse(await fs.readFile(join(dirname(dirname(upstreamRoot)), "settings.json"), "utf8"))).upstreams.find((entry) => entry.summary.id === upstreamId && entry.summary.agentId === context.agentId);
+		const ledger = Ledger.parse(parse(await fs.readFile(join(context.paths.uploads, "ledger.yaml"), "utf8")));
+		if (ledger.scope.upstream !== upstreamId || ledger.scope.agent !== context.agentId) return result;
+		for (const batch of ledger.batches) for (const item of batch.items) {
+			if (!(item.entity.kind === "claim" ? item.entity.value.holder === context.agentId : item.entity.value.reporter_agent_id === context.agentId)) continue;
+			add([item.entity.value.id], batch.owner.sourceSession);
+			if (item.state === "delivered" && connection !== void 0 && connection.maintainerRevision !== void 0 && item.lastConnectionRevision === connection.maintainerRevision && connection.summary.maintainerEndpoint) result.deliveries.push({
+				entity: item.entity,
+				endpoint: connection.summary.maintainerEndpoint,
+				updatedAt: item.presentationAtMicros / 1e3,
+				sessionId: batch.owner.sourceSession
+			});
+		}
+	} catch (error) {
+		if (!hasCode(error, "ENOENT")) context.logger.warn("Could not read historical delivery acknowledgements.");
+	}
+	return result;
+}
+//#endregion
+export { PresentationStore as n, historicalKnowledge as t };

package/lib/inbox-2CugZZQm.js

@@ -0,0 +1,188 @@
+import { S as timestampNanos, d as InboxIdSchema, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { C as StoreError, d as removeFile, l as writeYamlAtomic, m as renameFile, n as withFileLock, s as readYaml, w as hasCode } from "./lock-DbmlKOoX.js";
+import { i as inboxEventAt, n as InboxMessageSchema } from "./inbox-DFtE2fOp.js";
+import { randomBytes } from "node:crypto";
+import fs from "node:fs/promises";
+import { join } from "node:path";
+import { isDeepStrictEqual } from "node:util";
+//#region src/store/inbox.ts
+var InboxStore = class {
+	context;
+	processingStaleAfterSecs;
+	constructor(context, processingStaleAfterSecs = 600) {
+		this.context = context;
+		this.processingStaleAfterSecs = processingStaleAfterSecs;
+		if (!Number.isFinite(processingStaleAfterSecs) || processingStaleAfterSecs < 0) throw new StoreError("decode", "Invalid inbox lease timeout.");
+	}
+	locked(action) {
+		return withFileLock(this.context.paths.knowledgeLock, action, { timeoutMs: this.context.lockTimeoutMs });
+	}
+	async names() {
+		try {
+			return (await fs.readdir(this.context.paths.inbox)).filter((name) => name.endsWith(".yaml") && !name.includes(".tmp."));
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return [];
+			throw error;
+		}
+	}
+	leasePath(claimed) {
+		const id = InboxIdSchema.parse(claimed.message.id);
+		if (!claimed.leaseId.startsWith(`${id}.processing.`) || !/^inbox_[0-9a-f]{8}\.processing\.[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*\.yaml$/.test(claimed.leaseId)) throw new StoreError("decode", "Invalid inbox lease identifier.");
+		return join(this.context.paths.inbox, claimed.leaseId);
+	}
+	async exists(path) {
+		try {
+			await fs.access(path);
+			return true;
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return false;
+			throw error;
+		}
+	}
+	async acceptPulled(value) {
+		const message = InboxMessageSchema.parse(value);
+		await this.locked(async () => {
+			const existing = (await this.names()).filter((name) => name === `${message.id}.yaml` || name === `${message.id}.done.yaml` || name.startsWith(`${message.id}.processing.`));
+			if (existing.length === 0) {
+				await writeYamlAtomic(this.context.paths.pendingInbox(message.id), message, InboxMessageSchema, this.context.logger);
+				return;
+			}
+			for (const name of existing) {
+				const actual = await readYaml(join(this.context.paths.inbox, name), InboxMessageSchema);
+				const comparable = (value) => JSON.parse(JSON.stringify({
+					...value,
+					handled_at: void 0
+				}));
+				if (actual.id !== message.id || !isDeepStrictEqual(comparable(actual), comparable(message))) throw new StoreError("conflict", `Inbox snapshot conflict: ${message.id}`);
+			}
+		});
+	}
+	async pending() {
+		const pending = [];
+		for (const name of await this.names()) {
+			if (!/^inbox_[0-9a-f]{8}\.yaml$/.test(name)) continue;
+			const path = join(this.context.paths.inbox, name);
+			const message = await readYaml(path, InboxMessageSchema);
+			if (`${message.id}.yaml` !== name) throw new StoreError("decode", "Inbox ID differs from filename.");
+			if (await this.exists(this.context.paths.doneInbox(message.id))) {
+				await removeFile(path, this.context.logger);
+				continue;
+			}
+			pending.push({
+				message,
+				mtime: (await fs.stat(path)).mtimeMs
+			});
+		}
+		return pending.sort((a, b) => {
+			const first = timestampNanos(inboxEventAt(a.message));
+			const second = timestampNanos(inboxEventAt(b.message));
+			return (first < second ? -1 : first > second ? 1 : 0) || a.mtime - b.mtime || a.message.id.localeCompare(b.message.id);
+		}).map((item) => item.message);
+	}
+	listPending() {
+		return this.locked(() => this.pending());
+	}
+	async hasUnfinished() {
+		return (await this.names()).some((name) => /^inbox_[0-9a-f]{8}(?:\.processing\..+)?\.yaml$/.test(name));
+	}
+	async recoverUnlocked(nowMs, orphaned = false) {
+		let recovered = 0;
+		for (const name of await this.names()) {
+			if (!/^inbox_[0-9a-f]{8}\.processing\..+\.yaml$/.test(name)) continue;
+			const path = join(this.context.paths.inbox, name);
+			if (!orphaned && nowMs - (await fs.stat(path)).mtimeMs < this.processingStaleAfterSecs * 1e3) continue;
+			let message;
+			try {
+				message = await readYaml(path, InboxMessageSchema);
+			} catch (error) {
+				if (error instanceof StoreError && error.kind === "decode") {
+					this.context.logger.warn(`Preserved corrupt inbox lease: ${name}`);
+					continue;
+				}
+				throw error;
+			}
+			if (!name.startsWith(`${message.id}.processing.`)) {
+				this.context.logger.warn(`Preserved mismatched inbox lease: ${name}`);
+				continue;
+			}
+			const pending = this.context.paths.pendingInbox(message.id);
+			if (await this.exists(this.context.paths.doneInbox(message.id)) || await this.exists(pending)) await removeFile(path, this.context.logger);
+			else {
+				await renameFile(path, pending);
+				recovered += 1;
+			}
+		}
+		return recovered;
+	}
+	recoverStale(nowMs = Date.now()) {
+		return this.locked(() => this.recoverUnlocked(nowMs));
+	}
+	recoverOrphans() {
+		return this.locked(() => this.recoverUnlocked(Date.now(), true));
+	}
+	claimPending(limit = 1024) {
+		return this.locked(async () => {
+			await this.recoverUnlocked(Date.now());
+			const result = [];
+			for (const message of (await this.pending()).slice(0, limit)) {
+				const leaseId = `${message.id}.processing.${process.pid}.${randomBytes(8).toString("hex")}.yaml`;
+				const destination = join(this.context.paths.inbox, leaseId);
+				await renameFile(this.context.paths.pendingInbox(message.id), destination);
+				const now = /* @__PURE__ */ new Date();
+				await fs.utimes(destination, now, now);
+				result.push({
+					message,
+					leaseId
+				});
+			}
+			return result;
+		});
+	}
+	async validateSnapshotLocked(message) {
+		const comparable = (value) => ({
+			...value,
+			handled_at: void 0
+		});
+		const names = (await this.names()).filter((name) => name === `${message.id}.yaml` || name === `${message.id}.done.yaml` || name.startsWith(`${message.id}.processing.`));
+		for (const name of names) if (!isDeepStrictEqual(comparable(await readYaml(join(this.context.paths.inbox, name), InboxMessageSchema)), comparable(message))) throw new StoreError("conflict", "Inbox completion snapshot mismatch.");
+		return names;
+	}
+	async completeSnapshotLocked(message) {
+		const names = await this.validateSnapshotLocked(message);
+		if (!names.includes(`${message.id}.done.yaml`)) await writeYamlAtomic(this.context.paths.doneInbox(message.id), {
+			...message,
+			handled_at: nowSeconds()
+		}, InboxMessageSchema, this.context.logger);
+		for (const name of names) if (name !== `${message.id}.done.yaml`) await removeFile(join(this.context.paths.inbox, name), this.context.logger);
+	}
+	complete(claimed) {
+		const path = this.leasePath(claimed);
+		return this.locked(async () => {
+			if (!await this.exists(path)) {
+				if (await this.exists(this.context.paths.doneInbox(claimed.message.id))) return;
+				throw new StoreError("conflict", "Inbox lease is no longer owned by this task.");
+			}
+			const actual = await readYaml(path, InboxMessageSchema);
+			if (actual.id !== claimed.message.id) throw new StoreError("conflict", "Inbox lease snapshot mismatch.");
+			await writeYamlAtomic(this.context.paths.doneInbox(actual.id), {
+				...actual,
+				handled_at: nowSeconds()
+			}, InboxMessageSchema, this.context.logger);
+			await removeFile(path, this.context.logger);
+		});
+	}
+	release(claimed) {
+		const path = this.leasePath(claimed);
+		return this.locked(async () => {
+			if (!await this.exists(path)) return;
+			if (await this.exists(this.context.paths.doneInbox(claimed.message.id))) {
+				await removeFile(path, this.context.logger);
+				return;
+			}
+			const pending = this.context.paths.pendingInbox(claimed.message.id);
+			if (!await this.exists(pending)) await renameFile(path, pending);
+		});
+	}
+};
+//#endregion
+export { InboxStore as t };