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

package/lib/deliver-C-dmhkfm.js

@@ -0,0 +1,168 @@
+import { x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { n as claimRevision } from "./revision-DeoL_IUN.js";
+import { S as LockTimeoutError, n as withFileLock, t as acquireFileLease } from "./lock-DbmlKOoX.js";
+import { l as sameClaim, r as KnowledgeBusy, s as ensureKnowledgeReady } from "./alignment-CwH0nBf-.js";
+import { i as ClaimStore, r as reportedClaimSetKey, t as ReportedSetStore } from "./reported-sets-DdEKdeVb.js";
+import { a as disputeVersion, i as RejectedDisputeStore, o as consolidationReady, r as UploadStore, s as relatedIds } from "./uploads-BCA2p92b.js";
+import { t as DeliveryStatusStore } from "./delivery-status-M7-Rwoyj.js";
+import { t as TeamError } from "./errors-pPumDOGD.js";
+//#region src/upload/deliver.ts
+var UploadDelivery = class {
+	context;
+	team;
+	constructor(context, team) {
+		this.context = context;
+		this.team = team;
+	}
+	async deliver(signal) {
+		const report = {
+			deliveredClaims: 0,
+			deliveredDisputes: 0,
+			pendingClaims: 0,
+			pendingDisputes: 0,
+			warnings: []
+		};
+		const team = this.team;
+		if (team === null || this.context.mode === "solo") return report;
+		const queue = new UploadStore(this.context);
+		const status = new DeliveryStatusStore(this.context);
+		let snapshot = await queue.read();
+		if (snapshot.claims.length === 0 && snapshot.disputes.length === 0) return report;
+		let lease;
+		try {
+			lease = await acquireFileLease(this.context.paths.deliveryLock, { timeoutMs: 0 });
+		} catch (error) {
+			if (error instanceof LockTimeoutError) return {
+				...report,
+				pendingClaims: snapshot.claims.length,
+				pendingDisputes: snapshot.disputes.length
+			};
+			throw error;
+		}
+		try {
+			snapshot = await queue.read();
+			const initialIds = new Set(snapshot.claims.map((claim) => claim.id));
+			const attempted = /* @__PURE__ */ new Set();
+			let stopped = false;
+			for (let round = 0; round <= initialIds.size && !stopped; round += 1) {
+				let progressed = false;
+				for (const queued of (await queue.read()).claims.filter((claim) => initialIds.has(claim.id))) {
+					signal?.throwIfAborted();
+					lease.check();
+					let current;
+					try {
+						current = await withFileLock(this.context.paths.knowledgeLock, async () => {
+							await ensureKnowledgeReady(this.context.paths.root);
+							return new ClaimStore(this.context).list();
+						}, { timeoutMs: 0 });
+					} catch (error) {
+						if (!(error instanceof LockTimeoutError || error instanceof KnowledgeBusy)) throw error;
+						continue;
+					}
+					const pending = await queue.read();
+					const claim = pending.claims.find((claim) => claim.id === queued.id);
+					if (claim === void 0) continue;
+					if (attempted.has(claim.id)) continue;
+					if (!current.some((value) => sameClaim(value, claim))) {
+						await status.record({
+							kind: "claim",
+							id: claim.id,
+							reason: "version"
+						});
+						report.warnings.push(`Claim ${claim.id} 的待上传版本与本地不一致，已暂停该项；请在团队模式确认修订后重试。`);
+						continue;
+					}
+					if (relatedIds(pending.consolidations ?? []).has(claim.id) && !consolidationReady(claim, pending.consolidations ?? [], pending.acknowledgements ?? [], current)) {
+						await status.record({
+							kind: "claim",
+							id: claim.id,
+							reason: "dependency"
+						});
+						continue;
+					}
+					attempted.add(claim.id);
+					progressed = true;
+					try {
+						await team.request("maintainer", () => team.maintainer.upload(claim, signal));
+						lease.check();
+						await status.acknowledge("claim", claim.id, claimRevision(claim), team.maintainer.http.endpoint);
+						await queue.removeDeliveredClaims([claim]);
+						report.deliveredClaims += 1;
+					} catch (error) {
+						if (!(error instanceof TeamError)) throw error;
+						if (error.kind !== "cancelled") await status.record({
+							kind: "claim",
+							id: claim.id,
+							reason: error.kind === "legacy_route" ? "client" : error.kind,
+							...error.status === void 0 ? {} : { status: error.status }
+						});
+						report.warnings.push(error.message);
+						if (error.kind === "auth" || error.kind === "cancelled") {
+							stopped = true;
+							break;
+						}
+					}
+				}
+				if (!progressed) break;
+			}
+			const ledger = new ReportedSetStore(this.context);
+			const rejected = new RejectedDisputeStore(this.context);
+			for (const dispute of snapshot.disputes) {
+				signal?.throwIfAborted();
+				lease.check();
+				if (await rejected.contains(dispute)) {
+					await queue.removeDeliveredDisputes([dispute]);
+					continue;
+				}
+				try {
+					if ((await ledger.read()).reported_claim_sets[reportedClaimSetKey(dispute.claims)] === void 0) {
+						await team.request("maintainer", () => team.maintainer.report(dispute, signal));
+						lease.check();
+						await status.acknowledge("dispute", dispute.id, disputeVersion(dispute), team.maintainer.http.endpoint);
+						await ledger.record(dispute.claims, dispute.id, nowSeconds());
+						report.deliveredDisputes += 1;
+					}
+					await queue.removeDeliveredDisputes([dispute]);
+					await status.clear("dispute", dispute.id);
+				} catch (error) {
+					if (!(error instanceof TeamError)) throw error;
+					if (error.kind === "client" && error.status === 409) {
+						lease.check();
+						const previous = (await status.read()).issues[`dispute-${dispute.id}`];
+						await rejected.record(dispute, (previous?.version === disputeVersion(dispute) ? previous.attempts : 0) + 1);
+						await status.record({
+							kind: "dispute",
+							id: dispute.id,
+							version: disputeVersion(dispute),
+							reason: "rejected",
+							status: 409
+						});
+						const warning = `Dispute ${dispute.id} 被团队服务以 409 拒绝，已停止自动重试；本地记录保留，请核对当前 Claim。`;
+						report.warnings.push(warning);
+						this.context.logger.warn(warning);
+						await queue.removeDeliveredDisputes([dispute]);
+					} else {
+						if (error.kind !== "cancelled") await status.record({
+							kind: "dispute",
+							id: dispute.id,
+							version: disputeVersion(dispute),
+							reason: error.kind === "legacy_route" ? "client" : error.kind,
+							...error.status === void 0 ? {} : { status: error.status }
+						});
+						report.warnings.push(error.message);
+					}
+					if (error.kind === "auth" || error.kind === "cancelled") break;
+				}
+			}
+			const pending = await queue.read();
+			report.pendingClaims = pending.claims.length;
+			report.pendingDisputes = pending.disputes.length;
+			report.warnings = [...new Set(report.warnings)];
+			return report;
+		} finally {
+			await lease.release();
+		}
+	}
+};
+//#endregion
+export { UploadDelivery as t };

package/lib/delivery-status-M7-Rwoyj.js

@@ -0,0 +1,89 @@
+import { l as ClaimIdSchema, u as DisputeIdSchema } from "./claim-DOAGe8ZK.js";
+import { c as readYamlOr, l as writeYamlAtomic, n as withFileLock } from "./lock-DbmlKOoX.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+//#region src/store/delivery-status.ts
+const DeliveryIssueSchema = z.object({
+	kind: z.enum(["claim", "dispute"]),
+	id: z.union([ClaimIdSchema, DisputeIdSchema]),
+	reason: z.enum([
+		"auth",
+		"retryable",
+		"client",
+		"protocol",
+		"version",
+		"dependency",
+		"rejected"
+	]),
+	version: z.string().regex(/^[0-9a-f]{64}$/).optional(),
+	status: z.number().int().optional(),
+	attempts: z.number().int().nonnegative().default(0),
+	updatedAt: z.number().int().nonnegative()
+});
+const Receipt = z.object({
+	version: z.string(),
+	target: z.string().regex(/^[0-9a-f]{64}$/),
+	updatedAt: z.number().int().nonnegative().optional()
+});
+const State = z.object({
+	schemaVersion: z.literal(1),
+	issues: z.record(z.string(), DeliveryIssueSchema),
+	delivered: z.record(z.string(), Receipt).default({})
+});
+function deliveryTarget(endpoint) {
+	return createHash("sha256").update(new URL(endpoint).href.replace(/\/+$/, "")).digest("hex");
+}
+var DeliveryStatusStore = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	read() {
+		return readYamlOr(this.context.paths.deliveryStatus, State, () => State.parse({
+			schemaVersion: 1,
+			issues: {}
+		}));
+	}
+	async acknowledge(kind, id, version, endpoint) {
+		if (this.context.mode !== "team") return;
+		await withFileLock(`${this.context.paths.deliveryStatus}.lock`, async () => {
+			const state = await this.read();
+			const key = `${kind}-${id}`;
+			state.delivered[key] = {
+				version,
+				target: deliveryTarget(endpoint),
+				updatedAt: Date.now()
+			};
+			delete state.issues[key];
+			await writeYamlAtomic(this.context.paths.deliveryStatus, state, State, this.context.logger);
+		}, { timeoutMs: this.context.lockTimeoutMs });
+	}
+	async record(input) {
+		if (this.context.mode !== "team") return;
+		await withFileLock(`${this.context.paths.deliveryStatus}.lock`, async () => {
+			const state = await this.read();
+			const key = `${input.kind}-${input.id}`;
+			const previous = state.issues[key];
+			const attempted = !["version", "dependency"].includes(input.reason);
+			if (!attempted && previous?.reason === input.reason && previous.status === input.status) return;
+			state.issues[key] = {
+				...input,
+				attempts: (previous?.version === input.version ? previous?.attempts ?? 0 : 0) + Number(attempted),
+				updatedAt: Date.now()
+			};
+			await writeYamlAtomic(this.context.paths.deliveryStatus, state, State, this.context.logger);
+		}, { timeoutMs: this.context.lockTimeoutMs });
+	}
+	async clear(kind, id) {
+		if (this.context.mode !== "team") return;
+		await withFileLock(`${this.context.paths.deliveryStatus}.lock`, async () => {
+			const state = await this.read();
+			const key = `${kind}-${id}`;
+			if (state.issues[key] === void 0) return;
+			delete state.issues[key];
+			await writeYamlAtomic(this.context.paths.deliveryStatus, state, State, this.context.logger);
+		}, { timeoutMs: this.context.lockTimeoutMs });
+	}
+};
+//#endregion
+export { deliveryTarget as n, DeliveryStatusStore as t };

package/lib/dispute-CtrInHzf.js

@@ -0,0 +1,20 @@
+import { a as TextSchema, c as AgentIdSchema, l as ClaimIdSchema, o as optional, u as DisputeIdSchema, y as TimestampSchema } from "./claim-DOAGe8ZK.js";
+import { z } from "zod";
+//#region src/protocol/dispute.ts
+const DisputeSchema = z.object({
+	id: DisputeIdSchema,
+	name: TextSchema,
+	reporter_agent_id: AgentIdSchema.default(AgentIdSchema.parse("legacy-agent")),
+	claims: z.array(ClaimIdSchema),
+	summary: TextSchema,
+	status: z.enum(["open", "resolved"]),
+	created_at: TimestampSchema,
+	resolved_at: optional(TimestampSchema)
+});
+function validateAgentReport(value) {
+	const dispute = DisputeSchema.parse(value);
+	if (dispute.status !== "open" || dispute.resolved_at !== void 0) throw new Error("An agent report must be open without resolved_at.");
+	return dispute;
+}
+//#endregion
+export { validateAgentReport as n, DisputeSchema as t };

package/lib/disputes-ByEmi43j.js

@@ -0,0 +1,51 @@
+import { t as ClaimSchema, u as DisputeIdSchema } from "./claim-DOAGe8ZK.js";
+import { n as claimRevision } from "./revision-DeoL_IUN.js";
+import { C as StoreError, c as readYamlOr, d as removeFile, l as writeYamlAtomic, n as withFileLock } from "./lock-DbmlKOoX.js";
+import { a as EntityStore, i as ClaimStore } from "./reported-sets-DdEKdeVb.js";
+import { t as DisputeSchema } from "./dispute-CtrInHzf.js";
+import { r as UploadStore } from "./uploads-BCA2p92b.js";
+import { z } from "zod";
+//#region src/store/claim-edits.ts
+const PendingClaimEditSchema = z.object({
+	expected_revision: z.string().regex(/^sha256-v1:[0-9a-f]{64}$/),
+	target: ClaimSchema
+});
+var ClaimEditStore = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	async write(record) {
+		if (this.context.mode === "solo") return;
+		const parsed = PendingClaimEditSchema.parse(record);
+		if (parsed.target.holder !== this.context.agentId) throw new StoreError("ownership", "Pending edit belongs to another agent.");
+		await writeYamlAtomic(this.context.paths.claimEditPending, parsed, PendingClaimEditSchema, this.context.logger);
+	}
+	async recover() {
+		if (this.context.mode === "solo") return "none";
+		const load = () => readYamlOr(this.context.paths.claimEditPending, PendingClaimEditSchema, () => null);
+		if (await load() === null) return "none";
+		return withFileLock(this.context.paths.knowledgeLock, () => this.recoverLocked(), { timeoutMs: this.context.lockTimeoutMs });
+	}
+	async recoverLocked() {
+		if (this.context.mode === "solo") return "none";
+		const pending = await readYamlOr(this.context.paths.claimEditPending, PendingClaimEditSchema, () => null);
+		if (pending === null) return "none";
+		const current = await new ClaimStore(this.context).read(pending.target.id);
+		if (current.holder !== this.context.agentId) throw new StoreError("ownership", "Cannot recover another agent’s Claim.");
+		const landed = claimRevision(current) === claimRevision(pending.target);
+		if (landed) await new UploadStore(this.context).enqueue([current], [], true);
+		else if (claimRevision(current) !== pending.expected_revision) this.context.logger.warn(`Claim ${current.id} 的编辑日志已被其他版本取代，未自动加入团队上传。`);
+		await removeFile(this.context.paths.claimEditPending, this.context.logger);
+		return landed ? "queued" : "discarded";
+	}
+};
+//#endregion
+//#region src/store/disputes.ts
+var DisputeStore = class extends EntityStore {
+	constructor(context) {
+		super(context, context.paths.disputes, DisputeSchema, DisputeIdSchema);
+	}
+};
+//#endregion
+export { ClaimEditStore as n, PendingClaimEditSchema as r, DisputeStore as t };

package/lib/dream-agent-BVqxbKFc.js

@@ -0,0 +1,249 @@
+import { i as transportError, t as abortable } from "./structured-C9byFuzm.js";
+import { q as DreamValidationError } from "./evidence-store-DW7kj20i.js";
+import { _ as JobError } from "./lock-DbmlKOoX.js";
+import { n as DreamTools, r as isDreamTool } from "./service-BPwaZzFF.js";
+import { t as toolParameters } from "./tool-schema-3b4gH1zf.js";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+import { SessionId, appendPluginRecord } from "@deepseek-ai/dsh-session";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#region src/dsh-adapter/dream-agent.ts
+const descriptions = {
+	dream_record_candidates: "整批验证后登记候选；按 candidate_progress.current 逐项处理。当前组可保留原目标并扩展或调整种类，不能与其他待处理组重叠。",
+	dream_stage_group: "暂存完整操作组，不写 Claim。纯 A 废弃可简写 id/action/reason；其他修改遵循 schema。group:null 撤回草稿但不撤销候选。",
+	dream_validate: "校验当前草稿，返回 before/after、实际证据和 validation_id，随后逐 Claim 语义复核。",
+	dream_apply_group: "提交当前 validation_id 与逐 Claim 语义复核；先持久记录再写 Claim，返回真实执行结果。",
+	dream_keep_candidate: "明确保留当前候选，说明具体原因；不改变 Claim。",
+	dream_read_draft: "查看已接受草稿、当前候选和剩余模型轮数。",
+	dream_read_history: "分页读取本轮持久执行记录；回执不是独立事实证据。",
+	dream_review_sync: "读取已有整合的同步依赖；确认后用同一 validation_id 和简洁语义 review 提交。",
+	dream_finish: "提交 ABC 实际覆盖总结并结束；额度收尾时尚未完成的候选会标为未完成，不强求修改。",
+	read_claim: "完整读取本轮自有 Claim；目录和摘要不授予修改权限。",
+	read_trace: "先用 claim_id 分页查找已读自有 Claim 的关联 Trace（offset/limit 按条，默认 20、最多 100），再提供 claim_id 和 trace_id 分页读正文（offset/limit 按字符，默认 4000、最多 8000）。旧 id 仍可单独读取。Trace 是来源线索，不能单独证明事实。",
+	file_read: "读取当前候选的工作区直接材料，绑定 claim_ids，返回插件生成的证据 ID 与文件版本。",
+	file_glob: "在工作区按路径字面片段发现文件；只用于定位，再 file_read 才产生证据。",
+	file_grep: "在工作区按字面内容搜索；只用于定位，再 file_read 才产生证据。"
+};
+function dreamToolGuard(name, args) {
+	if (!isDreamTool(name)) return "Dream 只能调用声明的领域工具与工作区只读工具。";
+	const parsed = DreamTools[name].safeParse(args);
+	if (parsed.success) return void 0;
+	return `Dream 参数不合法，请按工具 schema 修复：${parsed.error.issues.slice(0, 8).map((issue) => `${issue.path.join(".") || "$"}: ${issue.code}${issue.code === "unrecognized_keys" ? `；删除多余字段 ${JSON.stringify(issue.keys.slice(0, 8)).slice(0, 400)}` : issue.code === "invalid_type" ? `；期望 ${issue.expected}` : ""}`).join("; ")}`;
+}
+function autonomousDreamRunner(ctx) {
+	return async ({ session, route, config, system, signal }) => {
+		const requestDeadline = new AbortController();
+		const bounded = AbortSignal.any([signal, requestDeadline.signal]);
+		let stepError;
+		let completed = false;
+		let clearRequestTimeout = () => {};
+		let toolJsonRetries = 0;
+		let toolJsonFeedback = "";
+		const binding = ctx.get("acnRuntime")?.backgroundSelection(session.knowledge.config);
+		const handle = await ctx.agents.create({
+			sessionId: SessionId(`acn-dream-${randomUUID()}`),
+			meta: {
+				cwd: session.workspace,
+				origin: "subagent",
+				delegationDepth: 1,
+				agentPreset: "acn-dream"
+			},
+			agentOptions: {
+				...route,
+				maxTokens: config.maxOutputTokens
+			},
+			signal: bounded,
+			setup: (child, agent) => {
+				if (binding !== void 0) appendPluginRecord(agent.session, "plugin:acn/team-selection", binding);
+				child.tools.restrict({ allow: [] });
+				child.tools.presentAs("native");
+				child.tools.guard((execution) => dreamToolGuard(execution.name, execution.arguments));
+				for (const name of Object.keys(DreamTools).filter(isDreamTool)) {
+					const tool = defineTool({
+						name,
+						description: descriptions[name],
+						parameters: {},
+						output: {
+							schema: { type: "json" },
+							render: (_args, result) => [{
+								type: "text",
+								text: JSON.stringify(result)
+							}]
+						},
+						execute: async (args, execution) => {
+							bounded.throwIfAborted();
+							execution.signal.throwIfAborted();
+							try {
+								return z.json().parse(await session.execute(name, args, AbortSignal.any([bounded, execution.signal])));
+							} catch (error) {
+								bounded.throwIfAborted();
+								if (error instanceof DreamValidationError || error instanceof z.ZodError) return {
+									error: error.message,
+									executed: false
+								};
+								throw error;
+							}
+						}
+					});
+					child.tools.register({
+						...tool,
+						parameters: toolParameters(DreamTools[name])
+					});
+				}
+				child.systemPrompt.suppressRuntimeContext();
+				child.systemPrompt.section({
+					name: "acn-dream-only",
+					order: 0,
+					text: system,
+					interpolate: false,
+					complete: true
+				});
+				const budgetContext = "acn-dream-budget";
+				child.systemPrompt.context({
+					name: budgetContext,
+					order: 0,
+					text: () => session.budgetNotice(),
+					interpolate: false,
+					required: true
+				});
+				const toolErrorContext = "acn-dream-tool-error";
+				child.systemPrompt.context({
+					name: toolErrorContext,
+					order: 1,
+					text: () => toolJsonFeedback,
+					interpolate: false,
+					required: true
+				});
+				const allowedContexts = /* @__PURE__ */ new Set([budgetContext, toolErrorContext]);
+				const shadowed = /* @__PURE__ */ new Set();
+				child.on("system-prompt/assemble", async (_assembly, _context, next) => {
+					const assembly = await next();
+					for (const context of assembly.contexts) if (!allowedContexts.has(context.name) && !shadowed.has(context.name)) {
+						child.systemPrompt.context({
+							name: context.name,
+							order: 0,
+							text: "",
+							interpolate: false
+						});
+						shadowed.add(context.name);
+					}
+					return {
+						...assembly,
+						contexts: assembly.contexts.filter((context) => allowedContexts.has(context.name)),
+						variables: {},
+						tools: assembly.tools.filter((tool) => isDreamTool(tool.name))
+					};
+				});
+				child.on("agent/pre-step", async (_payload, next) => {
+					if (session.finished) throw new JobError("dream_finished", "Dream 已完成。");
+					bounded.throwIfAborted();
+					return next();
+				});
+				child.on("agent/request", async (payload, next) => {
+					try {
+						await session.admitStep(AbortSignal.any([bounded, payload.signal]));
+					} catch (error) {
+						stepError = error instanceof Error ? error : new JobError("dream_step", "Dream 模型请求准入失败。");
+						throw stepError;
+					}
+					clearRequestTimeout();
+					const timeout = AbortSignal.timeout(config.timeoutMs);
+					const expire = () => {
+						requestDeadline.abort(timeout.reason);
+					};
+					timeout.addEventListener("abort", expire, { once: true });
+					clearRequestTimeout = () => {
+						timeout.removeEventListener("abort", expire);
+					};
+					return next();
+				});
+				child.on("agent/assistant-stream", ({ frame }) => {
+					if (frame.type !== "end") return;
+					clearRequestTimeout();
+					if (frame.outcome.kind === "committed" && frame.outcome.eventType === "assistant/message") toolJsonFeedback = "";
+				});
+				child.on("agent/request-error", async (payload, next) => {
+					clearRequestTimeout();
+					if (payload.failure.code !== "MALFORMED_RESPONSE" || !/(?:^|: )tool input is invalid JSON$/u.test(payload.failure.message)) return next();
+					bounded.throwIfAborted();
+					payload.signal.throwIfAborted();
+					if (toolJsonRetries < 2) {
+						toolJsonRetries += 1;
+						toolJsonFeedback = "工具参数 JSON 解析失败（MALFORMED_RESPONSE）。上一条模型响应未被接纳，该响应中的工具调用均未执行。请重新发出需要的工具调用，参数必须是完整合法的 JSON 对象，正确闭合并使用双引号和转义，同时遵守工具 schema。不要只输出解释或将失败调用视为已执行。已接受的进度保留，修复请求仍计入现有探索与收尾额度；按当前阶段和剩余额度行动。";
+						return { kind: "retry" };
+					}
+					stepError = new JobError("dream_tool_json", "模型返回的工具参数格式无效（MALFORMED_RESPONSE），自动重试两次后仍失败；进度和已用额度已保留，可稍后重试或更换知识模型。");
+				}, { prepend: true });
+				child.on("session/event", (_session, event) => {
+					if (event.type !== "turn/end") return;
+					clearRequestTimeout();
+					const reason = event.data.reason;
+					completed = reason.kind === "completed";
+					if (stepError !== void 0) return;
+					if (reason.kind === "error") {
+						const failure = transportError(reason.error);
+						stepError = new JobError(failure.kind, `Dream 模型调用失败：${failure.message} 已有进度和已用额度保留。`);
+					}
+					if (reason.kind === "max-tokens") stepError = new JobError("dream_output_limit", "Dream 模型输出达到 token 上限（MAX_TOKENS）；进度和已用额度保留，请精简整理范围或调整输出上限后重试。");
+				});
+			}
+		});
+		const cancel = () => {
+			handle.agent.cancel({ kind: "parent" });
+		};
+		bounded.addEventListener("abort", cancel, { once: true });
+		const waitForTurn = async () => {
+			await abortable(handle.agent.whenIdle(), bounded);
+			bounded.throwIfAborted();
+			if (!session.finished && !completed) throw stepError ?? new JobError("dream_incomplete", "Dream 子会话未正常结束；已有进度和额度保留，可通过 /acn-status retry 重试。");
+		};
+		try {
+			bounded.throwIfAborted();
+			handle.agent.followup(createUserMessage({
+				content: [{
+					type: "text",
+					text: JSON.stringify(await session.input())
+				}],
+				source: { kind: "acn-formation" }
+			}));
+			await waitForTurn();
+			for (let repairs = 0; !session.finished && !session.exhausted && repairs < 2; repairs += 1) {
+				completed = false;
+				handle.agent.followup(createUserMessage({
+					content: [{
+						type: "text",
+						text: "上一条总结没有完成 Dream。不要重复普通文本收尾。继续使用工具修复；逐组 dream_validate、dream_apply_group，然后 dream_finish。无变化也必须调用 dream_finish；已经接受的草稿和复核仍保留。"
+					}],
+					source: { kind: "acn-formation" }
+				}));
+				await waitForTurn();
+			}
+			if (!session.finished && session.exhausted && !session.wrappingUp) {
+				completed = false;
+				handle.agent.followup(createUserMessage({
+					content: [{
+						type: "text",
+						text: "探索额度已用尽，请完成本次 Dream 收尾并调用 dream_finish。"
+					}],
+					source: { kind: "acn-formation" }
+				}));
+				await waitForTurn();
+			}
+			if (!session.finished && session.exhausted) await session.finishBudget(bounded);
+			if (session.finished) return;
+			if (stepError !== void 0) throw stepError;
+			throw new JobError("dream_incomplete", "Dream 未调用 dream_finish；已有进度已保留，可通过 /acn-status retry 重试。");
+		} catch (error) {
+			signal.throwIfAborted();
+			if (requestDeadline.signal.aborted) throw new JobError("dream_timeout", "Dream 单次模型请求超时，子会话已停止，已用轮数和进度保留。", true);
+			throw error;
+		} finally {
+			clearRequestTimeout();
+			bounded.removeEventListener("abort", cancel);
+			await handle.dispose();
+		}
+	};
+}
+//#endregion
+export { autonomousDreamRunner as t };

package/lib/dream.js

@@ -0,0 +1,4 @@
+import { $ as OperationSchema, A as valueHash, B as CandidateSchema, C as expandDraft, D as sameIds, E as reviewInput, F as evidenceBody, G as DraftResponseSchema, H as CoverageSchema, I as independentReceipt, J as GroupSchema, K as DreamStateSchema, L as requireEvidenceIds, N as ReceiptSchema, O as validateCandidates, P as directEvidence, Q as KindSchema, S as contentHash, T as reaches, U as DiscoverySchema, V as CheckpointSchema, W as DraftGroupSchema, X as KeepReasonSchema, Y as HashSchema, Z as KeySchema, _ as dreamEligible, a as GlobArgs, at as ReviewInputSchema, b as validateSelfReview, c as privateDataHome, ct as ReviewSummarySchema, d as readEvidenceFile, dt as UpdateSchema, et as OriginSchema, f as receiptCurrent, ft as ValidationSchema, g as conservativeTokens, h as claimInput, i as EvidenceTools, it as QuoteSchema, k as validateConsolidationSources, l as authorizeFile, lt as SelfReviewSchema, m as INPUT_TOKENS, mt as text, n as EvidenceManifestSchema, nt as PreparedGroupSchema, o as GrepArgs, ot as ReviewRecordSchema, p as within, pt as requireDream, q as DreamValidationError, r as EvidenceStore, rt as ProgressSchema, s as ReadArgs, st as ReviewResponseSchema, t as ClaimArgs, tt as PlanSchema, u as discoverable, ut as SemanticReviewSchema, v as versions, w as prepareGroup, x as validateSemanticReview, y as coverageGaps, z as BasisSchema } from "./evidence-store-DW7kj20i.js";
+import { t as DreamStore } from "./checkpoint-c7aI4D-X.js";
+import { a as SyncValidationSchema, i as DreamSync, t as AcnDream } from "./service-BPwaZzFF.js";
+export { AcnDream, BasisSchema, CandidateSchema, CheckpointSchema, ClaimArgs, CoverageSchema, DiscoverySchema, DraftGroupSchema, DraftResponseSchema, DreamStateSchema, DreamStore, DreamSync, DreamValidationError, EvidenceManifestSchema, EvidenceStore, EvidenceTools, GlobArgs, GrepArgs, GroupSchema, HashSchema, INPUT_TOKENS, KeepReasonSchema, KeySchema, KindSchema, OperationSchema, OriginSchema, PlanSchema, PreparedGroupSchema, ProgressSchema, QuoteSchema, ReadArgs, ReceiptSchema, ReviewInputSchema, ReviewRecordSchema, ReviewResponseSchema, ReviewSummarySchema, SelfReviewSchema, SemanticReviewSchema, SyncValidationSchema, UpdateSchema, ValidationSchema, authorizeFile, claimInput, conservativeTokens, contentHash, coverageGaps, directEvidence, discoverable, dreamEligible, evidenceBody, expandDraft, independentReceipt, prepareGroup, privateDataHome, reaches, readEvidenceFile, receiptCurrent, requireDream, requireEvidenceIds, reviewInput, sameIds, text, validateCandidates, validateConsolidationSources, validateSelfReview, validateSemanticReview, valueHash, versions, within };