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

package/lib/service-BPwaZzFF.js

@@ -0,0 +1,1106 @@
+import { h as TraceIdSchema, l as ClaimIdSchema, t as ClaimSchema, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { n as resolveRoute, r as structuredCall } from "./structured-C9byFuzm.js";
+import { A as valueHash, B as CandidateSchema, C as expandDraft, D as sameIds, E as reviewInput, G as DraftResponseSchema, M as validateEvidenceSummaryPreservation, O as validateCandidates, U as DiscoverySchema, W as DraftGroupSchema, X as KeepReasonSchema, Y as HashSchema, Z as KeySchema, _ as dreamEligible, a as GlobArgs, b as validateSelfReview, ct as ReviewSummarySchema, g as conservativeTokens, h as claimInput, j as validateEvidencePreservation, k as validateConsolidationSources, o as GrepArgs, pt as requireDream, q as DreamValidationError, r as EvidenceStore, rt as ProgressSchema, s as ReadArgs, st as ReviewResponseSchema, ut as SemanticReviewSchema, w as prepareGroup, x as validateSemanticReview } from "./evidence-store-DW7kj20i.js";
+import { C as StoreError, S as LockTimeoutError, _ as JobError, c as readYamlOr, g as DreamYield, h as DreamStopped, l as writeYamlAtomic, n as withFileLock, s as readYaml, w as hasCode, x as jobPriority } from "./lock-DbmlKOoX.js";
+import { l as sameClaim, r as KnowledgeBusy, s as ensureKnowledgeReady } 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, t as ConsolidationDeliverySchema } from "./uploads-BCA2p92b.js";
+import { t as UploadDelivery } from "./deliver-C-dmhkfm.js";
+import { z } from "zod";
+import fs from "node:fs/promises";
+import { join } from "node:path";
+//#region src/dream/sync.ts
+const SyncValidationSchema = z.strictObject({
+	validation_id: HashSchema,
+	input: z.strictObject({
+		before: ClaimSchema,
+		carriers: z.array(ClaimSchema),
+		previous_dependency: ConsolidationDeliverySchema,
+		current_source: ClaimSchema
+	})
+});
+const SyncRecordSchema = z.strictObject({
+	validation: SyncValidationSchema,
+	review: SemanticReviewSchema,
+	applied: z.boolean(),
+	abandoned: z.boolean().default(false)
+});
+var DreamSync = class {
+	context;
+	semanticReview;
+	constructor(context, semanticReview = false) {
+		this.context = context;
+		this.semanticReview = semanticReview;
+	}
+	async resume(jobId, sourceId, signal) {
+		const root = join(this.context.paths.dreamJob(jobId), "sync_reviews");
+		let files;
+		try {
+			files = await fs.readdir(root);
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return false;
+			throw error;
+		}
+		for (const file of files.filter((name) => /^[0-9a-f]{64}\.yaml$/.test(name)).sort()) {
+			const path = join(root, file);
+			const record = await readYaml(path, SyncRecordSchema);
+			if (record.validation.input.before.id !== sourceId || record.abandoned) continue;
+			if (record.applied) return true;
+			try {
+				await this.apply(jobId, record.validation, record.review, signal);
+				return true;
+			} catch (error) {
+				if (!(error instanceof DreamValidationError || error instanceof StoreError && error.kind === "conflict")) throw error;
+				await writeYamlAtomic(path, {
+					...record,
+					abandoned: true
+				}, SyncRecordSchema, this.context.logger);
+			}
+		}
+		return false;
+	}
+	async prepare(sourceId, carrierIds, signal) {
+		return withFileLock(this.context.paths.knowledgeLock, async () => {
+			await ensureKnowledgeReady(this.context.paths.root);
+			return this.prepareLocked(sourceId, carrierIds);
+		}, { signal });
+	}
+	async prepareLocked(sourceId, carrierIds) {
+		requireDream(this.context.mode === "team", "单人模式没有整合交付依赖。");
+		const previous = (await new UploadStore(this.context).read()).consolidations?.find((group) => group.retired.id === sourceId);
+		requireDream(previous !== void 0, "没有对应的待交付整合来源。");
+		const current = await new ClaimStore(this.context).list();
+		const source = current.find((claim) => claim.id === sourceId);
+		requireDream(source !== void 0 && sameClaim(source, previous.retired) && source.holder === this.context.agentId, "来源已变化，旧弃用请求不能重绑。");
+		const carriers = carrierIds.map((id) => current.find((claim) => claim.id === id));
+		requireDream(carriers.length > 0 && new Set(carrierIds).size === carrierIds.length && carriers.every((claim) => claim !== void 0 && claim.holder === this.context.agentId && claim.status !== "deprecated"), "承接必须是当前完整、唯一、存续的自身 Claim。");
+		const input = {
+			before: previous.before,
+			carriers: carriers.filter((claim) => claim !== void 0),
+			previous_dependency: previous,
+			current_source: source
+		};
+		if (!this.semanticReview) validateEvidenceSummaryPreservation(input.before, input.carriers);
+		return SyncValidationSchema.parse({
+			validation_id: valueHash(input),
+			input
+		});
+	}
+	async apply(jobId, validation, review, signal) {
+		const input = validation.input;
+		const carrierIds = input.carriers.map((claim) => claim.id);
+		requireDream(valueHash(input) === validation.validation_id, "同步复核哈希必须绑定完整输入。");
+		requireDream(review.claims.length === 1 && review.claims[0]?.claim_id === input.before.id, "同步复核只描述原整合来源。");
+		const item = review.claims[0];
+		requireDream(item !== void 0 && item.final_name === input.current_source.name && item.name_reason.trim() !== "" && !item.factual_correction && item.evidence_ids.length === 0 && sameIds(item.output_ids, carrierIds), "同步复核只能确认当前承接完整保留信息，不能纠正事实或省略承接项。");
+		validateConsolidationSources(input.before, input.carriers, carrierIds);
+		await withFileLock(this.context.paths.knowledgeLock, async () => {
+			await ensureKnowledgeReady(this.context.paths.root);
+			const path = join(this.context.paths.dreamJob(KeySchema.parse(jobId)), "sync_reviews", `${validation.validation_id}.yaml`);
+			if ((await readYamlOr(path, SyncRecordSchema, () => null))?.applied) return;
+			const current = await this.prepareLocked(input.before.id, carrierIds);
+			const revised = {
+				...input.previous_dependency,
+				carriers: input.carriers
+			};
+			const rebound = valueHash(current.input.previous_dependency) === valueHash(revised) && current.input.carriers.every((claim, index) => input.carriers[index] !== void 0 && sameClaim(claim, input.carriers[index]));
+			requireDream(current.validation_id === validation.validation_id || rebound, "同步输入版本已变化，必须重新读取和复核。");
+			signal.throwIfAborted();
+			await writeYamlAtomic(path, {
+				validation,
+				review,
+				applied: false
+			}, SyncRecordSchema, this.context.logger);
+			await new UploadStore(this.context).rebind(input.previous_dependency, revised);
+			await writeYamlAtomic(path, {
+				validation,
+				review,
+				applied: true
+			}, SyncRecordSchema, this.context.logger);
+		}, { signal });
+	}
+};
+//#endregion
+//#region src/dream/autonomous.ts
+const groupId = { group_id: KeySchema };
+const DreamTools = {
+	dream_record_candidates: z.strictObject({ candidates: z.array(CandidateSchema).min(1) }),
+	dream_stage_group: z.strictObject({
+		...groupId,
+		group: DraftGroupSchema.nullable()
+	}),
+	dream_validate: z.strictObject(groupId),
+	dream_apply_group: z.strictObject({
+		...groupId,
+		validation_id: HashSchema,
+		review: SemanticReviewSchema
+	}),
+	dream_keep_candidate: z.strictObject({
+		...groupId,
+		reason_kind: KeepReasonSchema,
+		reason: z.string().min(1)
+	}),
+	dream_read_draft: z.strictObject({ group_id: KeySchema.optional() }),
+	dream_read_history: z.strictObject({
+		offset: z.number().int().nonnegative().default(0),
+		limit: z.number().int().min(1).max(10).default(5)
+	}),
+	dream_review_sync: z.strictObject({
+		source_id: ClaimIdSchema,
+		carrier_ids: z.array(ClaimIdSchema).min(1),
+		validation_id: HashSchema.optional(),
+		review: SemanticReviewSchema.optional()
+	}),
+	dream_finish: z.strictObject({ review: ReviewSummarySchema }),
+	read_claim: z.strictObject({ id: ClaimIdSchema }),
+	read_trace: z.strictObject({
+		claim_id: ClaimIdSchema.optional(),
+		trace_id: TraceIdSchema.optional(),
+		id: TraceIdSchema.optional(),
+		offset: z.number().int().nonnegative().default(0),
+		limit: z.number().int().min(1).max(8e3).optional()
+	}).refine((value) => value.id === void 0 ? value.claim_id !== void 0 : value.claim_id === void 0 && value.trace_id === void 0, "提供 claim_id，按需提供 trace_id；旧 id 入口不能混用其它 ID 字段。"),
+	file_read: ReadArgs,
+	file_glob: GlobArgs,
+	file_grep: GrepArgs
+};
+const isDreamTool = (name) => Object.hasOwn(DreamTools, name);
+var DreamSession = class DreamSession {
+	knowledge;
+	job;
+	control;
+	progress;
+	claims;
+	originalHigh;
+	workspace;
+	boundary;
+	pending = Promise.resolve();
+	constructor(knowledge, job, control, progress, claims, originalHigh, workspace, boundary) {
+		this.knowledge = knowledge;
+		this.job = job;
+		this.control = control;
+		this.progress = progress;
+		this.claims = claims;
+		this.originalHigh = originalHigh;
+		this.workspace = workspace;
+		this.boundary = boundary;
+	}
+	static async create(knowledge, job, control, boundary) {
+		const store = knowledge.dreamStore();
+		const origin = await store.origin(job.id);
+		requireDream(origin?.workspace_root !== void 0, "缺少 Dream 工作区快照。");
+		const progress = await store.progress(job.id) ?? ProgressSchema.parse({
+			schemaVersion: 1,
+			discovery: {
+				review: {
+					quality: "尚未检查",
+					evidence: "尚未探索",
+					consolidation: "尚未检查"
+				},
+				candidates: [],
+				sync_candidates: []
+			},
+			entries: [],
+			syncCompleted: [],
+			finished: false,
+			summary: null
+		});
+		const input = claimInput(origin.claims.filter((claim) => claim.status !== "deprecated"));
+		if (progress.autonomy === void 0) progress.autonomy = {
+			steps: 0,
+			epoch: 0,
+			limit: knowledge.config.dream.maxModelSteps,
+			read_ids: input.loaded.map((claim) => claim.id)
+		};
+		const claims = [...origin.claims];
+		for (const { checkpoint } of await store.records(job.id)) for (const group of checkpoint.groups.filter((item) => item.completed && !item.skipped)) for (const after of group.after) {
+			const index = claims.findIndex((claim) => claim.id === after.id);
+			const previous = claims[index];
+			if (index >= 0 && previous !== void 0 && Date.parse(after.updated_at ?? after.created_at) >= Date.parse(previous.updated_at ?? previous.created_at)) claims[index] = after;
+		}
+		for (const entry of progress.entries.filter((item) => item.status === "pending")) {
+			const record = (await store.records(job.id)).find(({ checkpoint }) => entry.validation !== null && checkpoint.operation?.group_id === entry.candidate.group_id && checkpoint.operation.validation_id === entry.validation.validation_id && checkpoint.applied);
+			if (record !== void 0) {
+				entry.status = record.checkpoint.groups.some((group) => group.skipped) ? "skipped" : "executed";
+				entry.reason = "从持久执行回执恢复。";
+			}
+		}
+		if ((await store.final(job.id))?.applied) progress.finished = true;
+		await store.saveProgress(job.id, progress);
+		return new DreamSession(knowledge, job, control, progress, claims, new Set(origin.claims.filter((claim) => claim.confidence === "high").map((claim) => claim.id)), origin.workspace_root, boundary);
+	}
+	get finished() {
+		return this.progress.finished;
+	}
+	get exhausted() {
+		const budget = this.progress.autonomy;
+		return budget !== void 0 && budget.steps >= budget.limit;
+	}
+	get wrappingUp() {
+		return this.progress.autonomy?.wrap_up !== void 0;
+	}
+	budgetNotice() {
+		const budget = this.progress.autonomy;
+		if (budget === void 0) return "";
+		return `Dream 运行额度：\n${JSON.stringify({
+			budget,
+			phase: this.wrappingUp ? "wrap_up" : "exploration",
+			instruction: this.wrappingUp ? "探索额度已用尽，现在进行本次 Dream 的有限收尾。禁止发现新候选、读取新证据或启动同步复核；只可完成已登记项的草稿、校验与提交，或保留原样。立即用 dream_finish 总结真实覆盖和未完成事项，剩余 pending 将记为未完成并丢弃未提交草稿。本次结束后不会再次续做；不为赶结束跳过校验。" : "按剩余额度安排探索；完成时调用 dream_finish，不把未执行事项写成已完成。"
+		})}`;
+	}
+	async admitStep(signal) {
+		this.control.signal.throwIfAborted();
+		signal?.throwIfAborted();
+		await this.boundary();
+		requireDream(!this.finished, "Dream 已结束。");
+		const budget = this.progress.autonomy;
+		requireDream(budget !== void 0, "缺少持久轮数预算。");
+		if (this.exhausted) {
+			budget.wrap_up ??= {
+				steps: 0,
+				limit: this.knowledge.config.dream.maxWrapUpSteps
+			};
+			if (budget.wrap_up.steps >= budget.wrap_up.limit) {
+				await this.finishBudget(signal);
+				throw new JobError("dream_finished", "Dream 已按额度收尾结束。");
+			}
+			budget.wrap_up.steps += 1;
+		} else budget.steps += 1;
+		await this.save();
+		signal?.throwIfAborted();
+	}
+	async finishBudget(signal) {
+		if (this.finished) return;
+		requireDream(this.exhausted, "尚未耗尽探索额度。");
+		const control = {
+			...this.control,
+			signal: signal === void 0 ? this.control.signal : AbortSignal.any([this.control.signal, signal])
+		};
+		control.signal.throwIfAborted();
+		const review = Object.fromEntries([
+			"quality",
+			"evidence",
+			"consolidation"
+		].map((kind) => {
+			const entries = this.progress.entries.filter((entry) => entry.candidate.kind === kind);
+			return [kind, `模型未提交收尾总结，插件按持久记录终结本次：${entries.filter((entry) => entry.status === "executed").length} 项已执行，${entries.filter((entry) => entry.status === "kept").length} 项明确保留，${entries.filter((entry) => entry.status === "pending" || entry.status === "skipped").length} 项未完成或跳过。未检查范围不能视作已验证；详见逐项回执。`];
+		}));
+		await this.finish(ReviewSummarySchema.parse(review), control);
+	}
+	async finish(review, control) {
+		if (this.exhausted) for (const entry of this.progress.entries.filter((item) => item.status === "pending")) {
+			entry.status = "skipped";
+			entry.reason = "本次额度已用尽，收尾时仍未完成；丢弃未提交草稿，不代表知识无效。";
+			entry.draft = null;
+			entry.validation = null;
+			entry.review = null;
+		}
+		requireDream(this.progress.entries.every((entry) => entry.status !== "pending"), "仍有候选待处理。");
+		if (!this.exhausted && this.readable().length > 0 && !this.progress.finish_reminder_sent && !this.progress.proposal_attempted && this.progress.entries.length === 0 && this.progress.exploration_receipts === 0 && (await this.knowledge.dreamStore().records(this.job.id)).length === 0) {
+			this.progress.finish_reminder_sent = true;
+			await this.save();
+			return {
+				accepted: false,
+				finished: false,
+				confirmation_required: true,
+				activity: {
+					exploration_receipts: 0,
+					proposal_attempted: false,
+					executed_groups: 0
+				},
+				note: "本轮尚无探索回执或修改提案。这是一次结束前提醒，不要求增加工具调用或修改数量。请检查：A 判断记忆层级，high 也可清理纯工作记录；B 才受 medium/low 门槛限制；C 可以保留分开的知识。尚未暂存/受理不是不能提出候选的理由。可以继续探索或暂存草稿；若仍决定全部保留，请在 ABC 总结中简述代表 Claim 的保留依据、B 未选候选的原因（未探索不等于查证后缺证据），再调用 dream_finish 即可结束，不会重复此提醒。"
+			};
+		}
+		this.progress.discovery.review = review;
+		await this.save();
+		const checkpoint = await this.knowledge.dreamStore().finish(this.job.id, this.progress, control);
+		control.committed?.();
+		this.progress.finished = true;
+		await this.save();
+		return {
+			finished: true,
+			updatedClaimIds: Object.keys(checkpoint.self_versions),
+			budget_limited: this.exhausted
+		};
+	}
+	save() {
+		return this.knowledge.dreamStore().saveProgress(this.job.id, this.progress);
+	}
+	current(groupId) {
+		const entry = this.progress.entries.find((item) => item.status === "pending");
+		requireDream(entry !== void 0 && (groupId === void 0 || entry.candidate.group_id === groupId), "请先处理 candidate_progress.current；不能跳过当前候选或重放已执行组。");
+		return entry;
+	}
+	readable() {
+		return this.claims.filter((claim) => this.progress.autonomy?.read_ids.includes(claim.id));
+	}
+	candidateProgress() {
+		return {
+			current: this.progress.entries.find((entry) => entry.status === "pending")?.candidate ?? null,
+			entries: this.progress.entries.map(({ candidate, status, reason }) => ({
+				...candidate,
+				status,
+				reason
+			}))
+		};
+	}
+	async input() {
+		const store = this.knowledge.dreamStore();
+		const origin = await store.origin(this.job.id);
+		return {
+			workspace_root: this.workspace,
+			dream_context: {
+				agent_id: this.knowledge.agentId,
+				snapshot_at: origin?.snapshot_at,
+				eligibility: this.claims.map((claim) => ({
+					id: claim.id,
+					owned: true,
+					evidence_eligible: origin?.claims.some((original) => original.id === claim.id && original.confidence !== "high") && claim.status !== "deprecated"
+				}))
+			},
+			claims: this.readable(),
+			coverage: origin?.coverage,
+			claim_catalog: this.claims.filter((claim) => !this.progress.autonomy?.read_ids.includes(claim.id)).map(({ id, name, scope, status }) => ({
+				id,
+				name,
+				scope,
+				status
+			})),
+			policy_context: {
+				available: false,
+				complete: false
+			},
+			pending_consolidation_sync: (await new UploadStore(this.knowledge.context()).read()).consolidations ?? [],
+			capabilities: {
+				evidence_calibration: this.knowledge.config.dream.evidenceCalibration,
+				shell: false,
+				evidence_limits: {
+					calls_per_group: this.knowledge.config.dream.evidenceMaxCalls,
+					bytes_per_group: this.knowledge.config.dream.evidenceMaxBytes
+				}
+			},
+			budget: this.progress.autonomy,
+			authoritative_state: {
+				candidate_progress: this.candidateProgress(),
+				drafts: this.progress.entries.filter((entry) => entry.status === "pending"),
+				executions: (await store.records(this.job.id)).map(({ checkpoint }) => ({
+					operation: checkpoint.operation,
+					groups: checkpoint.groups
+				})),
+				evidence: await this.evidenceState()
+			}
+		};
+	}
+	async evidenceState() {
+		return Object.fromEntries(await Promise.all(this.progress.entries.filter((entry) => entry.status === "pending").map(async (entry) => [entry.candidate.group_id, await new EvidenceStore(this.knowledge.context(), this.job.id, entry.candidate.group_id).read()])));
+	}
+	register(candidates) {
+		const next = structuredClone(this.progress.entries);
+		const groups = /* @__PURE__ */ new Set();
+		for (const candidate of candidates) {
+			requireDream(candidate.group_id !== "_discovery", "该组名为宿主只读探索保留，请使用其他 group_id。");
+			requireDream(!groups.has(candidate.group_id), "同一批不能重复登记 group_id。");
+			groups.add(candidate.group_id);
+			validateCandidates([candidate], this.readable(), this.knowledge.context().agentId, this.knowledge.config.dream.evidenceCalibration);
+			requireDream(candidate.kind !== "evidence" || candidate.claim_ids.every((id) => !this.originalHigh.has(id)), "high Claim 不进入证据校准；资格以本轮原始版本为准。");
+			const prior = next.find((entry) => entry.status === "pending" && entry.candidate.group_id === candidate.group_id);
+			for (const entry of next.filter((item) => item.status === "pending")) if (entry === prior) requireDream(entry.candidate.claim_ids.every((id) => candidate.claim_ids.includes(id)), "不能静默删除当前候选的 Claim；先处理或明确保留。");
+			else requireDream(!entry.candidate.claim_ids.some((id) => candidate.claim_ids.includes(id)), "待处理候选不能重叠；请在已有组内细化。");
+			if (prior !== void 0) {
+				if (prior.candidate.kind !== candidate.kind || !sameIds(prior.candidate.claim_ids, candidate.claim_ids)) {
+					prior.validation = null;
+					prior.review = null;
+				}
+				prior.candidate = candidate;
+			} else next.push({
+				candidate,
+				status: "pending",
+				reason: "",
+				draft: null,
+				validation: null,
+				review: null
+			});
+		}
+		this.progress.entries = next;
+		this.progress.discovery.candidates = next.map((entry) => entry.candidate);
+	}
+	execute(name, args, signal) {
+		const control = {
+			...this.control,
+			signal: signal === void 0 ? this.control.signal : AbortSignal.any([this.control.signal, signal])
+		};
+		const result = this.pending.then(async () => {
+			control.signal.throwIfAborted();
+			await this.boundary();
+			control.signal.throwIfAborted();
+			requireDream(!this.finished, "Dream 已结束。");
+			const value = await this.dispatch(name, args, control);
+			if ([
+				"read_claim",
+				"read_trace",
+				"file_read",
+				"file_glob",
+				"file_grep"
+			].includes(name)) {
+				this.progress.exploration_receipts += 1;
+				await this.save();
+			}
+			return value;
+		});
+		this.pending = result.catch(() => {});
+		return result;
+	}
+	async dispatch(name, args, control) {
+		if (this.wrappingUp) requireDream(![
+			"dream_record_candidates",
+			"file_read",
+			"file_glob",
+			"file_grep",
+			"read_trace",
+			"dream_review_sync"
+		].includes(name), "已进入有限收尾；不能展开新探索，请处理已有候选或调用 dream_finish。");
+		if (name === "dream_record_candidates") {
+			const input = DreamTools[name].parse(args);
+			this.register(input.candidates);
+			await this.save();
+		} else if (name === "read_claim") {
+			const { id } = DreamTools[name].parse(args);
+			const claim = this.claims.find((claim) => claim.id === id);
+			requireDream(claim !== void 0, "只可读取本轮冻结的自有 Claim。");
+			const current = (await this.knowledge.snapshot()).claims.find((value) => value.id === id);
+			requireDream(current !== void 0 && sameClaim(current, claim), "Claim 已被外部修改，本轮请保留该项。");
+			if (!this.progress.autonomy?.read_ids.includes(id)) this.progress.autonomy?.read_ids.push(id);
+			await this.save();
+			return claim;
+		} else if (name === "read_trace") {
+			const input = DreamTools[name].parse(args);
+			if (input.claim_id !== void 0) requireDream(this.readable().some((claim) => claim.id === input.claim_id), "请先 read_claim 读取本轮自有 Claim，再查询其 Trace。");
+			if (input.claim_id !== void 0 && input.trace_id === void 0) return {
+				...await this.knowledge.listTraces({
+					claimId: input.claim_id,
+					offset: input.offset,
+					limit: Math.min(input.limit ?? 20, 100)
+				}),
+				independent_evidence: false
+			};
+			const id = input.trace_id ?? input.id;
+			requireDream(id !== void 0, "读取 Trace 正文需要 trace_id。");
+			const trace = await new TraceStore(this.knowledge.context()).read(id);
+			requireDream(trace !== null && trace.agent === this.knowledge.agentId && [...trace.input_claims, ...trace.output_claims].some((id) => input.claim_id === void 0 ? this.readable().some((claim) => claim.id === id) : id === input.claim_id), "只可读取本轮已读 Claim 关联的本地自身 Trace。");
+			const limit = input.limit ?? 4e3;
+			const chars = Array.from(JSON.stringify(trace));
+			const end = Math.min(chars.length, input.offset + limit);
+			return {
+				content: chars.slice(input.offset, end).join(""),
+				total_chars: chars.length,
+				truncated: input.offset > 0 || end < chars.length,
+				next_offset: end < chars.length ? end : null,
+				independent_evidence: false
+			};
+		} else if (name === "file_read" || name === "file_glob" || name === "file_grep") {
+			const entry = name === "file_read" ? this.current() : void 0;
+			const original = await this.knowledge.dreamStore().origin(this.job.id);
+			const eligible = entry === void 0 ? (original?.claims ?? []).filter((claim) => claim.confidence !== "high" && claim.status !== "deprecated") : this.readable().filter((claim) => entry.candidate.claim_ids.includes(claim.id) && original?.claims.some((input) => input.id === claim.id && input.confidence !== "high") && claim.status !== "deprecated");
+			const evidence = new EvidenceStore(this.knowledge.context(), this.job.id, entry?.candidate.group_id ?? "_discovery");
+			await evidence.initialize(this.workspace, eligible, this.knowledge.config.dream, control.signal);
+			await evidence.reopen(control.signal);
+			return evidence.execute(name === "file_read" ? "read" : name === "file_glob" ? "glob" : "grep", DreamTools[name].parse(args), eligible, control.signal);
+		} else if (name === "dream_stage_group") {
+			const input = DreamTools[name].parse(args);
+			if (input.group !== null) {
+				this.progress.proposal_attempted = true;
+				await this.save();
+			}
+			if (input.group === null) {
+				const entry = this.current(input.group_id);
+				entry.draft = null;
+				entry.validation = null;
+				entry.review = null;
+				await this.save();
+			} else {
+				const group = expandDraft(input.group, this.readable());
+				const receipts = z.record(z.string(), z.json()).parse((await new EvidenceStore(this.knowledge.context(), this.job.id, input.group_id).read())?.receipts ?? {});
+				prepareGroup(group, this.readable(), this.knowledge.context().agentId, void 0, {
+					enabled: this.knowledge.config.dream.evidenceCalibration,
+					receipts,
+					semanticReview: true
+				});
+				if (!this.progress.entries.some((entry) => entry.status === "pending" && entry.candidate.group_id === input.group_id)) {
+					requireDream(!this.wrappingUp, "收尾阶段不能新增候选。");
+					requireDream(!this.progress.entries.some((entry) => entry.status === "pending"), "先处理当前候选。");
+					this.register([{
+						group_id: input.group_id,
+						claim_ids: input.group.operations.map((op) => op.id),
+						kind: input.group.kind,
+						reason: input.group.reason
+					}]);
+				}
+				const entry = this.current(input.group_id);
+				requireDream(input.group.kind === entry.candidate.kind && sameIds(input.group.operations.map((op) => op.id), entry.candidate.claim_ids), "草稿必须包含当前候选全部且仅这些 ID 与 kind。");
+				entry.draft = group;
+				entry.validation = null;
+				entry.review = null;
+				await this.save();
+			}
+		} else if (name === "dream_validate") {
+			const input = DreamTools[name].parse(args);
+			const entry = this.current(input.group_id);
+			requireDream(entry.draft !== null, "请先暂存完整草稿。");
+			requireDream(entry.draft.kind === entry.candidate.kind && sameIds(entry.draft.updates.map((claim) => claim.id), entry.candidate.claim_ids), "候选已细化，请保留原编辑并补齐当前候选的完整草稿后再 validate。");
+			const receipts = z.record(z.string(), z.json()).parse((await new EvidenceStore(this.knowledge.context(), this.job.id, input.group_id).read())?.receipts ?? {});
+			prepareGroup(entry.draft, this.readable(), this.knowledge.context().agentId, void 0, {
+				enabled: this.knowledge.config.dream.evidenceCalibration,
+				receipts,
+				semanticReview: true
+			});
+			entry.validation = reviewInput(input.group_id, entry.draft, this.readable(), receipts);
+			await this.save();
+			return entry.validation;
+		} else if (name === "dream_apply_group") {
+			const input = DreamTools[name].parse(args);
+			const entry = this.current(input.group_id);
+			requireDream(entry.draft !== null && entry.validation !== null && input.validation_id === entry.validation.validation_id, "缺少当前草稿版本的 validate，请重新校验。");
+			const evidence = new EvidenceStore(this.knowledge.context(), this.job.id, input.group_id);
+			if (await evidence.read() !== null) await evidence.complete(control.signal);
+			const checkpoint = await this.knowledge.applyDreamGroup(this.job.id, input.group_id, entry.draft, entry.validation, input.review, null, control);
+			control.committed?.();
+			entry.status = checkpoint.groups.some((group) => group.skipped) ? "skipped" : "executed";
+			entry.reason = entry.status === "executed" ? "已按逐 Claim 语义复核提交。" : "外部版本或证据变化，未继续旧修改。";
+			entry.review = {
+				decision: "apply",
+				reason: entry.reason,
+				reason_kind: "useful_knowledge",
+				semantic: input.review,
+				self_review: null
+			};
+			if (entry.status === "executed") for (const after of checkpoint.groups.flatMap((group) => group.after)) {
+				const index = this.claims.findIndex((claim) => claim.id === after.id);
+				if (index >= 0) this.claims[index] = after;
+			}
+			await this.save();
+			return {
+				executed: entry.status === "executed",
+				candidate_progress: this.candidateProgress(),
+				changes: checkpoint.groups
+			};
+		} else if (name === "dream_keep_candidate") {
+			const input = DreamTools[name].parse(args);
+			const entry = this.current(input.group_id);
+			requireDream(input.reason_kind !== "no_consolidation_benefit" || entry.candidate.kind === "consolidation", "no_consolidation_benefit 仅适用于 C。");
+			entry.status = "kept";
+			entry.reason = `${input.reason_kind}: ${input.reason}`;
+			entry.draft = null;
+			entry.validation = null;
+			await this.save();
+		} else if (name === "dream_read_draft") {
+			const input = DreamTools[name].parse(args);
+			return {
+				candidate_progress: this.candidateProgress(),
+				drafts: this.progress.entries.filter((entry) => input.group_id === void 0 ? entry.status === "pending" : entry.candidate.group_id === input.group_id),
+				budget: this.progress.autonomy
+			};
+		} else if (name === "dream_read_history") {
+			const input = DreamTools[name].parse(args);
+			const records = await this.knowledge.dreamStore().records(this.job.id);
+			return {
+				records: records.slice(input.offset, input.offset + input.limit).map(({ checkpoint }) => checkpoint),
+				total: records.length
+			};
+		} else if (name === "dream_review_sync") {
+			const input = DreamTools[name].parse(args);
+			const sync = new DreamSync(this.knowledge.context(), true);
+			const validation = await sync.prepare(input.source_id, input.carrier_ids, control.signal);
+			if (input.review === void 0) return validation;
+			requireDream(input.validation_id === validation.validation_id, "同步依赖版本已变化，请重新读取并复核。");
+			await sync.apply(this.job.id, validation, input.review, control.signal);
+			return { synchronized: input.source_id };
+		} else if (name === "dream_finish") return this.finish(DreamTools[name].parse(args).review, control);
+		return {
+			candidate_progress: this.candidateProgress(),
+			budget: this.progress.autonomy
+		};
+	}
+};
+//#endregion
+//#region src/dream/service.ts
+const SummarySchema = z.strictObject({
+	checked: z.string(),
+	findings: z.string(),
+	uncertainties: z.string(),
+	next_steps: z.string()
+});
+var AcnDream = class {
+	knowledge;
+	backend;
+	render;
+	beforeCall;
+	options;
+	unregister;
+	timers = /* @__PURE__ */ new Set();
+	eligibilityRetry;
+	pending = Promise.resolve();
+	stopped = false;
+	closed = false;
+	active;
+	constructor(knowledge, backend, render, beforeCall, options = {}) {
+		this.knowledge = knowledge;
+		this.backend = backend;
+		this.render = render;
+		this.beforeCall = beforeCall;
+		this.options = options;
+		const worker = knowledge.jobs;
+		if (worker === null) throw new JobError("unconfigured", "请先配置 agentId。");
+		this.unregister = knowledge.config.dream.enabled ? worker.register("dream", async (job, control) => {
+			const run = this.run(job, control);
+			this.active = run;
+			try {
+				return await run;
+			} finally {
+				if (this.active === run) this.active = void 0;
+			}
+		}) : () => {};
+	}
+	async start() {
+		const worker = this.knowledge.jobs;
+		if (worker === null) return;
+		if (!this.knowledge.config.dream.enabled) {
+			await worker.queue.pauseDream(true);
+			return;
+		}
+		await worker.queue.pauseDream(false);
+		worker.wake(true);
+		await this.check();
+		this.schedule();
+	}
+	schedule() {
+		const deadline = Date.now() + this.knowledge.config.dream.checkIntervalHours * 36e5;
+		const wait = () => {
+			if (this.closed) return;
+			const remaining = deadline - Date.now();
+			if (remaining > 0) {
+				const timer = setTimeout(() => {
+					this.timers.delete(timer);
+					wait();
+				}, Math.min(remaining, 2147483647));
+				timer.unref();
+				this.timers.add(timer);
+			} else {
+				this.trigger();
+				this.schedule();
+			}
+		};
+		wait();
+	}
+	trigger() {
+		this.pending = this.pending.then(() => this.check()).catch(() => {
+			this.knowledge.logger.warn("Dream eligibility check could not complete; the next trigger will retry.");
+		});
+	}
+	async flush() {
+		await this.pending;
+	}
+	async check() {
+		if (this.closed || this.stopped || !this.knowledge.config.dream.enabled) return;
+		const worker = this.knowledge.jobs;
+		if (worker === null || (await worker.queue.list()).some((job) => job.kind === "dream" && (job.state === "queued" || job.state === "running"))) return;
+		const eligible = await this.eligible(false);
+		if (this.closed || this.stopped) return;
+		if (eligible === null) {
+			if (this.eligibilityRetry === void 0) {
+				const timer = setTimeout(() => {
+					this.timers.delete(timer);
+					this.eligibilityRetry = void 0;
+					this.trigger();
+				}, 1e3);
+				timer.unref();
+				this.timers.add(timer);
+				this.eligibilityRetry = timer;
+			}
+		} else if (eligible) await worker.enqueue("dream", {
+			manual: false,
+			workspace_root: await this.workspace()
+		});
+	}
+	async eligible(manual) {
+		try {
+			const snapshot = await this.knowledge.snapshot(void 0, 0);
+			return dreamEligible(this.knowledge.config.dream, await this.knowledge.dreamStore().state(), snapshot.claims, this.knowledge.context().agentId, manual);
+		} catch (error) {
+			if (error instanceof KnowledgeBusy || error instanceof LockTimeoutError) return null;
+			throw error;
+		}
+	}
+	async workspace(input) {
+		return fs.realpath(input ?? await this.options.workspace?.() ?? process.cwd());
+	}
+	async request(workspace, sessionId) {
+		if (!this.knowledge.config.dream.enabled) throw new JobError("disabled", "Dream 已关闭，请先启用 dream.enabled。");
+		const worker = this.knowledge.jobs;
+		if (worker === null) throw new JobError("unconfigured", "请先配置 agentId。");
+		this.stopped = false;
+		const pending = await worker.queue.pauseDream(false);
+		worker.wake(true);
+		if (pending[0] !== void 0) return pending[0];
+		if (await this.eligible(true) === false) throw new JobError("empty", "没有可整理的自身 active/stale Claim。");
+		return worker.enqueue("dream", {
+			manual: true,
+			workspace_root: await this.workspace(workspace)
+		}, sessionId);
+	}
+	async stop() {
+		this.stopped = true;
+		if (this.eligibilityRetry !== void 0) {
+			clearTimeout(this.eligibilityRetry);
+			this.timers.delete(this.eligibilityRetry);
+			this.eligibilityRetry = void 0;
+		}
+		const worker = this.knowledge.jobs;
+		if (worker === null) return 0;
+		const jobs = await worker.queue.pauseDream(true);
+		worker.cancelDream(new DreamStopped());
+		return jobs.length;
+	}
+	async boundary(job, control) {
+		control.signal.throwIfAborted();
+		const jobs = await this.knowledge.jobs?.queue.list() ?? [];
+		if (jobs.some((current) => current.id === job.id && current.payload["paused"] === true)) throw new DreamStopped();
+		if (jobs.some((job) => this.knowledge.jobs?.canRun(job) && jobPriority[job.kind] < jobPriority.dream)) throw new DreamYield();
+	}
+	async call(job, control, phase, data, schema, parse = (value) => value, systemName = "claim_dream_legacy.j2") {
+		await this.boundary(job, control);
+		await this.beforeCall?.();
+		const route = await resolveRoute(this.knowledge.config.llm, this.knowledge.context());
+		return structuredCall({
+			backend: this.backend,
+			context: this.knowledge.context(),
+			config: this.knowledge.config.llm,
+			route,
+			jobId: job.id,
+			phase,
+			system: this.render(systemName, {}),
+			input: JSON.stringify({
+				phase,
+				...data
+			}),
+			schema,
+			parse: (value) => parse(schema.parse(value)),
+			signal: control.signal
+		});
+	}
+	async run(job, control) {
+		const store = this.knowledge.dreamStore();
+		await store.recover();
+		await this.boundary(job, control);
+		let origin = await store.origin(job.id);
+		if (origin === null) {
+			const claims = (await this.knowledge.dreamSnapshot(control.signal)).filter((claim) => claim.holder === this.knowledge.agentId);
+			if (!dreamEligible(this.knowledge.config.dream, await store.state(), claims, this.knowledge.context().agentId, job.payload["manual"] === true)) return { skipped: "not_eligible" };
+			const input = claimInput(claims.filter((claim) => claim.status !== "deprecated"));
+			origin = {
+				snapshot_at: nowSeconds(),
+				claims,
+				coverage: input.coverage,
+				workspace_root: await this.workspace(typeof job.payload["workspace_root"] === "string" ? job.payload["workspace_root"] : void 0)
+			};
+			await store.saveOrigin(job.id, origin);
+		}
+		if (this.options.run !== void 0) {
+			const session = await DreamSession.create(this.knowledge, job, control, () => this.boundary(job, control));
+			if (!session.finished) {
+				await this.beforeCall?.();
+				await this.options.run({
+					session,
+					route: await resolveRoute(this.knowledge.config.llm, this.knowledge.context()),
+					config: this.knowledge.config.llm,
+					system: this.render("claim_dream.j2", {}),
+					signal: control.signal
+				});
+				requireDream(session.finished, "自主 Dream 尚未完成。");
+			}
+			await new UploadDelivery(this.knowledge.context(), this.knowledge.team).deliver(control.signal);
+			return {
+				updatedClaimIds: [...new Set((await store.records(job.id)).flatMap(({ checkpoint }) => Object.keys(checkpoint.self_versions)))],
+				modelSteps: session.progress.autonomy?.steps ?? 0,
+				wrapUpSteps: session.progress.autonomy?.wrap_up?.steps ?? 0,
+				budgetLimited: session.exhausted,
+				incompleteCandidates: session.progress.entries.filter((entry) => entry.status === "skipped").map((entry) => ({
+					groupId: entry.candidate.group_id,
+					claimIds: entry.candidate.claim_ids,
+					reason: entry.reason ?? ""
+				})),
+				report: "Dream report.md 已保存。"
+			};
+		}
+		const loaded = claimInput(origin.claims.filter((claim) => claim.status !== "deprecated")).loaded;
+		const evidenceEnabled = this.knowledge.config.dream.evidenceCalibration && this.options.explore !== void 0 && origin.workspace_root !== void 0;
+		let progress = await store.progress(job.id);
+		if (progress === null) {
+			const discovery = await this.call(job, control, "candidates", {
+				dream_context: {
+					agent_id: this.knowledge.agentId,
+					snapshot_at: origin.snapshot_at,
+					trigger: job.payload["manual"] === true ? "manual" : "automatic"
+				},
+				claims: loaded,
+				coverage: origin.coverage,
+				policy_context: {
+					available: false,
+					complete: false
+				},
+				pending_consolidation_sync: (await new UploadStore(this.knowledge.context()).read()).consolidations ?? [],
+				evidence_calibration: {
+					available: evidenceEnabled,
+					tools: evidenceEnabled ? [
+						"read",
+						"grep",
+						"glob",
+						"claim(list/read)"
+					] : [],
+					high_excluded: true
+				}
+			}, DiscoverySchema, (value) => {
+				validateCandidates(value.candidates, loaded, this.knowledge.context().agentId, evidenceEnabled);
+				requireDream(new Set(value.sync_candidates.map((item) => item.source_id)).size === value.sync_candidates.length, "同步候选来源不能重复。");
+				return value;
+			});
+			progress = ProgressSchema.parse({
+				schemaVersion: 1,
+				discovery,
+				entries: discovery.candidates.map((candidate) => ({
+					candidate,
+					status: "pending",
+					reason: "",
+					draft: null,
+					validation: null,
+					review: null
+				})),
+				syncCompleted: [],
+				finished: false,
+				summary: null
+			});
+			await store.saveProgress(job.id, progress);
+		}
+		await this.compact(job, control, progress);
+		for (const entry of progress.entries) {
+			if (entry.status !== "pending") continue;
+			await this.boundary(job, control);
+			const previous = (await store.records(job.id)).find((record) => record.checkpoint.operation?.group_id === entry.candidate.group_id);
+			if (previous?.checkpoint.applied) {
+				entry.status = previous.checkpoint.groups.some((group) => group.skipped) ? "skipped" : "executed";
+				entry.reason = entry.status === "skipped" ? "外部版本变化，旧方案未继续。" : "从已持久执行回执恢复，未重放模型。";
+				await store.saveProgress(job.id, progress);
+				continue;
+			}
+			const before = loaded.filter((claim) => entry.candidate.claim_ids.includes(claim.id));
+			const current = (await this.knowledge.snapshot()).claims;
+			if (!before.every((claim) => current.some((value) => sameClaim(value, claim)))) {
+				entry.status = "skipped";
+				entry.reason = "分析后 Claim 已被外部修改，本候选保留当前版本。";
+				await store.saveProgress(job.id, progress);
+				continue;
+			}
+			let receipts = {};
+			let evidenceStore;
+			if (entry.candidate.kind === "evidence") {
+				if (!evidenceEnabled || origin.workspace_root === void 0 || this.options.explore === void 0) {
+					entry.status = "kept";
+					entry.reason = "证据校准已关闭或受限子会话不可用，保持原样。";
+					await store.saveProgress(job.id, progress);
+					continue;
+				}
+				const evidence = new EvidenceStore(this.knowledge.context(), job.id, entry.candidate.group_id);
+				evidenceStore = evidence;
+				let manifest = await evidence.initialize(origin.workspace_root, before, this.knowledge.config.dream, control.signal);
+				if (!await evidence.current(manifest)) {
+					entry.status = "skipped";
+					entry.reason = "查证文件版本已变化，本组保持原样；不会重用旧证据授权。";
+					await store.saveProgress(job.id, progress);
+					continue;
+				}
+				if (!manifest.completed) {
+					await this.boundary(job, control);
+					await this.beforeCall?.();
+					await this.options.explore({
+						store: evidence,
+						claims: before,
+						route: await resolveRoute(this.knowledge.config.llm, this.knowledge.context()),
+						config: this.knowledge.config.llm,
+						signal: control.signal
+					});
+					await this.boundary(job, control);
+					await evidence.complete(control.signal);
+					manifest = await evidence.read() ?? manifest;
+				}
+				receipts = z.record(z.string(), z.json()).parse(manifest.receipts);
+				if (manifest.model_steps >= manifest.limits.steps && Object.keys(receipts).length === 0) {
+					entry.status = "kept";
+					entry.reason = "查证模型轮数已耗尽且未取得直接证据，保持原样。";
+					await store.saveProgress(job.id, progress);
+					continue;
+				}
+			}
+			let repairs = 0;
+			while (entry.status === "pending") {
+				await this.boundary(job, control);
+				if (entry.validation !== null) try {
+					validateEvidencePreservation(entry.validation.input);
+				} catch (error) {
+					if (!(error instanceof DreamValidationError)) throw error;
+					entry.reason = error.message;
+					entry.draft = null;
+					entry.validation = null;
+					entry.review = null;
+					await store.saveProgress(job.id, progress);
+				}
+				if (evidenceStore !== void 0) {
+					const manifest = await evidenceStore.read();
+					requireDream(manifest !== null, "查证清单丢失。");
+					if (!await evidenceStore.current(manifest)) {
+						entry.status = "skipped";
+						entry.reason = "查证材料已改变；不复用旧验证或复核授权。";
+						await store.saveProgress(job.id, progress);
+						break;
+					}
+				}
+				if (entry.draft === null || entry.validation === null) {
+					const proposed = await this.call(job, control, "draft", {
+						candidate: entry.candidate,
+						before,
+						evidence: receipts,
+						coverage: origin.coverage,
+						review_summary: progress.discovery.review,
+						prior_feedback: entry.reason,
+						prior_summary: progress.summary
+					}, DraftResponseSchema, (value) => {
+						if (value.action === "keep") {
+							requireDream(value.reason_kind !== "no_consolidation_benefit" || entry.candidate.kind === "consolidation", "no_consolidation_benefit 仅用于整合。");
+							return value;
+						}
+						requireDream(value.group.kind === entry.candidate.kind && sameIds(value.group.operations.map((operation) => operation.id), entry.candidate.claim_ids), "草稿必须处理当前候选的全部且仅这些 ID 与 kind。");
+						prepareGroup(expandDraft(value.group, before), loaded, this.knowledge.context().agentId, nowSeconds(), {
+							enabled: evidenceEnabled,
+							receipts
+						});
+						return value;
+					});
+					await store.archive(job.id, `${entry.candidate.group_id}-draft-${repairs}`, proposed);
+					if (proposed.action === "keep") {
+						entry.status = "kept";
+						entry.reason = `${proposed.reason_kind}: ${proposed.reason}`;
+						await store.saveProgress(job.id, progress);
+						break;
+					}
+					entry.draft = expandDraft(proposed.group, before);
+					entry.validation = reviewInput(entry.candidate.group_id, entry.draft, before, receipts);
+					entry.review = null;
+					await store.saveProgress(job.id, progress);
+				}
+				const validation = entry.validation;
+				const reviewed = await this.call(job, control, "review", {
+					candidate: entry.candidate,
+					validation,
+					draft: entry.draft,
+					before,
+					review_summary: progress.discovery.review,
+					prior_feedback: entry.reason,
+					prior_summary: progress.summary
+				}, ReviewResponseSchema, (value) => {
+					if (value.decision !== "apply") return value;
+					requireDream(value.semantic !== null && value.self_review !== null, "执行前必须同时给出逐 Claim 语义复核与双向全文引用复核。");
+					validateSelfReview(validation, value.self_review);
+					validateSemanticReview(validation, value.semantic);
+					return value;
+				});
+				entry.review = reviewed;
+				await store.saveProgress(job.id, progress);
+				if (reviewed.decision === "keep") {
+					entry.status = "kept";
+					entry.reason = `${reviewed.reason_kind}: ${reviewed.reason}`;
+					await store.saveProgress(job.id, progress);
+					break;
+				}
+				if (reviewed.decision === "repair") {
+					repairs += 1;
+					entry.reason = reviewed.reason;
+					entry.draft = null;
+					entry.validation = null;
+					await store.saveProgress(job.id, progress);
+					if (repairs >= this.knowledge.config.llm.structuredRetries) throw new JobError("dream_repair", "本组多次复核要求修复，已保留候选与草稿反馈；请检查报告后重试。");
+					continue;
+				}
+				requireDream(reviewed.semantic !== null && reviewed.self_review !== null, "缺少复核。");
+				await this.boundary(job, control);
+				const record = await this.knowledge.applyDreamGroup(job.id, entry.candidate.group_id, entry.draft, validation, reviewed.semantic, reviewed.self_review, control);
+				control.committed?.();
+				entry.status = record.groups.some((group) => group.skipped) ? "skipped" : "executed";
+				entry.reason = entry.status === "skipped" ? "外部版本或证据版本变化，或来源环冲突；已生效结果保留。" : reviewed.reason;
+				await store.saveProgress(job.id, progress);
+			}
+			await this.compact(job, control, progress);
+		}
+		for (const candidate of progress.discovery.sync_candidates) if (!progress.syncCompleted.includes(candidate.source_id)) {
+			await this.boundary(job, control);
+			const sync = new DreamSync(this.knowledge.context());
+			if (await sync.resume(job.id, candidate.source_id, control.signal)) {
+				progress.syncCompleted.push(candidate.source_id);
+				await store.saveProgress(job.id, progress);
+				continue;
+			}
+			const validation = await sync.prepare(candidate.source_id, candidate.carrier_ids);
+			const review = await this.call(job, control, "sync_review", {
+				validation,
+				reason: candidate.reason,
+				note: "只确认完整信息承接，不修改 Claim，不纠正事实。"
+			}, SemanticReviewSchema);
+			await sync.apply(job.id, validation, review, control.signal);
+			progress.syncCompleted.push(candidate.source_id);
+			await store.saveProgress(job.id, progress);
+		}
+		await this.boundary(job, control);
+		const final = await store.finish(job.id, progress, control);
+		control.committed?.();
+		progress.finished = true;
+		await store.saveProgress(job.id, progress);
+		await new UploadDelivery(this.knowledge.context(), this.knowledge.team).deliver(control.signal);
+		return {
+			updatedClaimIds: Object.keys(final.self_versions),
+			report: "Dream report.md 已保存。",
+			skipped: progress.entries.filter((entry) => entry.status === "skipped").map((entry) => entry.candidate.group_id),
+			kept: progress.entries.filter((entry) => entry.status === "kept").map((entry) => entry.candidate.group_id)
+		};
+	}
+	async compact(job, control, progress) {
+		const handled = progress.entries.filter((entry) => entry.status !== "pending");
+		const history = handled.slice(progress.compactedThrough);
+		if (conservativeTokens(JSON.stringify(history)) < 64e3 / 2) return;
+		await this.knowledge.dreamStore().archive(job.id, `context-${history.length}`, history);
+		const previews = history.map((entry) => ({
+			group_id: entry.candidate.group_id,
+			status: entry.status,
+			validation_id: entry.validation?.validation_id,
+			preview: Array.from(entry.reason).slice(0, 400).join(""),
+			preview_truncated: Array.from(entry.reason).length > 400
+		}));
+		progress.summary = await this.call(job, control, "compaction", {
+			prior_summary: progress.summary,
+			history: previews
+		}, SummarySchema, (value) => {
+			requireDream(Object.values(value).reduce((sum, value) => sum + Array.from(value).length, 0) <= 12e3, "压缩摘要超过 12000 字符。");
+			return value;
+		}, "dream_compaction.j2");
+		progress.compactedThrough = handled.length;
+		await this.knowledge.dreamStore().saveProgress(job.id, progress);
+	}
+	async close() {
+		this.closed = true;
+		this.unregister();
+		this.knowledge.jobs?.cancelDream();
+		for (const timer of this.timers) clearTimeout(timer);
+		this.timers.clear();
+		await this.pending;
+		await this.active?.catch(() => {});
+	}
+};
+//#endregion
+export { SyncValidationSchema as a, DreamSync as i, DreamTools as n, isDreamTool as r, AcnDream as t };