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

package/lib/upstreams-DEi-56tD.js

@@ -0,0 +1,495 @@
+import { S as timestampNanos, i as effectiveUpdatedAt, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { R as nextClaimUpdateAt } from "./evidence-store-DW7kj20i.js";
+import { n as claimRevision } from "./revision-DeoL_IUN.js";
+import { n as RevisionConflict, t as KnowledgeError } from "./errors-Bp_2WXBr.js";
+import { n as validateClaimText } from "./regular-file-BFpqMoub.js";
+import { C as StoreError, S as LockTimeoutError, d as removeFile, f as writeTextAtomic, n as withFileLock, u as cleanupAtomicTemps, w as hasCode } from "./lock-DbmlKOoX.js";
+import { n as AnalysisReadBoundary, r as KnowledgeBusy } from "./alignment-CwH0nBf-.js";
+import { i as ClaimStore } from "./reported-sets-DdEKdeVb.js";
+import { t as TraceStore } from "./traces-CHBo8y1z.js";
+import { r as UploadStore } from "./uploads-BCA2p92b.js";
+import { t as DreamStore } from "./checkpoint-c7aI4D-X.js";
+import { C as resolveConfig, S as activeUpstream, b as UpstreamNameSchema, v as ConfigError, w as upstreamsOf, x as UpstreamSchema } from "./session-binding-zCSuizHs.js";
+import { a as assertStorageName, n as agentHomePath, r as expandHomePath, t as AgentPaths } from "./paths-B7NI9Ano.js";
+import { n as ClaimEditStore } from "./disputes-ByEmi43j.js";
+import { n as FormationStore } from "./checkpoint-CPFPOxBM.js";
+import { n as InboxEffectStore } from "./effects-DX1iy6FM.js";
+import { t as TeamFacade } from "./service-BQaszW_v.js";
+import { t as DurableWorker } from "./worker-HMGzJFWd.js";
+import { r as MAX_TRACE_TASK_PAGE_LIMIT, t as ClaimUpdateSchema } from "./types-C2ST2Zdg.js";
+import { a as validatePage, n as claimListPage, r as page } from "./pages-BEWC3kmZ.js";
+import { n as PresentationStore, t as historicalKnowledge } from "./history-DPMHX3ZE.js";
+import { z } from "zod";
+import { createHash, randomUUID } from "node:crypto";
+import fs, { readFile, realpath } from "node:fs/promises";
+import { join, resolve } from "node:path";
+//#region src/store/library-directory.ts
+const Summary = z.object({
+	id: UpstreamNameSchema,
+	name: UpstreamSchema.shape.name,
+	agentId: UpstreamSchema.shape.agentId,
+	enabled: UpstreamSchema.shape.enabled,
+	maintainerEndpoint: UpstreamSchema.shape.maintainerEndpoint,
+	routerEndpoint: UpstreamSchema.shape.routerEndpoint
+});
+const Index = z.object({
+	schemaVersion: z.literal(1),
+	upstreams: z.array(z.object({ summary: Summary })),
+	preferences: z.object({ defaultUpstream: z.string().nullable().optional() }).optional()
+});
+const ObjectRecord = z.record(z.string(), z.unknown());
+async function sameDirectory(left, right) {
+	const a = resolve(expandHomePath(left));
+	const b = resolve(expandHomePath(right));
+	if (a === b) return true;
+	try {
+		const [first, second] = await Promise.all([realpath(a), realpath(b)]);
+		return process.platform === "win32" ? first.toLowerCase() === second.toLowerCase() : first === second;
+	} catch {
+		return false;
+	}
+}
+async function readIndex(home) {
+	let text;
+	try {
+		text = await readFile(join(expandHomePath(home), "settings.json"), "utf8");
+	} catch (error) {
+		if (hasCode(error, "ENOENT")) return null;
+		throw new ConfigError(["libraryIndex"]);
+	}
+	try {
+		const raw = ObjectRecord.parse(JSON.parse(text));
+		const known = Index.parse(raw);
+		if (new Set(known.upstreams.map((item) => item.summary.id)).size !== known.upstreams.length) throw new ConfigError(["libraryIndex"]);
+		return {
+			raw,
+			known
+		};
+	} catch {
+		throw new ConfigError(["libraryIndex"]);
+	}
+}
+async function prepareLibraryDirectory(previous, next) {
+	const before = resolveConfig(previous);
+	const after = resolveConfig(next);
+	if ((before.upstreams !== void 0 || before.agentId !== "" || after.upstreams !== void 0) && await sameDirectory(before.home, after.home)) return {
+		...next,
+		home: before.home
+	};
+	const index = await readIndex(after.home);
+	if (index === null) return next;
+	const upstreams = {};
+	for (const { summary } of index.known.upstreams) {
+		const { id, ...value } = summary;
+		const parsed = UpstreamSchema.safeParse({
+			...value,
+			timeoutMs: after.team.timeoutMs
+		});
+		if (!parsed.success) throw new ConfigError(["libraryIndex"]);
+		Object.defineProperty(upstreams, id, {
+			value: parsed.data,
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+	}
+	const preferred = index.known.preferences?.defaultUpstream ?? "";
+	return {
+		...next,
+		upstreams,
+		upstream: upstreams[preferred]?.enabled ? preferred : "",
+		agentId: "",
+		connections: [],
+		defaultConnection: ""
+	};
+}
+async function syncLibraryIndex(config, logger) {
+	const profiles = upstreamsOf(config);
+	if (config.upstreams === void 0 && Object.keys(profiles).length === 0) return;
+	const path = join(expandHomePath(config.home), "settings.json");
+	await withFileLock(`${path}.lock`, async () => {
+		const index = await readIndex(config.home);
+		const previous = index?.known.upstreams ?? [];
+		const summaries = Object.entries(profiles).map(([id, item]) => Summary.parse({
+			id,
+			...item
+		}));
+		const selected = config.upstreams === void 0 ? config.agentId ? "personal" : "" : config.upstream;
+		const expected = {
+			upstreams: summaries,
+			defaultUpstream: selected || null
+		};
+		if (index !== null && JSON.stringify({
+			upstreams: previous.map((item) => item.summary),
+			defaultUpstream: index.known.preferences?.defaultUpstream ?? null
+		}) === JSON.stringify(expected)) return;
+		const stored = z.array(ObjectRecord).parse(index?.raw.upstreams ?? []);
+		const upstreams = summaries.map((summary) => {
+			const position = previous.findIndex((item) => item.summary.id === summary.id);
+			const old = position < 0 ? void 0 : previous[position]?.summary;
+			const fields = position < 0 ? {} : stored[position] ?? {};
+			const sameTarget = old !== void 0 && old.agentId === summary.agentId && old.maintainerEndpoint === summary.maintainerEndpoint;
+			return {
+				...fields,
+				summary,
+				maintainerRevision: sameTarget && typeof fields.maintainerRevision === "string" ? fields.maintainerRevision : randomUUID(),
+				identityEpoch: old?.agentId === summary.agentId && typeof fields.identityEpoch === "string" ? fields.identityEpoch : randomUUID()
+			};
+		});
+		const preferences = ObjectRecord.parse(index?.raw.preferences ?? {});
+		await writeTextAtomic(path, JSON.stringify({
+			...index?.raw,
+			schemaVersion: 1,
+			revision: randomUUID(),
+			upstreams,
+			preferences: {
+				...preferences,
+				defaultUpstream: selected || null
+			}
+		}, null, 2) + "\n", logger);
+	});
+}
+//#endregion
+//#region src/knowledge/service.ts
+function missing(error) {
+	return hasCode(error, "ENOENT") || error instanceof StoreError && error.kind === "io" && hasCode(error.cause, "ENOENT");
+}
+var AcnKnowledge = class {
+	config;
+	logger;
+	agentId;
+	mode;
+	storeContext;
+	team;
+	jobs;
+	cache;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(config, logger, credential) {
+		this.config = config;
+		this.logger = logger;
+		this.agentId = config.agentId || null;
+		this.mode = config.team.routerEndpoint ? "team" : "solo";
+		this.storeContext = this.agentId === null ? null : {
+			agentId: this.agentId,
+			paths: new AgentPaths(agentHomePath(config.home, this.agentId, activeUpstream(config))),
+			mode: this.mode,
+			logger
+		};
+		this.team = this.agentId !== null && this.mode === "team" ? new TeamFacade(config.team, this.agentId, logger, credential) : null;
+		this.jobs = this.storeContext === null ? null : new DurableWorker(this.storeContext);
+	}
+	get active() {
+		return this.mode === "solo" || this.config.legacyEnabled;
+	}
+	get configured() {
+		return this.agentId !== null;
+	}
+	teamStatus() {
+		return this.team?.status() ?? {
+			mode: "solo",
+			router: { state: "unknown" },
+			maintainer: { state: "unknown" }
+		};
+	}
+	context() {
+		if (this.storeContext === null) throw new KnowledgeError("unconfigured", "Configure agentId on the acn-knowledge row first.");
+		return this.storeContext;
+	}
+	async initialize() {
+		if (!this.configured) return;
+		if ((await historicalKnowledge(this.context())).applications.some((record) => record.state === "prepared")) throw new KnowledgeError("conflict", "知识目录还有未完成的历史提交，请先在原程序完成处理；当前插件不会重放旧任务。");
+		await new PresentationStore(this.context()).initialize();
+		await cleanupAtomicTemps(this.context().paths.root, this.logger);
+		await new DreamStore(this.context()).recover();
+		await new ClaimEditStore(this.context()).recover();
+		await new FormationStore(this.context()).recover();
+		await new InboxEffectStore(this.context()).recover();
+	}
+	async snapshot(signal, lockTimeoutMs) {
+		return this.consistentRead(async () => {
+			const context = this.context();
+			let stamp;
+			try {
+				const stat = await fs.stat(context.paths.claims, { bigint: true });
+				stamp = `${stat.mtimeNs}:${stat.ctimeNs}`;
+			} catch (error) {
+				if (!hasCode(error, "ENOENT")) throw error;
+				stamp = "missing";
+			}
+			if (this.cache !== void 0 && this.cache.stamp === stamp && performance.now() - this.cache.checked < 2e3) return structuredClone({
+				claims: this.cache.claims,
+				version: this.cache.version
+			});
+			const claims = await new ClaimStore(context).list();
+			const revisions = [...claims].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).map((claim) => `${claim.id}:${claimRevision(claim)}`).join("\n");
+			const version = { claimsDigest: createHash("sha256").update(revisions).digest("hex") };
+			this.cache = {
+				stamp,
+				checked: performance.now(),
+				claims,
+				version
+			};
+			return structuredClone({
+				claims,
+				version
+			});
+		}, signal, lockTimeoutMs);
+	}
+	async knowledgeVersion(signal, lockTimeoutMs) {
+		return (await this.snapshot(signal, lockTimeoutMs)).version;
+	}
+	async listClaims(query = {}, signal) {
+		return this.consistentRead(async () => {
+			return claimListPage(await new ClaimStore(this.context()).list(), query);
+		}, signal);
+	}
+	async readClaim(id, signal) {
+		return this.consistentRead(async () => {
+			const claim = await this.readOwnedClaim(id);
+			return {
+				claim,
+				revision: claimRevision(claim)
+			};
+		}, signal);
+	}
+	async readOwnedClaim(id) {
+		let claim;
+		try {
+			claim = await new ClaimStore(this.context()).read(id);
+		} catch (error) {
+			if (missing(error)) throw new KnowledgeError("not_found", `Claim ${id} was not found.`);
+			throw error;
+		}
+		if (claim.holder !== this.agentId) throw new KnowledgeError("ownership", `Claim ${id} is not held by this agent.`);
+		return claim;
+	}
+	async updateClaim(input, signal) {
+		const parsed = ClaimUpdateSchema.safeParse(input);
+		if (!parsed.success) throw new KnowledgeError("validation", "Invalid Claim update fields.");
+		const { id, expected_revision, ...fields } = parsed.data;
+		if (!Object.values(fields).some((value) => value !== void 0)) throw new KnowledgeError("validation", "Claim update requires at least one editable field.");
+		const context = this.context();
+		const result = await withFileLock(context.paths.knowledgeLock, async () => {
+			signal?.throwIfAborted();
+			await new DreamStore(context).recoverLocked();
+			await new ClaimEditStore(context).recoverLocked();
+			await new FormationStore(context).recoverLocked();
+			await new InboxEffectStore(context).recoverLocked();
+			const current = await this.readOwnedClaim(id);
+			const revision = claimRevision(current);
+			if (expected_revision !== revision) throw new RevisionConflict(revision);
+			const next = { ...current };
+			for (const key of [
+				"name",
+				"statement",
+				"scope",
+				"evidence_summary",
+				"confidence",
+				"status"
+			]) {
+				const value = fields[key];
+				if (value !== void 0) Object.assign(next, { [key]: value });
+			}
+			validateClaimText({
+				name: next.name,
+				statement: next.statement,
+				scope: next.scope,
+				evidence_summary: next.evidence_summary
+			});
+			next.updated_at = nextClaimUpdateAt(nowSeconds(), effectiveUpdatedAt(current));
+			signal?.throwIfAborted();
+			if (context.mode === "team") await new ClaimEditStore(context).write({
+				expected_revision: revision,
+				target: next
+			});
+			await new ClaimStore(context).write(next);
+			if (context.mode === "team") {
+				await new UploadStore(context).enqueue([next], [], true);
+				await removeFile(context.paths.claimEditPending, this.logger);
+			}
+			this.cache = void 0;
+			return {
+				claim: next,
+				revision: claimRevision(next),
+				sync_pending: context.mode === "team",
+				...context.mode === "team" ? { sync_warning: "Claim 已保存到本地，等待团队同步。" } : {}
+			};
+		}, {
+			signal,
+			timeoutMs: context.lockTimeoutMs
+		});
+		await this.notifyChanged(signal);
+		return result;
+	}
+	async listTraces(query = {}, signal) {
+		return this.consistentRead(async () => {
+			const offset = query.offset ?? 0;
+			const limit = query.limit ?? 20;
+			validatePage(offset, limit);
+			const traces = (await new TraceStore(this.context()).list()).filter((trace) => trace.agent === this.agentId && (query.claimId === void 0 || trace.input_claims.includes(query.claimId) || trace.output_claims.includes(query.claimId)));
+			traces.sort((a, b) => {
+				const delta = timestampNanos(b.created_at) - timestampNanos(a.created_at);
+				return delta === 0n ? a.id < b.id ? -1 : a.id > b.id ? 1 : 0 : delta > 0n ? 1 : -1;
+			});
+			return page(traces.map(({ id, name, created_at, input_claims, output_claims }) => ({
+				id,
+				name,
+				created_at,
+				input_claims,
+				output_claims
+			})), offset, limit);
+		}, signal);
+	}
+	async readTrace(id, options = {}, signal) {
+		return this.consistentRead(async () => {
+			const offset = options.taskOffset ?? 0;
+			const limit = options.taskLimit ?? 4e3;
+			validatePage(offset, limit, MAX_TRACE_TASK_PAGE_LIMIT);
+			let trace;
+			try {
+				trace = await new TraceStore(this.context()).read(id);
+			} catch (error) {
+				if (missing(error)) throw new KnowledgeError("not_found", `Trace ${id} was not found.`);
+				throw error;
+			}
+			if (trace.agent !== this.agentId) throw new KnowledgeError("ownership", `Trace ${id} is not owned by this agent.`);
+			const chars = Array.from(trace.task);
+			const end = Math.min(offset + limit, chars.length);
+			return {
+				...trace,
+				task: chars.slice(offset, end).join(""),
+				task_offset: offset,
+				task_limit: limit,
+				task_omitted: chars.length - end,
+				next_task_offset: end < chars.length ? end : null
+			};
+		}, signal);
+	}
+	onClaimsChanged(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	async applyFormation(...args) {
+		const result = await new FormationStore(this.context()).commit(...args);
+		if (result.applied) await this.notifyChanged(args[1].signal);
+		return result;
+	}
+	async applyInboxEffect(...args) {
+		const result = await new InboxEffectStore(this.context()).commit(...args);
+		if (result.applied > 0) await this.notifyChanged(args[3].signal);
+		return result;
+	}
+	async consistentRead(action, signal, lockTimeoutMs) {
+		const context = this.context();
+		try {
+			return await withFileLock(context.paths.knowledgeLock, async () => {
+				signal?.throwIfAborted();
+				await new DreamStore(context).recoverLocked();
+				await new ClaimEditStore(context).recoverLocked();
+				await new FormationStore(context).recoverLocked();
+				await new InboxEffectStore(context).recoverLocked();
+				const boundary = await AnalysisReadBoundary.begin(context.paths.root);
+				const result = await action();
+				await boundary.finish(context.paths.root);
+				signal?.throwIfAborted();
+				return result;
+			}, {
+				signal,
+				timeoutMs: lockTimeoutMs ?? context.lockTimeoutMs
+			});
+		} catch (error) {
+			signal?.throwIfAborted();
+			if (error instanceof LockTimeoutError) throw new KnowledgeBusy();
+			throw error;
+		}
+	}
+	async notifyChanged(signal) {
+		this.cache = void 0;
+		try {
+			const version = await this.knowledgeVersion(signal);
+			for (const listener of this.listeners) try {
+				listener(version);
+			} catch {
+				this.logger.warn("Claim change observer failed.");
+			}
+		} catch {
+			this.logger.warn("Knowledge was committed; its change notice will be checked on the next foreground step.");
+		}
+	}
+	dreamStore() {
+		return new DreamStore(this.context(), async () => {
+			await new ClaimEditStore(this.context()).recoverLocked();
+			await new FormationStore(this.context()).recoverLocked();
+			await new InboxEffectStore(this.context()).recoverLocked();
+		});
+	}
+	async dreamSnapshot(signal) {
+		return withFileLock(this.context().paths.knowledgeLock, async () => {
+			await new DreamStore(this.context()).recoverLocked();
+			await new ClaimEditStore(this.context()).recoverLocked();
+			await new FormationStore(this.context()).recoverLocked();
+			await new InboxEffectStore(this.context()).recoverLocked();
+			signal.throwIfAborted();
+			return new ClaimStore(this.context()).list();
+		}, {
+			signal,
+			timeoutMs: this.context().lockTimeoutMs
+		});
+	}
+	async applyDreamGroup(...args) {
+		const result = await this.dreamStore().commitGroup(...args);
+		await this.notifyChanged(args[6].signal);
+		return result;
+	}
+};
+//#endregion
+//#region src/dsh-adapter/team-credentials.ts
+function credentialReference(reference) {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(reference)) throw new ConfigError(["team.keyEnv"]);
+	return reference;
+}
+function teamCredentials(ctx) {
+	return async (reference) => {
+		const provider = ctx.get("credentials");
+		return provider === void 0 ? process.env[reference] : (await provider.resolve(credentialReference(reference)))?.value;
+	};
+}
+//#endregion
+//#region src/upstreams.ts
+function resolveUpstream(config, key, includeDisabled = false) {
+	const profile = upstreamsOf(config)[key];
+	if (profile === void 0 || !profile.enabled && !includeDisabled) return void 0;
+	assertStorageName(key);
+	return resolveConfig({
+		...config,
+		upstreams: void 0,
+		upstream: key,
+		connections: [],
+		defaultConnection: "",
+		sessionEpoch: 0,
+		agentId: profile.agentId,
+		legacyEnabled: true,
+		team: {
+			...config.team,
+			routerEndpoint: profile.routerEndpoint,
+			maintainerEndpoint: profile.maintainerEndpoint,
+			keyEnv: profile.keyEnv,
+			timeoutMs: profile.timeoutMs
+		}
+	});
+}
+function defaultUpstream(config) {
+	return config.upstreams === void 0 ? config.agentId ? "personal" : "" : config.upstream;
+}
+async function canonicalProjectPath(cwd) {
+	const path = resolve(cwd);
+	try {
+		return await realpath(path);
+	} catch {
+		return path;
+	}
+}
+//#endregion
+export { teamCredentials as a, syncLibraryIndex as c, credentialReference as i, defaultUpstream as n, AcnKnowledge as o, resolveUpstream as r, prepareLibraryDirectory as s, canonicalProjectPath as t };

package/lib/worker-HMGzJFWd.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-c7aI4D-X.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":"清理与整合已有知识，可选启用受限证据校准。"}}