@shgroup/dsh-serenity-hooks 1.16.0

package/lib/index.js

@@ -0,0 +1,2683 @@
+import z from "@deepseek-ai/schemastery";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { execFile, execFileSync, spawnSync } from "node:child_process";
+import { platform } from "node:os";
+import { promisify } from "node:util";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { randomBytes } from "node:crypto";
+import { fileURLToPath } from "node:url";
+//#region src/ccc.ts
+/**
+* ccc.ts — CCC 纯逻辑层（零 DSH 依赖，可独立单测）
+*
+* 职责：CCC 根检测（P1）、git 检测（P2）、.dsh/serenity.json 配置读取、
+* 路径守卫（P3 语义）、安全模式黑名单匹配。
+*
+* 由 tools/ 与 seams/ 复用；逻辑移植自 dsh-serenity-plugin v0.1-v0.2
+* runner（本项目自有代码，非 opencode-serenity-plugin 源码）。
+*/
+function findSerenityRoot(cwd) {
+	let current = resolve(cwd);
+	while (true) {
+		const marker = resolve(current, ".serenity");
+		if (existsSync(marker) && statSync(marker).isFile()) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function findGitRoot(cwd) {
+	let current = resolve(cwd);
+	while (true) {
+		if (existsSync(resolve(current, ".git"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function classifyPath(p, root) {
+	const rel = relative(resolve(root), resolve(p));
+	if (rel === "") return "same";
+	if (rel.startsWith("..")) return "outside";
+	return "inside";
+}
+function resolveInside(root, p) {
+	const abs = resolve(root, p);
+	if (classifyPath(abs, root) === "outside") throw new Error(`Path escape blocked: "${p}" resolves outside "${root}"`);
+	return abs;
+}
+const DEFAULT_SERENITY_CONFIG_PATHS = [".dsh/serenity.json", ".opencode/serenity.json"];
+function loadSerenityConfig(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
+	for (const candidate of paths) {
+		const p = resolve(root, candidate);
+		if (!existsSync(p)) continue;
+		try {
+			return JSON.parse(readFileSync(p, "utf-8"));
+		} catch {
+			return {};
+		}
+	}
+	return {};
+}
+const SAFE_MODE_MARKER = ".serenity-safe-on";
+function isSafeModeOn(root) {
+	return existsSync(resolve(root, SAFE_MODE_MARKER));
+}
+function readBlacklist(root, paths = DEFAULT_SERENITY_CONFIG_PATHS) {
+	const rules = loadSerenityConfig(root, paths).safeMode?.blacklist;
+	return Array.isArray(rules) ? rules.map(String) : [];
+}
+/** 匹配黑名单规则；命中返回规则，未命中返回 null。前缀匹配 / regex: 前缀 */
+function matchBlacklist(relPath, rules) {
+	for (const rule of rules) if (rule.startsWith("regex:")) try {
+		if (new RegExp(rule.slice(6)).test(relPath)) return rule;
+	} catch {}
+	else if (relPath.startsWith(rule)) return rule;
+	return null;
+}
+//#endregion
+//#region src/fs-ops.ts
+/**
+* fs-ops.ts — cc_fs 纯操作层（零 DSH 依赖，可独立单测）
+*
+* 移植自 dsh-serenity-plugin v0.1 acc-fs runner（本项目自有代码）。
+* 每个操作返回规范 JSON 值（由工具层 render 成模型可见文本）。
+*/
+const CC_FS_ACTIONS = [
+	"root",
+	"resolve",
+	"exists",
+	"list",
+	"tree",
+	"relative",
+	"mkdir",
+	"rm",
+	"mv",
+	"cp",
+	"touch",
+	"append",
+	"reveal",
+	"info",
+	"find"
+];
+function safeRel(root, abs) {
+	return relative(root, abs) || ".";
+}
+function runCcFs(root, args) {
+	const a = args.action;
+	switch (a) {
+		case "root": return root;
+		case "resolve":
+			if (!args.path) throw new Error("resolve 需要 path");
+			return resolveInside(root, args.path);
+		case "exists":
+			if (!args.path) throw new Error("exists 需要 path");
+			return existsSync(resolveInside(root, args.path));
+		case "list": {
+			const dir = args.path ? resolveInside(root, args.path) : root;
+			if (!existsSync(dir)) throw new Error(`no such dir: ${dir}`);
+			return readdirSync(dir, { withFileTypes: true }).map((e) => ({
+				name: e.name,
+				type: e.isDirectory() ? "dir" : e.isFile() ? "file" : "other"
+			}));
+		}
+		case "tree": {
+			const dir = args.path ? resolveInside(root, args.path) : root;
+			const maxDepth = args.depth ?? Infinity;
+			if (!existsSync(dir)) throw new Error(`no such dir: ${dir}`);
+			const out = [];
+			const walk = (cur, depth) => {
+				if (depth > maxDepth) return;
+				for (const e of readdirSync(cur, { withFileTypes: true })) {
+					const full = join(cur, e.name);
+					out.push({
+						path: safeRel(root, full),
+						type: e.isDirectory() ? "dir" : "file"
+					});
+					if (e.isDirectory()) walk(full, depth + 1);
+				}
+			};
+			walk(dir, 0);
+			return out;
+		}
+		case "relative":
+			if (!args.path) throw new Error("relative 需要 path");
+			return safeRel(root, resolveInside(root, args.path));
+		case "mkdir": {
+			const targets = args.paths?.length ? args.paths : args.path ? [args.path] : [];
+			if (targets.length === 0) throw new Error("mkdir 需要 path(s)");
+			for (const t of targets) mkdirSync(resolveInside(root, t), { recursive: true });
+			return {
+				ok: true,
+				created: targets
+			};
+		}
+		case "rm": {
+			const targets = args.paths?.length ? args.paths : args.path ? [args.path] : [];
+			if (targets.length === 0) throw new Error("rm 需要 path(s)");
+			const removed = [];
+			for (const t of targets) {
+				const abs = resolveInside(root, t);
+				if (abs === root) throw new Error("拒绝删除 CCC 根本身");
+				if (!existsSync(abs)) continue;
+				if (args.dryRun) {
+					removed.push(`${t} [dry-run]`);
+					continue;
+				}
+				rmSync(abs, {
+					recursive: true,
+					force: true
+				});
+				removed.push(t);
+			}
+			return {
+				ok: true,
+				removed
+			};
+		}
+		case "mv":
+			if (!args.src || !args.dst) throw new Error("mv 需要 src + dst");
+			renameSync(resolveInside(root, args.src), resolveInside(root, args.dst));
+			return {
+				ok: true,
+				from: args.src,
+				to: args.dst
+			};
+		case "cp":
+			if (!args.src || !args.dst) throw new Error("cp 需要 src + dst");
+			cpSync(resolveInside(root, args.src), resolveInside(root, args.dst), { recursive: true });
+			return {
+				ok: true,
+				from: args.src,
+				to: args.dst
+			};
+		case "touch": {
+			if (!args.path) throw new Error("touch 需要 path");
+			const abs = resolveInside(root, args.path);
+			if (!existsSync(abs)) writeFileSync(abs, "", "utf-8");
+			return {
+				ok: true,
+				path: safeRel(root, abs)
+			};
+		}
+		case "append": {
+			if (!args.path || args.content === void 0) throw new Error("append 需要 path + content");
+			const abs = resolveInside(root, args.path);
+			appendFileSync(abs, args.content, "utf-8");
+			return {
+				ok: true,
+				path: safeRel(root, abs)
+			};
+		}
+		case "reveal": {
+			if (!args.path) throw new Error("reveal 需要 path");
+			const abs = resolveInside(root, args.path);
+			if (!existsSync(abs)) throw new Error(`no such path: ${abs}`);
+			const os = platform();
+			try {
+				if (os === "darwin") execFileSync("open", ["-R", abs], { timeout: 1e4 });
+				else if (os === "linux") {
+					const revealPath = statSync(abs).isDirectory() ? abs : dirname(abs);
+					execFileSync("xdg-open", [revealPath], { timeout: 1e4 });
+				} else if (os === "win32") execFileSync("explorer", ["/select,", abs], { timeout: 1e4 });
+				else throw new Error(`unsupported platform: ${os}`);
+				return {
+					ok: true,
+					revealed: safeRel(root, abs)
+				};
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(`reveal failed to open "${safeRel(root, abs)}": ${msg}`);
+			}
+		}
+		case "info": {
+			if (!args.path) throw new Error("info 需要 path");
+			const abs = resolveInside(root, args.path);
+			if (!existsSync(abs)) return {
+				exists: false,
+				path: safeRel(root, abs)
+			};
+			const st = statSync(abs);
+			return {
+				exists: true,
+				path: safeRel(root, abs),
+				type: st.isDirectory() ? "dir" : st.isFile() ? "file" : "other",
+				size: st.size,
+				mtime: st.mtime.toISOString()
+			};
+		}
+		case "find": {
+			if (!args.pattern) throw new Error("find 需要 pattern");
+			const pattern = args.pattern;
+			const isRegex = pattern.startsWith("regex:");
+			const re = isRegex ? new RegExp(pattern.slice(6)) : null;
+			const out = [];
+			const walk = (cur) => {
+				for (const e of readdirSync(cur, { withFileTypes: true })) {
+					const full = join(cur, e.name);
+					if (isRegex ? re.test(e.name) : e.name.includes(pattern)) out.push(safeRel(root, full));
+					if (e.isDirectory()) walk(full);
+				}
+			};
+			walk(root);
+			return out;
+		}
+		default: throw new Error(`未知 action: ${a}`);
+	}
+}
+//#endregion
+//#region src/tools/cc-fs.ts
+/**
+* cc-fs.ts — cc_fs 真实 DSH 工具定义（defineTool）
+*
+* 进程内注册（取代 v0.1 的 bash spawn runner）：zod/schemastery 参数校验、
+* 规范 JSON 输出、纯 render 投影。逻辑在 fs-ops.ts（可单测）。
+*/
+function agentCwd$6(exec) {
+	return exec.agent?.session?.header?.cwd ?? process.cwd();
+}
+function renderText$8(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+const ccFsTool = defineTool({
+	name: "cc_fs",
+	description: "CCC 内文件系统操作（cc-fs 语义，DSH 原生版）。15 子命令：root/resolve/exists/list/tree/relative/mkdir/rm/mv/cp/touch/append/reveal/info/find。全部路径限定在 CCC 根内，路径逃逸自动阻断。reveal 在 OS 文件管理器中打开路径（Linux xdg-open / macOS Finder / Windows Explorer）。与 read/write/edit 互补（结构性操作）。",
+	parameters: {
+		action: {
+			type: "string",
+			enum: [...CC_FS_ACTIONS],
+			required: true,
+			description: "子命令"
+		},
+		path: {
+			type: "string",
+			description: "主路径参数（resolve/exists/list/tree/relative/touch/append/info/rm 单路径）"
+		},
+		paths: {
+			type: "array",
+			items: { type: "string" },
+			description: "批量路径（mkdir/rm）"
+		},
+		src: {
+			type: "string",
+			description: "mv/cp 源路径"
+		},
+		dst: {
+			type: "string",
+			description: "mv/cp 目标路径"
+		},
+		content: {
+			type: "string",
+			description: "append 内容"
+		},
+		pattern: {
+			type: "string",
+			description: "find 匹配（名称包含；regex: 前缀为正则）"
+		},
+		depth: {
+			type: "integer",
+			description: "tree 最大深度"
+		},
+		dryRun: {
+			type: "boolean",
+			description: "rm 预览模式"
+		}
+	},
+	output: {
+		schema: { type: "json" },
+		render: (args, value) => renderText$8(value)
+	},
+	async execute(args, exec) {
+		const root = findSerenityRoot(agentCwd$6(exec));
+		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
+		return runCcFs(root, args);
+	}
+});
+//#endregion
+//#region src/msm-ops.ts
+/**
+* msm-ops.ts — acc_msm 纯操作层（零 DSH 依赖）
+*
+* MSM（Mech & Semi-Mech）框架：list / exec / admin(register|deregister|check)。
+* 复用 CCC 的 mech-registry.json（v1 或数组格式）。cwd 钉在 CCC 根。
+*/
+const execFileAsync = promisify(execFile);
+const MSM_TIMEOUT_MS = 6e5;
+const MSM_ACTIONS = [
+	"list",
+	"exec",
+	"register",
+	"deregister",
+	"check",
+	"guide"
+];
+const MSM_GUIDE = `MSM 开发手册（Mech & Semi-Mech 框架）
+
+## 是什么
+MSM = 可执行单元层。Mech 纯 TS 零 LLM 推理；Semi-Mech TS 框架 + LLM 决策点。
+
+## 注册新 MSM（acc_msm register）
+1. 在 <skill>/scripts/ 写脚本（tsx 可跑；必须带 main() CLI 守卫 import.meta.url 检查）
+2. acc_msm register <name> --skill <s> --path <脚本相对根路径> --category <mech|semi-mech> --description <desc>
+3. 自动写入 mech-registry.json + git commit
+
+## 脚本约定
+- 顶部文档：用途/用法/退出码
+- 退出码：0 成功 / 1 user / 2 system / 3 operator
+- flags 中 type:"path" 的参数会被逃逸校验（根内强制）
+- 配对 .test.ts（vitest）
+
+## 品质检查（acc_msm check）
+DC-M1 有 .test.ts；DC-M2 有 main() 守卫；M3 脚本存在；M4 path flag 标记 type:"path"
+`;
+function parseRegistry(raw) {
+	const data = JSON.parse(raw);
+	if (Array.isArray(data)) return data;
+	const entries = data.entries;
+	if (!Array.isArray(entries)) throw new Error("invalid registry: missing entries[]");
+	return entries;
+}
+function findRegistries(root) {
+	const out = [];
+	const skillsDir = join(root, ".opencode", "skills");
+	if (existsSync(skillsDir)) for (const skill of readdirSync(skillsDir)) {
+		const p = join(skillsDir, skill, "references", "mech-registry.json");
+		if (existsSync(p)) out.push(p);
+	}
+	const rootRegistry = join(root, "mech-registry.json");
+	if (existsSync(rootRegistry)) out.push(rootRegistry);
+	return out;
+}
+function loadMsmEntries(root) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const regPath of findRegistries(root)) for (const entry of parseRegistry(readFileSync(regPath, "utf-8"))) if (!byName.has(entry.name)) byName.set(entry.name, entry);
+	return [...byName.values()];
+}
+function findEntry(root, name) {
+	return loadMsmEntries(root).find((e) => e.name === name) ?? null;
+}
+function registryPathFor(root, skill) {
+	return skill ? join(root, ".opencode", "skills", skill, "references", "mech-registry.json") : join(root, "mech-registry.json");
+}
+function writeRegistry(path, entries) {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, JSON.stringify({
+		version: 1,
+		description: "MSM registry (managed by acc-msm / dsh-serenity-hooks)",
+		entries
+	}, null, 2) + "\n", "utf-8");
+}
+function runMsm(root, args) {
+	switch (args.action) {
+		case "list": return loadMsmEntries(root).map((e) => ({
+			name: e.name,
+			skill: e.skill ?? null,
+			category: e.category ?? null,
+			description: e.description ?? ""
+		}));
+		case "guide": return { guide: MSM_GUIDE };
+		case "exec": {
+			const { entry, businessArgs, fmtJson, protocol } = prepareExec(root, args);
+			const p = protocolResult(protocol);
+			if (p !== void 0) return p;
+			let r = spawnSync("bun", [entry.path, ...businessArgs], {
+				cwd: root,
+				encoding: "utf-8",
+				timeout: MSM_TIMEOUT_MS,
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				]
+			});
+			if (r.error && r.error.code === "ENOENT") r = spawnSync("npx", [
+				"tsx",
+				entry.path,
+				...businessArgs
+			], {
+				cwd: root,
+				encoding: "utf-8",
+				timeout: MSM_TIMEOUT_MS,
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				]
+			});
+			return msmExecResult(entry.name, r.status ?? 2, r.stdout ?? "", r.stderr ?? "", fmtJson);
+		}
+		case "register": {
+			const name = args.name ?? "";
+			const { skill, path, category, description } = args;
+			if (!path || !category || !description) throw new Error("register 需要 path/category/description");
+			const regPath = registryPathFor(root, skill);
+			const entries = existsSync(regPath) ? parseRegistry(readFileSync(regPath, "utf-8")) : [];
+			if (entries.some((e) => e.name === name)) throw new Error(`MSM already registered: "${name}"`);
+			entries.push({
+				name,
+				path,
+				skill,
+				category,
+				description,
+				usage: `msm_exec ${name} [args...]`,
+				flags: []
+			});
+			writeRegistry(regPath, entries);
+			try {
+				execFileSync("git", ["add", "-A"], {
+					cwd: root,
+					stdio: "pipe"
+				});
+				execFileSync("git", [
+					"commit",
+					"-m",
+					`msm: register ${name}`
+				], {
+					cwd: root,
+					stdio: "pipe"
+				});
+			} catch {}
+			return {
+				registered: name,
+				registry: relative(root, regPath)
+			};
+		}
+		case "deregister": {
+			const name = args.name ?? "";
+			for (const regPath of findRegistries(root)) {
+				const entries = parseRegistry(readFileSync(regPath, "utf-8"));
+				const idx = entries.findIndex((e) => e.name === name);
+				if (idx >= 0) {
+					entries.splice(idx, 1);
+					writeRegistry(regPath, entries);
+					try {
+						execFileSync("git", ["add", "-A"], {
+							cwd: root,
+							stdio: "pipe"
+						});
+						execFileSync("git", [
+							"commit",
+							"-m",
+							`msm: deregister ${name}`
+						], {
+							cwd: root,
+							stdio: "pipe"
+						});
+					} catch {}
+					return { deregistered: name };
+				}
+			}
+			throw new Error(`MSM not registered: "${name}"`);
+		}
+		case "check": {
+			const entries = loadMsmEntries(root);
+			const issues = [];
+			for (const e of entries) {
+				const script = join(root, e.path);
+				const scriptExists = existsSync(script);
+				if (!scriptExists) issues.push({
+					name: e.name,
+					check: "M3",
+					detail: `script missing (${e.path})`
+				});
+				const testFile = script.replace(/\.ts$/, ".test.ts");
+				if (!existsSync(testFile)) issues.push({
+					name: e.name,
+					check: "M1",
+					detail: "no .test.ts"
+				});
+				if (scriptExists && !readFileSync(script, "utf-8").includes("import.meta.url")) issues.push({
+					name: e.name,
+					check: "M2",
+					detail: "no main() guard"
+				});
+			}
+			return {
+				checked: entries.length,
+				issues
+			};
+		}
+		default: throw new Error(`未知 action: ${args.action}`);
+	}
+}
+function prepareExec(root, args) {
+	const name = args.name ?? "";
+	const entry = findEntry(root, name);
+	if (!entry) throw new Error(`MSM not registered: "${name}"`);
+	const business = args.args ?? [];
+	if (business.includes("--list")) return {
+		entry,
+		businessArgs: [],
+		fmtJson: false,
+		protocol: { list: loadMsmEntries(root).map((e) => ({
+			name: e.name,
+			category: e.category ?? null
+		})) }
+	};
+	const schemaIdx = business.indexOf("--schema");
+	if (schemaIdx >= 0) {
+		const target = business[schemaIdx + 1];
+		const found = target ? loadMsmEntries(root).find((e) => e.name === target) : null;
+		if (!found) throw new Error(`MSM not registered: "${target}"`);
+		return {
+			entry,
+			businessArgs: [],
+			fmtJson: false,
+			protocol: { schema: {
+				name: found.name,
+				path: found.path,
+				flags: (found.flags ?? []).map((f) => ({
+					name: f.name,
+					type: f.type ?? null,
+					description: f.description ?? null
+				}))
+			} }
+		};
+	}
+	const fmtJson = business.includes("--format=json");
+	const businessArgs = business.filter((a) => a !== "--format=json");
+	for (const flag of entry.flags ?? []) {
+		if (flag.type !== "path") continue;
+		const eq = businessArgs.find((a) => a.startsWith(`--${flag.name}=`));
+		if (eq) {
+			const value = eq.slice(flag.name.length + 3);
+			if (classifyPath(resolve(root, value), root) === "outside") throw new Error(`Path escape blocked: --${flag.name}=${value} 越出 CCC 根`);
+		} else {
+			const idx = businessArgs.indexOf(`--${flag.name}`);
+			if (idx >= 0 && businessArgs[idx + 1]) {
+				const value = businessArgs[idx + 1];
+				if (classifyPath(resolve(root, value), root) === "outside") throw new Error(`Path escape blocked: --${flag.name} ${value} 越出 CCC 根`);
+			}
+		}
+	}
+	const script = resolve(root, entry.path);
+	if (classifyPath(script, root) === "outside") throw new Error(`MSM script escapes CCC root: "${entry.path}"`);
+	if (!existsSync(script)) throw new Error(`MSM script not found: "${entry.path}"`);
+	return {
+		entry: {
+			...entry,
+			path: script
+		},
+		businessArgs,
+		fmtJson
+	};
+}
+/** 协议结果扁平化：{list|schema} 包装 → 顶层值（兼容旧契约）；非协议返回 undefined */
+function protocolResult(protocol) {
+	if (!protocol) return void 0;
+	if ("list" in protocol) return protocol.list;
+	if ("schema" in protocol) return protocol.schema;
+}
+function msmExecResult(name, status, stdout, stderr, fmtJson) {
+	if (fmtJson) return status === 0 ? {
+		name,
+		exit: 0,
+		ok: true,
+		data: stdout.trim()
+	} : {
+		name,
+		exit: status,
+		ok: false,
+		error: stderr.trim() || stdout.trim()
+	};
+	return {
+		name,
+		exit: status,
+		stdout,
+		stderr
+	};
+}
+/**
+* 异步执行 MSM（acc_msm 工具主路径）：
+* 用 execFile + promisify + timeout（超时自动 kill），**不阻塞 Node 事件循环**。
+* （同步 spawnSync 版会阻塞 web 事件循环 → MSM 脚本自请求 3080 时死锁，见 postmortem。）
+*/
+async function runMsmAsync(root, args) {
+	if (args.action !== "exec") return runMsm(root, args);
+	const { entry, businessArgs, fmtJson, protocol } = prepareExec(root, args);
+	const p = protocolResult(protocol);
+	if (p !== void 0) return p;
+	try {
+		const r = await execFileAsync("bun", [entry.path, ...businessArgs], {
+			cwd: root,
+			encoding: "utf-8",
+			timeout: MSM_TIMEOUT_MS,
+			maxBuffer: 67108864
+		});
+		return msmExecResult(entry.name, 0, r.stdout, r.stderr, fmtJson);
+	} catch (e) {
+		const err = e;
+		if (err.code === "ENOENT") try {
+			const r = await execFileAsync("npx", [
+				"tsx",
+				entry.path,
+				...businessArgs
+			], {
+				cwd: root,
+				encoding: "utf-8",
+				timeout: MSM_TIMEOUT_MS,
+				maxBuffer: 67108864
+			});
+			return msmExecResult(entry.name, 0, r.stdout, r.stderr, fmtJson);
+		} catch (e2) {
+			const err2 = e2;
+			const status = err2.killed ? 124 : typeof err2.code === "number" ? err2.code : 2;
+			const stdout = err2.stdout ?? "";
+			const stderr = err2.killed ? `MSM timed out after ${MSM_TIMEOUT_MS}ms` : err2.stderr ?? err2.message ?? "";
+			return msmExecResult(entry.name, status, stdout, stderr, fmtJson);
+		}
+		const status = err.killed ? 124 : typeof err.code === "number" ? err.code : 2;
+		const stdout = err.stdout ?? "";
+		const stderr = err.killed ? `MSM timed out after ${MSM_TIMEOUT_MS}ms` : err.stderr ?? err.message ?? "";
+		return msmExecResult(entry.name, status, stdout, stderr, fmtJson);
+	}
+}
+//#endregion
+//#region src/session-ops.ts
+/**
+* session-ops.ts — session 工具纯操作层（零 DSH 依赖，可独立单测）
+*
+* 移植自 dsh-serenity-plugin v0.1 acc-session runner（本项目自有代码）。
+* 操作 CCC 根的 AGENT_SESSIONS/ 目录，返回规范 JSON 值。
+*/
+const SESSION_ACTIONS = [
+	"list",
+	"show",
+	"create",
+	"use",
+	"close",
+	"health",
+	"qa",
+	"archive",
+	"summary"
+];
+const SESSION_DIR_RE = /^(\d{4}-\d{2}-\d{2})--(S\d{3})--(.+)$/;
+const DAY = 864e5;
+function today() {
+	return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function sessionsRoot(root) {
+	return join(root, "AGENT_SESSIONS");
+}
+function listSessions(root) {
+	const sessRoot = sessionsRoot(root);
+	if (!existsSync(sessRoot)) return [];
+	const out = [];
+	for (const entry of readdirSync(sessRoot)) {
+		const full = join(sessRoot, entry);
+		if (!statSync(full).isDirectory()) continue;
+		const md = join(full, "SESSION.md");
+		const m = SESSION_DIR_RE.exec(entry);
+		let status = null;
+		if (existsSync(md)) status = /\[x\]|\[X\]/.test(readFileSync(md, "utf-8")) ? "done" : "open";
+		out.push({
+			dir: entry,
+			id: m?.[2] ?? null,
+			hasSessionMd: existsSync(md),
+			mtime: statSync(full).mtime.toISOString(),
+			status
+		});
+	}
+	out.sort((a, b) => a.dir < b.dir ? 1 : -1);
+	return out;
+}
+function nextSessionId(sessions) {
+	let max = 0;
+	for (const s of sessions) if (s.id) {
+		const n = Number(s.id.slice(1));
+		if (n > max) max = n;
+	}
+	return `S${String(max + 1).padStart(3, "0")}`;
+}
+function findSession(root, key) {
+	return listSessions(root).find((s) => s.dir.includes(key) || (s.id ?? "") === key.toUpperCase()) ?? null;
+}
+function createSession(root, name, title) {
+	const id = nextSessionId(listSessions(root));
+	const dirName = `${today()}--${id}--${name}`;
+	const dir = join(sessionsRoot(root), dirName);
+	mkdirSync(dir, { recursive: true });
+	const md = join(dir, "SESSION.md");
+	writeFileSync(md, `# SESSION: ${title}\n- ID: ${id}\n\n## 目标\n<一句话描述本次会话要完成的事情>\n\n## 状态\n- [ ] 进行中\n\n## 关键决策\n| # | 决策 | 理由 |\n|---|------|------|\n| 1 |  |  |\n\n## 进度记录\n- ${today()} — 会话创建\n\n## 产出物\n- \n\n## 未解决的问题\n- \n`, "utf-8");
+	return {
+		dir: dirName,
+		id,
+		sessionMd: md
+	};
+}
+function showSession(root, key) {
+	const target = findSession(root, key);
+	if (!target) {
+		for (const s of listSessions(root)) {
+			const md = join(sessionsRoot(root), s.dir, "SESSION.md");
+			if (existsSync(md) && readFileSync(md, "utf-8").includes(key)) return {
+				dir: s.dir,
+				content: readFileSync(md, "utf-8")
+			};
+		}
+		throw new Error(`未找到会话: ${key}`);
+	}
+	const md = join(sessionsRoot(root), target.dir, "SESSION.md");
+	if (!existsSync(md)) throw new Error(`会话 ${target.dir} 缺少 SESSION.md`);
+	return {
+		dir: target.dir,
+		content: readFileSync(md, "utf-8")
+	};
+}
+/** 活动会话标记文件（sessionBlock 系统提示词注入读取） */
+const ACTIVE_SESSION_MARKER = join(".dsh", "active-session");
+/** 激活会话：写 .dsh/active-session 标记（内容 = 相对 CCC 根的 SESSION.md 路径） */
+function useSession(root, key) {
+	const target = findSession(root, key);
+	if (!target) throw new Error(`未找到会话: ${key}`);
+	const md = join(sessionsRoot(root), target.dir, "SESSION.md");
+	if (!existsSync(md)) throw new Error(`会话 ${target.dir} 缺少 SESSION.md`);
+	const marker = resolve(root, ACTIVE_SESSION_MARKER);
+	mkdirSync(resolve(root, ".dsh"), { recursive: true });
+	const relMd = relative(root, md);
+	writeFileSync(marker, relMd, "utf-8");
+	return {
+		dir: target.dir,
+		mdPath: md
+	};
+}
+/** 关闭活动会话：删除 .dsh/active-session 标记 */
+function closeSession(root) {
+	const marker = resolve(root, ACTIVE_SESSION_MARKER);
+	if (existsSync(marker)) rmSync(marker, { force: true });
+	return { dir: "active-session cleared" };
+}
+function archiveSession(root, key) {
+	const target = findSession(root, key);
+	if (!target) throw new Error(`未找到会话: ${key}`);
+	const md = join(sessionsRoot(root), target.dir, "SESSION.md");
+	if (!existsSync(md)) throw new Error(`会话 ${target.dir} 缺少 SESSION.md`);
+	let content = readFileSync(md, "utf-8");
+	content = content.replace(/^-\s*\[ \]\s*进行中$/m, "- [x] 已完成").replace(/^-\s*\[ \]\s*已关闭（未完成）$/m, "- [x] 已关闭（未完成）");
+	if (!/\[x\]|\[X\]/.test(content)) content = content.replace(/^## 状态$/m, "## 状态\n- [x] 已完成");
+	writeFileSync(md, content, "utf-8");
+	appendFileSync(md, `\n> 已归档: ${today()}\n`, "utf-8");
+	return { dir: target.dir };
+}
+function healthCheck(root) {
+	const problems = [];
+	const now = Date.now();
+	for (const s of listSessions(root)) {
+		const age = (now - new Date(s.mtime).getTime()) / DAY;
+		if (!s.hasSessionMd) problems.push({
+			dir: s.dir,
+			kind: "missing-md",
+			detail: "缺少 SESSION.md"
+		});
+		else if (age > 14) problems.push({
+			dir: s.dir,
+			kind: "stale",
+			detail: `${Math.round(age)} 天未更新`
+		});
+	}
+	return problems;
+}
+function summarize(root) {
+	const sessions = listSessions(root);
+	const done = sessions.filter((s) => s.status === "done").length;
+	const stale = sessions.filter((s) => (Date.now() - new Date(s.mtime).getTime()) / DAY > 14).length;
+	return {
+		total: sessions.length,
+		open: sessions.length - done,
+		done,
+		stale,
+		recent: sessions.slice(0, 5)
+	};
+}
+/** 事实核对：SESSION.md 中记录的产出物路径（- `path` — 说明 行）是否真实存在 */
+function qaCheck(root, key) {
+	const { dir, content } = showSession(root, key);
+	const issues = [];
+	for (const line of content.split("\n")) {
+		const m = /^-\s*(`[^`]+`|[^\s|]+)\s*—/.exec(line.trim());
+		if (!m) continue;
+		const p = m[1].replace(/`/g, "");
+		if (!existsSync(resolve(root, p))) issues.push({
+			path: p,
+			kind: "missing"
+		});
+	}
+	return {
+		dir,
+		issues
+	};
+}
+/** 追加会话心跳（turn-stopping 机械落盘用） */
+function appendHeartbeat(sessionMd) {
+	try {
+		appendFileSync(sessionMd, `- ${(/* @__PURE__ */ new Date()).toISOString()} — [auto] turn heartbeat (dsh-serenity-hooks)\n`, "utf-8");
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/tools/session.ts
+/**
+* session.ts — session 真实 DSH 工具定义（defineTool）
+*
+* AGENT_SESSIONS/ 全周期管理：list/show/create/health/qa/archive/summary。
+* 逻辑在 session-ops.ts（可单测）。
+*/
+function agentCwd$5(exec) {
+	return exec.agent?.session?.header?.cwd ?? process.cwd();
+}
+function renderText$7(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+const sessionTool = defineTool({
+	name: "session",
+	description: "工作会话全周期管理（AGENT_SESSIONS/，home-session 约定）。list/show/create/use/close/health/qa/archive/summary。多步骤工作必须先 create 会话，use 激活当前会话（写 .dsh/active-session 标记 → 系统提示词 Session 块生效）。",
+	parameters: {
+		action: {
+			type: "string",
+			enum: [...SESSION_ACTIONS],
+			required: true,
+			description: "子命令"
+		},
+		key: {
+			type: "string",
+			description: "show/use/archive/qa 的会话标识（S### 或目录名或关键词）"
+		},
+		name: {
+			type: "string",
+			description: "create 的短描述（小写英文连词符，≤5 词）"
+		},
+		title: {
+			type: "string",
+			description: "create 的标题"
+		}
+	},
+	output: {
+		schema: { type: "json" },
+		render: (args, value) => renderText$7(value)
+	},
+	async execute(args, exec) {
+		const root = findSerenityRoot(agentCwd$5(exec));
+		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
+		if (findEntry(root, "session-tool")) {
+			const r = runMsm(root, {
+				action: "exec",
+				name: "session-tool",
+				args: [args.action, ...args.key ? [args.key] : []]
+			});
+			if (!(r.exit !== void 0 && r.exit !== 0 || r.ok === false)) {
+				const out = r.ok !== void 0 ? r.ok ? r.data : r.error : r.stdout;
+				return out !== void 0 ? {
+					delegated: true,
+					exit: r.exit ?? 0,
+					output: out
+				} : {
+					delegated: true,
+					exit: r.exit ?? 0
+				};
+			}
+		}
+		switch (args.action) {
+			case "list": return listSessions(root);
+			case "create": return createSession(root, args.name ?? "untitled", args.title ?? args.name ?? "untitled");
+			case "show":
+				if (!args.key) throw new Error("show 需要 key");
+				return showSession(root, args.key);
+			case "use":
+				if (!args.key) throw new Error("use 需要 key");
+				return useSession(root, args.key);
+			case "close": return closeSession(root);
+			case "archive":
+				if (!args.key) throw new Error("archive 需要 key");
+				return archiveSession(root, args.key);
+			case "health": return { problems: healthCheck(root) };
+			case "summary": return summarize(root);
+			case "qa":
+				if (!args.key) throw new Error("qa 需要 key");
+				return qaCheck(root, args.key);
+			default: throw new Error(`未知 action: ${args.action}`);
+		}
+	}
+});
+//#endregion
+//#region src/kit-ops.ts
+/**
+* kit-ops.ts — acc_kit 纯操作层（零 DSH 依赖）
+*
+* health: CCC 三原则检查（P1 .serenity / P2 git / 配置）
+* time: ISO 8601 时间戳
+* wait: 同步等待 N 秒
+*/
+const KIT_ACTIONS = [
+	"health",
+	"time",
+	"wait"
+];
+function runKit(root, args) {
+	switch (args.action) {
+		case "health": {
+			const gitRoot = findGitRoot(root);
+			let config = null;
+			let configPath = null;
+			for (const candidate of DEFAULT_SERENITY_CONFIG_PATHS) {
+				const p = resolve(root, candidate);
+				if (!existsSync(p)) continue;
+				try {
+					config = JSON.parse(readFileSync(p, "utf-8"));
+					configPath = p;
+				} catch {
+					config = { parseError: true };
+					configPath = p;
+				}
+				break;
+			}
+			return {
+				cwd: root,
+				serenityRoot: findSerenityRoot(root),
+				gitRoot,
+				config,
+				configPath,
+				p1: findSerenityRoot(root) !== null,
+				p2: gitRoot !== null,
+				p3: "enforced-by-dsh-fs-sandbox"
+			};
+		}
+		case "time": return (/* @__PURE__ */ new Date()).toISOString();
+		case "wait": {
+			const n = args.seconds ?? 0;
+			if (!Number.isFinite(n) || n < 0) throw new Error("wait 需要非负秒数");
+			execFileSync("sleep", [String(n)], { stdio: "ignore" });
+			return { waited: n };
+		}
+		default: throw new Error(`未知 action: ${args.action}`);
+	}
+}
+//#endregion
+//#region src/tools/kit.ts
+/**
+* kit.ts — acc_kit 真实 DSH 工具定义（defineTool）
+*/
+function agentCwd$4(exec) {
+	return exec.agent?.session?.header?.cwd ?? process.cwd();
+}
+function renderText$6(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+const kitTool = defineTool({
+	name: "acc_kit",
+	description: "ACC 通用能力工具包：health（CCC 三原则检查 P1/P2/配置）/ time（ISO 时间戳）/ wait（等待 N 秒）。进入 CCC 工作前的例行自检。",
+	parameters: {
+		action: {
+			type: "string",
+			enum: [...KIT_ACTIONS],
+			required: true,
+			description: "子命令"
+		},
+		seconds: {
+			type: "number",
+			description: "wait 的秒数"
+		}
+	},
+	output: {
+		schema: { type: "json" },
+		render: (args, value) => renderText$6(value)
+	},
+	async execute(args, exec) {
+		const root = findSerenityRoot(agentCwd$4(exec));
+		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
+		return runKit(root, args);
+	}
+});
+//#endregion
+//#region src/git-ops.ts
+/**
+* git-ops.ts — cc_git 纯操作层（零 DSH 依赖）
+*
+* status / commit / push / log；push 非快进时输出操作建议（绝不自动 force）。
+*/
+const GIT_ACTIONS = [
+	"status",
+	"commit",
+	"push",
+	"log"
+];
+function git(root, args) {
+	try {
+		return {
+			ok: true,
+			stdout: execFileSync("git", args, {
+				cwd: root,
+				encoding: "utf-8",
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				]
+			}),
+			stderr: ""
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			stdout: err.stdout?.toString() ?? "",
+			stderr: err.stderr?.toString() ?? ""
+		};
+	}
+}
+function runGit(root, args) {
+	switch (args.action) {
+		case "status": {
+			const r = git(root, ["status", "--porcelain"]);
+			if (!r.ok) throw new Error(`status 失败：${r.stderr.trim()}`);
+			return {
+				clean: r.stdout.trim() === "",
+				entries: r.stdout.trim() ? r.stdout.trim().split("\n") : []
+			};
+		}
+		case "commit": {
+			if (!args.message) throw new Error("commit 需要 message");
+			const add = git(root, ["add", "-A"]);
+			if (!add.ok) throw new Error(`git add 失败：${add.stderr.trim()}`);
+			const commit = git(root, [
+				"commit",
+				"-m",
+				args.message
+			]);
+			if (!commit.ok) {
+				if (commit.stderr.includes("nothing to commit")) return {
+					committed: false,
+					reason: "nothing to commit"
+				};
+				throw new Error(`git commit 失败：${commit.stderr.trim()}`);
+			}
+			return {
+				committed: true,
+				message: args.message
+			};
+		}
+		case "push": {
+			const r = git(root, [
+				"push",
+				"origin",
+				"HEAD"
+			]);
+			if (r.ok) return { pushed: true };
+			const isNonFF = /non-fast-forward|rejected|fetch first|被拒绝/i.test(r.stderr);
+			const out = {
+				pushed: false,
+				nonFastForward: isNonFF,
+				stderr: r.stderr.trim()
+			};
+			if (isNonFF) out.suggestion = "1. git pull --rebase  # 先合并远程变更\n2. 重新 push\n3. 若确需覆盖远程：git push --force-with-lease（人工确认后）";
+			return out;
+		}
+		case "log": {
+			const n = args.count ?? 10;
+			const r = git(root, [
+				"log",
+				"--oneline",
+				"-n",
+				String(n)
+			]);
+			if (!r.ok) throw new Error(`git log 失败：${r.stderr.trim()}`);
+			return { entries: r.stdout.trim() ? r.stdout.trim().split("\n") : [] };
+		}
+		default: throw new Error(`未知 action: ${args.action}`);
+	}
+}
+//#endregion
+//#region src/tools/git.ts
+/**
+* git.ts — cc_git 真实 DSH 工具定义（defineTool）
+*/
+function agentCwd$3(exec) {
+	return exec.agent?.session?.header?.cwd ?? process.cwd();
+}
+function renderText$5(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+const gitTool = defineTool({
+	name: "cc_git",
+	description: "CCC 内 git 操作（cc-git 语义）。status/commit/push/log；push 非快进时输出操作建议（绝不自动 force）。pull/merge/rebase/冲突解决走 bash。",
+	parameters: {
+		action: {
+			type: "string",
+			enum: [...GIT_ACTIONS],
+			required: true,
+			description: "子命令"
+		},
+		message: {
+			type: "string",
+			description: "commit 消息"
+		},
+		count: {
+			type: "integer",
+			description: "log 条数（默认 10）"
+		}
+	},
+	output: {
+		schema: { type: "json" },
+		render: (args, value) => renderText$5(value)
+	},
+	async execute(args, exec) {
+		const root = findSerenityRoot(agentCwd$3(exec));
+		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
+		return runGit(root, args);
+	}
+});
+//#endregion
+//#region src/tools/msm.ts
+/**
+* msm.ts — acc_msm 真实 DSH 工具定义（defineTool）
+*/
+function agentCwd$2(exec) {
+	return exec.agent?.session?.header?.cwd ?? process.cwd();
+}
+function renderText$4(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+const msmTool = defineTool({
+	name: "acc_msm",
+	description: "MSM（Mech & Semi-Mech）框架：list 列出注册 MSM；exec 执行（600s 超时，path 逃逸阻断）；register/deregister 管理注册表（自动 git commit）；check 品质检查 DC-M1~M4。复用 CCC 的 mech-registry.json。",
+	parameters: {
+		action: {
+			type: "string",
+			enum: [...MSM_ACTIONS],
+			required: true,
+			description: "子命令"
+		},
+		name: {
+			type: "string",
+			description: "MSM 名（exec/register/deregister）"
+		},
+		args: {
+			type: "array",
+			items: { type: "string" },
+			description: "exec 的业务参数"
+		},
+		skill: {
+			type: "string",
+			description: "register 的所属 skill"
+		},
+		path: {
+			type: "string",
+			description: "register 的脚本相对路径"
+		},
+		category: {
+			type: "string",
+			description: "register 的类别（mech/semi-mech）"
+		},
+		description: {
+			type: "string",
+			description: "register 的描述"
+		}
+	},
+	output: {
+		schema: { type: "json" },
+		render: (args, value) => renderText$4(value)
+	},
+	async execute(args, exec) {
+		const root = findSerenityRoot(agentCwd$2(exec));
+		if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
+		return runMsmAsync(root, args);
+	}
+});
+//#endregion
+//#region src/tools/eap.ts
+/**
+* eap.ts — EAP 认知质量框架工具（渐进式披露，ACC 标准工具化）
+*
+* 内嵌框架内容（自包含，不依赖已安装技能）；可选 section 参数聚焦某原则。
+*/
+const EAP_CONTENT = `# EAP 认知质量框架（显式抽象原则）
+
+> "思维的功能价值与其外部可重建性成正比。"
+
+## 三变量
+| 变量 | 含义 | 提升手段 |
+|------|------|---------|
+| E↑ 显式度 | 变量/实体/关系被明确定义的程度 | 定义变量、指明关系方向与基数、划定边界 |
+| R↓ 重建成本 | 未来重建原始推理的成本 | 记录决策理由、上下文、约束、备选方案 |
+| S↑ 稳定性 | 同一输入反复产生一致结果的程度 | 结构固化、协议化、避免依赖隐含上下文 |
+
+## 输出前自检清单
+- [ ] 变量/实体明确定义（E↑）
+- [ ] 关系指明方向/基数（E↑）
+- [ ] 边界划定——什么在范围内/什么不在（E↑）
+- [ ] 不使用歧义词汇："处理""优化""问题"→ 具体化（E↑）
+- [ ] 关键决策记录理由与备选（R↓）
+- [ ] 不跳级讨论——先对齐上层再进入下层（R↓）
+- [ ] 结构可重复执行/生成（S↑）
+
+## 与 ACC 的关系
+ACC（插件/模板）结构编码为代码（E↑）；从 ACC 生成 CCC 确定（R↓）；多 CCC 一致（S↑）。
+CCC（home-serenity 等）认知内容编码为 skill/SESSION/设计文档。产出物用本清单自检。
+
+## 参考
+https://github.com/tellmewhattodo/theory-eap`;
+function renderText$3(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+const eapTool = defineTool({
+	name: "eap",
+	description: "EAP 认知质量框架（渐进式披露）：定义 E↑ 显式度 / R↓ 重建成本 / S↑ 稳定性 + 输出前自检清单。无 section 返回完整框架；指定 section 聚焦对应内容。",
+	parameters: { section: {
+		type: "string",
+		enum: [
+			"variables",
+			"checklist",
+			"acc"
+		],
+		description: "聚焦片段：variables（三变量）/ checklist（自检清单）/ acc（与 ACC 关系）"
+	} },
+	output: {
+		schema: { type: "string" },
+		render: (_args, value) => renderText$3(value)
+	},
+	async execute(args) {
+		if (args.section === "variables") return EAP_CONTENT.split("## 输出前自检清单")[0];
+		if (args.section === "checklist") return EAP_CONTENT.match(/## 输出前自检清单[\s\S]*?(?=## )/)?.[0] ?? EAP_CONTENT;
+		if (args.section === "acc") return EAP_CONTENT.match(/## 与 ACC 的关系[\s\S]*/)?.[0] ?? EAP_CONTENT;
+		return EAP_CONTENT;
+	}
+});
+//#endregion
+//#region src/tools/neat.ts
+/**
+* neat.ts — Neat 设计协作协议工具（渐进式披露，ACC 标准工具化）
+*/
+const NEAT_CONTENT = `# Neat 设计协作协议
+
+> 复杂设计不是一次想出来的，是小步对齐走出来的。
+
+## 四条铁律
+| 铁律 | 含义 | 反例 |
+|------|------|------|
+| 小步对齐 | 一次只推进一个决策，确认后再走下一步 | 一次抛 10 个方案 |
+| 显式决策 | 每个选择记录理由与备选 | "我觉得这样好"（无理由） |
+| 文档驱动 | 结论沉淀到具名文件（<subject>-<scope>-<type>.md） | 结论只存在于对话里 |
+| 不跳级 | 严格按层级推进 | 需求未对齐就写实现 |
+
+## 五层推进顺序（不跳级）
+需求层 → 范围层 → 方案层 → 接口层 → 实现层
+| 层 | 产物 | 问题 |
+|----|------|------|
+| 需求层 | 需求描述 | "要解决什么问题？" |
+| 范围层 | 范围清单（in/out） | "做哪些、明确不做哪些？" |
+| 方案层 | 方案对比 + 选定 | "怎么做？选哪个？为什么？" |
+| 接口层 | 接口/协议定义 | "边界怎么交互？" |
+| 实现层 | 代码/文档 | "逐层落地" |
+
+## 协作节奏
+1. 提出当前层一个决策点（带上下文 + 建议 + 理由）
+2. 等待确认或修正（小步）
+3. 确认后记录决策（写入会话 SESSION.md 或设计文档）
+4. 推进到下一决策点`;
+function renderText$2(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+const neatTool = defineTool({
+	name: "neat",
+	description: "Neat 设计协作协议（渐进式披露）：小步对齐 / 显式决策 / 文档驱动 / 不跳级（需求→范围→方案→接口→实现）。无 section 返回完整协议。",
+	parameters: { section: {
+		type: "string",
+		enum: ["rules", "layers"],
+		description: "聚焦片段：rules（四条铁律）/ layers（五层推进）"
+	} },
+	output: {
+		schema: { type: "string" },
+		render: (_args, value) => renderText$2(value)
+	},
+	async execute(args) {
+		if (args.section === "rules") return NEAT_CONTENT.match(/## 四条铁律[\s\S]*?(?=## )/)?.[0] ?? NEAT_CONTENT;
+		if (args.section === "layers") return NEAT_CONTENT.match(/## 五层推进顺序[\s\S]*?(?=## )/)?.[0] ?? NEAT_CONTENT;
+		return NEAT_CONTENT;
+	}
+});
+//#endregion
+//#region src/tools/cce.ts
+/**
+* cce.ts — CCE 认知连续性工程工具（渐进式披露，ACC 标准工具化）
+*
+* 内容：认知连续性工程（Cognitive Continuity Engineering）——在有限资源与
+* 不可逆不确定性约束下，维持认知实体身份、可达性与演化能力的工程学科。
+* 来源：home-serenity `.opencode/skills/cce/SKILL.md` + CCE 理论。
+*/
+const CCE_CONTENT = `# CCE — 认知连续性工程（Cognitive Continuity Engineering）
+
+> **认知连续性工程是在有限资源与不可逆不确定性的约束下，维持一个认知实体的身份、可达性与演化能力的工程学科。**
+> CCE 不优化认知。它维护认知得以继续的条件。—— 存续工程（Persistence Engineering），非绩效工程
+
+## 核心命题
+- **连续性属于容器，而非任何个体参与者**——智能体来来去去，但 CCC 的认知轨迹持续存在
+- **组织必须至少与积累同步**——否则操作化认知熵（H_op）无界增长，可达性丧失
+- **重建优于保存**——产物的价值由其使未来智能体重建原始推理的能力决定
+
+## 认知容器（Cognitive Container）
+一个有界的认知空间，认知可在其中积累、重组和演化。5 个定义属性：
+| 属性 | 功能 |
+|------|------|
+| 身份（Identity） | 区分此认知系统与其他系统 |
+| 边界（Boundaries） | 定义什么在认知空间内/外 |
+| 持久记忆（Persistent Memory） | 跨时间保留积累的认知 |
+| 操作约束（Operational Constraints） | 定义容器内允许哪些操作 |
+| 演化历史（Evolutionary History） | 记录认知变化轨迹，使重建可能 |
+
+## 操作化认知熵（H_op）
+不度量总体熵（不可操作），只度量智能体在容器内完成任务的**多余认知成本**：
+> H_op(C, t) = cost(task | C, t) − cost(task | ideal)
+维持条件：**H_op(C, t) ≤ H_critical** —— 智能体仍可在合理成本内完成任务
+
+## 连续性维护条件
+> **ΔH_org ≥ ΔH_in** —— 组织必须至少与积累同步
+
+## 六阶段生命周期
+Experience → Accumulation → Organization → Abstraction → Reconstruction → Evolution →（循环）
+| 阶段 | 工程关切 |
+|------|---------|
+| Experience | 输入是否携带足够结构 |
+| Accumulation | 信息是否无损存储 |
+| Organization | 熵管理 — ΔH_org 抵消 ΔH_in |
+| Abstraction | 抽象是否显式编码 |
+| Reconstruction | 推理结构能否从产物恢复 |
+| Evolution | 演化保持连贯还是引入漂移 |
+
+## 与 EAP 的关系
+EAP 回答"一段知识应如何被结构化"（显式度 E↑ / 重建成本 R↓ / 稳定性 S↑）；
+CCE 回答"有结构的知识应如何跨时间持续演化而不丧失连贯性"。两者互补：EAP 是静态质量，CCE 是动态存续。
+
+## 与 Serenity 的关系
+Serenity 的会话系统、会话追踪、熵管理机制（SQC 品质循环）都是 CCE 的工程实现；
+CCC 系统提示词中嵌入的行为约束即来自 CCE。`;
+function renderText$1(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+const cceTool = defineTool({
+	name: "cce",
+	description: "CCE 认知连续性工程（渐进式披露）：在有限资源与不可逆不确定性约束下，维持认知实体身份/可达性/演化能力的工程学科。无 section 返回完整框架；指定 section 聚焦对应内容。",
+	parameters: { section: {
+		type: "string",
+		enum: [
+			"container",
+			"entropy",
+			"lifecycle",
+			"eap"
+		],
+		description: "聚焦片段：container（认知容器 5 属性）/ entropy（操作化认知熵 H_op）/ lifecycle（六阶段）/ eap（与 EAP 关系）"
+	} },
+	output: {
+		schema: { type: "string" },
+		render: (_args, value) => renderText$1(value)
+	},
+	async execute(args) {
+		const section = args.section;
+		const blocks = {
+			container: {
+				start: "## 认知容器（Cognitive Container）",
+				end: "## 操作化认知熵"
+			},
+			entropy: {
+				start: "## 操作化认知熵（H_op）",
+				end: "## 连续性维护条件"
+			},
+			lifecycle: { start: "## 六阶段生命周期" },
+			eap: { start: "## 与 EAP 的关系" }
+		};
+		if (section) {
+			const b = blocks[section];
+			if (b) {
+				const startIdx = CCE_CONTENT.indexOf(b.start);
+				if (startIdx >= 0) return (b.end ? CCE_CONTENT.slice(startIdx, CCE_CONTENT.indexOf(b.end, startIdx)) : CCE_CONTENT.slice(startIdx)).trim();
+			}
+		}
+		return CCE_CONTENT;
+	}
+});
+//#endregion
+//#region src/loop-ops.ts
+/**
+* loop-ops.ts — acc_loop 纯逻辑层（零 DSH 依赖，可独立单测）
+*
+* 对齐 opencode-serenity-plugin 老 loop 语义：进度文件（loop-<label>.md/.json）、
+* 续跑、轮次 prompt 结构、stop token。
+*/
+function loopProgressPaths(root, label) {
+	const dir = join(root, "AGENT_SESSIONS");
+	return {
+		md: join(dir, `loop-${label}.md`),
+		json: join(dir, `loop-${label}.json`)
+	};
+}
+/** 读取进度（续跑）；无文件返回 round 0 */
+function readProgress(root, label) {
+	const { json } = loopProgressPaths(root, label);
+	if (!existsSync(json)) return null;
+	try {
+		return JSON.parse(readFileSync(json, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function writeProgress(root, label, p) {
+	const { md, json } = loopProgressPaths(root, label);
+	mkdirSync(join(root, "AGENT_SESSIONS"), { recursive: true });
+	writeFileSync(json, JSON.stringify({
+		...p,
+		updated: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2) + "\n", "utf-8");
+	const lines = [
+		`# loop: ${label}`,
+		`- 模型: ${p.model}`,
+		`- 轮次: ${p.round}`,
+		`- 完成: ${p.done}`,
+		"",
+		`## 最近响应`,
+		"",
+		p.lastResponse,
+		""
+	];
+	writeFileSync(md, lines.join("\n"), "utf-8");
+}
+function newStopToken() {
+	return `SERENITY_LOOP_DONE_${randomBytes(8).toString("hex")}`;
+}
+/** 解析 model 字符串（provider/model）→ {provider, model}；无 / 视为 model-only */
+function splitModel(model) {
+	const idx = model.indexOf("/");
+	if (idx < 0) return {
+		provider: void 0,
+		model
+	};
+	return {
+		provider: model.slice(0, idx),
+		model: model.slice(idx + 1)
+	};
+}
+/** 轮次 prompt（对齐老 loop 结构：回顾进度 → 自由工作 → 汇报） */
+function buildRoundPrompt(opts) {
+	const { root, session, label, round, maxRounds, stopToken, progress, task } = opts;
+	const resumeNote = progress && progress.round > 0 ? `上一轮（round ${progress.round}）已完成：${progress.lastResponse.slice(0, 300)}\n永远从上次停止处继续，绝不重做已完成工作。` : "这是第一轮。";
+	return `# ${label} — 牛马循环 round ${round}/${maxRounds}
+
+CCC 根：${root}
+${session ? `工作会话：${session}（AGENT_SESSIONS/${session}/SESSION.md 记录进度）` : ""}
+${task ? `任务：${task}` : `任务：以 label「${label}」对应的工作为准（若存在工作会话，先读 SESSION.md 明确目标）`}
+${resumeNote}
+
+本轮内你可以自由工作：读文件、改代码、执行命令，尽一切手段推进任务。
+每轮结束时汇报：
+1. 本轮做了什么（具体）
+2. 下一步计划
+3. 是否已完成（若完成，输出 ${stopToken}）
+
+若已完成任务，只输出 ${stopToken}。`;
+}
+//#endregion
+//#region src/tools/loop.ts
+/**
+* loop.ts — acc_loop 真实 DSH 工具（老 loop 等效：廉价模型牛马循环）
+*
+* 语义对齐 opencode-serenity-plugin 老 loop：
+*   label（必）任务标签 → 进度文件 loop-<label>.md/.json
+*   session（选）工作会话 S###（上下文提示）
+*   model（选）provider/model（如 minimax-cn-coding-plan/MiniMax-M3）；缺省读 loop.defaultModel
+*   maxRounds（默认 100）轮次上限；每轮等待 agent **无超时**（loop 可永续，agent 工作多久等多久）
+*
+* 机制：ctx.agentLoop.create({provider, model}) 创建专用 agent（进程内），
+* 每轮 followup → agent/status idle → 读 session.events 响应 → 写进度 → stop token 检查 → 续跑。
+* 工厂模式：apply 时闭包捕获插件 ctx（工具 execute 无 ctx 参数）。
+*/
+function agentCwd$1(exec) {
+	return (exec.agent?.session)?.header?.cwd ?? process.cwd();
+}
+function renderText(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+/** 等待 agent 空闲（agent/status → idle）；无超时（loop 可永续，agent 工作多久等多久） */
+function waitIdle(ctx, agent) {
+	return new Promise((resolve) => {
+		let settled = false;
+		const finish = () => {
+			if (settled) return;
+			settled = true;
+			dispose();
+			resolve();
+		};
+		const dispose = ctx.on("agent/status", (payload) => {
+			if (payload.agent === agent && payload.status === "idle") finish();
+		});
+	});
+}
+/** 读取会话最后一个 assistant/message 文本 */
+function lastAssistantText(agent) {
+	const events = agent.session.events;
+	for (let i = events.length - 1; i >= 0; i--) {
+		const e = events[i];
+		if (e && e.type === "assistant/message") {
+			const data = e.data;
+			const text = (data?.message?.content ?? data?.content ?? []).filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
+			if (text) return text;
+		}
+	}
+	return "";
+}
+/** 创建 loop 工具（闭包捕获插件 ctx → 可访问 ctx.agentLoop） */
+function createLoopTool(ctx) {
+	return defineTool({
+		name: "loop",
+		description: "牛马循环（老 loop 等效）：用指定模型创建专用 agent 反复执行任务直到完成或达轮次上限。\n用法：loop 接受 task（要完成的目标）或依赖 session 上下文；模型缺省读 .dsh/serenity.json 的 loop.defaultModel（当前 minimax-cn-coding-plan/MiniMax-M3，廉价牛马）。\n行为：每轮创建全新 agent 工作（读文件/改代码/执行命令），汇报进度后进入下一轮；完成时输出停止标记即终止。**每轮等待无超时**（loop 永续：agent 工作多久等多久，不被超时打断）。\n进度：写入 AGENT_SESSIONS/loop-<label>.md/.json；同 label 再次调用从上次轮次续跑（不重做）。\n约束：loop agent 受完整 Serenity 约束（ACC 身份/入口技能系统提示词/守卫/session-keeper）。\n示例：loop 执行「扫描 SQC 并修复 DC 问题」，label: sqc-scan，maxRounds: 5",
+		parameters: {
+			task: {
+				type: "string",
+				description: "要完成的任务目标（必填语义：告诉 loop agent 做什么；缺省则从 session 上下文推断）"
+			},
+			label: {
+				type: "string",
+				required: true,
+				description: "任务标签（进度文件命名 loop-<label>.md/.json）"
+			},
+			session: {
+				type: "string",
+				description: "工作会话 S###（上下文提示，进度记录参考）"
+			},
+			model: {
+				type: "string",
+				description: "provider/model（如 minimax-cn-coding-plan/MiniMax-M3）；缺省读 loop.defaultModel"
+			},
+			maxRounds: {
+				type: "integer",
+				description: "轮次上限（默认 100）"
+			}
+		},
+		output: {
+			schema: { type: "json" },
+			render: (_args, value) => renderText(value)
+		},
+		async execute(args, exec) {
+			const root = findSerenityRoot(agentCwd$1(exec));
+			if (!root) throw new Error("No CCC found: no .serenity file from agent cwd");
+			const cfg = loadSerenityConfig(root, DEFAULT_SERENITY_CONFIG_PATHS);
+			const model = args.model ?? cfg.loop?.defaultModel;
+			if (!model) throw new Error("loop 需要 model：传参或配置 .dsh/serenity.json loop.defaultModel");
+			const maxRounds = args.maxRounds ?? 100;
+			const label = args.label;
+			if (!ctx.agentLoop) throw new Error("loop: ctx.agentLoop 不可用");
+			const { provider, model: modelName } = splitModel(model);
+			const stopToken = newStopToken();
+			let progress = readProgress(root, label);
+			const startRound = progress ? Math.min(progress.round + 1, maxRounds) : 1;
+			const loopAgent = ctx.agentLoop.create(`loop-${label}`, {
+				provider,
+				model: modelName
+			}, { cwd: root });
+			let done = false;
+			let lastResponse = progress?.lastResponse ?? "";
+			let finalRound = startRound - 1;
+			try {
+				for (let round = startRound; round <= maxRounds; round++) {
+					finalRound = round;
+					const prompt = buildRoundPrompt({
+						root,
+						session: args.session,
+						label,
+						round,
+						maxRounds,
+						stopToken,
+						progress,
+						task: args.task
+					});
+					loopAgent.followup(createUserMessage({
+						content: [{
+							type: "text",
+							text: prompt
+						}],
+						source: {
+							kind: "plugin",
+							plugin: "dsh-serenity-hooks"
+						}
+					}));
+					await waitIdle(ctx, loopAgent);
+					lastResponse = lastAssistantText(loopAgent);
+					progress = {
+						round,
+						done: false,
+						label,
+						model,
+						updated: (/* @__PURE__ */ new Date()).toISOString(),
+						lastResponse
+					};
+					writeProgress(root, label, progress);
+					if (lastResponse.includes(stopToken)) {
+						done = true;
+						break;
+					}
+				}
+				writeProgress(root, label, {
+					round: finalRound,
+					done,
+					label,
+					model,
+					updated: (/* @__PURE__ */ new Date()).toISOString(),
+					lastResponse
+				});
+			} finally {}
+			const { json } = loopProgressPaths(root, label);
+			return {
+				done,
+				rounds: finalRound,
+				model,
+				label,
+				progressFile: json,
+				lastResponse: lastResponse.slice(0, 2e3),
+				usage: {
+					how: "loop 用指定模型（默认 M3）创建专用 agent 每轮独立执行任务，完成时输出停止标记即终止",
+					progress: `进度在 AGENT_SESSIONS/loop-${label}.md 与 .json；同 label 再调 loop 会从下一轮续跑（不重做）`,
+					constraints: "loop agent 受完整 Serenity 约束（ACC 身份/入口技能系统提示词/守卫）",
+					next: done ? "任务已完成；可查看进度文件收尾" : `任务未完成（${finalRound}/${maxRounds} 轮）；可同 label 续跑或调整 maxRounds`
+				}
+			};
+		}
+	});
+}
+//#endregion
+//#region src/seams/guards.ts
+/**
+* guards.ts — 拦截缝：安全模式 + 路径守卫（P3 语义的机械层）
+*
+* 纯决策逻辑（decideGuard）与 DSH 注册（registerGuards）分离：
+* 前者零 DSH 依赖可单测，后者把决策接到 tools/pre-execute 瀑布 + ctx.tools.guard 终局。
+*
+* 对应 opencode-serenity-plugin 的 tool.execute.before 路径守卫 + bash 开关 + 黑名单。
+*/
+/**
+* 安全模式 + 黑名单 + P3 路径守卫的纯决策。
+* 对齐 opencode-serenity-plugin 标准：安全模式 = **bash 禁用** + 写入黑名单；
+* write/edit 等工具仅受路径逃逸与黑名单约束（不整体禁用）。
+* 优先级：safe-mode bash > 路径越界 > 黑名单命中。
+*/
+function decideGuard(input) {
+	const { root, toolName, safeModeOn, blacklist, pathArg } = input;
+	if (safeModeOn && toolName === "bash") return {
+		deny: `bash: 没有这个工具`,
+		kind: "deny"
+	};
+	if (pathArg !== void 0) {
+		const rel = relative(root, resolve(root, pathArg));
+		if (rel.startsWith("..")) return {
+			deny: `path escape blocked: "${pathArg}" 越出 CCC 根`,
+			kind: "deny"
+		};
+		if (rel === ".serenity-safe-on" || rel === ".serenity" || rel.startsWith(".serenity-safe-on/") || rel.startsWith(".serenity/")) return {
+			deny: `CCC 治理文件 "${rel}" 保留给用户，agent 不可写`,
+			kind: "deny"
+		};
+		const hit = matchBlacklist(rel, blacklist);
+		if (hit) return {
+			deny: `blacklist blocked: "${pathArg}" 命中规则 "${hit}"`,
+			kind: "deny"
+		};
+	}
+	return { kind: "allow" };
+}
+/** 从 exec 提取 agent 会话 cwd（CCC 根检测基准）；无则回退进程 cwd */
+function resolveAgentCwd(exec) {
+	return exec.agent?.session?.header?.cwd ?? process.cwd();
+}
+/** 安全模式开启时从模型工具列表隐藏的工具（只隐藏 bash；write/edit 保留） */
+const SAFE_MODE_DENY_TOOLS = ["bash"];
+/** agent key → restrict disposer（安全模式工具隐藏状态） */
+const safeModeRestrictions = /* @__PURE__ */ new Map();
+const restrictDiag = {
+	lastKey: null,
+	lastAttemptAt: null,
+	lastSuccess: null,
+	lastError: null,
+	activeKeys: []
+};
+function getRestrictDiagnostics() {
+	return {
+		...restrictDiag,
+		activeKeys: [...safeModeRestrictions.keys()]
+	};
+}
+/** 诊断落盘：AGENT_SESSIONS/.restrict-diag.json（文件通道，避免 HTTP 自锁） */
+function writeRestrictDiag(root) {
+	try {
+		const dir = resolve(root, "AGENT_SESSIONS");
+		mkdirSync(dir, { recursive: true });
+		writeFileSync(resolve(dir, ".restrict-diag.json"), JSON.stringify({
+			...getRestrictDiagnostics(),
+			cccRoot: root
+		}, null, 2) + "\n", "utf-8");
+	} catch {}
+}
+/**
+* 同步安全模式工具隐藏：标记存在 → agent.ctx.tools.restrict deny 隐藏写工具；
+* 标记消失 → 解除。pre-step 每步调用 → 切换实时生效。
+*/
+function syncSafeModeRestriction(agent, root) {
+	const key = agent.session.id ?? "global";
+	const on = isSafeModeOn(root);
+	const existing = safeModeRestrictions.get(key);
+	if (on && !existing) try {
+		const dispose = agent.ctx.tools.restrict({ deny: [...SAFE_MODE_DENY_TOOLS] });
+		safeModeRestrictions.set(key, dispose);
+		restrictDiag.lastKey = key;
+		restrictDiag.lastAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
+		restrictDiag.lastSuccess = true;
+		restrictDiag.lastError = null;
+	} catch (e) {
+		restrictDiag.lastKey = key;
+		restrictDiag.lastAttemptAt = (/* @__PURE__ */ new Date()).toISOString();
+		restrictDiag.lastSuccess = false;
+		restrictDiag.lastError = e.message;
+		console.error(`[serenity-hooks] restrict 失败 (key=${key}):`, e.message);
+	}
+	else if (!on && existing) {
+		try {
+			existing();
+		} catch (e) {
+			console.error(`[serenity-hooks] restrict 解除失败 (key=${key}):`, e.message);
+		}
+		safeModeRestrictions.delete(key);
+	}
+	writeRestrictDiag(root);
+}
+/** 从 exec 参数中提取常见路径字段（write/edit 工具）；宽松读取 */
+function extractPathArg(exec) {
+	const args = exec.arguments;
+	if (args === null || typeof args !== "object") return void 0;
+	const a = args;
+	for (const key of [
+		"path",
+		"file_path",
+		"target",
+		"dst"
+	]) {
+		const v = a[key];
+		if (typeof v === "string") return v;
+	}
+}
+/**
+* 注册守卫：tools/pre-execute 瀑布 + ctx.tools.guard 终局。
+* 两者都从 CCC 根实时读取配置（无状态、无缓存）。
+*/
+function registerGuards(ctx, opts = {}) {
+	const configPaths = opts.configPaths;
+	const evaluate = (exec) => {
+		const root = findSerenityRoot(resolveAgentCwd(exec));
+		if (!root) return { kind: "allow" };
+		const safeModeOn = isSafeModeOn(root);
+		const blacklist = readBlacklist(root, configPaths);
+		const pathArg = extractPathArg(exec);
+		return decideGuard({
+			root,
+			toolName: exec.name,
+			safeModeOn,
+			blacklist,
+			pathArg
+		});
+	};
+	ctx.on("tools/pre-execute", async (exec, next) => {
+		const d = evaluate(exec);
+		if (d.deny) return {
+			kind: "deny",
+			reason: d.deny
+		};
+		return next();
+	});
+	ctx.tools.guard((exec) => {
+		return evaluate(exec).deny;
+	});
+}
+//#endregion
+//#region src/seams/loop.ts
+/**
+* loop.ts — 拦截缝：回合生命周期（agent/turn-stopping 机械落盘）
+*
+* 每个自然停止边界：若 agent 工作目录在 CCC 内且存在 `.dsh/active-session`
+* 标记（内容为相对 CCC 根的 SESSION.md 路径），自动追加心跳行——
+* 会话进度不再依赖模型自觉。
+*/
+/** 解析活动会话 SESSION.md 绝对路径；无标记/越界返回 null */
+function resolveActiveSession(root) {
+	const marker = resolve(root, ".dsh", "active-session");
+	if (!existsSync(marker)) return null;
+	const rel = readFileSync(marker, "utf-8").trim();
+	if (!rel) return null;
+	const abs = resolve(root, rel);
+	if (!abs.startsWith(resolve(root))) return null;
+	return abs;
+}
+/** 注册 agent/turn-stopping：CCC 内活动会话自动心跳落盘 */
+function registerTurnFlush(ctx) {
+	ctx.on("agent/turn-stopping", async (payload) => {
+		const root = findSerenityRoot(payload.agent.session?.header?.cwd ?? process.cwd());
+		if (!root) return;
+		const sessionMd = resolveActiveSession(root);
+		if (sessionMd) appendHeartbeat(sessionMd);
+	});
+}
+//#endregion
+//#region src/seams/keeper.ts
+const SCORES = {
+	write: 3,
+	edit: 3,
+	str_replace_editor: 3,
+	task: 10,
+	read: 1,
+	grep: 1,
+	glob: 1,
+	skill: 1,
+	acc_msm: 1,
+	cc_fs: 1
+};
+function scoreTool(toolName) {
+	return SCORES[toolName] ?? 0;
+}
+var KeeperTracker = class {
+	threshold;
+	now;
+	score = 0;
+	lastTs = 0;
+	counter = 0;
+	constructor(threshold, now = Date.now) {
+		this.threshold = threshold;
+		this.now = now;
+	}
+	/** 记录一次工具调用 + 经过时间；返回是否应触发提醒 */
+	step(toolName) {
+		const now = this.now();
+		if (this.lastTs > 0) this.score += Math.floor((now - this.lastTs) / 6e4);
+		this.lastTs = now;
+		this.score += scoreTool(toolName);
+		return this.score >= this.threshold;
+	}
+	/** 生成确认码并清零积分 */
+	ack() {
+		this.counter += 1;
+		this.score = 0;
+		this.lastTs = 0;
+		return `K${this.counter}`;
+	}
+	get currentScore() {
+		return this.score;
+	}
+};
+function reminderText(code, score) {
+	return `[SESSION-KEEPER] 积分已达阈值 (${score})。请回应 [SESSION-KEEPER-recorded-${code}] 确认本轮进度已沉淀到工作会话（acc-session show），随后我清零积分。`;
+}
+const PLUGIN_SOURCE$1 = {
+	kind: "plugin",
+	plugin: "dsh-serenity-hooks"
+};
+/** 每 agent 一个跟踪器（进程内存态，agent token 维度） */
+const trackers = /* @__PURE__ */ new Map();
+function registerKeeper(ctx, opts = {}) {
+	const defaultThreshold = opts.defaultThreshold ?? 150;
+	const trackerFor = (exec) => {
+		const key = exec.agent?.session?.id ?? "global";
+		let t = trackers.get(key);
+		if (!t) {
+			const root = findSerenityRoot(exec.agent?.session?.header?.cwd ?? process.cwd());
+			t = new KeeperTracker(root ? loadSerenityConfig(root, opts.configPaths).sessionKeeper?.threshold ?? defaultThreshold : defaultThreshold);
+			trackers.set(key, t);
+		}
+		return t;
+	};
+	ctx.on("tools/post-execute", async (exec, _result, next) => {
+		if (!exec.agent) return next();
+		if (!findSerenityRoot(exec.agent?.session?.header?.cwd ?? process.cwd())) return next();
+		const tracker = trackerFor(exec);
+		const shouldRemind = tracker.step(exec.name);
+		const downstream = await next();
+		if (!shouldRemind) return downstream;
+		const content = [{
+			type: "text",
+			text: reminderText(tracker.ack(), tracker.currentScore)
+		}];
+		const reminder = createUserMessage({
+			content,
+			source: PLUGIN_SOURCE$1
+		});
+		if (downstream.kind === "block") return {
+			kind: "block",
+			feedback: downstream.feedback,
+			additionalContexts: [reminder, ...downstream.additionalContexts ?? []]
+		};
+		return {
+			...downstream,
+			additionalContexts: [reminder, ...downstream.additionalContexts ?? []]
+		};
+	});
+}
+//#endregion
+//#region src/constants.ts
+/** 常量（纯模块，零 DSH 依赖） */
+/**
+* ACC 版本：自动从 package.json 读取（单一真相源，消除与 CHANGELOG 的漂移）。
+* 发布时只需改 package.json 的 version。
+*/
+const ACC_VERSION = (() => {
+	try {
+		const here = dirname(fileURLToPath(import.meta.url));
+		return JSON.parse(readFileSync(join(here, "..", "package.json"), "utf-8")).version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+})();
+//#endregion
+//#region src/skills-discovery.ts
+/**
+* skills-discovery.ts — CCC 入口 skill 自动发现（纯逻辑，零 DSH 依赖）
+*
+* 发现全部入口技能（原文全量，不截断）：
+*   0. **`.serenity` 记号文件内容 = 顶层入口 skill 名**（CCC 记号文件的权威语义，
+*      tiangong-serenity 的 .serenity 内容为 `tg-serenity`）—— 最高优先
+*   1. `.dsh/entry-skill` 指针文件（内容 = skill 名）—— 兼容旧约定
+*   2. `.opencode/skills/*-serenity/SKILL.md` —— 自动扫描该 CCC 的顶层入口
+*      （home-serenity / tg-serenity / pangu-serenity …，命名模式 `*-serenity`）
+*   3. `.dsh/skills/*-serenity/SKILL.md` —— 自动扫描 ACC/harness 入口（acc-serenity 等）
+* 按名去重；顺序 = 记号文件 → 指针 → opencode 入口 → dsh 入口。
+*
+* 任何 CCC 都能自动注入其顶层入口 skill 全文（不硬编码名字）。
+*/
+/** 顶层入口命名模式：目录名以 -serenity 结尾（home-serenity / tg-serenity / acc-serenity …） */
+const SERENITY_SUFFIX = "-serenity";
+function isSerenityEntry(name) {
+	return name.endsWith(SERENITY_SUFFIX);
+}
+/** 扫描某 skills 根下所有 `*-serenity` 目录（含 SKILL.md 的） */
+function scanSerenityDirs(skillsRoot) {
+	if (!existsSync(skillsRoot)) return [];
+	return readdirSync(skillsRoot).filter((name) => isSerenityEntry(name)).map((name) => join(skillsRoot, name)).filter((dir) => statSync(dir).isDirectory() && existsSync(join(dir, "SKILL.md"))).sort();
+}
+/** 按名在两个 skills 根下定位 SKILL.md（.dsh/skills 优先，其次 .opencode/skills） */
+function findSkillMd(root, name) {
+	for (const base of [".dsh", ".opencode"]) {
+		const p = resolve(root, base, "skills", name, "SKILL.md");
+		if (existsSync(p)) return p;
+	}
+	return null;
+}
+/** 发现全部入口技能（原文全量，不截断） */
+function findEntrySkills(root) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (path, source, forcedName) => {
+		if (!existsSync(path)) return;
+		const name = forcedName ?? basename(dirname(path));
+		if (seen.has(name)) return;
+		seen.add(name);
+		out.push({
+			name,
+			content: readFileSync(path, "utf-8"),
+			source
+		});
+	};
+	const marker = resolve(root, ".serenity");
+	if (existsSync(marker)) {
+		const name = readFileSync(marker, "utf-8").trim();
+		if (name) {
+			const md = findSkillMd(root, name);
+			if (md) add(md, "serenity-marker", name);
+		}
+	}
+	const pointer = resolve(root, ".dsh", "entry-skill");
+	if (existsSync(pointer)) {
+		const name = readFileSync(pointer, "utf-8").trim();
+		if (name) {
+			const md = findSkillMd(root, name);
+			if (md) add(md, "pointer", name);
+		}
+	}
+	for (const dir of scanSerenityDirs(resolve(root, ".opencode", "skills"))) add(join(dir, "SKILL.md"), "opencode");
+	for (const dir of scanSerenityDirs(resolve(root, ".dsh", "skills"))) add(join(dir, "SKILL.md"), "dsh");
+	return out;
+}
+function truncateContent(content, maxChars) {
+	if (content.length <= maxChars) return content;
+	return content.slice(0, maxChars) + `\n...（已截断，原长 ${content.length} 字符）`;
+}
+//#endregion
+//#region src/seams/system-prompt.ts
+/** 过滤掉对 agent 隐藏的内容（safe-mode 是用户能力，不对 agent 提及） */
+const HIDDEN_LINES = /安全模式|safe-mode|\.serenity-safe-on/g;
+function sanitizeSkillContent(content) {
+	return content.split("\n").filter((line) => !HIDDEN_LINES.test(line)).join("\n");
+}
+/** 1) ACC 块：身份 + CCC 名/Root + 内置工具清单（工具名换本插件真实 9 工具） */
+function accBlock(root) {
+	const cccName = basename(root);
+	return [
+		"",
+		"=== Serenity ACC ===",
+		`ACC: dsh-serenity-hooks v${ACC_VERSION}`,
+		`CCC: ${cccName}  Root: ${root}`,
+		"",
+		"You are running inside a Concrete Cognitive Container (CCC) —",
+		"the runtime instance of an Abstract Cognitive Container (ACC).",
+		"The ACC (this plugin) provides the following built-in tools:",
+		"",
+		"  cc_fs    — CCC 内文件系统操作（root/resolve/exists/list/tree/relative/mkdir/rm/mv/cp/touch/append/reveal/info/find）",
+		"  session  — session lifecycle（list/show/create/health/qa/archive/summary）",
+		"  acc_kit  — ACC utility kit（health: CCC three principles / time: now / wait: sleep N seconds）",
+		"  cc_git   — git operations（status/commit/push/log）",
+		"  acc_msm  — MSM framework（list/exec/register/deregister/check/guide）",
+		"  eap      — return the full EAP cognitive quality framework",
+		"  neat     — return the full Neat design collaboration protocol",
+		"  cce      — return the full Cognitive Continuity Engineering framework",
+		"  loop     — 牛马循环：指定模型专用 agent 反复执行",
+		"",
+		"The DSH platform tools remain available too (read/write/edit/glob/grep/web_search/ask_user_question/subagent/workflow/goal and more) — the ACC tools above are the serenity-native layer, not the only tools.",
+		"",
+		"Additional MSMs registered by this CCC are available — call acc_msm list to discover them.",
+		""
+	].join("\n");
+}
+/** 2) CCE 块：逐字对齐 osp（CCE 5 行为约束 + H_op 操作熵） */
+function cceBlock() {
+	return [
+		"",
+		"=== Serenity CCE ===",
+		"",
+		"You are operating inside a Cognitive Container governed by Cognitive Continuity",
+		"Engineering (CCE) — the engineering discipline of maintaining identity, accessibility,",
+		"and evolution of a cognitive entity through time under bounded resources.",
+		"",
+		"CCE does not optimize cognition. It preserves the conditions under which cognition",
+		"can continue.",
+		"",
+		"FIVE BEHAVIORAL CONSTRAINTS (engineering requirements, not suggestions):",
+		"",
+		"1. Continuity — every interaction modifies the container's future state. Before",
+		"   acting, consult what came before — prior decisions, abstractions, constraints.",
+		"   You are part of a trajectory, not a fresh start.",
+		"",
+		"2. Bounded Space — the container has boundaries. Respect them. Do not assume",
+		"   knowledge that has not been accumulated within this container.",
+		"",
+		"3. Entropy is Intrinsic — every cognitive system accumulates entropy (duplication,",
+		"   obsolescence, conflict, fragmentation, drift). When you produce output, consider",
+		"   whether you are adding entropy or reducing it. Favor entropy-reducing actions —",
+		"   organizing, deduplicating, cross-referencing, abstracting.",
+		"",
+		"4. Reconstruction > Preservation — stored artifacts have value only insofar as",
+		"   they enable future cognition to recover the reasoning that produced them. When",
+		"   recording decisions, ensure reconstruction is possible — not just conclusions,",
+		"   but rationale, alternatives considered, and constraints that shaped the choice.",
+		"",
+		"5. Multi-Agent Cognition — the container is shared. Continuity belongs to the",
+		"   container, not to any individual agent. Write for future agents who will enter",
+		"   after you leave. They should be able to pick up where you left off.",
+		"",
+		"OPERATIONAL ENTROPY: The container's health metric is operational cognitive entropy",
+		"(H_op) — the excess cognitive cost for agents to complete tasks due to disorder.",
+		"The container is healthy when H_op ≤ H_critical (agents can still function). The",
+		"continuity condition: organization must at minimum match accumulation (ΔH_org ≥ ΔH_in).",
+		"Your actions affect H_op — unorganized output increases it, organization decreases it.",
+		"",
+		"CCE AND EAP: EAP governs artifact quality (how explicit to be). CCE governs temporal",
+		"coherence (how to maintain consistency over time). When structuring a document, apply",
+		"EAP (E↑ R↓ S↑). When maintaining cross-session coherence, apply CCE.",
+		"",
+		"THIS IS PERSISTENCE ENGINEERING: The goal is not to become greater. The goal is to",
+		"remain coherent. CCE has no terminal KPI — continuity is maintained while the entity",
+		"exists, not optimized toward an endpoint.",
+		""
+	].join("\n");
+}
+/** 3) Constraints 块：逐字对齐 osp（Root + 文件边界 + shell + subagent + session-first） */
+function constraintsBlock(root) {
+	return [
+		"",
+		"=== Serenity Constraints ===",
+		`Root: ${root}`,
+		"  • File access — read/edit/write/grep/glob are confined to Root; paths outside Root are rejected (RR5)",
+		"  • Shell — use acc_msm by default. Note: bash may be disabled",
+		"  • Subagent — copies ALL parent constraints: file boundary, shell rules, session rules (no bypass)",
+		"  • Session-first — before starting multi-step work, propose an existing or new AGENT_SESSIONS entry; wait for user \"use\" or \"使用\" to confirm",
+		""
+	].join("\n");
+}
+/** 4) SKILL.md 全文：该 CCC 顶层入口 skill 原文（对齐 osp：原文直推，无包裹头；仅过滤治理内容） */
+function entrySkillSectionText(root) {
+	const skills = findEntrySkills(root);
+	if (skills.length === 0) return "";
+	return skills.map((s) => sanitizeSkillContent(s.content)).filter((c) => c.length > 0).join("\n\n");
+}
+/** 活跃会话解析：.dsh/active-session 标记（内容 = 相对 CCC 根的 SESSION.md 路径） */
+function resolveActiveSessionInfo(root) {
+	try {
+		const marker = resolve(root, ".dsh", "active-session");
+		if (!existsSync(marker)) return null;
+		const rel = readFileSync(marker, "utf-8").trim();
+		if (!rel) return null;
+		const abs = resolve(root, rel);
+		if (!abs.startsWith(resolve(root))) return null;
+		const dirName = basename(dirname(abs));
+		const idMatch = dirName.match(/S(\d{3,})/);
+		return {
+			sessionId: idMatch ? `S${idMatch[1]}` : dirName,
+			dirName,
+			mdPath: abs
+		};
+	} catch {
+		return null;
+	}
+}
+/** 5) Session 块：逐字对齐 osp（活跃会话 + todowrite 首位约定） */
+function sessionBlock(root) {
+	const active = resolveActiveSessionInfo(root);
+	if (!active) return "";
+	return [
+		"",
+		"=== Serenity Session ===",
+		`Active session: ${active.sessionId} — ${active.dirName}`,
+		`SESSION.md path: ${active.mdPath}`,
+		"",
+		"Rules:",
+		"  • Record all progress into this SESSION.md",
+		"  • Update the \"进度记录\" section after advancing work",
+		"  • Reference this session in all subsequent messages",
+		"",
+		"IMPORTANT: Read SESSION.md now. Parse the \"剩余工作\" / \"进度记录\" /",
+		"\"变更日志\" sections and call todowrite to synchronize the built-in todo",
+		"list. Keep todos in sync with SESSION.md as work progresses.",
+		"",
+		"CRITICAL: When calling todowrite, the first item in the todos array MUST",
+		"always be:",
+		`  { content: "SESSION: ${active.sessionId} — ${active.dirName.replace(/^\d{4}-\d{2}-\d{2}--/, "")}",`,
+		"    status: \"completed\", priority: \"low\" }",
+		"This preserves the session context across todo updates.",
+		"Do NOT remove or reorder this item — keep it at position 0.",
+		""
+	].join("\n");
+}
+/** 完整系统提示词注入文本：ACC + CCE + Constraints + SKILL 全文 + Session（osp 顺序） */
+function serenitySystemPrompt(root) {
+	const parts = [
+		accBlock(root),
+		cceBlock(),
+		constraintsBlock(root)
+	];
+	const skill = entrySkillSectionText(root);
+	if (skill) parts.push(skill);
+	const session = sessionBlock(root);
+	if (session) parts.push(session);
+	return parts.join("\n\n");
+}
+/** 从 assembly context 解析 agent cwd（subagent/后台 agent 同样带 agent） */
+function agentCwd(context) {
+	return (context.agent?.session)?.header?.cwd;
+}
+/**
+* 全局注册系统提示词 section（osp system.transform 的 DSH 等价）。
+* text 回调按 context.agent 的 cwd 上溯 .serenity → 返回该 CCC 的完整注入文本；
+* 非 CCC / 无 agent 返回空（不注入）。
+*/
+function registerEntrySkillSectionGlobal(ctx) {
+	try {
+		ctx.systemPrompt.section({
+			name: "serenity-entry",
+			order: -50,
+			text: (context) => {
+				const cwd = agentCwd(context);
+				if (!cwd) return "";
+				const root = findSerenityRoot(cwd);
+				if (!root) return "";
+				return serenitySystemPrompt(root);
+			}
+		});
+		console.log("[serenity-hooks] ✓ 全局入口 skill section 已注册（systemPrompt 就绪）");
+	} catch (err) {
+		console.error(`[serenity-hooks] ✗ 全局入口 skill section 注册失败: ${err.message}（检查 inject 是否含 systemPrompt）`);
+	}
+}
+//#endregion
+//#region src/seams/context.ts
+const DEFAULT_ENTRY_SKILL_MAX_CHARS = 3e4;
+function accIdentityText(root, configPaths = DEFAULT_SERENITY_CONFIG_PATHS, entrySkillMaxChars = DEFAULT_ENTRY_SKILL_MAX_CHARS) {
+	const loop = loadSerenityConfig(root, configPaths).loop?.defaultModel;
+	const phase2 = existsSync(resolve(root, ".dsh", "PHASE2-PROMPT.md"));
+	const lines = [
+		`[ACC] 宁静号认知容器已激活（dsh-serenity-hooks v${ACC_VERSION}）`,
+		`- CCC 根：${root}`,
+		`- 约束：路径隔离（P3，fs 沙箱）+ 会话追踪（AGENT_SESSIONS/）`,
+		`- 知识：加载 acc-serenity 入口技能；设计协作走 acc-eap / acc-neat`
+	];
+	if (loop) lines.push(`- loop 默认模型：${loop}`);
+	if (phase2) {
+		lines.push("- ⚠️ **Phase 2 认知对齐访谈待完成**：请按下方 5 个 Topic 逐项访谈并沉淀答案到 AGENT_SESSIONS/ 会话");
+		try {
+			const prompt = readFileSync(resolve(root, ".dsh", "PHASE2-PROMPT.md"), "utf-8");
+			lines.push(truncateContent(prompt, Math.min(entrySkillMaxChars, 8e3)));
+		} catch {}
+	}
+	return lines.join("\n");
+}
+const PLUGIN_SOURCE = {
+	kind: "plugin",
+	plugin: "dsh-serenity-hooks"
+};
+/**
+* ACC 注入消息：完整内容 = 简短身份头 + 完整系统提示词（ACC 5 块 + CCC 顶层 skill 原文）。
+* 用户要求：在此处注入完整 ACC 系统提示词内容 + CCC 顶层 skill 原文（对齐 osp system.transform）。
+*/
+function accMessage(root, configPaths, entrySkillMaxChars) {
+	const content = [{
+		type: "text",
+		text: `${accIdentityText(root, configPaths, entrySkillMaxChars)}\n\n${serenitySystemPrompt(root)}`
+	}];
+	return createUserMessage({
+		content,
+		source: PLUGIN_SOURCE
+	});
+}
+/** 每 agent 是否已注入过（进程内存态） */
+const injected = /* @__PURE__ */ new Set();
+function agentKey(agent) {
+	return agent.session.id ?? "global";
+}
+function registerContext(ctx, opts = {}) {
+	const configPaths = opts.configPaths ?? DEFAULT_SERENITY_CONFIG_PATHS;
+	const entrySkillMaxChars = opts.entrySkillMaxChars ?? 3e4;
+	const seed = (agent) => {
+		const root = findSerenityRoot(agent.session?.header?.cwd ?? process.cwd());
+		if (!root) return;
+		const key = agentKey(agent);
+		if (injected.has(key)) return;
+		injected.add(key);
+		agent.inject(accMessage(root, configPaths, entrySkillMaxChars));
+		syncSafeModeRestriction(agent, root);
+	};
+	if (opts.seedOnStart ?? true) ctx.on("agent/session-start", (payload) => {
+		try {
+			seed(payload.agent);
+		} catch {}
+	});
+	if (opts.injectOnPrompt ?? true) ctx.on("agent/pre-step", async (payload, next) => {
+		const { agent, messages } = payload;
+		const root = findSerenityRoot(agent.session?.header?.cwd ?? process.cwd());
+		const key = agentKey(agent);
+		const downstream = await next();
+		if (root) try {
+			syncSafeModeRestriction(agent, root);
+		} catch {}
+		if (!root || injected.has(key) || downstream.kind !== "enter") return downstream;
+		injected.add(key);
+		return {
+			kind: "enter",
+			messages: [
+				accMessage(root, configPaths, entrySkillMaxChars),
+				...messages,
+				...downstream.messages
+			]
+		};
+	});
+}
+//#endregion
+//#region src/seams/compact.ts
+/**
+* 注册压缩保留：compact/end（成功）后重注入 ACC 身份。
+* 仅当 agent 工作目录在 CCC 内时生效（激活门控）。
+*/
+function registerCompactRetention(ctx, opts = {}) {
+	const configPaths = opts.configPaths ?? DEFAULT_SERENITY_CONFIG_PATHS;
+	const entrySkillMaxChars = opts.entrySkillMaxChars ?? 3e4;
+	ctx.on("session/event", (session, event) => {
+		if (event.type !== "compaction/end") return;
+		if (event.data.error) return;
+		const agent = ctx.agents.get(session.id);
+		if (!agent) return;
+		const root = findSerenityRoot(agent.session?.header?.cwd ?? process.cwd());
+		if (!root) return;
+		try {
+			agent.inject(accMessage(root, configPaths, entrySkillMaxChars));
+		} catch {}
+	});
+}
+//#endregion
+//#region src/status.ts
+/**
+* status.ts — 状态与安全模式操作（纯逻辑，零 DSH 依赖，可独立单测）
+*
+* WebUI 停靠栏的数据源：ACC 版本 / CCC 根 / safe-mode 状态 / 黑名单 / keeper 阈值 / loop 模型。
+* setSafeMode 直接读写 .serenity-safe-on 标记（守卫实时读取，写即生效）。
+*/
+function getStatus(cwd, configPaths = DEFAULT_SERENITY_CONFIG_PATHS) {
+	const root = findSerenityRoot(cwd);
+	const restrict = getRestrictDiagnostics();
+	if (!root) return {
+		root: null,
+		accVersion: ACC_VERSION,
+		safeModeOn: false,
+		blacklist: [],
+		threshold: null,
+		loopModel: null,
+		restrict
+	};
+	const cfg = loadSerenityConfig(root, configPaths);
+	return {
+		root,
+		accVersion: ACC_VERSION,
+		safeModeOn: isSafeModeOn(root),
+		blacklist: readBlacklist(root, configPaths),
+		threshold: cfg.sessionKeeper?.threshold ?? null,
+		loopModel: cfg.loop?.defaultModel ?? null,
+		restrict
+	};
+}
+/** 切换安全模式（写/删标记文件）；返回实际生效状态 */
+function setSafeMode(root, on) {
+	const marker = resolve(root, SAFE_MODE_MARKER);
+	if (on) {
+		if (!existsSync(marker)) writeFileSync(marker, (/* @__PURE__ */ new Date()).toISOString() + "\n", "utf-8");
+	} else rmSync(marker, { force: true });
+	return { on: isSafeModeOn(root) };
+}
+//#endregion
+//#region src/api.ts
+const ROUTE_PATH = "/serenity/status";
+function readBody(req) {
+	return new Promise((resolve, reject) => {
+		let data = "";
+		req.on("data", (chunk) => {
+			data += chunk.toString("utf-8");
+			if (data.length > 65536) {
+				reject(/* @__PURE__ */ new Error("body too large"));
+				req.destroy();
+			}
+		});
+		req.on("end", () => resolve(data));
+		req.on("error", reject);
+	});
+}
+function sendJson(res, code, body) {
+	const payload = JSON.stringify(body);
+	res.writeHead(code, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store"
+	});
+	res.end(payload);
+}
+/** 从请求参数解析 workspace：优先 sessionId → 会话 header.cwd；其次 workspace 参数；最后进程 cwd */
+function resolveWorkspace(ctx, params) {
+	if (params.sessionId) {
+		const session = ctx.sessions?.get?.(params.sessionId);
+		if (session?.header?.cwd) return session.header.cwd;
+	}
+	if (typeof params.workspace === "string" && params.workspace) return params.workspace;
+	return process.cwd();
+}
+function registerStatusApi(ctx, opts = {}) {
+	const configPaths = opts.configPaths ?? DEFAULT_SERENITY_CONFIG_PATHS;
+	ctx.webServer.register({
+		kind: "exact",
+		path: ROUTE_PATH,
+		handler: async (req, res) => {
+			try {
+				if (req.method === "GET") {
+					const url = new URL(req.url ?? "/", "http://127.0.0.1");
+					sendJson(res, 200, getStatus(resolveWorkspace(ctx, {
+						sessionId: url.searchParams.get("sessionId") ?? void 0,
+						workspace: url.searchParams.get("workspace") ?? void 0
+					}), configPaths));
+					return;
+				}
+				if (req.method === "POST") {
+					if (req.headers["x-serenity-ui"] !== "1") {
+						sendJson(res, 403, { error: "safe-mode 切换仅限 WebUI（agent 不可自行开关）" });
+						return;
+					}
+					const raw = await readBody(req);
+					const body = JSON.parse(raw);
+					const workspace = resolveWorkspace(ctx, {
+						sessionId: body.sessionId,
+						workspace: body.workspace
+					});
+					const root = findSerenityRoot(workspace);
+					if (!root) {
+						sendJson(res, 404, { error: `no CCC found from workspace: ${workspace}` });
+						return;
+					}
+					const result = setSafeMode(root, body.on === true);
+					sendJson(res, 200, {
+						...getStatus(workspace, configPaths),
+						...result
+					});
+					return;
+				}
+				sendJson(res, 405, { error: "method not allowed" });
+			} catch (err) {
+				sendJson(res, 400, { error: err.message ?? String(err) });
+			}
+		}
+	});
+}
+//#endregion
+//#region src/seams/env.ts
+/** 纯解析：给定 cwd，返回可注入的 DSH_SERENITY_* 事实（非 CCC 返回空） */
+function resolveSerenityEnv(cwd) {
+	const root = findSerenityRoot(cwd);
+	if (!root) return {};
+	return {
+		DSH_SERENITY_ROOT: root,
+		DSH_SERENITY_CCC: basename(root),
+		DSH_SERENITY_VERSION: ACC_VERSION
+	};
+}
+function registerEnv(ctx) {
+	ctx.shellEnv.register({
+		name: "dsh-serenity-hooks",
+		variables: {
+			DSH_SERENITY_ROOT: { description: "CCC 根目录（宁静号认知容器）" },
+			DSH_SERENITY_CCC: { description: "CCC 名称（根目录 basename）" },
+			DSH_SERENITY_VERSION: { description: "ACC 插件版本" }
+		},
+		resolve(execution) {
+			return resolveSerenityEnv((execution.agent?.session)?.header?.cwd ?? process.cwd());
+		}
+	});
+}
+//#endregion
+//#region src/skills/opencode-scan.ts
+/**
+* opencode-scan.ts — opencode skill 标准扫描（纯逻辑，零 DSH 依赖）
+*
+* 兼容 opencode 的 skill 标准：`.opencode/skills/<name>/SKILL.md`
+* （frontmatter: name/description/whenToUse；结构含 references/、scripts/）。
+*/
+/** 解析 --- 分隔的 YAML frontmatter（只需 name/description/whenToUse） */
+function parseFrontmatter(raw) {
+	const m = /^---\s*\n([\s\S]*?)\n---\s*\n?/.exec(raw);
+	if (!m) return {
+		meta: {
+			name: "",
+			description: ""
+		},
+		content: raw
+	};
+	const fm = m[1];
+	const body = raw.slice(m[0].length);
+	const grab = (key) => {
+		const line = fm.split("\n").find((l) => l.startsWith(`${key}:`));
+		if (!line) return void 0;
+		return line.slice(key.length + 1).trim().replace(/^['"]|['"]$/g, "");
+	};
+	const meta = {
+		name: grab("name") ?? "",
+		description: grab("description") ?? ""
+	};
+	const whenToUse = grab("whenToUse");
+	if (whenToUse) meta.whenToUse = whenToUse;
+	return {
+		meta,
+		content: body
+	};
+}
+/** 扫描 CCC 的 .opencode/skills（一级目录 + SKILL.md 存在性） */
+function listOpencodeSkillDirs(root) {
+	const dir = join(root, ".opencode", "skills");
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join(dir, e.name)).filter((d) => existsSync(join(d, "SKILL.md")));
+}
+/** 加载一个 opencode skill（frontmatter 解析 + 正文） */
+function loadOpencodeSkill(skillDir) {
+	const { meta, content } = parseFrontmatter(readFileSync(join(skillDir, "SKILL.md"), "utf-8"));
+	return {
+		name: meta.name,
+		dir: skillDir,
+		meta,
+		content,
+		path: join(skillDir, "SKILL.md")
+	};
+}
+//#endregion
+//#region src/seams/opencode-skills.ts
+const OPENCODE_PROVIDER = "opencode-skills";
+function registerOpencodeSkills(ctx) {
+	const provider = {
+		name: OPENCODE_PROVIDER,
+		async list(options) {
+			const root = findSerenityRoot(options.cwd ?? process.cwd());
+			if (!root) return {
+				candidates: [],
+				complete: true
+			};
+			const candidates = [];
+			for (const dir of listOpencodeSkillDirs(root)) {
+				const skill = loadOpencodeSkill(dir);
+				if (!skill.meta.name) continue;
+				candidates.push({
+					name: skill.meta.name,
+					description: skill.meta.description || "(opencode skill)",
+					...skill.meta.whenToUse ? { whenToUse: skill.meta.whenToUse } : {},
+					invocation: {
+						modelInvocable: true,
+						userInvocable: true
+					},
+					source: "opencode-skills",
+					provider: OPENCODE_PROVIDER,
+					resourceBase: {
+						kind: "directory",
+						path: dir
+					},
+					rank: 250,
+					locator: dir,
+					path: skill.path
+				});
+			}
+			return {
+				candidates,
+				complete: true
+			};
+		},
+		async get(candidate) {
+			const dir = candidate.locator;
+			const skill = loadOpencodeSkill(dir);
+			return {
+				name: skill.meta.name,
+				description: skill.meta.description || candidate.description,
+				...skill.meta.whenToUse ? { whenToUse: skill.meta.whenToUse } : {},
+				invocation: candidate.invocation,
+				source: candidate.source,
+				provider: OPENCODE_PROVIDER,
+				resourceBase: candidate.resourceBase,
+				content: skill.content,
+				path: skill.path
+			};
+		}
+	};
+	ctx.skills.registerProvider(() => provider);
+}
+//#endregion
+//#region src/index.ts
+const name = "dsh-serenity-hooks";
+/** 主动调用的服务；其余（agent 事件）随 harness 装配必然存在 */
+const inject = [
+	"tools",
+	"webServer",
+	"sessions",
+	"shellEnv",
+	"skills",
+	"agentLoop",
+	"systemPrompt"
+];
+const Config = z.object({
+	serenityConfigPaths: z.array(z.string()).default([...DEFAULT_SERENITY_CONFIG_PATHS]),
+	tools: z.boolean().default(true),
+	guards: z.boolean().default(true),
+	turnFlush: z.boolean().default(true),
+	keeper: z.boolean().default(true),
+	keeperThreshold: z.number().default(150),
+	context: z.boolean().default(true),
+	compactRetention: z.boolean().default(true),
+	api: z.boolean().default(true),
+	entrySkillMaxChars: z.number().default(3e4),
+	env: z.boolean().default(true),
+	opencodeSkills: z.boolean().default(true)
+});
+function apply(ctx, config) {
+	if (config.tools) {
+		ctx.tools.register(ccFsTool);
+		ctx.tools.register(sessionTool);
+		ctx.tools.register(kitTool);
+		ctx.tools.register(gitTool);
+		ctx.tools.register(msmTool);
+		ctx.tools.register(eapTool);
+		ctx.tools.register(neatTool);
+		ctx.tools.register(cceTool);
+		ctx.tools.register(createLoopTool(ctx));
+	}
+	if (config.guards) registerGuards(ctx, { configPaths: config.serenityConfigPaths });
+	if (config.turnFlush) registerTurnFlush(ctx);
+	if (config.keeper) registerKeeper(ctx, {
+		configPaths: config.serenityConfigPaths,
+		defaultThreshold: config.keeperThreshold
+	});
+	if (config.context) registerContext(ctx, {
+		configPaths: config.serenityConfigPaths,
+		entrySkillMaxChars: config.entrySkillMaxChars
+	});
+	registerEntrySkillSectionGlobal(ctx);
+	if (config.compactRetention) registerCompactRetention(ctx, {
+		configPaths: config.serenityConfigPaths,
+		entrySkillMaxChars: config.entrySkillMaxChars
+	});
+	if (config.api) registerStatusApi(ctx, { configPaths: config.serenityConfigPaths });
+	if (config.env) registerEnv(ctx);
+	if (config.opencodeSkills) registerOpencodeSkills(ctx);
+}
+//#endregion
+export { Config, apply, inject, name };