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

package/lib/types/upload/deliver.d.ts

@@ -0,0 +1,15 @@
+import type { StoreContext } from '../store/context.js';
+import type { TeamFacade } from '../team/service.js';
+export interface DeliveryReport {
+    deliveredClaims: number;
+    deliveredDisputes: number;
+    pendingClaims: number;
+    pendingDisputes: number;
+    warnings: string[];
+}
+export declare class UploadDelivery {
+    readonly context: StoreContext;
+    readonly team: TeamFacade | null;
+    constructor(context: StoreContext, team: TeamFacade | null);
+    deliver(signal?: AbortSignal): Promise<DeliveryReport>;
+}

package/lib/types/upload/index.d.ts

@@ -0,0 +1,2 @@
+export * from './deliver.js';
+export * from './scheduler.js';

package/lib/types/upload/scheduler.d.ts

@@ -0,0 +1,19 @@
+import type { AcnKnowledge } from '../knowledge/service.js';
+import { UploadDelivery } from './deliver.js';
+export declare class UploadScheduler {
+    readonly knowledge: AcnKnowledge;
+    private readonly intervalMs;
+    private pending;
+    private requested;
+    private closed;
+    private readonly abort;
+    private timer;
+    private unsubscribe;
+    readonly delivery: UploadDelivery;
+    constructor(knowledge: AcnKnowledge, intervalMs?: number);
+    start(): void;
+    kick(): void;
+    private run;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}

package/lib/types/upstreams.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedConfig } from './config.js';
+export { upstreamsOf } from './config.js';
+export declare function resolveUpstream(config: ResolvedConfig, key: string, includeDisabled?: boolean): ResolvedConfig | undefined;
+export declare function defaultUpstream(config: ResolvedConfig): string;
+export declare function canonicalProjectPath(cwd: string): Promise<string>;

package/lib/types/worker/queue.d.ts

@@ -0,0 +1,17 @@
+import type { StoreContext } from '../store/context.js';
+import type { Job, JobKind } from './types.js';
+export declare function runnableJob(job: Job, kinds: Pick<ReadonlySet<JobKind>, 'has'>, now?: number): boolean;
+export declare class JobQueue {
+    readonly context: StoreContext;
+    constructor(context: StoreContext);
+    list(): Promise<Job[]>;
+    read(id: string): Promise<Job | null>;
+    private write;
+    private locked;
+    enqueue(kind: JobKind, payload: Job['payload'], sessionId?: string): Promise<Job>;
+    recoverRunning(): Promise<void>;
+    claim(kinds: ReadonlySet<JobKind>): Promise<Job | null>;
+    settle(job: Job, state: Job['state'], details?: Partial<Pick<Job, 'lastError' | 'lastErrorKind' | 'nextRunAt' | 'result' | 'attempts'>>): Promise<void>;
+    pauseDream(paused: boolean): Promise<Job[]>;
+    retry(id: string): Promise<Job>;
+}

package/lib/types/worker/types.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const JobKindSchema: z.ZodEnum<{
+    inbox: "inbox";
+    dream: "dream";
+    finalize: "finalize";
+    recap: "recap";
+}>;
+export type JobKind = z.infer<typeof JobKindSchema>;
+export declare const JobSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        inbox: "inbox";
+        dream: "dream";
+        finalize: "finalize";
+        recap: "recap";
+    }>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    payload: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    state: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    attempts: z.ZodNumber;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    ordinal: z.ZodOptional<z.ZodNumber>;
+    nextRunAt: z.ZodOptional<z.ZodNumber>;
+    lastError: z.ZodOptional<z.ZodString>;
+    lastErrorKind: z.ZodOptional<z.ZodString>;
+    result: z.ZodOptional<z.ZodJSONSchema>;
+}, z.core.$strict>;
+export type Job = z.infer<typeof JobSchema>;
+export declare const jobPriority: Record<JobKind, number>;
+export declare class JobError extends Error {
+    readonly kind: string;
+    readonly retryable: boolean;
+    readonly retryAfterMs?: number | undefined;
+    constructor(kind: string, message: string, retryable?: boolean, retryAfterMs?: number | undefined);
+}
+export declare class Preempted extends JobError {
+    constructor();
+}
+export declare class DreamStopped extends JobError {
+    constructor();
+}
+export declare class DreamYield extends JobError {
+    constructor();
+}

package/lib/types/worker/worker.d.ts

@@ -0,0 +1,39 @@
+import type { StoreContext } from '../store/context.js';
+import { JobQueue } from './queue.js';
+import { DreamStopped } from './types.js';
+import type { Job, JobKind } from './types.js';
+export interface JobControl {
+    signal: AbortSignal;
+    prepared(): void;
+    committed?(): void;
+}
+export type JobHandler = (job: Job, control: JobControl) => Promise<Job['result']>;
+export declare class DurableWorker {
+    readonly context: StoreContext;
+    private readonly options;
+    readonly queue: JobQueue;
+    private readonly handlers;
+    private lease;
+    private active;
+    private timer;
+    private ticking;
+    private closed;
+    private started;
+    private nextAcquire;
+    constructor(context: StoreContext, options?: {
+        pollMs?: number;
+        takeoverMs?: number;
+        retryBaseMs?: number;
+        staleMs?: number;
+    });
+    register(kind: JobKind, handler: JobHandler): () => void;
+    supports(kind: JobKind): boolean;
+    canRun(job: Job): boolean;
+    start(): Promise<void>;
+    wake(force?: boolean): void;
+    enqueue(kind: JobKind, payload: Job['payload'], sessionId?: string): Promise<Job>;
+    retry(id: string): Promise<Job>;
+    cancelDream(reason?: DreamStopped): void;
+    private tick;
+    close(): Promise<void>;
+}

package/lib/types-C2ST2Zdg.js

@@ -0,0 +1,17 @@
+import { a as TextSchema, l as ClaimIdSchema, n as ClaimStatusSchema, r as ConfidenceSchema } from "./claim-DOAGe8ZK.js";
+import { z } from "zod";
+//#region src/knowledge/types.ts
+const DEFAULT_TRACE_TASK_PAGE_LIMIT = 4e3;
+const MAX_TRACE_TASK_PAGE_LIMIT = 16e3;
+const ClaimUpdateSchema = z.strictObject({
+	id: ClaimIdSchema,
+	expected_revision: z.string(),
+	name: TextSchema.optional(),
+	statement: TextSchema.optional(),
+	scope: TextSchema.optional(),
+	evidence_summary: TextSchema.optional(),
+	confidence: ConfidenceSchema.optional(),
+	status: ClaimStatusSchema.optional()
+});
+//#endregion
+export { DEFAULT_TRACE_TASK_PAGE_LIMIT as n, MAX_TRACE_TASK_PAGE_LIMIT as r, ClaimUpdateSchema as t };

package/lib/upload.js

@@ -0,0 +1,3 @@
+import { t as UploadDelivery } from "./deliver-BuYQaPRW.js";
+import { t as UploadScheduler } from "./scheduler-MaUEbXr3.js";
+export { UploadDelivery, UploadScheduler };

package/lib/uploads-BCA2p92b.js

@@ -0,0 +1,210 @@
+import { S as timestampNanos, i as effectiveUpdatedAt, l as ClaimIdSchema, t as ClaimSchema, u as DisputeIdSchema, x as nowSeconds, y as TimestampSchema } from "./claim-DOAGe8ZK.js";
+import { n as claimRevision } from "./revision-DeoL_IUN.js";
+import { C as StoreError, c as readYamlOr, d as removeFile, l as writeYamlAtomic, n as withFileLock } from "./lock-DbmlKOoX.js";
+import { l as sameClaim } from "./alignment-CwH0nBf-.js";
+import { t as DisputeSchema } from "./dispute-CtrInHzf.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+//#region src/upload/consolidation.ts
+function relatedIds(groups) {
+	return new Set(groups.flatMap((group) => [group.retired.id, ...group.carriers.map((claim) => claim.id)]));
+}
+function carrierReady(claim, groups, acknowledged, current, visiting) {
+	if (claim.status !== "deprecated" && current.some((value) => sameClaim(value, claim)) && acknowledged.some((value) => sameClaim(value, claim))) return true;
+	if (visiting.has(claim.id)) return false;
+	visiting.add(claim.id);
+	const result = groups.some((group) => sameClaim(group.before, claim) && current.some((value) => sameClaim(value, group.retired)) && group.carriers.length > 0 && group.carriers.every((carrier) => carrierReady(carrier, groups, acknowledged, current, visiting)));
+	visiting.delete(claim.id);
+	return result;
+}
+function consolidationReady(claim, groups, acknowledged, current) {
+	return groups.filter((group) => sameClaim(group.retired, claim)).every((group) => group.carriers.length > 0 && group.carriers.every((carrier) => carrierReady(carrier, groups, acknowledged, current, /* @__PURE__ */ new Set())));
+}
+function pruneDeliveries(groups, acknowledgements, pending) {
+	const keep = new Set(groups.filter((group) => pending.some((claim) => sameClaim(claim, group.retired))));
+	let size = -1;
+	while (size !== keep.size) {
+		size = keep.size;
+		for (const group of keep) for (const carrier of group.carriers) for (const next of groups) if (sameClaim(next.before, carrier)) keep.add(next);
+	}
+	const retained = groups.filter((group) => keep.has(group));
+	const related = relatedIds(retained);
+	return {
+		consolidations: retained,
+		acknowledgements: acknowledgements.filter((claim) => related.has(claim.id))
+	};
+}
+//#endregion
+//#region src/store/rejected-disputes.ts
+const RejectionsSchema = z.record(z.string().regex(/^[0-9a-f]{64}$/), z.object({
+	dispute_id: DisputeIdSchema,
+	status: z.literal(409),
+	attempts: z.number().int().positive().default(1),
+	rejected_at: TimestampSchema
+}));
+const disputeVersion = (dispute) => createHash("sha256").update(JSON.stringify(DisputeSchema.parse(dispute))).digest("hex");
+var RejectedDisputeStore = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	async read(includeHistory = false) {
+		if (this.context.mode === "solo" && !includeHistory) return {};
+		return readYamlOr(this.context.paths.rejectedDisputes, RejectionsSchema, () => ({}));
+	}
+	async contains(dispute) {
+		return Object.hasOwn(await this.read(), disputeVersion(dispute));
+	}
+	async record(dispute, attempts = 1) {
+		if (this.context.mode === "solo") return;
+		await withFileLock(`${this.context.paths.rejectedDisputes}.lock`, async () => {
+			const records = await this.read();
+			const key = disputeVersion(dispute);
+			if (Object.hasOwn(records, key)) return;
+			records[key] = {
+				dispute_id: dispute.id,
+				status: 409,
+				attempts,
+				rejected_at: nowSeconds()
+			};
+			await writeYamlAtomic(this.context.paths.rejectedDisputes, records, RejectionsSchema, this.context.logger);
+		}, { timeoutMs: this.context.lockTimeoutMs });
+	}
+};
+//#endregion
+//#region src/store/uploads.ts
+const ConsolidationDeliverySchema = z.object({
+	before: ClaimSchema,
+	retired: ClaimSchema,
+	carriers: z.array(ClaimSchema)
+});
+const PendingUploadsSchema = z.object({
+	consolidations: z.array(ConsolidationDeliverySchema).default([]).transform((items) => items.length === 0 ? void 0 : items),
+	acknowledgements: z.array(ClaimSchema).default([]).transform((items) => items.length === 0 ? void 0 : items),
+	claims: z.array(ClaimSchema).default([]),
+	durable_claim_ids: z.array(ClaimIdSchema).default([]).transform((items) => items.length === 0 ? void 0 : [...new Set(items)].sort()),
+	disputes: z.array(DisputeSchema).default([])
+});
+var UploadStore = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	async read() {
+		if (this.context.mode === "solo") return PendingUploadsSchema.parse({});
+		return readYamlOr(this.context.paths.pendingUploads, PendingUploadsSchema, () => PendingUploadsSchema.parse({}));
+	}
+	async save(value) {
+		if (this.context.mode === "solo") return;
+		await this.modify(() => PendingUploadsSchema.parse(value));
+	}
+	async persist(value) {
+		if (value.claims.length === 0 && value.disputes.length === 0 && !value.consolidations?.length && !value.acknowledgements?.length) await removeFile(this.context.paths.pendingUploads, this.context.logger);
+		else await writeYamlAtomic(this.context.paths.pendingUploads, value, PendingUploadsSchema, this.context.logger);
+	}
+	async modify(update) {
+		if (this.context.mode === "solo") return;
+		await withFileLock(this.context.paths.pendingUploadsLock, async () => {
+			await this.persist(PendingUploadsSchema.parse(await update(await this.read())));
+		}, { timeoutMs: this.context.lockTimeoutMs });
+	}
+	async enqueue(claims, disputes, durable = false, dependencies = []) {
+		if (this.context.mode === "solo") return;
+		await this.modify(async (pending) => {
+			const rejected = await new RejectedDisputeStore(this.context).read();
+			const byClaim = new Map(pending.claims.map((claim) => [claim.id, claim]));
+			let consolidations = pending.consolidations ?? [];
+			for (const value of claims) {
+				const claim = ClaimSchema.parse(value);
+				const existing = byClaim.get(claim.id);
+				if (existing !== void 0 && timestampNanos(effectiveUpdatedAt(claim)) < timestampNanos(effectiveUpdatedAt(existing))) continue;
+				consolidations = claim.status === "deprecated" ? consolidations.map((group) => group.retired.id === claim.id ? {
+					...group,
+					retired: claim
+				} : group) : consolidations.filter((group) => group.retired.id !== claim.id);
+				byClaim.set(claim.id, claim);
+			}
+			const byDispute = new Map(pending.disputes.map((dispute) => [dispute.id, dispute]));
+			for (const value of disputes) {
+				const dispute = DisputeSchema.parse(value);
+				if (Object.hasOwn(rejected, disputeVersion(dispute))) continue;
+				const existing = byDispute.get(dispute.id);
+				if (existing === void 0 || timestampNanos(dispute.created_at) >= timestampNanos(existing.created_at)) byDispute.set(dispute.id, dispute);
+			}
+			const durableIds = new Set(pending.durable_claim_ids ?? []);
+			if (durable) for (const claim of claims) durableIds.add(claim.id);
+			for (const dependency of dependencies) if (byClaim.get(dependency.retired.id) !== void 0 && sameClaim(byClaim.get(dependency.retired.id) ?? dependency.before, dependency.retired)) {
+				consolidations = consolidations.filter((group) => group.retired.id !== dependency.retired.id);
+				consolidations.push(ConsolidationDeliverySchema.parse(dependency));
+			}
+			return PendingUploadsSchema.parse({
+				...pending,
+				consolidations,
+				claims: [...byClaim.values()].sort((a, b) => a.id.localeCompare(b.id)),
+				durable_claim_ids: [...durableIds].filter((id) => byClaim.has(id)).sort(),
+				disputes: [...byDispute.values()].sort((a, b) => a.id.localeCompare(b.id))
+			});
+		});
+	}
+	async removeDeliveredClaims(delivered) {
+		if (this.context.mode === "solo") return;
+		const revisions = new Map(delivered.map((claim) => [claim.id, claimRevision(claim)]));
+		await this.modify((pending) => {
+			const claims = pending.claims.filter((claim) => revisions.get(claim.id) !== claimRevision(claim));
+			const ids = new Set(claims.map((claim) => claim.id));
+			const acknowledgements = [...pending.acknowledgements ?? []];
+			for (const claim of delivered) {
+				const index = acknowledgements.findIndex((value) => value.id === claim.id);
+				if (index >= 0) acknowledgements.splice(index, 1);
+				acknowledgements.push(claim);
+			}
+			return PendingUploadsSchema.parse({
+				...pending,
+				...pruneDeliveries(pending.consolidations ?? [], acknowledgements, claims),
+				claims,
+				durable_claim_ids: pending.durable_claim_ids?.filter((id) => ids.has(id))
+			});
+		});
+	}
+	async rebind(previous, revised) {
+		if (this.context.mode === "solo") throw new StoreError("conflict", "Team delivery is disabled.");
+		await this.modify((pending) => {
+			const exact = (group, value) => sameClaim(group.before, value.before) && sameClaim(group.retired, value.retired) && group.carriers.length === value.carriers.length && group.carriers.every((claim, index) => value.carriers[index] !== void 0 && sameClaim(claim, value.carriers[index]));
+			if (pending.consolidations?.some((group) => exact(group, revised))) return pending;
+			if (!pending.consolidations?.some((group) => exact(group, previous)) || !pending.claims.some((claim) => sameClaim(claim, previous.retired))) throw new StoreError("conflict", "Consolidation dependency changed; review current versions.");
+			const claims = pending.claims.filter((claim) => !revised.carriers.some((carrier) => carrier.id === claim.id));
+			claims.push(...revised.carriers);
+			return PendingUploadsSchema.parse({
+				...pending,
+				claims,
+				durable_claim_ids: [.../* @__PURE__ */ new Set([...pending.durable_claim_ids ?? [], ...revised.carriers.map((claim) => claim.id)])],
+				consolidations: [...pending.consolidations.filter((group) => group.retired.id !== revised.retired.id), revised]
+			});
+		});
+	}
+	async removeDeliveredDisputes(delivered) {
+		if (this.context.mode === "solo") return;
+		const encoded = new Set(delivered.map((dispute) => JSON.stringify(DisputeSchema.parse(dispute))));
+		await this.modify((pending) => PendingUploadsSchema.parse({
+			...pending,
+			disputes: pending.disputes.filter((dispute) => !encoded.has(JSON.stringify(dispute)))
+		}));
+	}
+	async withdrawPolicy(policyId) {
+		if (this.context.mode === "solo") return;
+		await this.modify((pending) => {
+			const obsolete = (pending.consolidations ?? []).filter((group) => group.before.source_claim_ids.includes(policyId) || group.retired.source_claim_ids.includes(policyId));
+			const obsoleteIds = new Set(obsolete.map((group) => group.retired.id));
+			const carriers = new Set(obsolete.flatMap((group) => group.carriers.map((claim) => claim.id)));
+			const retained = (pending.consolidations ?? []).filter((group) => !obsoleteIds.has(group.retired.id));
+			const stillNeeded = new Set(retained.flatMap((group) => group.carriers.map((claim) => claim.id)));
+			return PendingUploadsSchema.parse({
+				...pending,
+				consolidations: retained,
+				claims: pending.claims.filter((claim) => !carriers.has(claim.id) || stillNeeded.has(claim.id) || pending.durable_claim_ids?.includes(claim.id) || claim.source_claim_ids.some((source) => source === policyId))
+			});
+		});
+	}
+};
+//#endregion
+export { disputeVersion as a, RejectedDisputeStore as i, PendingUploadsSchema as n, consolidationReady as o, UploadStore as r, relatedIds as s, ConsolidationDeliverySchema as t };

package/lib/worker-BBTYP2RE.js

@@ -0,0 +1,185 @@
+import { S as LockTimeoutError, _ as JobError, b as Preempted, g as DreamYield, h as DreamStopped, t as acquireFileLease, x as jobPriority } from "./lock-DbmlKOoX.js";
+import { t as DreamStore } from "./checkpoint-RgcdqifN.js";
+import { n as runnableJob, t as JobQueue } from "./queue-M917xHPS.js";
+//#region src/worker/worker.ts
+var DurableWorker = class {
+	context;
+	options;
+	queue;
+	handlers = /* @__PURE__ */ new Map();
+	lease;
+	active;
+	timer;
+	ticking;
+	closed = false;
+	started = false;
+	nextAcquire = 0;
+	constructor(context, options = {}) {
+		this.context = context;
+		this.options = options;
+		this.queue = new JobQueue(context);
+	}
+	register(kind, handler) {
+		this.handlers.set(kind, handler);
+		this.wake(true);
+		return () => {
+			if (this.handlers.get(kind) !== handler) return;
+			this.handlers.delete(kind);
+			if (this.active?.job.kind === kind && !this.active.prepared) this.active.abort.abort(new JobError("suspended", "后台处理器已暂停，任务保留。"));
+		};
+	}
+	supports(kind) {
+		return this.handlers.has(kind);
+	}
+	canRun(job) {
+		return runnableJob(job, this.handlers);
+	}
+	async start() {
+		if (this.started || this.closed) return;
+		this.started = true;
+		this.timer = setInterval(() => {
+			this.wake();
+		}, this.options.pollMs ?? 1e3);
+		this.timer.unref();
+		this.wake();
+		await Promise.resolve();
+	}
+	wake(force = false) {
+		if (!this.started || this.closed || this.ticking !== void 0) return;
+		if (force) this.nextAcquire = 0;
+		const tick = this.tick().catch(() => {
+			this.context.logger.warn("Background worker could not read or commit its local queue.");
+		});
+		this.ticking = tick;
+		tick.finally(() => {
+			if (this.ticking === tick) this.ticking = void 0;
+		});
+	}
+	async enqueue(kind, payload, sessionId) {
+		const job = await this.queue.enqueue(kind, payload, sessionId);
+		if (this.canRun(job) && this.active?.job.kind === "dream" && !this.active.prepared && jobPriority[kind] < jobPriority.dream) this.active.abort.abort(new DreamYield());
+		if (this.canRun(job) && kind === "finalize" && this.active?.job.kind === "recap" && this.active.job.sessionId === sessionId && !this.active.prepared) this.active.abort.abort(new Preempted());
+		this.wake(true);
+		return job;
+	}
+	async retry(id) {
+		const job = await this.queue.retry(id);
+		this.wake(true);
+		return job;
+	}
+	cancelDream(reason = new DreamStopped()) {
+		if (this.active?.job.kind === "dream") this.active.abort.abort(reason);
+	}
+	async tick() {
+		if (this.lease === void 0) {
+			if (Date.now() < this.nextAcquire) return;
+			try {
+				this.lease = await acquireFileLease(this.context.paths.workerLock, {
+					timeoutMs: 0,
+					staleMs: this.options.staleMs
+				});
+				await this.queue.recoverRunning();
+			} catch (error) {
+				if (this.lease !== void 0) {
+					await this.lease.release();
+					this.lease = void 0;
+				}
+				this.nextAcquire = Date.now() + (this.options.takeoverMs ?? 6e4);
+				if (!(error instanceof LockTimeoutError)) throw error;
+				return;
+			}
+		}
+		while (!this.closed) {
+			this.lease.check();
+			await new DreamStore(this.context).recover();
+			const job = await this.queue.claim(new Set(this.handlers.keys()));
+			if (job === null) return;
+			const handler = this.handlers.get(job.kind);
+			if (handler === void 0) {
+				await this.queue.settle(job, "queued");
+				return;
+			}
+			const active = {
+				job,
+				abort: new AbortController(),
+				prepared: false
+			};
+			this.active = active;
+			let checking = false;
+			const monitor = setInterval(() => {
+				if (checking || active.prepared || job.kind !== "recap" && job.kind !== "dream") return;
+				checking = true;
+				this.queue.list().then((jobs) => {
+					if (job.kind === "recap" && jobs.some((candidate) => candidate.kind === "finalize" && candidate.sessionId === job.sessionId && this.canRun(candidate))) active.abort.abort(new Preempted());
+					if (job.kind === "dream" && jobs.some((candidate) => candidate.id === job.id && candidate.payload["paused"] === true)) active.abort.abort(new DreamStopped());
+					if (job.kind === "dream" && jobs.some((candidate) => this.canRun(candidate) && jobPriority[candidate.kind] < jobPriority.dream)) active.abort.abort(new DreamYield());
+				}).catch(() => {
+					active.abort.abort(new JobError("storage", "Cannot inspect preemption queue."));
+				}).finally(() => {
+					checking = false;
+				});
+			}, this.options.pollMs ?? 1e3);
+			monitor.unref();
+			try {
+				const result = await handler(job, {
+					signal: active.abort.signal,
+					prepared: () => {
+						active.prepared = true;
+					},
+					committed: () => {
+						active.prepared = false;
+					}
+				});
+				this.lease.check();
+				await this.queue.settle(job, "succeeded", result === void 0 ? {} : { result });
+			} catch (error) {
+				const reason = active.abort.signal.aborted ? active.abort.signal.reason : error;
+				if (active.prepared) await this.queue.settle(job, job.attempts < 5 ? "queued" : "failed", {
+					lastErrorKind: "storage",
+					lastError: "本地提交待 checkpoint 恢复；请检查存储后重试任务。",
+					nextRunAt: Date.now() + 1e3
+				});
+				else if (reason instanceof DreamStopped || reason instanceof DreamYield) await this.queue.settle(job, "queued", { attempts: Math.max(0, job.attempts - 1) });
+				else if (this.closed || reason instanceof JobError && reason.kind === "suspended") await this.queue.settle(job, "queued");
+				else if (reason instanceof Preempted) await this.queue.settle(job, "succeeded", { result: { skipped: "superseded" } });
+				else {
+					const retryable = reason instanceof JobError && reason.retryable && job.attempts < 5;
+					await this.queue.settle(job, retryable ? "queued" : "failed", {
+						lastErrorKind: reason instanceof JobError ? reason.kind : "storage",
+						lastError: reason instanceof JobError ? reason.message + (reason.retryable && !retryable ? " 已达到自动重试上限，请修正原因后手动重试任务。" : "") : "后台任务失败；请检查本地存储和模型路由后重试。",
+						...retryable ? { nextRunAt: Date.now() + Math.max((this.options.retryBaseMs ?? 500) * 2 ** (job.attempts - 1), reason instanceof JobError ? reason.retryAfterMs ?? 0 : 0) } : {}
+					});
+				}
+			} finally {
+				clearInterval(monitor);
+				this.active = void 0;
+			}
+		}
+	}
+	async close() {
+		this.closed = true;
+		if (this.timer !== void 0) clearInterval(this.timer);
+		this.active?.abort.abort(new JobError("disposed", "Worker disposed."));
+		const finish = async () => {
+			await this.ticking;
+			if (this.lease !== void 0) {
+				await this.lease.release();
+				this.lease = void 0;
+			}
+		};
+		const completion = finish();
+		let timer;
+		await Promise.race([completion, new Promise((resolve) => {
+			timer = setTimeout(() => {
+				this.context.logger.warn("Worker is still reaching a safe point; lease retained until completion.");
+				resolve();
+			}, 1e4);
+		})]);
+		if (timer !== void 0) clearTimeout(timer);
+		completion.catch(() => {
+			this.context.logger.warn("Worker lease cleanup failed.");
+		});
+	}
+};
+//#endregion
+export { DurableWorker as t };

package/locale/commands/en.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN Commands","description":"Inspect and import knowledge, check and retry jobs, and control background work."}}

package/locale/commands/zh.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN 管理命令","description":"提供知识查询、导入、任务状态、重试和后台处理命令。"}}

package/locale/dream/en.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN Dream","description":"Clean up and consolidate knowledge, with optional bounded evidence calibration."}}

package/locale/dream/zh.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN 知识整理","description":"清理与整合已有知识，可选启用受限证据校准。"}}

package/locale/en.json

@@ -0,0 +1,7 @@
+{
+  "meta": {
+    "title": "agent-claim-network",
+    "description": "Distill reusable knowledge from agent work traces, and let experience flow across your team.",
+    "detail": "README_EN.md"
+  }
+}

package/locale/formation/en.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN Knowledge Formation","description":"Extract reusable knowledge from task records through Recap and Finalize."}}

package/locale/formation/zh.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN 知识形成","description":"通过 Recap 与 Finalize 从任务记录中提炼可复用知识。"}}

package/locale/inbox/en.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN Team Inbox","description":"Pull team suggestions, internalize them locally, and deliver results reliably."}}

package/locale/inbox/zh.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN 团队收件箱","description":"拉取团队建议，在本地复核内化并可靠投递结果。"}}

package/locale/knowledge/en.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN Knowledge Store","description":"Manage local Claims, Traces, durable jobs, and team connections."}}

package/locale/knowledge/zh.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN 知识存储","description":"管理本地 Claim、Trace、持久任务与团队连接。"}}

package/locale/prompt/en.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN Knowledge Context","description":"Freeze session knowledge catalogs and surface sources and changes."}}

package/locale/prompt/zh.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN 知识上下文","description":"为会话冻结知识目录，提示可引用来源与知识变化。"}}

package/locale/tools/en.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN Knowledge Tools","description":"Read and edit Claims, inspect Traces, and consult the team Router."}}

package/locale/tools/zh.json

@@ -0,0 +1 @@
+{"meta":{"title":"ACN 知识工具","description":"读取和编辑 Claim、查看 Trace，并查询团队 Router。"}}

package/locale/zh.json

@@ -0,0 +1,7 @@
+{
+  "meta": {
+    "title": "ACN记忆框架",
+    "description": "从agent工作轨迹中沉淀可复用的知识，让知识经验在团队中流动",
+    "detail": "README.md"
+  }
+}