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

package/lib/evidence-store-DW7kj20i.js

@@ -0,0 +1,1030 @@
+import { S as timestampNanos, b as normalizeTimestamp, h as TraceIdSchema, i as effectiveUpdatedAt, l as ClaimIdSchema, m as SourceIdSchema, n as ClaimStatusSchema, r as ConfidenceSchema, t as ClaimSchema, x as nowSeconds, y as TimestampSchema } from "./claim-DOAGe8ZK.js";
+import { u as FormationValidationError } from "./structured-C9byFuzm.js";
+import { n as claimRevision } from "./revision-DeoL_IUN.js";
+import { n as validateClaimText, t as openSingleFile } from "./regular-file-BFpqMoub.js";
+import { c as readYamlOr, l as writeYamlAtomic, n as withFileLock, w as hasCode } from "./lock-DbmlKOoX.js";
+import { l as sameClaim } from "./alignment-CwH0nBf-.js";
+import { z } from "zod";
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+//#region src/dream/schema.ts
+var DreamValidationError = class extends FormationValidationError {};
+const text = z.string().min(1).refine((value) => value.trim() !== "", "Text cannot be blank.");
+const KeySchema = z.string().regex(/^[a-zA-Z0-9_-]+$/);
+const HashSchema = z.string().regex(/^[0-9a-f]{64}$/);
+const KindSchema = z.enum([
+	"quality",
+	"evidence",
+	"consolidation"
+]);
+const ReviewSummarySchema = z.strictObject({
+	quality: text,
+	evidence: text,
+	consolidation: text
+});
+const BasisSchema = z.strictObject({
+	claim_id: ClaimIdSchema,
+	removed_or_changed: text,
+	added: z.string(),
+	justification: text,
+	evidence_ids: z.array(z.string())
+});
+const CoverageSchema = z.strictObject({
+	input_id: ClaimIdSchema,
+	output_ids: z.array(ClaimIdSchema),
+	note: text
+});
+const UpdateSchema = ClaimSchema.pick({
+	id: true,
+	name: true,
+	statement: true,
+	scope: true,
+	confidence: true,
+	status: true,
+	source_claim_ids: true,
+	evidence_summary: true
+}).strict();
+const GroupSchema = z.strictObject({
+	kind: KindSchema,
+	reason: text,
+	evidence_ids: z.array(z.string()),
+	coverage: z.array(CoverageSchema),
+	change_basis: z.array(BasisSchema).default([]),
+	updates: z.array(UpdateSchema)
+});
+const PlanSchema = z.object({
+	review: ReviewSummarySchema,
+	groups: z.array(GroupSchema)
+});
+const changes = z.strictObject({
+	name: z.string().optional(),
+	statement: z.string().optional(),
+	scope: z.string().optional(),
+	confidence: ConfidenceSchema.optional(),
+	status: ClaimStatusSchema.optional(),
+	source_claim_ids: z.array(SourceIdSchema).describe("继承已有来源。来源指向被整合或将废弃的输入时仍保留；仅来源等于存续 ID 自身时移除该自引用。").optional(),
+	evidence_summary: z.string().optional()
+});
+const OperationSchema = z.strictObject({
+	id: ClaimIdSchema,
+	action: z.enum([
+		"keep",
+		"update",
+		"deprecate"
+	]),
+	changes: changes.default({}),
+	reason: z.string().describe("仅供 quality/deprecate 且 changes 为空、无对应 change_basis 时简写依据。update、keep 及 evidence/consolidation 的所有 operation 必须省略此字段，修改依据放 group.change_basis.justification。").optional()
+});
+const DraftGroupSchema = z.strictObject({
+	kind: KindSchema,
+	reason: text,
+	evidence_ids: z.array(z.string()).default([]),
+	coverage: z.array(CoverageSchema).default([]),
+	change_basis: z.array(BasisSchema).default([]),
+	operations: z.array(OperationSchema).min(1)
+});
+const CandidateSchema = z.strictObject({
+	group_id: KeySchema,
+	claim_ids: z.array(ClaimIdSchema).min(1),
+	kind: KindSchema,
+	reason: text
+});
+const KeepReasonSchema = z.enum([
+	"insufficient_evidence",
+	"useful_knowledge",
+	"uncertain_preservation",
+	"no_consolidation_benefit",
+	"external_change"
+]);
+const DraftResponseSchema = z.discriminatedUnion("action", [z.strictObject({
+	action: z.literal("stage"),
+	group: DraftGroupSchema
+}), z.strictObject({
+	action: z.literal("keep"),
+	reason_kind: KeepReasonSchema,
+	reason: text
+})]);
+const DiscoverySchema = z.strictObject({
+	review: ReviewSummarySchema,
+	candidates: z.array(CandidateSchema),
+	sync_candidates: z.array(z.strictObject({
+		source_id: ClaimIdSchema,
+		carrier_ids: z.array(ClaimIdSchema).min(1),
+		reason: text
+	}))
+});
+const QuoteSchema = z.strictObject({
+	claim_id: ClaimIdSchema,
+	field: z.enum([
+		"name",
+		"statement",
+		"scope",
+		"evidence_summary"
+	]),
+	quote: text
+});
+const evidenceQuote = z.strictObject({
+	evidence_id: z.string(),
+	quote: text
+});
+const SelfReviewSchema = z.strictObject({
+	group_id: KeySchema,
+	validation_id: HashSchema,
+	preservation: z.array(z.strictObject({
+		before: QuoteSchema,
+		after: z.array(QuoteSchema),
+		disposition: z.enum([
+			"preserved",
+			"episodic",
+			"corrected"
+		]),
+		reason: text,
+		evidence: z.array(evidenceQuote)
+	})),
+	support: z.array(z.strictObject({
+		after: QuoteSchema,
+		before: z.array(QuoteSchema),
+		evidence: z.array(evidenceQuote),
+		reason: text
+	})),
+	scope_and_certainty: text
+});
+const SemanticReviewSchema = z.strictObject({
+	claims: z.array(z.strictObject({
+		claim_id: ClaimIdSchema,
+		final_name: z.string().default(""),
+		name_reason: z.string().default(""),
+		information_preserved: text,
+		removal_or_correction: text,
+		factual_correction: z.boolean(),
+		output_ids: z.array(ClaimIdSchema),
+		evidence_ids: z.array(z.string())
+	})),
+	scope_and_certainty: text
+});
+const ReviewInputSchema = z.strictObject({
+	group_id: KeySchema,
+	kind: KindSchema,
+	reason: text,
+	before: z.array(ClaimSchema),
+	after: z.array(UpdateSchema),
+	changes: z.array(OperationSchema),
+	coverage: z.array(CoverageSchema),
+	change_basis: z.array(BasisSchema),
+	unversioned_evidence_omitted: z.array(z.string()).default([]),
+	evidence: z.record(z.string(), z.json())
+});
+const ValidationSchema = z.strictObject({
+	validation_id: HashSchema,
+	input: ReviewInputSchema
+});
+const ReviewRecordSchema = z.strictObject({
+	validation: ValidationSchema,
+	review: SelfReviewSchema
+});
+const ReviewResponseSchema = z.strictObject({
+	decision: z.enum([
+		"apply",
+		"repair",
+		"keep"
+	]),
+	reason: text,
+	reason_kind: KeepReasonSchema,
+	semantic: SemanticReviewSchema.nullable(),
+	self_review: SelfReviewSchema.nullable()
+});
+const PreparedGroupSchema = z.object({
+	before: z.array(ClaimSchema),
+	after: z.array(ClaimSchema),
+	completed: z.boolean().default(false),
+	skipped: z.boolean().default(false)
+});
+const CheckpointSchema = z.object({
+	team_authorized: z.boolean().optional(),
+	snapshot_at: TimestampSchema,
+	input_versions: z.record(ClaimIdSchema, z.string()),
+	coverage: z.json(),
+	plan: PlanSchema,
+	receipts: z.record(z.string(), z.json()),
+	exploration_receipts: z.number().int().nonnegative().optional(),
+	groups: z.array(PreparedGroupSchema),
+	safety_reviews: z.array(z.json()).default([]),
+	self_reviews: z.array(ReviewRecordSchema).default([]),
+	trace_id: TraceIdSchema,
+	applied: z.boolean().default(false),
+	success_at: TimestampSchema.nullable().optional(),
+	self_versions: z.record(ClaimIdSchema, z.string()).default({}),
+	operation: z.object({
+		job_id: KeySchema,
+		group_id: KeySchema,
+		validation_id: HashSchema,
+		review: SemanticReviewSchema,
+		hard_validation_passed: z.boolean()
+	}).nullable().optional()
+});
+const DreamStateSchema = z.object({
+	last_success_at: TimestampSchema.nullable().default(null),
+	last_input_snapshot_at: TimestampSchema.nullable().default(null),
+	known_versions: z.record(ClaimIdSchema, z.string()).default({})
+});
+const OriginSchema = z.strictObject({
+	snapshot_at: TimestampSchema,
+	claims: z.array(ClaimSchema),
+	coverage: z.json(),
+	workspace_root: z.string().optional()
+});
+const ProgressSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	discovery: DiscoverySchema,
+	entries: z.array(z.strictObject({
+		candidate: CandidateSchema,
+		status: z.enum([
+			"pending",
+			"executed",
+			"kept",
+			"skipped"
+		]),
+		reason: z.string(),
+		draft: GroupSchema.nullable(),
+		validation: ValidationSchema.nullable(),
+		review: ReviewResponseSchema.nullable()
+	})),
+	syncCompleted: z.array(ClaimIdSchema),
+	finished: z.boolean(),
+	finish_reminder_sent: z.boolean().default(false),
+	proposal_attempted: z.boolean().default(false),
+	exploration_receipts: z.number().int().nonnegative().default(0),
+	summary: z.strictObject({
+		checked: z.string(),
+		findings: z.string(),
+		uncertainties: z.string(),
+		next_steps: z.string()
+	}).nullable(),
+	compactedThrough: z.number().int().nonnegative().default(0),
+	autonomy: z.strictObject({
+		steps: z.number().int().nonnegative(),
+		epoch: z.number().int().nonnegative(),
+		limit: z.number().int().positive(),
+		read_ids: z.array(ClaimIdSchema),
+		wrap_up: z.strictObject({
+			steps: z.number().int().nonnegative(),
+			limit: z.number().int().positive()
+		}).optional()
+	}).optional()
+});
+function requireDream(condition, message) {
+	if (!condition) throw new DreamValidationError(message);
+}
+//#endregion
+//#region src/knowledge/timestamps.ts
+function nextClaimUpdateAt(now, previous) {
+	const clock = timestampNanos(`${normalizeTimestamp(now).slice(0, 19)}Z`);
+	const successor = timestampNanos(previous) + 1000000000n;
+	const nanos = clock > successor ? clock : successor;
+	const seconds = nanos >= 0n ? nanos / 1000000000n : (nanos - 999999999n) / 1000000000n;
+	const fraction = nanos - seconds * 1000000000n;
+	return normalizeTimestamp(`${(/* @__PURE__ */ new Date(Number(seconds) * 1e3)).toISOString().slice(0, 19)}.${fraction.toString().padStart(9, "0")}Z`);
+}
+//#endregion
+//#region src/dream/evidence.ts
+const ReceiptSchema = z.object({
+	tool: z.literal("file_read"),
+	input: z.object({
+		path: z.string(),
+		claim_ids: z.array(ClaimIdSchema).optional(),
+		show_linenos: z.boolean().optional()
+	}).passthrough(),
+	output: z.object({
+		content: z.string(),
+		page: z.object({
+			returned_start: z.number().int().positive(),
+			returned_end: z.number().int().nonnegative()
+		}).passthrough().optional(),
+		file_version: z.object({
+			path: z.string(),
+			revision: z.strictObject({
+				sha256: z.string().regex(/^[0-9a-f]{64}$/),
+				byte_len: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
+			})
+		})
+	}).passthrough()
+}).passthrough();
+function independentReceipt(receipts, id) {
+	const parsed = ReceiptSchema.safeParse(receipts[id]);
+	return parsed.success ? parsed.data : null;
+}
+function directEvidence(receipts, ids, claimId) {
+	return ids.filter((id) => {
+		const receipt = independentReceipt(receipts, id);
+		return receipt !== null && (receipt.input.claim_ids === void 0 || receipt.input.claim_ids.includes(claimId));
+	});
+}
+function evidenceBody(receipt) {
+	const { content, page } = receipt.output;
+	if (receipt.input.show_linenos === false || page === void 0) return content;
+	const lines = content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+	let next = page.returned_start;
+	const body = [];
+	for (const line of lines) {
+		const prefix = `${next}|`;
+		if (!line.startsWith(prefix)) return content;
+		body.push(line.slice(prefix.length));
+		next += 1;
+	}
+	return next - 1 === page.returned_end ? body.join("") : content;
+}
+function requireEvidenceIds(ids, available, message) {
+	requireDream(new Set(ids).size === ids.length && ids.every((id) => available.includes(id)), message);
+}
+//#endregion
+//#region src/dream/preservation.ts
+function validateEvidenceSummaryPreservation(input, outputs) {
+	if (input.evidence_summary.trim() === "") return;
+	requireDream(outputs.some((output) => output.evidence_summary.includes(input.evidence_summary)), `必须在指定去向的 evidence_summary 中逐字保留 ${input.id} 的完整原证据摘要；置信度等级、相似引用或废弃历史不能代替。请保留原文，再追加本轮新证据、版本和适用限制；无法安全承接时 keep。`);
+}
+function validateEvidencePreservation(input) {
+	for (const original of input.before) {
+		validateEvidenceSummaryPreservation(original, input.after.filter((claim) => claim.id === original.id));
+		if (input.kind === "consolidation") {
+			const destinations = input.coverage.find((item) => item.input_id === original.id)?.output_ids ?? [];
+			validateEvidenceSummaryPreservation(original, input.after.filter((claim) => claim.status !== "deprecated" && destinations.includes(claim.id)));
+		}
+	}
+}
+//#endregion
+//#region src/dream/plan.ts
+const contentHash = (claim) => claimRevision(claim).slice(10);
+function valueHash(value) {
+	return createHash("sha256").update(JSON.stringify(value, (_key, item) => item !== null && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : item)).digest("hex");
+}
+function sameIds(a, b) {
+	return new Set(a).size === a.length && new Set(b).size === b.length && a.length === b.length && a.every((id) => b.includes(id));
+}
+const rank = {
+	low: 0,
+	medium: 1,
+	high: 2
+};
+function validateCandidates(candidates, readable, owner, evidenceEnabled = false) {
+	const groups = /* @__PURE__ */ new Set();
+	const ids = /* @__PURE__ */ new Set();
+	for (const candidate of candidates) {
+		requireDream(!groups.has(candidate.group_id), "候选 group_id 重复。");
+		groups.add(candidate.group_id);
+		requireDream(candidate.kind !== "evidence" || evidenceEnabled, "证据校准未启用或受限查证能力不可用。");
+		requireDream(new Set(candidate.claim_ids).size === candidate.claim_ids.length, "候选 Claim ID 必须唯一。");
+		for (const id of candidate.claim_ids) {
+			const claim = readable.find((claim) => claim.id === id);
+			requireDream(claim !== void 0 && claim.holder === owner && claim.status !== "deprecated", "候选只能包含完整展示过的自身非 deprecated Claim。");
+			requireDream(candidate.kind !== "evidence" || claim.confidence !== "high", "high Claim 不进入证据校准；不能先降级再纠正。");
+			requireDream(!ids.has(id), "同一 Claim 不得被多个未处理候选占用。");
+			ids.add(id);
+		}
+	}
+}
+function expandDraft(draft, readable) {
+	const basis = [...draft.change_basis];
+	const updates = draft.operations.map((operation) => {
+		const original = readable.find((claim) => claim.id === operation.id);
+		requireDream(original !== void 0, "操作只能针对本轮完整读过的 Claim。");
+		const fields = Object.keys(operation.changes);
+		if (operation.reason !== void 0) {
+			requireDream(draft.kind === "quality" && operation.action === "deprecate" && fields.length === 0 && operation.reason.trim() !== "" && !basis.some((item) => item.claim_id === operation.id), `${operation.id} 的 operation.reason 不是通用备注；当前为 ${draft.kind}/${operation.action}，请省略 reason，将修改依据放入 group.change_basis.justification。仅无 changes 且无对应 change_basis 的 quality/deprecate 可使用 reason 简写。`);
+			basis.push({
+				claim_id: operation.id,
+				removed_or_changed: "从当前知识中移除一次性记录，历史正文保持。",
+				added: "",
+				justification: operation.reason,
+				evidence_ids: []
+			});
+		}
+		requireDream(operation.action !== "keep" || fields.length === 0, "keep 不得携带 changes。");
+		requireDream(operation.action !== "update" || fields.length > 0, "update 必须携带 changes。");
+		requireDream(operation.action !== "deprecate" || fields.every((key) => key === "evidence_summary"), "deprecate 仅允许补充 evidence_summary；其余历史正文保持。");
+		const update = UpdateSchema.strip().parse({
+			...original,
+			...operation.changes,
+			...operation.action === "deprecate" ? { status: "deprecated" } : {}
+		});
+		requireDream(operation.action === "deprecate" || update.status !== "deprecated", "废弃必须使用 deprecate 动作。");
+		return update;
+	});
+	return GroupSchema.parse({
+		kind: draft.kind,
+		reason: draft.reason,
+		evidence_ids: draft.evidence_ids,
+		coverage: draft.coverage,
+		change_basis: basis,
+		updates
+	});
+}
+function reaches(id, target, graph, visited = /* @__PURE__ */ new Set()) {
+	if (id === target) return true;
+	if (visited.has(id)) return false;
+	visited.add(id);
+	return graph.find((claim) => claim.id === id)?.source_claim_ids.some((source) => source.startsWith("claim_") && graph.some((claim) => claim.id === source && reaches(claim.id, target, graph, visited))) ?? false;
+}
+function validateConsolidationSources(input, after, destinations) {
+	const missing = input.source_claim_ids.filter((source) => !after.some((claim) => destinations.includes(claim.id) && claim.status !== "deprecated" && (claim.source_claim_ids.includes(source) || source === claim.id)));
+	requireDream(missing.length === 0, `整合必须在存续去向中保留 ${input.id} 的既有来源：${missing.join(", ")}；来源对应输入将被 deprecated 也不能删除，仅合回来源 ID 自身时免去自引用。`);
+}
+function prepareGroup(group, readable, owner, now = nowSeconds(), evidence = {
+	enabled: false,
+	receipts: {}
+}) {
+	requireDream(group.kind !== "evidence" || evidence.enabled, "证据校准未启用。");
+	requireDream(group.evidence_ids.length === 0 || evidence.enabled, "证据校准关闭时不能引入新证据。");
+	requireEvidenceIds(group.evidence_ids, Object.keys(evidence.receipts), "组引用了不存在或重复的查证回执。");
+	for (const basis of group.change_basis) {
+		requireEvidenceIds(basis.evidence_ids, group.evidence_ids, "change_basis 只能引用本组已读证据。");
+		requireDream(directEvidence(evidence.receipts, basis.evidence_ids, basis.claim_id).length === basis.evidence_ids.length, "直接证据必须绑定对应 Claim，不能借用其他 Claim 的查证。");
+	}
+	requireDream(group.updates.length > 0 && new Set(group.updates.map((item) => item.id)).size === group.updates.length, "组必须包含唯一的更新 ID。");
+	const before = [];
+	const after = [];
+	const inputs = group.updates.map((item) => readable.find((claim) => claim.id === item.id));
+	requireDream(inputs.every((claim) => claim !== void 0 && claim.holder === owner && claim.status !== "deprecated"), "整理只能修改完整读过、自身持有、非废弃的 Claim。");
+	const inherited = new Set(inputs.flatMap((claim) => claim?.source_claim_ids ?? []));
+	for (const update of group.updates) {
+		const original = readable.find((claim) => claim.id === update.id);
+		requireDream(original !== void 0, "缺少原 Claim。");
+		validateClaimText({
+			name: update.name,
+			statement: update.statement,
+			scope: update.scope,
+			evidence_summary: update.evidence_summary
+		});
+		const ids = group.change_basis.find((basis) => basis.claim_id === original.id)?.evidence_ids ?? [];
+		const supported = directEvidence(evidence.receipts, ids, original.id).length > 0 && update.evidence_summary !== original.evidence_summary;
+		requireDream(rank[update.confidence] <= rank[original.confidence] || supported, "没有对应 Claim 的新独立证据和新的 evidence_summary，不得提高置信度。");
+		requireDream(new Set(update.source_claim_ids).size === update.source_claim_ids.length && update.source_claim_ids.every((source) => source !== update.id && inherited.has(source)), "source_claim_ids 只能继承本组已有来源，不得自引用或新增输入 ID。");
+		const target = {
+			...original,
+			...update
+		};
+		if (!evidence.semanticReview) validateEvidenceSummaryPreservation(original, [target]);
+		if (group.kind === "evidence" && !sameClaim(original, target)) requireDream(original.confidence !== "high" && supported, "B 类事实校准必须针对原始 medium/low Claim，引用对应新证据并更新 evidence_summary。");
+		if (!sameClaim(original, target)) target.updated_at = nextClaimUpdateAt(now, effectiveUpdatedAt(original));
+		before.push(original);
+		after.push(target);
+	}
+	const changed = before.filter((claim, index) => after[index] !== void 0 && !sameClaim(claim, after[index])).map((claim) => claim.id);
+	requireDream(sameIds(group.change_basis.map((item) => item.claim_id), changed), "change_basis 必须恰好解释全部变更，不能遗漏、重复或解释 keep。");
+	if (group.kind === "consolidation") {
+		const outputs = after.filter((claim) => claim.status !== "deprecated");
+		requireDream(before.length >= 2 && outputs.length > 0, "整合至少两个输入且必须有存续输出。");
+		requireDream(sameIds(group.coverage.map((item) => item.input_id), before.map((claim) => claim.id)), "coverage 必须恰好覆盖每条输入。");
+		for (const coverage of group.coverage) {
+			requireDream(coverage.output_ids.length > 0 && new Set(coverage.output_ids).size === coverage.output_ids.length && coverage.output_ids.every((id) => outputs.some((claim) => claim.id === id)), "coverage 的去向必须是本组存续 Claim。");
+			const original = before.find((claim) => claim.id === coverage.input_id);
+			requireDream(original !== void 0, "coverage 输入不存在。");
+			validateConsolidationSources(original, outputs, coverage.output_ids);
+			if (!evidence.semanticReview) validateEvidenceSummaryPreservation(original, outputs.filter((claim) => coverage.output_ids.includes(claim.id)));
+			requireDream(outputs.filter((claim) => coverage.output_ids.includes(claim.id)).every((claim) => rank[claim.confidence] <= rank[original.confidence] || directEvidence(evidence.receipts, group.change_basis.find((basis) => basis.claim_id === claim.id)?.evidence_ids ?? [], claim.id).length > 0 && claim.evidence_summary !== before.find((input) => input.id === claim.id)?.evidence_summary), "整合不得把较弱来源无证据提升为更高置信度。");
+		}
+		requireDream(outputs.some((claim) => before.find((input) => input.id === claim.id)?.statement !== claim.statement), "整合必须改写存续正文：至少一个存续 ID 应使用 update，并在 operations[].changes.statement 中提交不同于原文、完整承接有效信息的正文。仅 keep 一条并 deprecate 其余，或只修改名称/依据，均不满足要求。若没有安全且有收益的重组，返回 action=keep、reason_kind=no_consolidation_benefit，不能为通过校验无依据改写。");
+	}
+	const graph = [...readable.filter((claim) => !after.some((target) => target.id === claim.id)), ...after];
+	for (const target of after) for (const source of target.source_claim_ids) if (!before.find((claim) => claim.id === target.id)?.source_claim_ids.includes(source)) {
+		const claim = graph.find((claim) => claim.id === source);
+		requireDream(claim === void 0 || !reaches(claim.id, target.id, graph), "整理不得引入来源环。");
+	}
+	return {
+		before,
+		after,
+		completed: false,
+		skipped: false
+	};
+}
+function reviewInput(groupId, group, readable, receipts = {}) {
+	const input = {
+		group_id: groupId,
+		kind: group.kind,
+		reason: group.reason,
+		before: group.updates.flatMap((update) => readable.filter((claim) => claim.id === update.id)),
+		after: group.updates,
+		changes: group.updates.map((update) => {
+			const original = readable.find((claim) => claim.id === update.id);
+			const changes = Object.fromEntries(Object.entries(update).filter(([key, value]) => key !== "id" && JSON.stringify(original?.[key]) !== JSON.stringify(value)));
+			return {
+				id: update.id,
+				action: update.status === "deprecated" ? "deprecate" : Object.keys(changes).length === 0 ? "keep" : "update",
+				changes: update.status === "deprecated" ? Object.fromEntries(Object.entries(changes).filter(([key]) => key === "evidence_summary")) : changes
+			};
+		}),
+		coverage: group.coverage,
+		change_basis: group.change_basis,
+		unversioned_evidence_omitted: group.evidence_ids.filter((id) => independentReceipt(receipts, id) === null),
+		evidence: Object.fromEntries(group.evidence_ids.flatMap((id) => {
+			const receipt = receipts[id];
+			return receipt !== void 0 && independentReceipt(receipts, id) !== null ? [[id, receipt]] : [];
+		}))
+	};
+	return {
+		validation_id: valueHash(input),
+		input
+	};
+}
+//#endregion
+//#region src/dream/review.ts
+const fields = [
+	"name",
+	"statement",
+	"scope",
+	"evidence_summary"
+];
+function quoted(validation, side, quote) {
+	const claim = validation.input[side].find((claim) => claim.id === quote.claim_id);
+	requireDream(claim !== void 0, `复核引用 ${side}.${quote.claim_id}.${quote.field} 对应的 Claim 不存在。`);
+	requireDream(side !== "after" || claim.status !== "deprecated", `after 引用 ${quote.claim_id}.${quote.field} 指向 deprecated Claim，不能承接保留信息。其历史记录仍会保留，但 preservation.after 和 support.after 只能引用存续输出；按 coverage.output_ids 找到实际承接字段，不能把历史原名或 scope 当成存续去向。`);
+	const value = claim[quote.field];
+	requireDream(quote.quote.trim() !== "" && value.includes(quote.quote), `复核引用 ${side}.${quote.claim_id}.${quote.field} 必须是对应字段的逐字非空子串。请直接复制该字段原文，不翻译、改写或合并不连续片段；字段值中的引号与换行使用 JSON 转义。`);
+	return value;
+}
+function coverageGaps(validation, review) {
+	const gaps = [];
+	for (const side of ["before", "after"]) {
+		const quotes = side === "before" ? review.preservation.map((item) => item.before) : review.support.map((item) => item.after);
+		for (const claim of validation.input[side]) {
+			if (side === "after" && claim.status === "deprecated") continue;
+			for (const field of fields) {
+				const text = claim[field];
+				const covered = /* @__PURE__ */ new Set();
+				for (const quote of quotes.filter((quote) => quote.claim_id === claim.id && quote.field === field && quote.quote !== "")) {
+					let start = text.indexOf(quote.quote);
+					while (start !== -1) {
+						for (let index = start; index < start + quote.quote.length; index += 1) covered.add(index);
+						start = text.indexOf(quote.quote, start + 1);
+					}
+				}
+				const missing = [];
+				let fragment = "";
+				let offset = 0;
+				for (const char of text) {
+					if (!covered.has(offset) && !/[\s，。；：、,;:]/u.test(char)) fragment += char;
+					else if (fragment !== "") {
+						missing.push(fragment);
+						fragment = "";
+					}
+					offset += char.length;
+				}
+				if (fragment !== "") missing.push(fragment);
+				if (missing.length > 0) gaps.push({
+					side,
+					claim_id: claim.id,
+					field,
+					missing_fragments: missing
+				});
+			}
+		}
+	}
+	return gaps;
+}
+function validateSelfReview(validation, review) {
+	requireDream(review.validation_id === validation.validation_id && review.group_id === validation.input.group_id, "复核对应的草稿版本已变化，必须重新 validate。");
+	validateEvidencePreservation(validation.input);
+	const bad = [];
+	for (const [section, items] of [["preservation", review.preservation], ["support", review.support]]) for (const [index, item] of items.entries()) for (const [offset, quote] of item.evidence.entries()) {
+		const receipt = independentReceipt(validation.input.evidence, quote.evidence_id);
+		const text = quote.quote.trim();
+		if (receipt === null || text === "" || !receipt.output.content.includes(text) && !evidenceBody(receipt).includes(text)) bad.push({
+			location: `${section}.${index}.evidence.${offset}`,
+			evidence_id: quote.evidence_id,
+			source_preview: receipt === null ? "" : evidenceBody(receipt).slice(0, 240)
+		});
+	}
+	requireDream(bad.length === 0, `新证据引用必须逐字出现在对应版本回执中；错误 ${bad.length} 处：${JSON.stringify(bad.slice(0, 8))}`);
+	for (const item of review.preservation) {
+		quoted(validation, "before", item.before);
+		for (const quote of item.after) quoted(validation, "after", quote);
+		if (item.disposition === "preserved") requireDream(item.after.length > 0, "有效信息必须有存续输出引用。");
+		else if (item.disposition === "episodic") requireDream(validation.input.kind !== "evidence" && item.after.length === 0 && item.evidence.length === 0, "仅纯情景片段可在 A/C 中无证据移除。");
+		else validateCorrection(validation, item.before.claim_id, item.evidence.map((quote) => quote.evidence_id));
+	}
+	for (const item of review.support) {
+		quoted(validation, "after", item.after);
+		for (const quote of item.before) quoted(validation, "before", quote);
+		requireDream(item.before.length > 0 || item.evidence.length > 0, "每个输出断言必须有具体原文或新独立证据。");
+		if (item.evidence.length > 0) validateCorrection(validation, item.after.claim_id, [...new Set(item.evidence.map((quote) => quote.evidence_id))]);
+	}
+	const gaps = coverageGaps(validation, review);
+	requireDream(gaps.length === 0, `复核未覆盖完整 name/statement/scope/evidence_summary，含条件、否定、备选行动和证据限制：${JSON.stringify(gaps.slice(0, 8))}`);
+}
+function validateCorrection(validation, id, ids) {
+	const before = validation.input.before.find((claim) => claim.id === id);
+	const after = validation.input.after.find((claim) => claim.id === id);
+	requireDream(before !== void 0 && after !== void 0 && before.confidence !== "high", "high Claim 不能事实纠正，包括混入 A/C 或先降低置信度。");
+	const basis = validation.input.change_basis.find((basis) => basis.claim_id === id)?.evidence_ids ?? [];
+	const direct = directEvidence(validation.input.evidence, basis, id);
+	requireDream(ids.length > 0 && ids.every((id) => direct.includes(id)), "事实修订必须引用对应 Claim 的 change_basis 中的新直接证据。");
+	requireDream(after.evidence_summary !== before.evidence_summary, "事实修订必须更新 evidence_summary，说明新证据与限制。");
+}
+function validateSemanticReview(validation, review) {
+	requireDream(sameIds(review.claims.map((item) => item.claim_id), validation.input.before.map((claim) => claim.id)), "语义复核必须恰好覆盖全部输入 Claim。");
+	for (const item of review.claims) {
+		const after = validation.input.after.find((claim) => claim.id === item.claim_id);
+		requireDream(after !== void 0, "复核缺少输出 Claim。");
+		requireDream(item.final_name === after.name && item.name_reason.trim() !== "", "final_name 必须绑定最终名称，并说明名称与正文一致；废弃保留历史名称。");
+		requireEvidenceIds(item.evidence_ids, Object.keys(validation.input.evidence).filter((id) => independentReceipt(validation.input.evidence, id) !== null), "语义复核引用了无版本、未知或重复的独立证据。");
+		if (item.factual_correction || validation.input.kind === "evidence" && validation.input.changes.some((change) => change.id === item.claim_id && change.action !== "keep")) validateCorrection(validation, item.claim_id, item.evidence_ids);
+		requireDream(new Set(item.output_ids).size === item.output_ids.length && item.output_ids.every((id) => validation.input.after.some((claim) => claim.id === id && claim.status !== "deprecated")), "复核去向必须唯一且属于本组存续 Claim。");
+		if (validation.input.kind === "consolidation") requireDream(sameIds(item.output_ids, validation.input.coverage.find((coverage) => coverage.input_id === item.claim_id)?.output_ids ?? []), "语义复核必须与 coverage 的信息去向一致。");
+		else if (after.status !== "deprecated") requireDream(item.output_ids.includes(item.claim_id), "存续 Claim 必须包含自身信息去向。");
+	}
+}
+//#endregion
+//#region src/dream/candidates.ts
+const INPUT_TOKENS = 64e3;
+function conservativeTokens(text) {
+	return Array.from(text).reduce((sum, char) => sum + (char.codePointAt(0) !== void 0 && char.charCodeAt(0) < 128 ? 1 : 3), 0);
+}
+function claimInput(claims, budget = INPUT_TOKENS) {
+	const sorted = [...claims].sort((a, b) => {
+		const changed = timestampNanos(effectiveUpdatedAt(b)) - timestampNanos(effectiveUpdatedAt(a));
+		const created = timestampNanos(b.created_at) - timestampNanos(a.created_at);
+		return changed !== 0n ? changed > 0n ? 1 : -1 : created !== 0n ? created > 0n ? 1 : -1 : a.id.localeCompare(b.id);
+	});
+	const loaded = [];
+	let used = 0;
+	for (const claim of sorted) {
+		const cost = conservativeTokens(JSON.stringify(claim));
+		if (cost > budget) continue;
+		if (used + cost > budget) break;
+		used += cost;
+		loaded.push(claim);
+	}
+	return {
+		loaded,
+		coverage: {
+			total: claims.length,
+			included: loaded.length,
+			omitted: claims.length - loaded.length,
+			order: "effective_updated_at descending; oldest omitted first",
+			estimated_tokens: used,
+			budget_tokens: budget
+		}
+	};
+}
+function versions(claims) {
+	return Object.fromEntries([...claims].sort((a, b) => a.id.localeCompare(b.id)).map((claim) => [claim.id, contentHash(claim)]));
+}
+function dreamEligible(config, state, claims, owner, manual, now = Date.now()) {
+	const owned = claims.filter((claim) => claim.holder === owner);
+	if (!config.enabled || !owned.some((claim) => claim.status !== "deprecated")) return false;
+	if (manual) return true;
+	if (state.last_success_at !== void 0 && state.last_success_at !== null && now - Date.parse(state.last_success_at) < config.minIntervalHours * 36e5) return false;
+	return owned.filter((claim) => state.known_versions[claim.id] !== contentHash(claim)).length >= config.minChangedClaims;
+}
+//#endregion
+//#region src/dream/evidence-files.ts
+const within = (root, path) => {
+	const rel = relative(root, path);
+	return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+};
+const blocked = (part) => part.startsWith(".") || /^(?:memory\.md|user\.md|export_env\.sh|node_modules|memories)$/i.test(part) || /(?:^|[._-])(?:secrets?|credentials?|private[-_]?keys?|tokens?)(?:[._-]|$)/i.test(part) || /\.(?:pem|key|p12|pfx)$/i.test(part);
+async function authorizeFile(workspace, privateHome, input) {
+	requireDream(isAbsolute(workspace) && relative(await fs.realpath(workspace), workspace) === "", "查证工作区已变化。");
+	const path = resolve(workspace, input);
+	requireDream(within(workspace, path) && !within(await fs.realpath(privateHome), path), "查证路径必须位于工作区且不能进入私有数据目录。");
+	const parts = relative(workspace, path).split(sep);
+	requireDream(parts.every((part) => part !== "" && !blocked(part)) && !blocked(basename(workspace)), "查证不能读取私有、隐藏或凭据路径。");
+	let current = workspace;
+	for (const part of parts) {
+		current = resolve(current, part);
+		requireDream(!(await fs.lstat(current)).isSymbolicLink(), "查证不跟随符号链接。");
+	}
+	requireDream(relative(await fs.realpath(path), path) === "", "查证文件路径已变化。");
+	return path;
+}
+async function readEvidenceFile(workspace, privateHome, input, maxBytes) {
+	const path = await authorizeFile(workspace, privateHome, input);
+	const file = await openSingleFile(path, () => new DreamValidationError("查证仅接受单链接普通文件，不跟随符号链接。"));
+	try {
+		const before = await file.stat();
+		requireDream(before.isFile() && before.nlink === 1 && before.size <= maxBytes, "查证仅接受预算内的单链接普通文件。");
+		const buffer = Buffer.alloc(before.size + 1);
+		let length = 0;
+		while (length < buffer.length) {
+			const read = await file.read(buffer, length, buffer.length - length, length);
+			if (read.bytesRead === 0) break;
+			length += read.bytesRead;
+		}
+		const after = await file.stat();
+		const current = await fs.lstat(path);
+		requireDream(length === before.size && before.size === after.size && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs && before.ino === current.ino && before.dev === current.dev && after.nlink === 1 && !current.isSymbolicLink(), "查证读取期间文件发生变化。");
+		await authorizeFile(workspace, privateHome, input);
+		const bytes = buffer.subarray(0, length);
+		let content;
+		try {
+			content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+		} catch {
+			throw new DreamValidationError("查证仅接受 UTF-8 文本。");
+		}
+		requireDream(!content.includes("\0"), "查证不读取二进制内容。");
+		return {
+			path,
+			content,
+			revision: {
+				sha256: createHash("sha256").update(bytes).digest("hex"),
+				byte_len: length
+			}
+		};
+	} finally {
+		await file.close();
+	}
+}
+async function receiptCurrent(receipt, workspace, privateHome) {
+	try {
+		const { path, revision } = receipt.output.file_version;
+		if (path !== receipt.input.path) return false;
+		const file = await readEvidenceFile(workspace, privateHome, path, revision.byte_len);
+		return file.revision.sha256 === revision.sha256 && file.revision.byte_len === revision.byte_len;
+	} catch (error) {
+		if (hasCode(error, "ENOENT") || hasCode(error, "ENOTDIR") || hasCode(error, "ELOOP") || error instanceof DreamValidationError) return false;
+		throw error;
+	}
+}
+function discoverable(name) {
+	return !blocked(name);
+}
+//#endregion
+//#region src/dream/evidence-store.ts
+const ReadArgs = z.strictObject({
+	path: z.string().min(1),
+	claim_ids: z.array(ClaimIdSchema).min(1),
+	start: z.number().int().positive().default(1),
+	count: z.number().int().positive().max(2e3).default(200)
+});
+const GlobArgs = z.strictObject({ query: z.string().max(200).default("") });
+const GrepArgs = z.strictObject({ query: z.string().min(1).max(200) });
+const ClaimArgs = z.discriminatedUnion("action", [z.strictObject({ action: z.literal("list") }), z.strictObject({
+	action: z.literal("read"),
+	id: ClaimIdSchema
+})]);
+const EvidenceTools = {
+	read: ReadArgs,
+	glob: GlobArgs,
+	grep: GrepArgs,
+	claim: ClaimArgs
+};
+const LimitsSchema = z.strictObject({
+	calls: z.number().int().positive(),
+	steps: z.number().int().positive(),
+	bytes: z.number().int().positive(),
+	chars: z.number().int().positive(),
+	files: z.number().int().positive()
+});
+const EvidenceManifestSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	job_id: KeySchema,
+	group_id: KeySchema,
+	workspace_root: z.string(),
+	claim_versions: z.record(ClaimIdSchema, z.string()),
+	receipts: z.record(z.string(), ReceiptSchema),
+	calls: z.number().int().nonnegative(),
+	model_steps: z.number().int().nonnegative(),
+	bytes_read: z.number().int().nonnegative(),
+	files_examined: z.number().int().nonnegative(),
+	limits: LimitsSchema,
+	completed: z.boolean()
+});
+const privateDataHome = (context) => dirname(dirname(context.paths.root));
+var EvidenceStore = class {
+	context;
+	jobId;
+	groupId;
+	path;
+	constructor(context, jobId, groupId) {
+		this.context = context;
+		this.jobId = jobId;
+		this.groupId = groupId;
+		this.path = join(context.paths.dreamJob(jobId), "evidence", `${KeySchema.parse(groupId)}.yaml`);
+	}
+	async read() {
+		const manifest = await readYamlOr(this.path, EvidenceManifestSchema, () => null);
+		requireDream(manifest === null || manifest.job_id === this.jobId && manifest.group_id === this.groupId, "查证清单身份与任务不一致。");
+		return manifest;
+	}
+	save(manifest) {
+		return writeYamlAtomic(this.path, manifest, EvidenceManifestSchema, this.context.logger);
+	}
+	async initialize(workspace, claims, config, signal) {
+		return withFileLock(`${this.path}.lock`, async () => {
+			signal?.throwIfAborted();
+			requireDream(config.evidenceCalibration, "证据校准未启用。");
+			const prior = await this.read();
+			const versions = Object.fromEntries(claims.map((claim) => [claim.id, claimRevision(claim)]));
+			requireDream(claims.length > 0 && claims.every((claim) => claim.holder === this.context.agentId && claim.confidence !== "high" && claim.status !== "deprecated"), "受限查证仅接受自身 medium/low 候选。");
+			if (prior !== null) {
+				requireDream(prior.workspace_root === workspace && Object.entries(prior.claim_versions).every(([id, revision]) => versions[id] === revision), "查证权限不能换工作区、删除原目标或更换 Claim 版本。");
+				if (valueHash(prior.claim_versions) !== valueHash(versions)) {
+					prior.claim_versions = versions;
+					await this.save(prior);
+				}
+				return prior;
+			}
+			const manifest = {
+				schemaVersion: 1,
+				job_id: this.jobId,
+				group_id: this.groupId,
+				workspace_root: workspace,
+				claim_versions: versions,
+				receipts: {},
+				calls: 0,
+				model_steps: 0,
+				bytes_read: 0,
+				files_examined: 0,
+				limits: {
+					calls: config.evidenceMaxCalls,
+					steps: config.evidenceMaxSteps,
+					bytes: config.evidenceMaxBytes,
+					chars: config.evidenceMaxChars,
+					files: config.evidenceMaxFiles
+				},
+				completed: false
+			};
+			await this.save(manifest);
+			return manifest;
+		}, { signal });
+	}
+	async admitStep(signal) {
+		await withFileLock(`${this.path}.lock`, async () => {
+			signal.throwIfAborted();
+			const manifest = await this.read();
+			requireDream(manifest !== null && !manifest.completed && manifest.model_steps < manifest.limits.steps, "查证模型步数预算已用尽。");
+			manifest.model_steps += 1;
+			await this.save(manifest);
+		}, { signal });
+	}
+	async reopen(signal) {
+		await withFileLock(`${this.path}.lock`, async () => {
+			signal.throwIfAborted();
+			const manifest = await this.read();
+			requireDream(manifest !== null, "缺少查证清单。");
+			manifest.completed = false;
+			await this.save(manifest);
+		}, { signal });
+	}
+	async complete(signal) {
+		await withFileLock(`${this.path}.lock`, async () => {
+			signal.throwIfAborted();
+			const manifest = await this.read();
+			requireDream(manifest !== null, "缺少查证清单。");
+			manifest.completed = true;
+			await this.save(manifest);
+		}, { signal });
+	}
+	async current(manifest) {
+		for (const receipt of Object.values(manifest.receipts)) if (!await receiptCurrent(receipt, manifest.workspace_root, privateDataHome(this.context))) return false;
+		return true;
+	}
+	async authorize(receipts, workspace, before) {
+		if (Object.keys(receipts).length === 0) return true;
+		const manifest = await this.read();
+		requireDream(manifest !== null && manifest.completed && manifest.workspace_root === workspace, "证据缺少已完成的插件查证清单或工作区授权。");
+		for (const [id, raw] of Object.entries(receipts)) {
+			const receipt = independentReceipt(receipts, id);
+			const original = manifest.receipts[id];
+			requireDream(receipt !== null && original !== void 0 && valueHash(raw) === valueHash(original), "证据回执并非由本组受限读取产生。");
+			requireDream(receipt.input.claim_ids !== void 0 && receipt.input.claim_ids.length > 0 && receipt.input.claim_ids.every((id) => before.some((claim) => claim.id === id && manifest.claim_versions[id] === claimRevision(claim) && claim.confidence !== "high")), "证据授权的 Claim 或原始版本不一致。");
+			if (!await receiptCurrent(receipt, manifest.workspace_root, privateDataHome(this.context))) return false;
+		}
+		return true;
+	}
+	async execute(name, args, claims, signal) {
+		return withFileLock(`${this.path}.lock`, async () => {
+			signal.throwIfAborted();
+			const manifest = await this.read();
+			requireDream(manifest !== null && !manifest.completed, "查证已结束或尚未授权。");
+			requireDream(manifest.calls < manifest.limits.calls, "查证工具调用预算已用尽。");
+			manifest.calls += 1;
+			await this.save(manifest);
+			const eligible = claims.filter((claim) => manifest.claim_versions[claim.id] === claimRevision(claim));
+			if (name === "claim") {
+				const input = ClaimArgs.parse(args);
+				if (input.action === "list") return z.json().parse(eligible);
+				const claim = eligible.find((claim) => claim.id === input.id);
+				requireDream(claim !== void 0, "只读 claim 不能访问候选以外的知识。");
+				return z.json().parse(claim);
+			}
+			const load = async (path) => {
+				signal.throwIfAborted();
+				const allowed = await authorizeFile(manifest.workspace_root, privateDataHome(this.context), path);
+				const stat = await fs.lstat(allowed);
+				requireDream(stat.isFile() && stat.nlink === 1 && stat.size + 1 <= manifest.limits.bytes - manifest.bytes_read, "查证文件或总字节预算不允许本次读取。");
+				manifest.bytes_read += stat.size + 1;
+				await this.save(manifest);
+				return readEvidenceFile(manifest.workspace_root, privateDataHome(this.context), path, stat.size);
+			};
+			if (name === "read") {
+				const input = ReadArgs.parse(args);
+				requireDream(new Set(input.claim_ids).size === input.claim_ids.length && input.claim_ids.every((id) => eligible.some((claim) => claim.id === id)), `读取证据必须明确绑定本组可校准 Claim，允许的 claim_ids：${eligible.map((claim) => claim.id).join(", ")}。`);
+				const file = await load(input.path);
+				const lines = file.content.split("\n");
+				requireDream(input.start <= lines.length, "读取起始行超过文件。");
+				const selected = [];
+				let chars = 0;
+				for (const line of lines.slice(input.start - 1, input.start - 1 + input.count)) {
+					if (chars + line.length + 1 > manifest.limits.chars) break;
+					selected.push(line);
+					chars += line.length + 1;
+				}
+				requireDream(selected.length > 0, "单行超过查证字符预算，请缩小文件内容。");
+				const receipt = ReceiptSchema.parse({
+					tool: "file_read",
+					input: {
+						path: file.path,
+						claim_ids: input.claim_ids,
+						show_linenos: false,
+						start: input.start,
+						count: input.count
+					},
+					output: {
+						content: selected.join("\n"),
+						page: {
+							returned_start: input.start,
+							returned_end: input.start + selected.length - 1,
+							total_lines: lines.length,
+							truncated: input.start + selected.length - 1 < lines.length
+						},
+						file_version: {
+							path: file.path,
+							revision: file.revision
+						}
+					}
+				});
+				const evidence_id = `file_${randomUUID().replaceAll("-", "")}`;
+				manifest.receipts[evidence_id] = receipt;
+				await this.save(manifest);
+				signal.throwIfAborted();
+				return z.json().parse({
+					evidence_id,
+					...receipt
+				});
+			}
+			const input = name === "glob" ? GlobArgs.parse(args) : GrepArgs.parse(args);
+			const matches = [];
+			let chars = 0;
+			let truncated = false;
+			const walk = async (directory) => {
+				const dir = await fs.opendir(directory);
+				for await (const entry of dir) {
+					signal.throwIfAborted();
+					if (manifest.files_examined >= manifest.limits.files) {
+						truncated = true;
+						break;
+					}
+					manifest.files_examined += 1;
+					await this.save(manifest);
+					if (!discoverable(entry.name) || entry.isSymbolicLink()) continue;
+					const path = join(directory, entry.name);
+					try {
+						await authorizeFile(manifest.workspace_root, privateDataHome(this.context), path);
+						if (entry.isDirectory()) {
+							await walk(path);
+							if (truncated) break;
+						} else if (entry.isFile()) {
+							const label = relative(manifest.workspace_root, path);
+							if (name === "glob") {
+								if (!label.includes(input.query)) continue;
+								if (chars + label.length > manifest.limits.chars) {
+									truncated = true;
+									break;
+								}
+								matches.push({ path: label });
+								chars += label.length;
+							} else {
+								const file = await load(path);
+								for (const [index, line] of file.content.split("\n").entries()) if (line.includes(input.query)) {
+									if (chars + line.length + label.length > manifest.limits.chars) {
+										truncated = true;
+										break;
+									}
+									matches.push({
+										path: label,
+										line: index + 1,
+										text: line
+									});
+									chars += line.length + label.length;
+								}
+								if (truncated) break;
+							}
+						}
+					} catch (error) {
+						if (!(error instanceof DreamValidationError)) throw error;
+					}
+				}
+			};
+			await walk(manifest.workspace_root);
+			await this.save(manifest);
+			return z.json().parse({
+				matches,
+				truncated,
+				independent_evidence: false
+			});
+		}, { signal });
+	}
+};
+//#endregion
+export { OperationSchema as $, valueHash as A, CandidateSchema as B, expandDraft as C, sameIds as D, reviewInput as E, evidenceBody as F, DraftResponseSchema as G, CoverageSchema as H, independentReceipt as I, GroupSchema as J, DreamStateSchema as K, requireEvidenceIds as L, validateEvidenceSummaryPreservation as M, ReceiptSchema as N, validateCandidates as O, directEvidence as P, KindSchema as Q, nextClaimUpdateAt as R, contentHash as S, reaches as T, DiscoverySchema as U, CheckpointSchema as V, DraftGroupSchema as W, KeepReasonSchema as X, HashSchema as Y, KeySchema as Z, dreamEligible as _, GlobArgs as a, ReviewInputSchema as at, validateSelfReview as b, privateDataHome as c, ReviewSummarySchema as ct, readEvidenceFile as d, UpdateSchema as dt, OriginSchema as et, receiptCurrent as f, ValidationSchema as ft, conservativeTokens as g, claimInput as h, EvidenceTools as i, QuoteSchema as it, validateEvidencePreservation as j, validateConsolidationSources as k, authorizeFile as l, SelfReviewSchema as lt, INPUT_TOKENS as m, text as mt, EvidenceManifestSchema as n, PreparedGroupSchema as nt, GrepArgs as o, ReviewRecordSchema as ot, within as p, requireDream as pt, DreamValidationError as q, EvidenceStore as r, ProgressSchema as rt, ReadArgs as s, ReviewResponseSchema as st, ClaimArgs as t, PlanSchema as tt, discoverable as u, SemanticReviewSchema as ut, versions as v, prepareGroup as w, validateSemanticReview as x, coverageGaps as y, BasisSchema as z };