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

package/lib/auth-DFI9yowX.js

@@ -0,0 +1,71 @@
+import { a as TextSchema, c as AgentIdSchema, l as ClaimIdSchema, o as optional, t as ClaimSchema, u as DisputeIdSchema, y as TimestampSchema } from "./claim-DOAGe8ZK.js";
+import { z } from "zod";
+//#region src/protocol/router.ts
+const count = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const AgentQuerySchema = z.object({
+	scope: TextSchema,
+	semantic_query: TextSchema.nullable().default(null)
+});
+const CandidateClaimSchema = ClaimSchema.extend({
+	open_dispute_ids: z.array(DisputeIdSchema).default([]),
+	resolved_dispute_ids: z.array(DisputeIdSchema).default([])
+});
+const DisputeRefSchema = z.object({
+	id: DisputeIdSchema,
+	name: TextSchema,
+	claim_ids: z.array(ClaimIdSchema),
+	summary: TextSchema,
+	status: z.enum(["open", "resolved"])
+});
+const retrievalDebug = z.object({
+	mode: TextSchema,
+	failed_paths: z.array(TextSchema).default([]),
+	error_summaries: z.array(TextSchema).default([]),
+	lexical_hits: count.default(0),
+	vector_hits: count.default(0),
+	rerank_fallback: z.boolean().default(false),
+	candidates: z.array(z.object({
+		claim_id: TextSchema,
+		hit_sources: TextSchema,
+		lexical_score: count.default(0),
+		vector_score: count.default(0),
+		rank_before_rerank: count.default(0),
+		rank_after_rerank: count.default(0),
+		vector_status: TextSchema
+	})).default([])
+});
+const RouterQueryResultSchema = z.object({
+	candidate_claims: z.array(CandidateClaimSchema),
+	disputes: z.array(DisputeRefSchema),
+	retrieval_debug: optional(retrievalDebug)
+});
+const ScopeOverviewItemSchema = z.strictObject({
+	scope: TextSchema,
+	active_claims: count,
+	stale_claims: count,
+	open_disputes: count,
+	resolved_disputes: count,
+	latest_claim_created_at: TimestampSchema
+});
+const ScopesOverviewSnapshotSchema = z.strictObject({ scopes: z.array(ScopeOverviewItemSchema).default([]) });
+//#endregion
+//#region src/protocol/auth.ts
+const AuthEnvelopeSchema = z.strictObject({
+	agent_id: AgentIdSchema,
+	acn_key: TextSchema
+});
+const authRequestSchema = (data) => z.strictObject({
+	auth: AuthEnvelopeSchema,
+	data
+});
+const HealthRequestSchema = z.strictObject({
+	auth: AuthEnvelopeSchema.nullish(),
+	data: z.strictObject({}).default({})
+});
+const HealthResponseSchema = z.object({
+	status: z.string(),
+	team_auth_enabled: z.boolean(),
+	auth_passed: z.boolean().optional()
+});
+//#endregion
+export { AgentQuerySchema as a, RouterQueryResultSchema as c, authRequestSchema as i, ScopeOverviewItemSchema as l, HealthRequestSchema as n, CandidateClaimSchema as o, HealthResponseSchema as r, DisputeRefSchema as s, AuthEnvelopeSchema as t, ScopesOverviewSnapshotSchema as u };

package/lib/checkpoint-Bmt8q2vB.js

@@ -0,0 +1,188 @@
+import { t as ClaimSchema, v as deriveTraceId, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { c as TranscriptStore, l as processedThrough } from "./structured-lyQCK-Zk.js";
+import { C as StoreError, _ as JobError, c as readYamlOr, l as writeYamlAtomic, n as withFileLock } from "./lock-DbmlKOoX.js";
+import { a as analysisIsStale, c as observeApplied, i as STALE_PLAN_WARNING, l as sameClaim, o as claimChanges, s as ensureKnowledgeReady, t as AnalysisChanged } from "./alignment-CwH0nBf-.js";
+import { i as ClaimStore, r as reportedClaimSetKey, t as ReportedSetStore } from "./reported-sets-DdEKdeVb.js";
+import { t as TraceSchema } from "./trace-Da0RnL5R.js";
+import { t as TraceStore } from "./traces-CHBo8y1z.js";
+import { t as DisputeSchema } from "./dispute-CtrInHzf.js";
+import { r as UploadStore } from "./uploads-BCA2p92b.js";
+import { t as DreamStore } from "./checkpoint-RgcdqifN.js";
+import { n as ClaimEditStore, t as DisputeStore } from "./disputes-ByEmi43j.js";
+import { z } from "zod";
+//#region src/knowledge/disputes.ts
+async function newDisputes(context, proposed, local) {
+	const sets = /* @__PURE__ */ new Set();
+	if (context.mode === "solo") for (const dispute of local) sets.add(reportedClaimSetKey(dispute.claims));
+	else {
+		for (const dispute of (await new UploadStore(context).read()).disputes) sets.add(reportedClaimSetKey(dispute.claims));
+		for (const key of Object.keys((await new ReportedSetStore(context).read()).reported_claim_sets)) sets.add(key);
+	}
+	return proposed.filter((dispute) => {
+		const key = reportedClaimSetKey(dispute.claims);
+		if (sets.has(key)) return false;
+		sets.add(key);
+		return true;
+	});
+}
+//#endregion
+//#region src/formation/checkpoint.ts
+const CheckpointSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	sessionId: z.string().regex(/^[a-zA-Z0-9_-]+$/),
+	jobId: z.string().regex(/^[a-zA-Z0-9_-]+$/),
+	kind: z.enum(["recap", "finalize"]),
+	fromSeq: z.number().int().min(-1),
+	untilSeq: z.number().int().nonnegative(),
+	status: z.enum(["prepared", "applied"]),
+	analysisClaims: z.array(ClaimSchema).nullable(),
+	preparedClaims: z.array(ClaimSchema),
+	appliedClaims: z.array(ClaimSchema),
+	teamAuthorized: z.boolean().optional(),
+	disputes: z.array(DisputeSchema),
+	trace: TraceSchema.nullable(),
+	warnings: z.array(z.string())
+});
+var FormationStore = class {
+	context;
+	transcript;
+	constructor(context) {
+		this.context = context;
+		this.transcript = new TranscriptStore(context);
+	}
+	async read(sessionId) {
+		const checkpoint = await readYamlOr(this.context.paths.finalizeCheckpoint(sessionId), CheckpointSchema, () => null);
+		if (checkpoint !== null && checkpoint.sessionId !== sessionId) throw new StoreError("decode", "Checkpoint session differs from its directory.");
+		return checkpoint;
+	}
+	write(checkpoint) {
+		return writeYamlAtomic(this.context.paths.finalizeCheckpoint(checkpoint.sessionId), checkpoint, CheckpointSchema, this.context.logger);
+	}
+	async recover() {
+		const ids = await this.transcript.sessions();
+		if ((await Promise.all(ids.map((id) => this.read(id)))).filter((value) => value !== null).length === 0) return;
+		await withFileLock(this.context.paths.knowledgeLock, () => this.recoverLocked(), { timeoutMs: this.context.lockTimeoutMs });
+	}
+	async recoverLocked() {
+		await new DreamStore(this.context).recoverLocked();
+		for (const id of await this.transcript.sessions()) {
+			const checkpoint = await this.read(id);
+			if (checkpoint === null) continue;
+			if (checkpoint.status === "prepared") await this.applyLocked(checkpoint);
+			else {
+				const state = await this.transcript.state(id);
+				if (processedThrough(state) < checkpoint.untilSeq || checkpoint.kind === "finalize" && state.finalizedThroughSeq < checkpoint.untilSeq) await this.transcript.advance(id, checkpoint.kind, checkpoint.untilSeq);
+			}
+		}
+	}
+	async commit(input, control) {
+		return withFileLock(this.context.paths.knowledgeLock, async () => {
+			await new DreamStore(this.context).recoverLocked();
+			await ensureKnowledgeReady(this.context.paths.root);
+			await new ClaimEditStore(this.context).recoverLocked();
+			await this.recoverLocked();
+			if (processedThrough(await this.transcript.state(input.sessionId)) >= input.untilSeq) return {
+				applied: false,
+				warnings: [],
+				claimCount: 0,
+				disputeCount: 0,
+				traceCount: 0
+			};
+			control.signal.throwIfAborted();
+			const { claims, disputes, usedClaimIds, warnings } = input.prepared;
+			if (claimChanges(input.analysisClaims, claims, [], await new ClaimStore(this.context).list()).length > 0) throw new AnalysisChanged();
+			const createdAt = nowSeconds();
+			const traceName = Array.from(input.task.split("\n").find((line) => line.trim()) ?? "session_recap").slice(0, 60).join("");
+			const existingTraces = new Set((await new TraceStore(this.context).list()).map((trace) => trace.id));
+			let traceId = deriveTraceId(createdAt, traceName, usedClaimIds, claims.map((claim) => claim.id));
+			for (let attempt = 0; existingTraces.has(traceId); attempt += 1) {
+				if (attempt >= 7) throw new JobError("id_collision", "Trace ID 冲突；请重试本次形成任务。");
+				traceId = deriveTraceId(createdAt, traceName, usedClaimIds, claims.map((claim) => claim.id));
+			}
+			const trace = claims.length === 0 && usedClaimIds.length === 0 ? null : TraceSchema.parse({
+				id: traceId,
+				name: traceName,
+				task: input.task,
+				agent: this.context.agentId,
+				input_claims: usedClaimIds,
+				output_claims: claims.map((claim) => claim.id),
+				created_at: createdAt
+			});
+			const existingDisputes = await new DisputeStore(this.context).list();
+			const uniqueDisputes = await newDisputes(this.context, disputes, existingDisputes);
+			if (uniqueDisputes.some((dispute) => existingDisputes.some((value) => value.id === dispute.id))) throw new JobError("id_collision", "Dispute ID 冲突；请重试本次形成任务。");
+			const checkpoint = CheckpointSchema.parse({
+				schemaVersion: 1,
+				sessionId: input.sessionId,
+				jobId: input.jobId,
+				kind: input.kind,
+				fromSeq: input.fromSeq,
+				untilSeq: input.untilSeq,
+				status: "prepared",
+				teamAuthorized: this.context.mode === "team",
+				analysisClaims: input.analysisClaims,
+				preparedClaims: claims,
+				appliedClaims: [],
+				disputes: uniqueDisputes,
+				trace,
+				warnings
+			});
+			control.signal.throwIfAborted();
+			control.prepared();
+			await this.write(checkpoint);
+			await this.applyLocked(checkpoint);
+			return {
+				applied: true,
+				warnings: checkpoint.warnings,
+				claimCount: checkpoint.appliedClaims.length,
+				disputeCount: checkpoint.disputes.length,
+				traceCount: checkpoint.trace === null ? 0 : 1,
+				entityIds: [
+					...checkpoint.appliedClaims.map((claim) => claim.id),
+					...checkpoint.disputes.map((dispute) => dispute.id),
+					...checkpoint.trace === null ? [] : [checkpoint.trace.id]
+				]
+			};
+		}, {
+			timeoutMs: this.context.lockTimeoutMs,
+			signal: control.signal
+		});
+	}
+	async applyLocked(checkpoint) {
+		await ensureKnowledgeReady(this.context.paths.root);
+		const current = await new ClaimStore(this.context).list();
+		observeApplied(checkpoint.preparedClaims, current, checkpoint.appliedClaims);
+		if (analysisIsStale(checkpoint.analysisClaims, claimChanges(checkpoint.analysisClaims, checkpoint.preparedClaims, checkpoint.appliedClaims, current))) {
+			if (checkpoint.preparedClaims.some((claim) => !checkpoint.appliedClaims.some((applied) => applied.id === claim.id)) || checkpoint.disputes.length > 0) {
+				checkpoint.warnings.push(STALE_PLAN_WARNING);
+				this.context.logger.warn(STALE_PLAN_WARNING);
+			}
+			checkpoint.preparedClaims = [];
+			checkpoint.disputes = [];
+			checkpoint.analysisClaims = current;
+			await this.write(checkpoint);
+		}
+		const targets = [...checkpoint.preparedClaims].sort((a, b) => Number(a.status === "deprecated") - Number(b.status === "deprecated"));
+		for (const claim of targets) if (!checkpoint.appliedClaims.some((applied) => applied.id === claim.id)) {
+			await new ClaimStore(this.context).write(claim);
+			checkpoint.appliedClaims.push(claim);
+			await this.write(checkpoint);
+		}
+		if (checkpoint.trace !== null) {
+			checkpoint.trace.output_claims = checkpoint.appliedClaims.map((claim) => claim.id);
+			if (checkpoint.trace.output_claims.length > 0 || checkpoint.trace.input_claims.length > 0) await new TraceStore(this.context).write(checkpoint.trace);
+		}
+		for (const dispute of checkpoint.disputes) await new DisputeStore(this.context).write(dispute);
+		if (checkpoint.teamAuthorized === void 0 && this.context.mode === "team") checkpoint.warnings.push("旧形成事务缺少团队共享授权，仅恢复本地效果。");
+		if (checkpoint.teamAuthorized === true && this.context.mode === "team") {
+			const actual = await new ClaimStore(this.context).list();
+			await new UploadStore(this.context).enqueue(checkpoint.appliedClaims.filter((claim) => actual.some((value) => sameClaim(value, claim))), checkpoint.disputes, true);
+		}
+		checkpoint.status = "applied";
+		await this.write(checkpoint);
+		await this.transcript.advance(checkpoint.sessionId, checkpoint.kind, checkpoint.untilSeq);
+		for (const warning of checkpoint.warnings) this.context.logger.warn(warning);
+	}
+};
+//#endregion
+export { FormationStore as n, newDisputes as r, CheckpointSchema as t };

package/lib/checkpoint-RgcdqifN.js

@@ -0,0 +1,318 @@
+import { m as SourceIdSchema, v as deriveTraceId, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { A as valueHash, E as reviewInput, K as DreamStateSchema, S as contentHash, T as reaches, V as CheckpointSchema, Z as KeySchema, b as validateSelfReview, et as OriginSchema, pt as requireDream, r as EvidenceStore, rt as ProgressSchema, v as versions, w as prepareGroup, x as validateSemanticReview } from "./evidence-store-DLFvSuNa.js";
+import { C as StoreError, c as readYamlOr, d as removeFile, f as writeTextAtomic, l as writeYamlAtomic, n as withFileLock, s as readYaml, w as hasCode } from "./lock-DbmlKOoX.js";
+import { l as sameClaim } from "./alignment-CwH0nBf-.js";
+import { i as ClaimStore } from "./reported-sets-DdEKdeVb.js";
+import { t as TraceSchema } from "./trace-Da0RnL5R.js";
+import { t as TraceStore } from "./traces-CHBo8y1z.js";
+import { r as UploadStore } from "./uploads-BCA2p92b.js";
+import { z } from "zod";
+import fs from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+//#region src/dream/audit.ts
+async function executionAudit(context, jobId, checkpoint) {
+	const id = checkpoint.operation?.validation_id ?? "final";
+	const note = `# Dream ${checkpoint.applied ? "已应用" : "prepared（尚未确认完成）"}\n\n这份记录核对结构、来源和版本，不保证语义正确。\n\n组：${checkpoint.operation?.group_id ?? "final"}。\n\n${checkpoint.groups.map((group) => `- completed=${group.completed} skipped=${group.skipped}：${group.before.map((claim) => claim.id).join(", ")}`).join("\n")}\n\n实际变更：${Object.keys(checkpoint.self_versions).join(", ") || "无"}\n\n\`\`\`json\n${JSON.stringify(checkpoint, null, 2)}\n\`\`\`\n`;
+	await writeTextAtomic(join(context.paths.dreamJob(jobId), "executions", `${id}.md`), note, context.logger);
+}
+async function jobReport(context, jobId, progress, coverage, records) {
+	const note = `# Dream ${progress.finished ? "本次已结束" : progress.autonomy?.wrap_up !== void 0 ? "额度收尾中" : "处理中"}\n\n模型轮数：${progress.autonomy === void 0 ? "旧阶段模式" : `${progress.autonomy.steps}/${progress.autonomy.limit}；收尾 ${progress.autonomy.wrap_up?.steps ?? 0}/${progress.autonomy.wrap_up?.limit ?? 0}`}\n\n质量清理：${progress.discovery.review.quality}\n\n证据校准：${progress.discovery.review.evidence}\n\n主题整合：${progress.discovery.review.consolidation}\n\n覆盖：\`${JSON.stringify(coverage)}\`\n\n${progress.entries.map((entry) => `- ${entry.candidate.group_id}：${entry.status}；${entry.reason || entry.candidate.reason}`).join("\n") || "本轮没有需要修改的候选。"}\n\n实际修改 ID：${[...new Set(records.flatMap((record) => Object.keys(record.self_versions)))].join(", ") || "无"}\n\n未探索不代表不存在；保持原样是合法结果。已提交组的保留信息与最终名称经过模型语义复核，硬校验不证明语义正确。\n`;
+	await writeTextAtomic(join(context.paths.dreamJob(jobId), "report.md"), note, context.logger);
+}
+//#endregion
+//#region src/dream/checkpoint.ts
+const sameJson = (a, b) => valueHash(a) === valueHash(b);
+var DreamStore = class {
+	context;
+	settleRegular;
+	constructor(context, settleRegular) {
+		this.context = context;
+		this.settleRegular = settleRegular;
+	}
+	state() {
+		return readYamlOr(this.context.paths.dreamState, DreamStateSchema, () => DreamStateSchema.parse({}));
+	}
+	origin(jobId) {
+		return readYamlOr(join(this.context.paths.dreamJob(jobId), "origin.yaml"), OriginSchema, () => null);
+	}
+	progress(jobId) {
+		return readYamlOr(join(this.context.paths.dreamJob(jobId), "progress.yaml"), ProgressSchema, () => null);
+	}
+	final(jobId) {
+		return readYamlOr(this.context.paths.dreamFinal(jobId), CheckpointSchema, () => null);
+	}
+	async saveOrigin(jobId, origin) {
+		if (await this.origin(jobId) === null) await writeYamlAtomic(join(this.context.paths.dreamJob(jobId), "origin.yaml"), origin, OriginSchema, this.context.logger);
+	}
+	async saveProgress(jobId, progress) {
+		await writeYamlAtomic(join(this.context.paths.dreamJob(jobId), "progress.yaml"), progress, ProgressSchema, this.context.logger);
+		await this.report(jobId, progress);
+	}
+	async report(jobId, progress) {
+		await jobReport(this.context, jobId, progress, (await this.origin(jobId))?.coverage, (await this.records(jobId)).map((entry) => entry.checkpoint));
+	}
+	async records(jobId) {
+		const root = join(this.context.paths.dreamJob(jobId), "executions");
+		let files;
+		try {
+			files = (await fs.readdir(root)).filter((name) => /^[0-9a-f]{64}\.yaml$/.test(name));
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return [];
+			throw error;
+		}
+		return await Promise.all(files.sort().map(async (name) => {
+			const path = join(root, name);
+			const checkpoint = await readYaml(path, CheckpointSchema);
+			if (checkpoint.operation?.job_id !== jobId || checkpoint.operation.validation_id !== name.slice(0, -5)) throw new StoreError("conflict", "Dream execution identity differs from its directory.");
+			return {
+				path,
+				checkpoint
+			};
+		}));
+	}
+	async jobs() {
+		try {
+			return (await fs.readdir(this.context.paths.dreamRoot, { withFileTypes: true })).filter((entry) => entry.isDirectory() && KeySchema.safeParse(entry.name).success).map((entry) => entry.name);
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return [];
+			throw error;
+		}
+	}
+	async pending() {
+		const path = await readYamlOr(this.context.paths.dreamPending, z.string(), () => null);
+		if (path === null) return null;
+		const resolved = resolve(path);
+		const location = relative(this.context.paths.root, resolved).split("\\").join("/");
+		if (!/^dream\/[a-zA-Z0-9_-]+\/executions\/[0-9a-f]{64}\.yaml$/.test(location) && !/^runtime\/supervisor\/dream\/[a-zA-Z0-9_-]+\.yaml$/.test(location)) throw new StoreError("conflict", "Dream pending path is outside the allowed commit directories.");
+		return resolved;
+	}
+	async unfinished() {
+		const pending = await this.pending();
+		const paths = new Set(pending === null ? [] : [pending]);
+		for (const job of await this.jobs()) for (const record of await this.records(job)) if (!record.checkpoint.applied) paths.add(record.path);
+		const root = dirname(this.context.paths.dreamFinal("scan"));
+		let files = [];
+		try {
+			files = await fs.readdir(root);
+		} catch (error) {
+			if (!hasCode(error, "ENOENT")) throw error;
+		}
+		for (const file of files.filter((name) => /^[a-zA-Z0-9_-]+\.yaml$/.test(name)).sort()) {
+			const path = join(root, file);
+			if (!(await readYaml(path, CheckpointSchema)).applied) paths.add(path);
+		}
+		return [...paths];
+	}
+	async recover() {
+		if ((await this.unfinished()).length === 0) return;
+		await withFileLock(this.context.paths.knowledgeLock, () => this.recoverLocked(), { timeoutMs: this.context.lockTimeoutMs });
+	}
+	async recoverLocked() {
+		for (const path of await this.unfinished()) await this.applyLocked(path);
+	}
+	async commitGroup(jobId, groupId, group, validation, semantic, selfReview, control) {
+		const evidence = new EvidenceStore(this.context, jobId, groupId);
+		const receipts = z.record(z.string(), z.json()).parse((await evidence.read())?.receipts ?? {});
+		requireDream(sameJson(reviewInput(groupId, group, validation.input.before, receipts), validation), "草稿、真实查证回执与复核版本不一致。");
+		if (selfReview !== null) validateSelfReview(validation, selfReview);
+		validateSemanticReview(validation, semantic);
+		const prepared = prepareGroup(group, validation.input.before, this.context.agentId, nowSeconds(), {
+			enabled: group.kind === "evidence" || Object.keys(receipts).length > 0,
+			receipts,
+			semanticReview: selfReview === null
+		});
+		return withFileLock(this.context.paths.knowledgeLock, async () => {
+			await this.recoverLocked();
+			await this.settleRegular?.();
+			const path = this.context.paths.dreamExecution(jobId, validation.validation_id);
+			const existing = await readYamlOr(path, CheckpointSchema, () => null);
+			if (existing !== null) {
+				requireDream(existing.operation?.group_id === groupId, "执行回执属于其他组。");
+				return this.applyLocked(path);
+			}
+			const origin = await this.origin(jobId);
+			requireDream(origin !== null, "缺少 Dream 原始快照。");
+			const priorTargets = (await this.records(jobId)).flatMap(({ checkpoint }) => checkpoint.groups.filter((item) => item.completed && !item.skipped).flatMap((item) => item.after));
+			requireDream(prepared.before.every((claim) => origin.claims.some((original) => sameClaim(original, claim)) || selfReview === null && priorTargets.some((target) => sameClaim(target, claim))), "执行前 Claim 必须来自冻结快照或本轮已提交版本，不能采用外部并发修改。");
+			for (const item of semantic.claims) if (item.factual_correction || group.kind === "evidence") requireDream(origin.claims.some((claim) => claim.id === item.claim_id && claim.confidence !== "high"), "本轮原始 high Claim 不得先降级再进行事实校准。");
+			await evidence.authorize(validation.input.evidence, origin.workspace_root, prepared.before);
+			const snapshot_at = nowSeconds();
+			const checkpoint = CheckpointSchema.parse({
+				team_authorized: this.context.mode === "team",
+				snapshot_at,
+				input_versions: {},
+				coverage: origin.coverage,
+				plan: {
+					review: {
+						quality: "逐组复核",
+						evidence: "独立文件版本、逐 Claim 依据与引用校验；不保证语义正确",
+						consolidation: "逐输入核对信息去向"
+					},
+					groups: [group]
+				},
+				receipts: validation.input.evidence,
+				exploration_receipts: Object.keys(receipts).length,
+				groups: [prepared],
+				safety_reviews: [],
+				self_reviews: selfReview === null ? [] : [{
+					validation,
+					review: selfReview
+				}],
+				trace_id: deriveTraceId(snapshot_at, "dream_claim_review", prepared.before.map((claim) => claim.id), prepared.after.map((claim) => claim.id)),
+				applied: false,
+				success_at: null,
+				self_versions: {},
+				operation: {
+					job_id: jobId,
+					group_id: groupId,
+					validation_id: validation.validation_id,
+					review: semantic,
+					hard_validation_passed: true
+				}
+			});
+			control.signal.throwIfAborted();
+			control.prepared();
+			await writeYamlAtomic(path, checkpoint, CheckpointSchema, this.context.logger);
+			return this.applyLocked(path);
+		}, {
+			timeoutMs: this.context.lockTimeoutMs,
+			signal: control.signal
+		});
+	}
+	async finish(jobId, progress, control) {
+		requireDream(progress.entries.every((entry) => entry.status !== "pending"), "仍有已登记候选未执行或明确保留，不能结束。");
+		return withFileLock(this.context.paths.knowledgeLock, async () => {
+			await this.recoverLocked();
+			await this.settleRegular?.();
+			const path = this.context.paths.dreamFinal(jobId);
+			if (await readYamlOr(path, CheckpointSchema, () => null) !== null) return this.applyLocked(path);
+			const origin = await this.origin(jobId);
+			requireDream(origin !== null, "缺少 Dream 原始快照。");
+			const records = (await this.records(jobId)).map((record) => record.checkpoint);
+			requireDream(records.every((record) => record.applied), "整理组仍待恢复。");
+			const checkpoint = CheckpointSchema.parse({
+				team_authorized: this.context.mode === "team",
+				snapshot_at: origin.snapshot_at,
+				input_versions: versions(origin.claims),
+				coverage: origin.coverage,
+				plan: {
+					review: progress.discovery.review,
+					groups: records.flatMap((record) => record.plan.groups)
+				},
+				receipts: Object.fromEntries(records.flatMap((record) => Object.entries(record.receipts))),
+				exploration_receipts: records.reduce((count, record) => count + (record.exploration_receipts ?? 0), 0),
+				groups: records.flatMap((record) => record.groups),
+				safety_reviews: [],
+				self_reviews: records.flatMap((record) => record.self_reviews),
+				trace_id: deriveTraceId(nowSeconds(), "dream_claim_review", [], []),
+				applied: false,
+				success_at: null,
+				self_versions: Object.fromEntries(records.flatMap((record) => Object.entries(record.self_versions))),
+				operation: null
+			});
+			control.signal.throwIfAborted();
+			control.prepared();
+			await writeYamlAtomic(path, checkpoint, CheckpointSchema, this.context.logger);
+			return this.applyLocked(path);
+		}, {
+			timeoutMs: this.context.lockTimeoutMs,
+			signal: control.signal
+		});
+	}
+	async applyLocked(path) {
+		const checkpoint = await readYaml(path, CheckpointSchema);
+		const pointer = await this.pending();
+		if (pointer !== null && pointer !== path) throw new StoreError("conflict", "Another Dream group requires recovery first.");
+		if (checkpoint.applied && pointer === null) return checkpoint;
+		const jobId = checkpoint.operation?.job_id ?? KeySchema.parse(path.slice(dirname(path).length + 1, -5));
+		requireDream(checkpoint.operation === null || checkpoint.operation === void 0 || checkpoint.operation.hard_validation_passed, "执行记录尚未通过硬校验。");
+		requireDream(checkpoint.safety_reviews.length === 0, "不支持没有受限查证授权清单的旧 safety_reviews；不能跳过其证据依赖。");
+		requireDream(checkpoint.groups.length === checkpoint.plan.groups.length, "整理提交的组数量不一致。");
+		for (const group of checkpoint.groups) requireDream(group.before.length === group.after.length && group.before.every((claim, index) => claim.id === group.after[index]?.id && claim.holder === this.context.agentId && group.after[index]?.holder === this.context.agentId), "整理提交的 before/after 或 holder 不一致。");
+		await executionAudit(this.context, jobId, checkpoint);
+		if (!checkpoint.applied) {
+			if (checkpoint.team_authorized === void 0 && this.context.mode === "team") this.context.logger.warn("旧 Dream 事务缺少团队共享授权，仅恢复本地效果。");
+			await writeYamlAtomic(this.context.paths.dreamPending, path, z.string(), this.context.logger);
+			for (const [index, group] of checkpoint.groups.entries()) {
+				if (group.completed) continue;
+				const plan = checkpoint.plan.groups[index];
+				requireDream(plan !== void 0, "缺少提交计划。");
+				const selected = Object.fromEntries(plan.evidence_ids.map((id) => {
+					const receipt = checkpoint.receipts[id];
+					requireDream(receipt !== void 0, "执行记录缺少证据依赖。");
+					return [id, receipt];
+				}));
+				const origin = await this.origin(jobId);
+				const validEvidence = await new EvidenceStore(this.context, jobId, checkpoint.operation?.group_id ?? "legacy").authorize(selected, origin?.workspace_root, group.before);
+				const current = await new ClaimStore(this.context).list();
+				const graph = [...current.filter((claim) => !group.after.some((target) => target.id === claim.id)), ...group.after];
+				const conflict = !validEvidence || group.before.some((before, index) => !current.some((claim) => claim.id === before.id && (sameClaim(claim, before) || group.after[index] !== void 0 && sameClaim(claim, group.after[index])))) || group.after.some((after) => after.source_claim_ids.some((source) => !group.before.find((before) => before.id === after.id)?.source_claim_ids.includes(source) && graph.some((claim) => claim.id === source && reaches(claim.id, after.id, graph))));
+				if (!conflict) {
+					for (const target of [...group.after].sort((a, b) => Number(a.status === "deprecated") - Number(b.status === "deprecated"))) if (!current.some((claim) => sameClaim(claim, target))) await new ClaimStore(this.context).write(target);
+				}
+				const actual = await new ClaimStore(this.context).list();
+				const staged = group.after.filter((target) => actual.some((claim) => sameClaim(claim, target)));
+				const dependencies = plan.kind === "consolidation" ? staged.filter((claim) => claim.status === "deprecated").map((retired) => {
+					const before = group.before.find((claim) => claim.id === retired.id);
+					requireDream(before !== void 0, "整合缺少来源原文。");
+					const ids = plan.coverage.find((item) => item.input_id === retired.id)?.output_ids ?? [];
+					return {
+						before,
+						retired,
+						carriers: group.after.filter((claim) => ids.includes(claim.id) && claim.status !== "deprecated")
+					};
+				}) : [];
+				if (checkpoint.team_authorized === true) await new UploadStore(this.context).enqueue(staged, [], true, dependencies);
+				for (const claim of staged) if (!group.before.some((before) => sameClaim(before, claim))) checkpoint.self_versions[claim.id] = contentHash(claim);
+				group.skipped = conflict;
+				group.completed = true;
+				await writeYamlAtomic(path, checkpoint, CheckpointSchema, this.context.logger);
+				await executionAudit(this.context, jobId, checkpoint);
+			}
+			const input_claims = [...new Set(checkpoint.groups.flatMap((group) => group.before.map((claim) => claim.id)))].map((id) => SourceIdSchema.parse(id));
+			await new TraceStore(this.context).write(TraceSchema.parse({
+				id: checkpoint.trace_id,
+				name: "dream_claim_review",
+				task: JSON.stringify({
+					kind: "dream",
+					coverage: checkpoint.coverage,
+					review: checkpoint.plan,
+					evidence: checkpoint.receipts,
+					groups: checkpoint.groups,
+					self_reviews: checkpoint.self_reviews
+				}),
+				agent: this.context.agentId,
+				input_claims,
+				output_claims: Object.keys(checkpoint.self_versions),
+				created_at: checkpoint.snapshot_at
+			}));
+			checkpoint.applied = true;
+			checkpoint.success_at = nowSeconds();
+			await writeYamlAtomic(path, checkpoint, CheckpointSchema, this.context.logger);
+		}
+		await executionAudit(this.context, jobId, checkpoint);
+		const previous = await this.state();
+		const state = checkpoint.operation !== null && checkpoint.operation !== void 0 || previous.last_success_at !== void 0 && previous.last_success_at !== null && checkpoint.success_at !== null && checkpoint.success_at !== void 0 && Date.parse(previous.last_success_at) > Date.parse(checkpoint.success_at) ? {
+			...previous,
+			known_versions: {
+				...previous.known_versions,
+				...checkpoint.self_versions
+			}
+		} : {
+			last_success_at: checkpoint.success_at,
+			last_input_snapshot_at: checkpoint.snapshot_at,
+			known_versions: {
+				...checkpoint.input_versions,
+				...checkpoint.self_versions
+			}
+		};
+		await writeYamlAtomic(this.context.paths.dreamState, state, DreamStateSchema, this.context.logger);
+		await removeFile(this.context.paths.dreamPending, this.context.logger);
+		return checkpoint;
+	}
+	async archive(jobId, key, value) {
+		await writeTextAtomic(join(this.context.paths.dreamJob(jobId), "history", `${KeySchema.parse(key)}.json`), JSON.stringify(value, null, 2), this.context.logger);
+	}
+};
+//#endregion
+export { DreamStore as t };