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

package/lib/plugins/commands.js

@@ -0,0 +1,590 @@
+import { h as TraceIdSchema, l as ClaimIdSchema, t as ClaimSchema } from "../claim-DOAGe8ZK.js";
+import { n as RevisionConflict, t as KnowledgeError } from "../errors-Bp_2WXBr.js";
+import { n as validateClaimText, t as openSingleFile } from "../regular-file-BFpqMoub.js";
+import { _ as JobError, i as decodeYaml, n as withFileLock, p as writeTextAtomicIfAbsent, w as hasCode } from "../lock-DbmlKOoX.js";
+import { t as TraceSchema } from "../trace-Da0RnL5R.js";
+import { r as UploadStore } from "../uploads-BCA2p92b.js";
+import { _ as unboundSession, f as sessionChanged, r as configurationBusy } from "../session-binding-zCSuizHs.js";
+import { r as expandHomePath } from "../paths-B7NI9Ano.js";
+import { n as isSubagent } from "../subagent-yJsFxHmH.js";
+import { t as JobQueue } from "../queue-M917xHPS.js";
+import { i as commandMessage, n as allActivities } from "../activities-B8U-iW4-.js";
+import { z } from "zod";
+import fs from "node:fs/promises";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+//#region src/commands/claim.ts
+function commandWords(input, literalBackslashes = false) {
+	const words = [];
+	let current = "";
+	let quote;
+	let escaped = false;
+	let started = false;
+	for (const char of input) if (escaped) {
+		current += char;
+		escaped = false;
+		started = true;
+	} else if (char === "\\" && !literalBackslashes) {
+		escaped = true;
+		started = true;
+	} else if (quote !== void 0) if (char === quote) quote = void 0;
+	else current += char;
+	else if (char === "\"" || char === "'") {
+		quote = char;
+		started = true;
+	} else if (/\s/u.test(char)) {
+		if (started) words.push(current);
+		current = "";
+		started = false;
+	} else {
+		current += char;
+		started = true;
+	}
+	if (quote !== void 0 || escaped) throw new KnowledgeError("validation", "Unclosed command quote or escape.");
+	if (started) words.push(current);
+	return words;
+}
+async function claimCommand(knowledge, input, readOnly, signal) {
+	const words = commandWords(input.trim());
+	const action = words[0];
+	if (action === "show") {
+		if (words.length !== 2) throw new KnowledgeError("validation", "Usage: /claim show <id>");
+		return JSON.stringify(await knowledge.readClaim(ClaimIdSchema.parse(words[1])), null, 2);
+	}
+	if (action === "set") {
+		if (readOnly) throw new KnowledgeError("ownership", "Subagents cannot modify ACN knowledge.");
+		if (words.length < 3) throw new KnowledgeError("validation", "Usage: /claim set <id> <field>=<value> ...");
+		const id = ClaimIdSchema.parse(words[1]);
+		const fields = {};
+		for (const word of words.slice(2)) {
+			const separator = word.indexOf("=");
+			const field = word.slice(0, separator);
+			if (separator < 1 || ![
+				"name",
+				"statement",
+				"scope",
+				"evidence_summary",
+				"confidence",
+				"status"
+			].includes(field) || field in fields) throw new KnowledgeError("validation", "Use each editable Claim field at most once.");
+			fields[field] = word.slice(separator + 1);
+		}
+		const detail = await knowledge.readClaim(id);
+		return JSON.stringify(await knowledge.updateClaim({
+			...fields,
+			id,
+			expected_revision: detail.revision
+		}, signal), null, 2);
+	}
+	const query = [];
+	let offset = 0;
+	let limit = 20;
+	let includeDeprecated = false;
+	const listWords = action === "list" ? words.slice(1) : words;
+	for (let index = 0; index < listWords.length; index += 1) {
+		const word = listWords[index];
+		if (word === "--include-deprecated") includeDeprecated = true;
+		else if (word === "--offset" || word === "--limit") {
+			const number = Number(listWords[index + 1]);
+			if (word === "--offset") offset = number;
+			else limit = number;
+			index += 1;
+		} else if (word !== void 0 && word.startsWith("--")) throw new KnowledgeError("validation", "Unknown Claim list option.");
+		else if (word !== void 0) query.push(word);
+	}
+	const result = await knowledge.listClaims({
+		query: query.join(" "),
+		offset,
+		limit,
+		includeDeprecated
+	});
+	const rows = result.items.map((item) => `${item.id} | ${JSON.stringify(item.name.text)} | ${JSON.stringify(item.scope.text)} | ${item.confidence} | ${item.status}`);
+	if (rows.length === 0) rows.push("没有匹配的 Claim。");
+	if (result.next_offset !== null) rows.push(`另有 ${result.omitted} 条；下一页：/claim list ${JSON.stringify(query.join(" "))} --offset ${result.next_offset} --limit ${result.limit}${includeDeprecated ? " --include-deprecated" : ""}`);
+	return rows.join("\n");
+}
+function commandDomainError(error) {
+	if (error instanceof RevisionConflict) return `Claim 已改变，请重新读取。当前 revision: ${error.currentRevision}`;
+	if (error instanceof KnowledgeError) return error.message;
+}
+//#endregion
+//#region src/commands/status.ts
+async function statusCommand(knowledge, options = {}) {
+	if (!knowledge.configured) return "ACN 未配置。打开 DSH「设置 → ACN 插件设置 → 工作配置」，新建配置并填写 Agent ID；保存后生效，无需手改 YAML 或重启。\nACN is not configured. Open DSH Settings → ACN settings → Work configurations, create a work configuration, enter an Agent ID, and save it. Advanced/headless setup: see docs/config.md.";
+	const claims = await knowledge.listClaims({
+		includeDeprecated: true,
+		limit: 100
+	});
+	const traces = await knowledge.listTraces({ limit: 100 });
+	const queue = await new UploadStore(knowledge.context()).read();
+	const jobs = await new JobQueue(knowledge.context()).list();
+	const activities = await allActivities(knowledge);
+	const paused = new Set(activities.filter((item) => item.state === "paused").map((item) => item.id));
+	const outstanding = (job) => job.state === "failed" || job.payload["paused"] === true || paused.has(job.id);
+	const sorted = jobs.filter((job) => !options.failed || outstanding(job)).sort((a, b) => Number(outstanding(b)) - Number(outstanding(a)) || b.updatedAt - a.updatedAt || a.id.localeCompare(b.id));
+	const page = options.page ?? 1;
+	const shown = sorted.slice((page - 1) * 10, page * 10);
+	const team = knowledge.teamStatus();
+	const deliveries = activities.filter((item) => item.kind === "delivery" && item.requiresAttention);
+	return [
+		`ACN: ${knowledge.mode}`,
+		`agentId: ${knowledge.agentId}`,
+		`数据目录 / Data directory: ${knowledge.context().paths.root}`,
+		`Claim: ${claims.items.length + claims.omitted}`,
+		`Trace: ${traces.items.length + traces.omitted}`,
+		`待上传 / Pending Claim: ${queue.claims.length}; Dispute: ${queue.disputes.length}`,
+		knowledge.mode === "solo" ? "团队连接: 单人模式，不请求团队服务。 / Solo: no team requests." : `团队连接 / Team: Router=${team.router.state}; Maintainer=${team.maintainer.state}`,
+		...[team.router.error, team.maintainer.error].filter((error) => error !== void 0),
+		`后台任务 / Tasks: queued=${jobs.filter((job) => job.state === "queued").length} running=${jobs.filter((job) => job.state === "running").length} failed=${jobs.filter((job) => job.state === "failed").length}`,
+		`页 / Page ${page}/${Math.max(1, Math.ceil(sorted.length / 10))}; ${options.failed ? "失败与暂停 / Failed and paused" : "未解决任务优先 / Unresolved tasks first"}`,
+		...shown.map((job) => `${job.id} ${job.kind} ${job.state} attempts=${job.attempts}${job.payload["paused"] === true || paused.has(job.id) ? " — 已暂停 / paused" : ""}${job.lastError === void 0 ? "" : ` — ${job.lastError}`}`),
+		...sorted.length > page * 10 ? [`下一页 / Next: /acn-status ${options.failed ? "failed" : "all"} ${page + 1}`] : [],
+		...jobs.some(outstanding) ? ["查看全部失败与暂停 / List failures: /acn-status failed [page]", "重试任务 / Retry: /acn-status retry <job_id>"] : [],
+		...deliveries.length === 0 ? [] : [`团队投递异常 / Delivery issues: ${deliveries.length}. 打开 ACN「知识与活动」查看实体 ID、原因和恢复操作。 / Open ACN Knowledge and activity for entity IDs and recovery actions.`]
+	].join("\n");
+}
+//#endregion
+//#region src/commands/import.ts
+const MAX_FILE_BYTES = 16 * 1024 * 1024;
+function invalid(message) {
+	throw new KnowledgeError("validation", message);
+}
+function stamp(info) {
+	return `${info.dev}:${info.ino}:${info.size}:${info.mtimeMs}:${info.ctimeMs}`;
+}
+async function directory(path, required = false) {
+	try {
+		const info = await fs.lstat(path);
+		if (!info.isDirectory() || info.isSymbolicLink()) invalid("Import directories must be regular directories, without symbolic links.");
+		return true;
+	} catch (error) {
+		if (!required && hasCode(error, "ENOENT")) return false;
+		throw error;
+	}
+}
+async function readSource(path) {
+	const file = await openSingleFile(path, () => new KnowledgeError("validation", "Import accepts single-link regular UTF-8 files without symbolic links."));
+	try {
+		const before = await file.stat();
+		if (!before.isFile() || before.nlink !== 1 || before.size > MAX_FILE_BYTES) invalid("Import accepts single-link regular UTF-8 files up to 16 MiB.");
+		let text;
+		try {
+			text = new TextDecoder("utf-8", {
+				fatal: true,
+				ignoreBOM: true
+			}).decode(await file.readFile());
+		} catch (error) {
+			if (error instanceof TypeError) invalid("Import source is not valid UTF-8.");
+			throw error;
+		}
+		const snapshot = stamp(before);
+		if (snapshot !== stamp(await file.stat())) invalid("Import source changed while reading; stop source writers and retry.");
+		return {
+			path,
+			text,
+			stamp: snapshot
+		};
+	} finally {
+		await file.close();
+	}
+}
+async function entities(root, name, schema, idSchema) {
+	const path = join(root, name);
+	if (!await directory(path)) return [];
+	const values = [];
+	for (const entry of (await fs.readdir(path)).sort()) {
+		if (!entry.endsWith(".yaml") || entry.includes(".tmp.")) continue;
+		const id = entry.slice(0, -5);
+		if (!idSchema.safeParse(id).success) invalid(`Invalid ${name} filename in import source.`);
+		const file = await readSource(join(path, entry));
+		let value;
+		try {
+			value = decodeYaml(schema, file.text);
+		} catch {
+			invalid(`Invalid ${name} document in import source.`);
+		}
+		if (value.id !== id) invalid(`Import ${name} ID differs from its filename.`);
+		values.push({
+			file,
+			value
+		});
+	}
+	return values;
+}
+function inside(parent, child) {
+	const path = relative(parent, child);
+	return path === "" || !path.startsWith(`..${sep}`) && path !== ".." && !isAbsolute(path);
+}
+function importWords(input, platform = process.platform) {
+	if (platform !== "win32") return commandWords(input);
+	const words = [];
+	let offset = 0;
+	while (offset < input.length) {
+		if (/\s/u.test(input[offset] ?? "")) {
+			offset += 1;
+			continue;
+		}
+		const quote = input[offset];
+		if (quote === "\"" || quote === "'") {
+			const end = input.indexOf(quote, offset + 1);
+			if (end === -1 || end + 1 < input.length && !/\s/u.test(input[end + 1] ?? "")) invalid("Unclosed or invalid import path quote.");
+			let word = input.slice(offset + 1, end);
+			if (quote === "\"" && /^(?:[^\\]|\\\\)*$/.test(word) && (!word.startsWith("\\\\") || word.startsWith("\\\\\\\\"))) try {
+				const decoded = JSON.parse(input.slice(offset, end + 1));
+				if (typeof decoded === "string") word = decoded;
+			} catch {}
+			words.push(word);
+			offset = end + 1;
+		} else {
+			const end = input.slice(offset).search(/\s/u);
+			const length = end === -1 ? input.length - offset : end;
+			words.push(input.slice(offset, offset + length));
+			offset += length;
+		}
+	}
+	return words;
+}
+async function importCommand(knowledge, input, readOnly, signal) {
+	if (readOnly) throw new KnowledgeError("ownership", "Subagents cannot import private knowledge.");
+	const words = importWords(input);
+	const options = new Set(words.filter((word) => word.startsWith("--")));
+	const paths = words.filter((word) => !word.startsWith("--"));
+	if (paths.length !== 1 || paths[0] === "" || [...options].some((option) => !["--dry-run"].includes(option))) invalid("Usage: /acn-import [--dry-run] <acn_agent_home>");
+	const source = resolve(expandHomePath(paths[0] ?? ""));
+	await directory(source, true);
+	const context = knowledge.context();
+	const canonical = await fs.realpath(source);
+	async function actual(path) {
+		try {
+			return await fs.realpath(path);
+		} catch (error) {
+			if (!hasCode(error, "ENOENT")) throw error;
+			const parent = resolve(path, "..");
+			if (parent === path) throw error;
+			return join(await actual(parent), basename(path));
+		}
+	}
+	const target = await actual(context.paths.root);
+	if (inside(canonical, target) || inside(target, canonical)) invalid("Import source and target must be separate directories.");
+	const claims = await entities(source, "claims", ClaimSchema, ClaimIdSchema);
+	const traces = await entities(source, "traces", TraceSchema, TraceIdSchema);
+	for (const { value } of claims) {
+		if (value.holder !== context.agentId) throw new KnowledgeError("ownership", "Import contains a Claim held by another agent.");
+		validateClaimText({
+			name: value.name,
+			statement: value.statement,
+			scope: value.scope,
+			evidence_summary: value.evidence_summary
+		});
+	}
+	for (const { value } of traces) if (value.agent !== context.agentId) throw new KnowledgeError("ownership", "Import contains a Trace owned by another agent.");
+	const allFiles = [...claims.map((item) => item.file), ...traces.map((item) => item.file)];
+	if (allFiles.length === 0) invalid("No importable data found. Pass the agent directory containing claims/ or traces/.");
+	for (const file of allFiles) if (file.stamp !== stamp(await fs.lstat(file.path))) invalid("Import source changed; stop source writers and retry.");
+	const report = {
+		dryRun: options.has("--dry-run"),
+		claims: [],
+		traces: [],
+		skipped: []
+	};
+	const publish = async (path, text) => {
+		if (!report.dryRun) return writeTextAtomicIfAbsent(path, text, context.logger);
+		try {
+			await fs.lstat(path);
+			return false;
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return true;
+			throw error;
+		}
+	};
+	const apply = async () => {
+		for (const name of ["claims", "traces"]) await directory(join(context.paths.root, name));
+		for (const [items, category] of [[claims, "claims"], [traces, "traces"]]) for (const { file, value } of items) {
+			signal?.throwIfAborted();
+			const created = await publish(join(context.paths[category], `${value.id}.yaml`), file.text);
+			(created ? report[category] : report.skipped).push(created ? value.id : `${category}/${value.id}`);
+		}
+	};
+	if (report.dryRun) await apply();
+	else {
+		await knowledge.initialize();
+		await withFileLock(context.paths.knowledgeLock, apply, {
+			signal,
+			timeoutMs: context.lockTimeoutMs
+		});
+	}
+	return report;
+}
+function renderImportReport(report) {
+	return `${report.dryRun ? "导入预览（未写入）" : "导入完成"}：Claim ${report.claims.length}；Trace ${report.traces.length}。\n${report.skipped.length === 0 ? "没有冲突。" : `已跳过 ${report.skipped.length} 个已有目标：${report.skipped.join(", ")}`}\n源目录保持只读；导入不会加入团队上传队列。`;
+}
+//#endregion
+//#region src/plugins/commands.ts
+const name = "acn-commands";
+const inject = [
+	"acnKnowledge",
+	"acnRuntime",
+	"commands",
+	"sessions"
+];
+function apply(ctx) {
+	const knowledge = ctx.acnKnowledge;
+	const pool = ctx.acnRuntime;
+	let applying = () => false;
+	ctx.inject(["acnConfiguration"], (child) => {
+		const service = child.acnConfiguration;
+		applying = () => service.pending > 0;
+		child.effect(() => () => {
+			applying = () => false;
+		});
+	});
+	const denied = (agent) => {
+		if (applying()) return configurationBusy;
+		return pool.allowed(agent.session.header) ? void 0 : pool.unbound(agent.session.header) ? unboundSession : sessionChanged;
+	};
+	ctx.commands.register({
+		name: "acn-status",
+		description: "Show ACN status or retry a failed job.",
+		input: { hint: "[failed [page] | all [page] | retry <job_id>]" },
+		handler: async ({ agent, rawInput }) => {
+			const reason = denied(agent);
+			if (reason !== void 0) return {
+				kind: "error",
+				text: commandMessage(reason)
+			};
+			const knowledge = await pool.knowledge(agent.session.header);
+			const parts = rawInput.trim().split(/\s+/);
+			if (rawInput.trim() === "") return {
+				kind: "success",
+				text: await statusCommand(knowledge)
+			};
+			if (["failed", "all"].includes(parts[0] ?? "") && parts.length <= 2 && (parts[1] === void 0 || /^[1-9][0-9]*$/.test(parts[1]))) {
+				const page = Number(parts[1] ?? 1);
+				if (Number.isSafeInteger(page)) return {
+					kind: "success",
+					text: await statusCommand(knowledge, {
+						failed: parts[0] === "failed",
+						page
+					})
+				};
+			}
+			if (parts.length !== 2 || parts[0] !== "retry" || !/^[a-zA-Z0-9_-]+$/.test(parts[1] ?? "")) return {
+				kind: "error",
+				text: "用法 / Usage: /acn-status [failed [page] | all [page] | retry <job_id>]"
+			};
+			if (isSubagent(agent.session.header)) return {
+				kind: "error",
+				text: "子 agent 不能重试知识形成任务。"
+			};
+			const worker = knowledge.jobs;
+			if (worker === null) return {
+				kind: "error",
+				text: "请先配置 agentId。"
+			};
+			try {
+				const current = await worker.queue.read(parts[1] ?? "");
+				if (current !== null && !worker.supports(current.kind)) throw new JobError("handler_inactive", "对应后台组件未启用，请在插件管理中启用后重试。");
+				if (current?.kind === "dream" && current.payload["paused"] === true && current.state !== "failed") {
+					await worker.queue.pauseDream(false);
+					worker.wake(true);
+					return {
+						kind: "success",
+						text: commandMessage(`Dream 已恢复：${current.id}`)
+					};
+				}
+				return {
+					kind: "success",
+					text: `任务已重新入队：${(await worker.retry(parts[1] ?? "")).id}`
+				};
+			} catch (error) {
+				if (error instanceof JobError) return {
+					kind: "error",
+					text: commandMessage(error.message, error.kind)
+				};
+				throw error;
+			}
+		}
+	});
+	if (!knowledge.configured && knowledge.config.upstreams === void 0) return;
+	ctx.commands.register({
+		name: "acn-import",
+		description: "Import owned knowledge from a separate read-only agent directory.",
+		input: { hint: "[--dry-run] <acn_agent_home>" },
+		handler: async ({ agent, rawInput, signal }) => {
+			const reason = denied(agent);
+			if (reason !== void 0) return {
+				kind: "error",
+				text: commandMessage(reason)
+			};
+			const knowledge = await pool.knowledge(agent.session.header);
+			try {
+				return {
+					kind: "success",
+					text: renderImportReport(await importCommand(knowledge, rawInput, isSubagent(agent.session.header), signal))
+				};
+			} catch (error) {
+				const message = commandDomainError(error);
+				if (message !== void 0) return {
+					kind: "error",
+					text: message
+				};
+				throw error;
+			}
+		}
+	});
+	ctx.inject(knowledge.config.upstreams === void 0 ? ["acnDream", "commands"] : ["commands"], (child) => {
+		child.commands.register({
+			name: "dream",
+			description: "Organize owned knowledge or stop at a recoverable boundary.",
+			input: { hint: "[stop]" },
+			handler: async ({ agent, rawInput }) => {
+				const reason = denied(agent);
+				if (reason !== void 0) return {
+					kind: "error",
+					text: commandMessage(reason)
+				};
+				if (isSubagent(agent.session.header)) return {
+					kind: "error",
+					text: "子 agent 不能触发或停止 Dream。"
+				};
+				const service = (await pool.service(agent.session.header)).dream;
+				if (service === void 0) return {
+					kind: "error",
+					text: "Dream 组件未启用。"
+				};
+				if (rawInput.trim() === "stop") return {
+					kind: "success",
+					text: `已请求停止 ${await service.stop()} 个 Dream 任务；正在提交的组会完成，草稿和进度保留。再次 /dream 或重启可继续。`
+				};
+				if (rawInput.trim() !== "") return {
+					kind: "error",
+					text: "用法：/dream [stop]"
+				};
+				try {
+					const job = await service.request(agent.session.header.cwd, agent.session.id);
+					return {
+						kind: "success",
+						text: `Dream 任务 ${job.id}；使用 /acn-status 查看状态，报告路径：${join((await pool.knowledge(agent.session.header)).context().paths.dreamJob(job.id), "report.md")}`
+					};
+				} catch (error) {
+					if (error instanceof JobError) return {
+						kind: "error",
+						text: commandMessage(error.message, error.kind)
+					};
+					throw error;
+				}
+			}
+		});
+	});
+	ctx.inject(knowledge.config.upstreams === void 0 ? ["acnInbox", "commands"] : ["commands"], (child) => {
+		child.commands.register({
+			name: "inbox",
+			description: "Sync team Inbox and queue local internalization.",
+			handler: async ({ agent, signal }) => {
+				const reason = denied(agent);
+				if (reason !== void 0) return {
+					kind: "error",
+					text: commandMessage(reason)
+				};
+				const knowledge = await pool.knowledge(agent.session.header);
+				if (isSubagent(agent.session.header)) return {
+					kind: "error",
+					text: "子 agent 不能触发 Inbox 内化。"
+				};
+				const service = (await pool.service(agent.session.header)).inbox;
+				if (service === void 0) return {
+					kind: "error",
+					text: "Inbox 组件未启用。"
+				};
+				const report = await service.request(signal, agent.session.id);
+				return {
+					kind: "success",
+					text: `${knowledge.mode === "solo" ? "单人模式没有团队 inbox；处理本地 pending。\n" : ""}拉取 ${report.pulled}；持久化 ${report.accepted}；确认 ${report.acknowledged}；待内化 ${report.pending}。任务 ${report.jobId} 已入队。${report.warnings.length === 0 ? "" : `\n${report.warnings.join("\n")}`}`
+				};
+			}
+		});
+	});
+	ctx.inject(knowledge.config.upstreams === void 0 ? ["acnFormation", "commands"] : ["commands"], (child) => {
+		child.commands.register({
+			name: "recap",
+			description: "Review this session’s unprocessed knowledge without closing it.",
+			handler: async ({ agent }) => {
+				const reason = denied(agent);
+				if (reason !== void 0) return {
+					kind: "error",
+					text: commandMessage(reason)
+				};
+				if (isSubagent(agent.session.header)) return {
+					kind: "error",
+					text: "子 agent 不能触发知识形成。"
+				};
+				const service = (await pool.service(agent.session.header)).formation;
+				if (service === void 0) return {
+					kind: "error",
+					text: "知识形成组件未启用。"
+				};
+				const job = await service.recap(agent.session.id);
+				return {
+					kind: "success",
+					text: job === null ? "没有可复盘的新增内容，未创建任务。" : `Recap 任务：${job.id}；使用 /acn-status 查看结果。`
+				};
+			}
+		});
+		child.commands.register({
+			name: "acn-finalize",
+			description: "Form knowledge from this session’s unprocessed transcript.",
+			handler: async ({ agent }) => {
+				const reason = denied(agent);
+				if (reason !== void 0) return {
+					kind: "error",
+					text: commandMessage(reason)
+				};
+				if (isSubagent(agent.session.header)) return {
+					kind: "error",
+					text: "子 agent 不能触发知识形成。"
+				};
+				const service = (await pool.service(agent.session.header)).formation;
+				if (service === void 0) return {
+					kind: "error",
+					text: "知识形成组件未启用。"
+				};
+				return {
+					kind: "success",
+					text: `Finalize 已入队：${(await service.finalize(agent.session.id)).id}；使用 /acn-status 查看结果。`
+				};
+			}
+		});
+	});
+	ctx.commands.register({
+		name: "claim",
+		description: "Browse, read or revise local Claims.",
+		input: { hint: "[query] | show <id> | set <id> <field>=<value> ..." },
+		handler: async ({ agent, rawInput, signal }) => {
+			const reason = denied(agent);
+			if (reason !== void 0) return {
+				kind: "error",
+				text: commandMessage(reason)
+			};
+			const knowledge = await pool.knowledge(agent.session.header);
+			try {
+				return {
+					kind: "success",
+					text: await claimCommand(knowledge, rawInput, isSubagent(agent.session.header), signal)
+				};
+			} catch (error) {
+				const message = commandDomainError(error) ?? (error instanceof z.ZodError ? "Invalid Claim identifier or editable fields." : void 0);
+				if (message === void 0) throw error;
+				return {
+					kind: "error",
+					text: message
+				};
+			}
+		}
+	});
+}
+var commands_default = {
+	name,
+	inject,
+	apply
+};
+//#endregion
+export { apply, commands_default as default, importCommand, inject, name };

package/lib/plugins/dream.js

@@ -0,0 +1,66 @@
+import { o as RouteSchema } from "../structured-C9byFuzm.js";
+import { c as readYamlOr, l as writeYamlAtomic, n as withFileLock } from "../lock-DbmlKOoX.js";
+import { t as AcnDream } from "../service-BPwaZzFF.js";
+import { d as sessionAllowed } from "../session-binding-zCSuizHs.js";
+import { n as projectEvent, r as structuredBackend } from "../formation-D4LO31WW.js";
+import { t as autonomousDreamRunner } from "../dream-agent-BVqxbKFc.js";
+import { t as loadPromptRenderer } from "../render-CJaVcKKC.js";
+import { n as isSubagent } from "../subagent-yJsFxHmH.js";
+import { z } from "zod";
+//#region src/plugins/dream.ts
+const name = "acn-dream";
+const inject = [
+	"acnKnowledge",
+	"acnRuntime",
+	"agents",
+	"sessions",
+	"llm",
+	"tools",
+	"systemPrompt"
+];
+async function apply(ctx) {
+	const knowledge = ctx.acnKnowledge;
+	ctx.effect(() => ctx.acnRuntime.component("dream"));
+	if (!knowledge.configured || knowledge.config.upstreams !== void 0) return;
+	let pending = Promise.resolve();
+	const render = await loadPromptRenderer();
+	const service = new AcnDream(knowledge, structuredBackend(ctx), render, () => pending, {
+		workspace: async () => {
+			await pending;
+			return readYamlOr(knowledge.context().paths.dreamWorkspace, z.string(), () => process.cwd());
+		},
+		run: autonomousDreamRunner(ctx)
+	});
+	ctx.provide("acnDream", service);
+	if (!knowledge.active) {
+		ctx.effect(() => () => service.close());
+		return;
+	}
+	ctx.on("session/event", (session, event) => {
+		if (!sessionAllowed(ctx, knowledge.config, session.header) || isSubagent(session.header)) return;
+		const route = projectEvent(event).route;
+		if (route !== void 0) pending = pending.then(() => withFileLock(`${knowledge.context().paths.lastRoute}.lock`, () => writeYamlAtomic(knowledge.context().paths.lastRoute, route, RouteSchema, knowledge.logger))).catch(() => {
+			ctx.logger.warn("Could not persist the background Dream route.");
+		});
+	});
+	ctx.on("agent/created", ({ agent }) => {
+		if (!sessionAllowed(ctx, knowledge.config, agent.session.header) || isSubagent(agent.session.header)) return;
+		const cwd = agent.session.header.cwd;
+		if (cwd !== void 0) pending = pending.then(() => withFileLock(`${knowledge.context().paths.dreamWorkspace}.lock`, () => writeYamlAtomic(knowledge.context().paths.dreamWorkspace, cwd, z.string(), knowledge.logger))).catch(() => {
+			ctx.logger.warn("Could not persist the background Dream workspace.");
+		});
+		service.trigger();
+	});
+	ctx.effect(() => async () => {
+		await service.close();
+		await pending;
+	});
+	await service.start();
+}
+var dream_default = {
+	name,
+	inject,
+	apply
+};
+//#endregion
+export { apply, dream_default as default, inject, name };