@shgroup/dsh-serenity-hooks 1.51.5 → 1.52.0

package/lib/index.js

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { a as hostSessions, c as hostWeb, i as hostService, l as hostWebServer, n as hostInjected, o as hostSettings, r as hostLlm, s as hostSubagents, t as hostAgents } from "./access-CNccNtgf.js";
-import { _ as resolveInside, a as findSerenityRoot, c as matchBlacklist, d as readCccName$1, f as readExclusiveTools, h as readTrajectorySkills, i as findGitRoot, l as pathInside, m as readSafeModeHiddenTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readHandymanConfig, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-DXky9UZu.js";
+import { _ as resolveInside, a as findSerenityRoot$1, c as matchBlacklist, d as readCccName$1, f as readExclusiveTools, h as readTrajectorySkills, i as findGitRoot, l as pathInside, m as readSafeModeHiddenTools, n as SAFE_MODE_MARKER, o as isSafeModeOn, p as readHandymanConfig, r as classifyPath, s as loadSerenityConfig, t as DEFAULT_SERENITY_CONFIG_PATHS, u as readBlacklist } from "./ccc-DXky9UZu.js";
 import { i as cccRootForExec, n as agentCwdFor, o as listCccs, r as cccRootForCwd, t as NO_CCC_FROM_AGENT_CWD } from "./ccc-roots-Bo0HKLlM.js";
 import { A as localIdStamp, C as setActiveSessionInfo, D as isoLocal, E as useSession, O as localFileStamp, S as sessionsRoot, T as summarize, _ as namingTitleFor, a as pruneMissingBindings, b as resolveSessionByTitle, c as setBindingStore, d as clearActiveSessionInfo, f as createSession, g as listSessions, h as getActiveSessionInfo, i as listBoundSessionIds, k as localHuman, l as DEFAULT_SESSION_SCOPE, m as findSession, n as PLUGIN_SOURCE, o as readLastBound, p as extractSessionMdPathFromText, r as appendBound, s as resolveSessionTrajectoryLabel, t as ACC_MESSAGE_KIND, u as TRAJECTORY_ACTIONS, v as parseSessionContextFromEvents, w as showSession, x as sessionEvents$1, y as readActiveSessionMd } from "./message-source-BExngUPX.js";
 import { a as readWeixinCredential, c as weixinInboundDir, d as LOCALSTORE_SCOPES, f as checkLocalstoreGitCompliance, g as runLocalStore, h as readStore, i as matchWeixinRoute, l as weixinSessionIdFor, m as readGitTrack, n as extractWeixinText, o as readWeixinSettings, p as localstorePath, r as hasVoiceItem, s as sanitizeFileName$1, t as extractWeixinMedia } from "./weixin-route-BNyH5ghC.js";
@@ -424,7 +424,7 @@ function runCcFs(root, args) {
 * 进程内注册（取代 v0.1 的 bash spawn runner）：zod/schemastery 参数校验、
 * 规范 JSON 输出、纯 render 投影。逻辑在 fs-ops.ts（可单测）。
 */
-function renderText$9(value) {
+function renderText$10(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -496,7 +496,7 @@ const ccFsTool = defineTool({
 	},
 	output: {
 		schema: { type: "json" },
-		render: (args, value) => renderText$9(value)
+		render: (args, value) => renderText$10(value)
 	},
 	async execute(args, exec) {
 		const root = cccRootForExec(exec);
@@ -572,7 +572,7 @@ async function runKit(root, args, hostCtx) {
 /**
 * kit.ts — dashboard 真实 DSH 工具定义（defineTool）（v1.30：acc_kit → dashboard）
 */
-function renderText$8(value) {
+function renderText$9(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -600,7 +600,7 @@ function createKitTool(ctx) {
 		},
 		output: {
 			schema: { type: "json" },
-			render: (args, value) => renderText$8(value)
+			render: (args, value) => renderText$9(value)
 		},
 		async execute(args, exec) {
 			return await runKit(cccRootForExec(exec), args, ctx);
@@ -915,7 +915,7 @@ function runGit(root, args) {
 /**
 * git.ts — container_git 真实 DSH 工具定义（defineTool）（v1.30：cc_git → container_git）
 */
-function renderText$7(value) {
+function renderText$8(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -963,7 +963,7 @@ const gitTool = defineTool({
 	},
 	output: {
 		schema: { type: "json" },
-		render: (args, value) => renderText$7(value)
+		render: (args, value) => renderText$8(value)
 	},
 	async execute(args, exec) {
 		const root = cccRootForExec(exec);
@@ -1078,6 +1078,8 @@ Directory of ACC capabilities — each area lists where to go for details (guide
                          原 logbook 已并入（v1.33 用户裁决：废除 logbook 词）；close/archive 删（归档走 container_fs mv），
                          health/qa/summary 分别并入 use / list，hook-develop-guide 并进 container_admin msm guide
   ② 认知质量框架      → praxis（eap/neat/cce/ontology 四合一——可实践理论注入，section 渐进披露，无参即目录）
+                          ontology（v1.52 D121：本体工程**引擎**——init/check/explain/verify/review/compliance；
+                          与 praxis ontology 的分工 = 那个是**方法文本**、这个是**能跑的那个**）
   ③ 工具与执行        → container_fs（容器文件系统 15 子命令）/ container_git（git）/ dashboard（health 含注册表检查/time/wait）
                          acc_msm 已并入 msm（执行+发现）与 container_admin（管理）——msm("<name>", ["<args>"])；inspect=true 查用法
                          handyman（杂工 agent 编排——guide 子命令：handyman guide）
@@ -3146,6 +3148,7 @@ function toolsBlock() {
 		"  container_git— git operations (status/commit/push/log)",
 		"  msm          — execute a registered CCC MSM: msm(name, args); partial name returns candidates; inspect=true shows usage",
 		"  praxis       — actionable theory injection: praxis (index) / praxis eap / praxis neat / praxis cce / praxis ontology",
+		"  ontology     — ontology engineering ENGINE (executable): init (write template) / check (M1-M10 structural; level=strict adds L1-L5 hints) / explain (summary) / verify (V1-V4 runtime compliance) / review (semantic-review prompt) / compliance (axiom-vs-skill checklist). Sibling of `praxis ontology` — that one is the METHOD TEXT, this one RUNS it. path must stay inside the container; the receipt carries the engine exit code (0/1/2/4) and the engine text verbatim, so read it rather than assuming success",
 		"  handyman     — delegate work to a worker agent on a CCC-whitelisted model; mode=\"foreground\" (default) = child agent(s) run once and return their final text (jobs=[...] fans out in parallel, cap 10, per-job model); mode=\"background\" = loop-validated worker (completion code + round cap + restart + progress file), jobs=[] orchestrates parallel work",
 		"  localstore   — ACC local credential/config storage (CCC-root localstore.json; git policy localstore.gitTrack default deny)",
 		"  container_admin — container administration (the maintenance bay): role (Skiff roles: guide/validate/apply/list) / msm (register/deregister/check/guide/catalog/ccc-config) / config (view)",
@@ -4141,7 +4144,7 @@ function skiffMsmGate(root, sessionId, action, name) {
 function agentSessionId$1(exec) {
 	return exec.agent?.session?.id ?? "";
 }
-function renderText$6(value) {
+function renderText$7(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -4191,7 +4194,7 @@ const msmTool = defineTool({
 	},
 	output: {
 		schema: { type: "json" },
-		render: (args, value) => renderText$6(value)
+		render: (args, value) => renderText$7(value)
 	},
 	async execute(args, exec) {
 		const root = cccRootForExec(exec);
@@ -4531,6 +4534,26 @@ O ── Ontology
 ⑤ register it through the container's registry (never by editing the registry file directly)
 \`\`\`
 
+**Retrofit — modelling a system that already exists** (the reverse direction; the three workflows above
+assume the model comes first, which is not how it usually goes)
+
+\`\`\`
+① draw the boundary as an ACTIVITY, not as a system ("developing X", not "the whole of X")
+② enumerate the artefacts by MEASURING, never by recall — list the files, the registry entries, the
+  running processes; a model built from memory reproduces memory's errors
+③ classify each artefact: type · instance · property. Only types get a class
+④ for every type: rigidity + identity. A role/stage is anti-rigid; a thing that persists is rigid
+⑤ write the relations that carry OWNERSHIP and CAUSALITY first (owner · produces · guards · proves)
+⑥ write axioms from the rules you ALREADY follow but never wrote down — that is where the payout is
+⑦ record known failure modes as INSTANCES, not as prose paragraphs
+⑧ strict check → 0 errors; then the semantic review
+\`\`\`
+
+🔴 **The tell that a retrofit model is worth keeping**: running it surfaces at least one
+**contradiction in the existing system** — a thing owned in two places, a declared value that does not
+match reality, a rule everyone follows that nobody wrote down. A model that only restates what was
+already obvious has not earned its maintenance cost.
+
 ## 10. Universal axioms (violating any of these is a defect, not a style choice)
 
 | Axiom | Content | Consequence of violation |
@@ -4544,6 +4567,51 @@ O ── Ontology
 **Axiom discipline**: axioms are named (\`AX-*\`), individually citable, and each carries a rationale.
 Breaking an axiom is allowed only by stating the break explicitly and recording the reason.
 
+### The axiom rule expression (what \`M8\` parses, and what \`M9\` resolves against)
+
+\`sr:rule\` is **not free text** — it is a small expression language:
+
+\`\`\`
+expr        ::= implication
+implication ::= or_expr ('implies' or_expr)?
+or_expr     ::= and_expr ('or' and_expr)*
+and_expr    ::= not_expr ('and' not_expr)*
+not_expr    ::= 'not' not_expr | comparison
+comparison  ::= additive (cmp additive)?          ← at most ONE comparison; it does not chain
+cmp         ::= == | != | > | >= | < | <= | in    ← there is no 'not in'; see the traps below
+additive    ::= primary (('+' | '-') primary)*
+primary     ::= quantifier | func_call | prop_access | literal | '(' expr ')'
+quantifier  ::= ('exists' | 'forall') ident 'in' Type ':' expr
+func_call   ::= ident '(' (expr (',' expr)*)? ')'
+prop_access ::= ident ('.' ident)*
+literal     ::= number | 'string' | true | false | null
+\`\`\`
+
+🔴 **The property that makes every other trap dangerous**: \`M8\` accepts a rule as soon as a **prefix**
+parses. It never requires the input to be consumed to the end, so whatever follows the longest parsable
+prefix is **silently dropped** — and \`M9\` then checks only the AST that survived, so the dropped tail is
+invisible to **both** checks. Measured, with its control: \`Thing.count >= 1 NoSuchType.x == 1\` passes
+**clean**, while the same fragment alone (\`NoSuchType.x == 1\`) raises an M9 warning. And
+\`Thing.count >= 1 garbage here\` passes clean. ⇒ **A green check does not mean the whole rule was
+understood.** Keep one rule to a single clause; if you suspect a fragment is being dropped, put it alone
+in a throwaway axiom — a fragment that complains alone but not in place is a fragment being dropped.
+
+**Traps, each measured against the engine** (\`check --level strict\`, one probe axiom per boundary):
+
+| Trap | What the engine actually does |
+|---|---|
+| \`exists\` / \`forall\` / \`in\` are **reserved words** | they cannot be used as identifiers or property names: \`ReleaseTag.exists\` ⇒ \`Expected identifier after '.'\`. Express existence through a counted property (\`X.count >= 1\`) instead |
+| there is **no \`distinct\`** | \`count(distinct version)\` ⇒ \`Expected ')' after args of count\` (the argument parse stops at \`distinct\`, then hits \`version\`). Put the derived quantity in its own property (\`VersionTriple.distinctCount == 1\`) |
+| there is **no \`not in\`** | the operator is unreachable: \`x not in y\` parses as \`x\` and the rest vanishes **with no message**. Write \`not (x in y)\` — verified clean |
+| comparisons do **not chain** | \`a >= 1 >= 0\` parses as \`a >= 1\`; the tail is dropped silently. Use \`and\` |
+| \`M9\` checks **exactly two things** | (a) dotted paths of **two or more** segments ⇒ **warning** when the head is neither a declared type nor a relation; (b) a quantifier's **type name** ⇒ **error** when undeclared. Single bare identifiers and **function-call names are never checked**: \`noSuchFunction(X) == 1\` and \`noSuchBareThing == 1\` both pass clean ⇒ a mistyped relation inside \`occupies(…)\` is invisible |
+| \`M8\` errors are fatal, **M9's property tier is only a warning** | \`check\` can exit non-zero on M8 alone while a wrong head name slips past as a warning ⇒ read the warnings, not just the exit code |
+
+**Rule of thumb**: if a constraint cannot be said in this grammar, it is probably a
+**description + rationale** (prose) rather than a rule — say it there, do not bend the syntax.
+⚠️ Prose is also the honest place for anything the checks **cannot** see: a constraint the engine silently
+drops is worse than an unstated one, because it reads as verified.
+
 ## 11. Dispatching a review subagent
 
 Both OEPE review stages run in an isolated context. Three rules make them work:
@@ -4600,7 +4668,7 @@ const PRAXIS_INDEX = `praxis — 可实践理论注入（认知框架，按需
           praxis ontology（本体论工程方法群——触发/编码/四组判据 M·L·D·V/OEPE 循环/公理/反模式）
 无参返回本目录；详情以对应框架原文为准（单一真相源）。
 `;
-function renderText$5(value) {
+function renderText$6(value) {
 	return [{
 		type: "text",
 		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
@@ -4621,7 +4689,7 @@ const praxisTool = defineTool({
 	} },
 	output: {
 		schema: { type: "string" },
-		render: (_args, value) => renderText$5(value)
+		render: (_args, value) => renderText$6(value)
 	},
 	async execute(args) {
 		if (args.section === "eap") return EAP_CONTENT;
@@ -4632,6 +4700,2773 @@ const praxisTool = defineTool({
 	}
 });
 //#endregion
+//#region src/ontology/engine.ts
+/**
+* engine.ts — Ontology Definition, Validation & Semantic Review（ACC 侧引擎）
+*
+* 来源：宁静号 CCC 的 MSM `ontology-engineering`
+*   （原 `.opencode/skills/home-ontology/scripts/ontology-engineering.ts`；
+*    2026-10-11 owner 裁「搬到 ACC」）。
+*   搬迁方式 = **复制 ＋ 机械改写**，不是重写 —— 判据群（M1–M10／L1–L5／D1–D8／V1–V4）与
+*   全部输出文案**逐字保留**，只在"如何被调用/如何吐字"这一层做了三处改写（见下）。
+*
+* 本文件是**纯引擎**：只用 node 内建模块，不依赖宿主与 CCC。三段分工：
+*   · 引擎（本文件）＝ 解析与检查；
+*   · 工具壳 `src/tools/ontology-eng.ts` ＝ 参数、路径守卫、把结果翻成回执；
+*   · 方法手册 `src/tools/ontology.ts`（praxis 第四段）＝ 人/模型读的方法论。
+*
+* 🔴 搬迁改写清单（相对原 MSM 脚本，行为差异仅此三处）：
+*   ① **输出不再直写 `process.stdout`** ⇒ 经 `emit()`／`emitErr()` 汇聚。宿主是**长驻进程**，
+*      工具调用必须**返回文本**（且不能污染服务器自己的 stdout）。
+*   ② **`main()` ＋ `process.argv` 守卫 ⇒ 导出 `runOntologyCli(argv, opts)`**：**不再 `process.exit`**，
+*      退出码（0/1/2/4）改为**返回值**，由工具壳翻译成可读回执。
+*   ③ **运行时工作目录由调用方给**（`opts.cwd` = CCC 根）：引擎多处按相对路径解析
+*      `.opencode/skills` ⇒ 改用**显式基准目录 `BASE`**（一律 `resolve(BASE, …)`），
+*      **不用 `process.chdir`** —— chdir 在 **worker 线程里不被支持**
+*      （`ERR_WORKER_UNSUPPORTED_OPERATION`；vitest 就用 worker 跑），且长驻进程
+*      改全局 cwd 是隐患。`BASE` 只在本进程内、由 `runOntologyCli` 的 try/finally
+*      保存与恢复；`resolve(BASE, x)` 对**绝对路径天然无害**（原样返回）⇒ 生产路径
+*      （工具壳传绝对路径进来）行为不变。
+*
+* subcommands（与原脚本逐一对应）：
+*   init       <path> [--template minimal|full]       写一份 Turtle 模板
+*   check      <path> [--level normal|strict]         M1–M10 结构检查（strict 另出 L1–L5 提示）
+*   explain    <path>                                 自然语言摘要
+*   verify     <path> [--level operational|continuity|full]  V1–V4 运行时合规
+*   review     <path> [--level semantic|onto-clean|full] [--format prompt|json]  语义审查提示词
+*   compliance <path> [--skills <dir>] [--format prompt|json]  公理↔skill 合规清单
+*
+* 退出码：0 成功 ／ 1 user（参数或校验失败）／ 2 system（文件缺失／解析失败）／ 4 internal
+* 错误码：PARAMETER_MISSING ／ PARAMETER_INVALID_VALUE ／ ONTO_FILE_NOT_FOUND ／ ONTO_PARSE_ERROR
+*        ／ ONTO_AXIOM_PARSE_ERROR ／ ONTO_VALIDATION_FAILED ／ INTERNAL_UNHANDLED_STATE
+*/
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let OUT = { write: (s) => void process.stdout.write(s) };
+let ERR = { write: (s) => void process.stderr.write(s) };
+function emit(s) {
+	OUT.write(s);
+}
+function emitErr(s) {
+	ERR.write(s);
+}
+var MsmError = class extends Error {
+	code;
+	category;
+	message;
+	context;
+	remediation;
+	cause;
+	constructor(code, category, message, context = {}, remediation, cause) {
+		super(message);
+		this.code = code;
+		this.category = category;
+		this.message = message;
+		this.context = context;
+		this.remediation = remediation;
+		this.cause = cause;
+		this.name = "MsmError";
+	}
+	toStderr() {
+		const lines = [
+			`[${this.code}]`,
+			`  code: ${this.code}`,
+			`  category: ${this.category}`,
+			`  message: ${this.message}`,
+			`  cause: ${this.cause !== void 0 && this.cause !== "" ? this.cause instanceof Error ? this.cause.message : String(this.cause) : "(no underlying cause)"}`
+		];
+		if (this.remediation) lines.push(`  remediation: ${this.remediation}`);
+		if (Object.keys(this.context).length > 0) lines.push(`  context: ${JSON.stringify(this.context)}`);
+		return lines.join("\n");
+	}
+	exitCode() {
+		return {
+			user: 1,
+			system: 2,
+			operator: 3,
+			internal: 4
+		}[this.category];
+	}
+};
+function emitError(err) {
+	emitErr(err.toStderr() + "\n");
+}
+const RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+const RDFS = "http://www.w3.org/2000/01/rdf-schema#";
+const OWL = "http://www.w3.org/2002/07/owl#";
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+/** `sr:` 命名空间 —— **容器约定**（宁静号及同源 CCC 用 `http://home-serenity/ontology#`）。
+*  可用 `runOntologyCli(argv, { namespace })` 覆盖；缺省与原 MSM 脚本**逐字相同**。 */
+let SR = "http://home-serenity/ontology#";
+/** 顶层 skill 名 —— 引擎有三处按它定位容器级资产（根标记 / MSM 注册表 / 合规扫描）。
+*  可用 `runOntologyCli(argv, { topSkill })` 覆盖；缺省 = 宁静号的顶层 skill。 */
+let TOP_SKILL = "home-serenity";
+/** 容器根（CCC root）—— 由调用方给定（改写 ③）。**ACC 侧必须给**：插件安装在宿主 profile 下，
+*  沿 `__dirname` 上溯只会走到安装路径，永远命不中 CCC 的 `.opencode/skills/...`。 */
+let ROOT = void 0;
+/** 相对路径的解析基准 —— 由调用方给（= CCC 根，见改写 ③）。**不用 `process.chdir`**：
+*  chdir 在 worker 线程里不被支持（`ERR_WORKER_UNSUPPORTED_OPERATION`，vitest 就用 worker 跑），
+*  且在长驻进程里改全局 cwd 是隐患。缺省 = 进程启动时的工作目录。 */
+let BASE = process.cwd();
+const STD_PREFIXES = {
+	rdf: RDF,
+	rdfs: RDFS,
+	owl: OWL,
+	xsd: XSD,
+	sr: SR
+};
+function tokenizeTurtle(input) {
+	const tokens = [];
+	const errors = [];
+	let i = 0;
+	let safety = 0;
+	function peek(n = 0) {
+		return i + n < input.length ? input[i + n] : "";
+	}
+	while (i < input.length) {
+		if (++safety > 5e5) {
+			errors.push(`Tokenizer safety limit exceeded at position ${i}`);
+			break;
+		}
+		const ch = input[i];
+		if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+			i++;
+			continue;
+		}
+		if (ch === "#") {
+			while (i < input.length && input[i] !== "\n") i++;
+			continue;
+		}
+		if (ch === "@") {
+			const start = i;
+			i++;
+			let kw = "";
+			while (i < input.length && /[a-z]/i.test(input[i])) {
+				kw += input[i];
+				i++;
+			}
+			if (kw === "prefix" || kw === "base") tokens.push({
+				kind: kw,
+				value: kw,
+				pos: start
+			});
+			else errors.push(`Unknown directive @${kw} at ${start}`);
+			continue;
+		}
+		if (ch === "<") {
+			const start = i;
+			let iri = "";
+			i++;
+			while (i < input.length && input[i] !== ">") {
+				iri += input[i];
+				i++;
+			}
+			if (i < input.length) i++;
+			else errors.push(`Unclosed IRI at ${start}`);
+			tokens.push({
+				kind: "iri",
+				value: iri,
+				pos: start
+			});
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			const start = i, quote = ch;
+			let val = "";
+			i++;
+			if (input[i] === quote && input[i + 1] === quote) {
+				i += 2;
+				while (i < input.length && !(input[i] === quote && input[i + 1] === quote && input[i + 2] === quote)) {
+					val += input[i];
+					i++;
+				}
+				if (i < input.length) i += 3;
+				else errors.push(`Unclosed triple-quoted string at ${start}`);
+			} else {
+				while (i < input.length && input[i] !== quote) {
+					if (input[i] === "\\" && i + 1 < input.length) val += input[++i];
+					else val += input[i];
+					i++;
+				}
+				if (i < input.length) i++;
+				else errors.push(`Unclosed string at ${start}`);
+			}
+			const tk = {
+				kind: "literal",
+				value: val,
+				pos: start
+			};
+			if (input[i] === "@" && /[a-z]/i.test(input[i + 1])) {
+				i++;
+				let lang = "";
+				while (i < input.length && /[a-z-]/i.test(input[i])) {
+					lang += input[i];
+					i++;
+				}
+				tk.lang = lang;
+			} else if (input.slice(i, i + 2) === "^^") {
+				i += 2;
+				if (input[i] === "<") {
+					i++;
+					let dt = "";
+					while (i < input.length && input[i] !== ">") {
+						dt += input[i];
+						i++;
+					}
+					if (i < input.length) i++;
+					tk.datatype = dt;
+				}
+			}
+			tokens.push(tk);
+			continue;
+		}
+		if (/[0-9]/.test(ch) || ch === "-" && /[0-9]/.test(peek(1))) {
+			const start = i;
+			let num = "";
+			if (ch === "-") {
+				num += ch;
+				i++;
+			}
+			if (input[i] === ".") {
+				num += ".";
+				i++;
+			}
+			while (i < input.length && /[0-9]/.test(input[i])) {
+				num += input[i];
+				i++;
+			}
+			if (input[i] === "." && !/[a-zA-Z]/.test(peek(1))) {
+				num += ".";
+				i++;
+				while (i < input.length && /[0-9]/.test(input[i])) {
+					num += input[i];
+					i++;
+				}
+			}
+			if (input[i] === "e" || input[i] === "E") {
+				num += input[i];
+				i++;
+				if (input[i] === "-" || input[i] === "+") {
+					num += input[i];
+					i++;
+				}
+				while (i < input.length && /[0-9]/.test(input[i])) {
+					num += input[i];
+					i++;
+				}
+			}
+			tokens.push({
+				kind: "number",
+				value: num,
+				pos: start
+			});
+			continue;
+		}
+		if (/[a-zA-Z_:]/.test(ch)) {
+			const start = i;
+			let ident = "";
+			while (i < input.length && /[a-zA-Z0-9_-]/.test(input[i])) {
+				ident += input[i];
+				i++;
+			}
+			if (i < input.length && input[i] === ":") {
+				ident += ":";
+				i++;
+				while (i < input.length && /[a-zA-Z0-9_-]/.test(input[i])) {
+					ident += input[i];
+					i++;
+				}
+				tokens.push({
+					kind: ident === "a" ? "a" : "qname",
+					value: ident,
+					pos: start
+				});
+			} else if (ident === "a") tokens.push({
+				kind: "a",
+				value: "a",
+				pos: start
+			});
+			else if (ident === "true" || ident === "false") tokens.push({
+				kind: "boolean",
+				value: ident,
+				pos: start
+			});
+			else tokens.push({
+				kind: "qname",
+				value: ident.startsWith(":") ? ident : ":" + ident,
+				pos: start
+			});
+			continue;
+		}
+		switch (ch) {
+			case ".":
+				tokens.push({
+					kind: "dot",
+					value: ".",
+					pos: i
+				});
+				i++;
+				break;
+			case ";":
+				tokens.push({
+					kind: "semi",
+					value: ";",
+					pos: i
+				});
+				i++;
+				break;
+			case ",":
+				tokens.push({
+					kind: "comma",
+					value: ",",
+					pos: i
+				});
+				i++;
+				break;
+			case "[":
+				tokens.push({
+					kind: "lbracket",
+					value: "[",
+					pos: i
+				});
+				i++;
+				break;
+			case "]":
+				tokens.push({
+					kind: "rbracket",
+					value: "]",
+					pos: i
+				});
+				i++;
+				break;
+			case "(":
+				tokens.push({
+					kind: "lparen",
+					value: "(",
+					pos: i
+				});
+				i++;
+				break;
+			case ")":
+				tokens.push({
+					kind: "rparen",
+					value: ")",
+					pos: i
+				});
+				i++;
+				break;
+			default:
+				errors.push(`Unexpected character '${ch}' at position ${i}`);
+				i++;
+		}
+	}
+	tokens.push({
+		kind: "eof",
+		value: "",
+		pos: i
+	});
+	return {
+		tokens,
+		errors
+	};
+}
+function parseTurtle(raw) {
+	const { tokens, errors } = tokenizeTurtle(raw);
+	if (errors.length > 0) return {
+		prefixes: /* @__PURE__ */ new Map(),
+		triples: [],
+		errors
+	};
+	const prefixes = /* @__PURE__ */ new Map();
+	const p2q = /* @__PURE__ */ new Map();
+	let baseIri = "http://example.org/onto#";
+	let pos = 0;
+	let blankCounter = 0;
+	function nextBnode() {
+		return `_:b${blankCounter++}`;
+	}
+	function peek() {
+		return tokens[pos];
+	}
+	function advance() {
+		return tokens[pos++];
+	}
+	function resolveIri(tk) {
+		if (tk.kind === "iri") return tk.value;
+		if (tk.kind === "a") return "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+		if (tk.kind === "qname") {
+			const colon = tk.value.indexOf(":");
+			const prefix = tk.value.slice(0, colon);
+			const local = tk.value.slice(colon + 1);
+			if (prefix === "") return baseIri + local;
+			const ns = prefixes.get(prefix);
+			return ns ? ns + local : `unknown:${tk.value}`;
+		}
+		return tk.value;
+	}
+	function parseObject() {
+		const tk = peek();
+		if (tk.kind === "iri") {
+			advance();
+			return {
+				value: tk.value,
+				type: "iri"
+			};
+		}
+		if (tk.kind === "qname" || tk.kind === "a") {
+			advance();
+			return {
+				value: resolveIri(tk),
+				type: "iri"
+			};
+		}
+		if (tk.kind === "literal") {
+			advance();
+			return {
+				value: tk.value,
+				type: "literal",
+				datatype: tk.datatype
+			};
+		}
+		if (tk.kind === "number") {
+			advance();
+			return {
+				value: tk.value.includes(".") ? parseFloat(tk.value) : parseInt(tk.value, 10),
+				type: "literal",
+				datatype: tk.value.includes(".") ? "http://www.w3.org/2001/XMLSchema#double" : "http://www.w3.org/2001/XMLSchema#integer"
+			};
+		}
+		if (tk.kind === "boolean") {
+			advance();
+			return {
+				value: tk.value === "true",
+				type: "literal",
+				datatype: "http://www.w3.org/2001/XMLSchema#boolean"
+			};
+		}
+		if (tk.kind === "lbracket") {
+			const bnode = nextBnode();
+			advance();
+			while (peek().kind !== "rbracket" && peek().kind !== "eof") {
+				const pred = peek();
+				if (pred.kind !== "qname" && pred.kind !== "a") {
+					errors.push(`Expected predicate in blank node at ${pred.pos}`);
+					break;
+				}
+				advance();
+				const obj = parseObject();
+				if (!obj) {
+					errors.push(`Expected object in blank node at ${peek().pos}`);
+					break;
+				}
+				obj.type === "iri" ? obj.value : `${obj.value}`;
+				triples.push({
+					subject: bnode,
+					predicate: resolveIri(pred),
+					object: obj.value,
+					objectType: obj.type,
+					objectDatatype: obj.datatype
+				});
+				if (peek().kind === "semi") advance();
+				else if (peek().kind === "dot") {
+					advance();
+					break;
+				} else break;
+			}
+			if (peek().kind === "dot") advance();
+			if (peek().kind === "rbracket") advance();
+			else errors.push(`Expected ] at position ${peek().pos}`);
+			return {
+				value: bnode,
+				type: "blank"
+			};
+		}
+		if (tk.kind === "lparen") {
+			advance();
+			const values = [];
+			while (peek().kind !== "rparen" && peek().kind !== "eof") {
+				if (peek().kind === "comma") {
+					advance();
+					continue;
+				}
+				const obj = parseObject();
+				if (obj) values.push(obj);
+				else break;
+			}
+			if (peek().kind === "rparen") advance();
+			return {
+				value: values.map((v) => v.type === "iri" ? `<${v.value}>` : `"${v.value}"`).join(" "),
+				type: "literal"
+			};
+		}
+		return null;
+	}
+	const triples = [];
+	let safetyLoop = 0;
+	while (peek().kind !== "eof") {
+		if (++safetyLoop > 1e5) {
+			errors.push("Parser safety limit exceeded");
+			break;
+		}
+		const tk = peek();
+		if (tk.kind === "prefix") {
+			advance();
+			const nameTk = peek();
+			if (nameTk.kind !== "qname") {
+				errors.push(`Expected prefix name after @prefix at ${nameTk.pos}`);
+				break;
+			}
+			const nameStr = nameTk.value.replace(/:$/, "");
+			advance();
+			const iriTk = peek();
+			if (iriTk.kind !== "iri") {
+				errors.push(`Expected IRI after prefix name at ${iriTk.pos}`);
+				break;
+			}
+			advance();
+			prefixes.set(nameStr, iriTk.value);
+			p2q.set(iriTk.value, nameStr);
+			if (peek().kind === "dot") advance();
+			continue;
+		}
+		if (tk.kind === "base") {
+			advance();
+			const iriTk = peek();
+			if (iriTk.kind !== "iri") {
+				errors.push(`Expected IRI after @base at ${iriTk.pos}`);
+				break;
+			}
+			baseIri = iriTk.value;
+			advance();
+			if (peek().kind === "dot") advance();
+			continue;
+		}
+		let subject = "";
+		if (tk.kind === "lbracket") {
+			subject = nextBnode();
+			advance();
+			const subjPred = peek();
+			if (subjPred.kind !== "qname" && subjPred.kind !== "a") {
+				errors.push(`Expected predicate in blank node subject at ${subjPred.pos}`);
+				break;
+			}
+			advance();
+			const subjObj = parseObject();
+			if (!subjObj) {
+				errors.push(`Expected object in blank node at ${peek().pos}`);
+				break;
+			}
+			triples.push({
+				subject,
+				predicate: resolveIri(subjPred),
+				object: subjObj.value,
+				objectType: subjObj.type,
+				objectDatatype: subjObj.datatype
+			});
+			if (peek().kind === "rbracket") advance();
+			else {
+				errors.push(`Expected ] at ${peek().pos}`);
+				break;
+			}
+		} else if (tk.kind === "qname" || tk.kind === "iri") {
+			subject = resolveIri(tk);
+			advance();
+		} else {
+			errors.push(`Expected subject at position ${tk.pos}, got ${tk.kind}`);
+			break;
+		}
+		let subjDone = false;
+		let currentPred = "";
+		while (!subjDone && peek().kind !== "eof") {
+			const pk = peek();
+			if (pk.kind === "dot") {
+				advance();
+				subjDone = true;
+				continue;
+			}
+			if (pk.kind === "semi") {
+				advance();
+				currentPred = "";
+				continue;
+			}
+			if (pk.kind === "comma") {
+				advance();
+				if (!currentPred) {
+					errors.push(`Comma without preceding predicate at ${pk.pos}`);
+					break;
+				}
+				const obj = parseObject();
+				if (!obj) {
+					errors.push(`Expected object after comma at ${peek().pos}`);
+					break;
+				}
+				triples.push({
+					subject,
+					predicate: currentPred,
+					object: obj.value,
+					objectType: obj.type,
+					objectDatatype: obj.datatype
+				});
+				continue;
+			}
+			if (pk.kind === "qname" || pk.kind === "a") {
+				currentPred = resolveIri(pk);
+				advance();
+				const obj = parseObject();
+				if (!obj) {
+					errors.push(`Expected object after predicate at ${peek().pos}`);
+					break;
+				}
+				triples.push({
+					subject,
+					predicate: currentPred,
+					object: obj.value,
+					objectType: obj.type,
+					objectDatatype: obj.datatype
+				});
+				continue;
+			}
+			if (pk.kind === "rbracket") break;
+			errors.push(`Unexpected token ${pk.kind} at ${pk.pos}`);
+			break;
+		}
+	}
+	return {
+		prefixes,
+		triples,
+		errors
+	};
+}
+function i2q(iri, prefixes) {
+	let best = null;
+	let bestLen = 0;
+	for (const [p, ns] of prefixes) if (iri.startsWith(ns) && ns.length > bestLen) {
+		best = p;
+		bestLen = ns.length;
+	}
+	if (best !== null) return best + ":" + iri.slice(bestLen);
+	for (const [p, ns] of Object.entries(STD_PREFIXES)) if (iri.startsWith(ns)) return p + ":" + iri.slice(ns.length);
+	return "<" + iri + ">";
+}
+function stripDefaultPrefix(name) {
+	if (name.startsWith(":")) return name.slice(1);
+	return name;
+}
+function turtleToOnto(r) {
+	const { prefixes, triples, errors } = r;
+	const onto = {
+		types: {},
+		relations: {},
+		axioms: []
+	};
+	const subjectMap = /* @__PURE__ */ new Map();
+	for (const t of triples) {
+		const list = subjectMap.get(t.subject) || [];
+		list.push(t);
+		subjectMap.set(t.subject, list);
+	}
+	const typeIris = /* @__PURE__ */ new Set();
+	const propIris = /* @__PURE__ */ new Set();
+	const ontologyIris = /* @__PURE__ */ new Set();
+	for (const [subj, stmts] of subjectMap) for (const s of stmts) if (s.predicate === "http://www.w3.org/1999/02/22-rdf-syntax-ns#type") {
+		const obj = typeof s.object === "string" ? s.object : "";
+		if (obj === "http://www.w3.org/2002/07/owl#Class" || obj === "http://www.w3.org/2000/01/rdf-schema#Class") typeIris.add(subj);
+		else if (obj === "http://www.w3.org/2002/07/owl#ObjectProperty" || obj === "http://www.w3.org/2002/07/owl#DatatypeProperty" || obj === "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property") propIris.add(subj);
+		else if (obj === "http://www.w3.org/2002/07/owl#Ontology") ontologyIris.add(subj);
+		else if (obj === "http://www.w3.org/2002/07/owl#FunctionalProperty") {
+			const pname = stripDefaultPrefix(i2q(subj, prefixes));
+			if (!onto.relations[pname]) onto.relations[pname] = {};
+			onto.relations[pname].functional = true;
+		} else if (obj === "http://www.w3.org/2002/07/owl#TransitiveProperty") {
+			const pname = stripDefaultPrefix(i2q(subj, prefixes));
+			if (!onto.relations[pname]) onto.relations[pname] = {};
+			onto.relations[pname].transitive = true;
+		} else if (obj === "http://www.w3.org/2002/07/owl#SymmetricProperty") {
+			const pname = stripDefaultPrefix(i2q(subj, prefixes));
+			if (!onto.relations[pname]) onto.relations[pname] = {};
+			onto.relations[pname].symmetric = true;
+		}
+	}
+	for (const [subj, stmts] of subjectMap) if (ontologyIris.has(subj)) for (const s of stmts) {
+		if (s.predicate === SR + "name" || s.predicate === "http://www.w3.org/2000/01/rdf-schema#label") onto.name = String(s.object);
+		if (s.predicate === "http://www.w3.org/2002/07/owl#versionInfo") onto.version = String(s.object);
+		if (s.predicate === "http://www.w3.org/2002/07/owl#imports") {
+			if (!onto.imports) onto.imports = [];
+			onto.imports.push(String(s.object));
+		}
+	}
+	for (const [iri, stmts] of subjectMap) {
+		if (!typeIris.has(iri)) continue;
+		const name = stripDefaultPrefix(i2q(iri, prefixes));
+		const td = {};
+		for (const s of stmts) {
+			if (s.predicate === "http://www.w3.org/2000/01/rdf-schema#subClassOf") td.superTypes = [...td.superTypes || [], stripDefaultPrefix(i2q(String(s.object), prefixes))];
+			if (s.predicate === "http://www.w3.org/2000/01/rdf-schema#label" || s.predicate === "http://www.w3.org/2000/01/rdf-schema#comment") td.description = String(s.object);
+			if (s.predicate === SR + "rigidity") td.rigidity = String(s.object);
+			if (s.predicate === SR + "identity") td.identity = [...td.identity || [], String(s.object)];
+			if (s.predicate === SR + "dependsOn") td.dependsOn = [...td.dependsOn || [], stripDefaultPrefix(i2q(String(s.object), prefixes))];
+		}
+		for (const s of stmts) if (s.predicate === SR + "property" && s.objectType === "blank") {
+			const pnode = String(s.object);
+			const pstmts = subjectMap.get(pnode) || [];
+			const pdef = { type: "string" };
+			for (const ps of pstmts) {
+				if (ps.predicate === SR + "name") {}
+				if (ps.predicate === SR + "propType" || ps.predicate === "http://www.w3.org/1999/02/22-rdf-syntax-ns#type") pdef.type = String(ps.object);
+				if (ps.predicate === SR + "cardinality") pdef.cardinality = String(ps.object);
+				if (ps.predicate === SR + "values") {
+					if (ps.objectType === "literal") pdef.values = String(ps.object).split(/\s+/).filter(Boolean);
+				}
+			}
+			const propName = pstmts.find((ps) => ps.predicate === SR + "name");
+			if (propName && typeof propName.object === "string") {
+				if (!td.properties) td.properties = {};
+				td.properties[propName.object] = pdef;
+			}
+		}
+		onto.types[name] = td;
+	}
+	for (const [iri, stmts] of subjectMap) {
+		if (!propIris.has(iri)) continue;
+		const name = stripDefaultPrefix(i2q(iri, prefixes));
+		const rd = {};
+		for (const s of stmts) {
+			if (s.predicate === "http://www.w3.org/2000/01/rdf-schema#domain") rd.domain = stripDefaultPrefix(i2q(String(s.object), prefixes));
+			if (s.predicate === "http://www.w3.org/2000/01/rdf-schema#range") rd.range = stripDefaultPrefix(i2q(String(s.object), prefixes));
+			if (s.predicate === SR + "cardinality") rd.cardinality = String(s.object);
+		}
+		onto.relations[name] = rd;
+	}
+	for (const [subj, stmts] of subjectMap) for (const s of stmts) if (s.predicate === SR + "axiom" && s.objectType === "blank") {
+		const anode = String(s.object);
+		const astmts = subjectMap.get(anode) || [];
+		const ad = { rule: "" };
+		for (const as_ of astmts) {
+			if (as_.predicate === SR + "description" || as_.predicate === "http://www.w3.org/2000/01/rdf-schema#label") ad.description = String(as_.object);
+			if (as_.predicate === SR + "rule") ad.rule = String(as_.object);
+			if (as_.predicate === SR + "axiomType") ad.type = String(as_.object);
+		}
+		onto.axioms.push(ad);
+	}
+	return onto;
+}
+function ontoToTurtle(onto, baseIri = "http://example.org/onto#") {
+	const lines = [];
+	const p = (s) => lines.push(s);
+	p(`@prefix rdf: <${RDF}> .`);
+	p(`@prefix rdfs: <${RDFS}> .`);
+	p(`@prefix owl: <${OWL}> .`);
+	p(`@prefix xsd: <${XSD}> .`);
+	p(`@prefix sr: <${SR}> .`);
+	p(`@prefix : <${baseIri}> .`);
+	p("");
+	function lit(v) {
+		if (typeof v === "string") return JSON.stringify(v);
+		return String(v);
+	}
+	function semicolon(i, total) {
+		return i < total - 1 ? " ;" : " .";
+	}
+	function qname(s) {
+		if (s.includes(":") || s.startsWith("<") || s.startsWith("_:")) return s;
+		return ":" + s;
+	}
+	const headerStmts = [];
+	headerStmts.push("a owl:Ontology");
+	if (onto.name) headerStmts.push(`sr:name ${lit(onto.name)}`);
+	if (onto.version) headerStmts.push(`owl:versionInfo ${lit(onto.version)}`);
+	if (onto.imports && onto.imports.length > 0) for (const imp of onto.imports) headerStmts.push(`owl:imports <${imp}>`);
+	for (let i = 0; i < headerStmts.length; i++) if (i === 0) p(`:onto ${headerStmts[i]} ;`);
+	else p(`    ${headerStmts[i]}${semicolon(i, headerStmts.length)}`);
+	p("");
+	const types = onto.types || {};
+	for (const [name, td] of Object.entries(types)) {
+		const stmts = [];
+		stmts.push("a owl:Class");
+		if (td.description) stmts.push(`rdfs:label ${lit(td.description)}`);
+		if (td.superTypes) for (const st of td.superTypes) stmts.push(`rdfs:subClassOf ${qname(st)}`);
+		if (td.rigidity) stmts.push(`sr:rigidity ${lit(td.rigidity)}`);
+		if (td.identity) for (const id of td.identity) stmts.push(`sr:identity ${qname(id)}`);
+		if (td.dependsOn) for (const dep of td.dependsOn) stmts.push(`sr:dependsOn ${qname(dep)}`);
+		if (td.properties) for (const [pname, pd] of Object.entries(td.properties)) {
+			const pstmts = [];
+			pstmts.push(`sr:name ${lit(pname)}`);
+			pstmts.push(`sr:propType ${lit(pd.type)}`);
+			if (pd.cardinality) pstmts.push(`sr:cardinality ${lit(pd.cardinality)}`);
+			if (pd.values && pd.values.length > 0) pstmts.push(`sr:values (${pd.values.map(lit).join(" ")})`);
+			stmts.push(`sr:property [\n      ${pstmts.join(" ;\n      ")}\n    ]`);
+		}
+		if (td.axioms) for (const ax of td.axioms) {
+			const astmts = [];
+			astmts.push(`sr:rule ${lit(ax)}`);
+			stmts.push(`sr:axiom [\n      ${astmts.join(" ;\n      ")}\n    ]`);
+		}
+		for (let i = 0; i < stmts.length; i++) if (i === 0) p(`:${name} ${stmts[i]} ;`);
+		else p(`    ${stmts[i]}${semicolon(i, stmts.length)}`);
+		p("");
+	}
+	const relations = onto.relations || {};
+	for (const [name, rd] of Object.entries(relations)) {
+		const stmts = [];
+		const flags = [];
+		stmts.push("a owl:ObjectProperty");
+		if (rd.functional) flags.push("owl:FunctionalProperty");
+		if (rd.transitive) flags.push("owl:TransitiveProperty");
+		if (rd.symmetric) flags.push("owl:SymmetricProperty");
+		if (flags.length > 0) stmts.push(`a ${flags.join(", ")}`);
+		if (rd.domain) stmts.push(`rdfs:domain ${qname(rd.domain)}`);
+		if (rd.range) stmts.push(`rdfs:range ${qname(rd.range)}`);
+		if (rd.cardinality) stmts.push(`sr:cardinality ${lit(rd.cardinality)}`);
+		for (let i = 0; i < stmts.length; i++) if (i === 0) p(`:${name} ${stmts[i]} ;`);
+		else p(`    ${stmts[i]}${semicolon(i, stmts.length)}`);
+		p("");
+	}
+	const axioms = onto.axioms || [];
+	for (const ax of axioms) {
+		const astmts = [];
+		if (ax.description) astmts.push(`sr:description ${lit(ax.description)}`);
+		astmts.push(`sr:rule ${lit(ax.rule)}`);
+		if (ax.type) astmts.push(`sr:axiomType ${lit(ax.type)}`);
+		p(`:onto sr:axiom [`);
+		for (let i = 0; i < astmts.length; i++) p(`    ${astmts[i]}${i < astmts.length - 1 ? " ;" : ""}`);
+		p(`  ] .\n`);
+	}
+	return lines.join("\n");
+}
+const KEYWORDS = {
+	"and": "and",
+	"or": "or",
+	"not": "not",
+	"implies": "implies",
+	"exists": "exists",
+	"forall": "forall",
+	"in": "in",
+	"true": "boolean",
+	"false": "boolean",
+	"null": "null"
+};
+function tokenize(input) {
+	const tokens = [];
+	const errors = [];
+	let i = 0;
+	function advance(n) {
+		i += n;
+	}
+	function pos() {
+		return i;
+	}
+	while (i < input.length) {
+		const ch = input[i];
+		if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+			advance(1);
+			continue;
+		}
+		if (ch === "'") {
+			const start = pos();
+			advance(1);
+			let val = "";
+			while (i < input.length && input[i] !== "'") {
+				val += input[i];
+				advance(1);
+			}
+			if (i >= input.length) errors.push({
+				message: "Unterminated string literal",
+				pos: start
+			});
+			else advance(1);
+			tokens.push({
+				kind: "string",
+				value: val,
+				pos: start
+			});
+			continue;
+		}
+		if (/[0-9]/.test(ch)) {
+			const start = pos();
+			let num = "";
+			while (i < input.length && /[0-9]/.test(input[i])) {
+				num += input[i];
+				advance(1);
+			}
+			if (i < input.length && input[i] === "." && i + 1 < input.length && /[0-9]/.test(input[i + 1])) {
+				num += ".";
+				advance(1);
+				while (i < input.length && /[0-9]/.test(input[i])) {
+					num += input[i];
+					advance(1);
+				}
+			}
+			tokens.push({
+				kind: "number",
+				value: num,
+				pos: start
+			});
+			continue;
+		}
+		if (/[a-zA-Z_]/.test(ch)) {
+			const start = pos();
+			let ident = "";
+			while (i < input.length && /[a-zA-Z0-9_]/.test(input[i])) {
+				ident += input[i];
+				advance(1);
+			}
+			const kw = KEYWORDS[ident];
+			tokens.push({
+				kind: kw || "ident",
+				value: ident,
+				pos: start
+			});
+			continue;
+		}
+		if (ch === ">" || ch === "<" || ch === "=" || ch === "!") {
+			const start = pos();
+			const op = input.slice(i, i + 2);
+			if (op === ">=") {
+				tokens.push({
+					kind: "gte",
+					value: ">=",
+					pos: start
+				});
+				advance(2);
+			} else if (op === "<=") {
+				tokens.push({
+					kind: "lte",
+					value: "<=",
+					pos: start
+				});
+				advance(2);
+			} else if (op === "==") {
+				tokens.push({
+					kind: "eq",
+					value: "==",
+					pos: start
+				});
+				advance(2);
+			} else if (op === "!=") {
+				tokens.push({
+					kind: "neq",
+					value: "!=",
+					pos: start
+				});
+				advance(2);
+			} else if (ch === ">") {
+				tokens.push({
+					kind: "gt",
+					value: ">",
+					pos: start
+				});
+				advance(1);
+			} else if (ch === "<") {
+				tokens.push({
+					kind: "lt",
+					value: "<",
+					pos: start
+				});
+				advance(1);
+			} else {
+				errors.push({
+					message: `Unexpected character: ${ch}`,
+					pos: start
+				});
+				advance(1);
+			}
+			continue;
+		}
+		switch (ch) {
+			case "(":
+				tokens.push({
+					kind: "lparen",
+					value: "(",
+					pos: pos()
+				});
+				advance(1);
+				break;
+			case ")":
+				tokens.push({
+					kind: "rparen",
+					value: ")",
+					pos: pos()
+				});
+				advance(1);
+				break;
+			case ",":
+				tokens.push({
+					kind: "comma",
+					value: ",",
+					pos: pos()
+				});
+				advance(1);
+				break;
+			case ":":
+				tokens.push({
+					kind: "colon",
+					value: ":",
+					pos: pos()
+				});
+				advance(1);
+				break;
+			case ".":
+				tokens.push({
+					kind: "dot",
+					value: ".",
+					pos: pos()
+				});
+				advance(1);
+				break;
+			case "+":
+				tokens.push({
+					kind: "plus",
+					value: "+",
+					pos: pos()
+				});
+				advance(1);
+				break;
+			case "-":
+				tokens.push({
+					kind: "minus",
+					value: "-",
+					pos: pos()
+				});
+				advance(1);
+				break;
+			default:
+				errors.push({
+					message: `Unexpected character: ${ch}`,
+					pos: pos()
+				});
+				advance(1);
+		}
+	}
+	tokens.push({
+		kind: "eof",
+		value: "",
+		pos: i
+	});
+	return {
+		tokens,
+		errors
+	};
+}
+var AxiomParser = class {
+	tokens;
+	idx;
+	errors;
+	constructor(tokens) {
+		this.tokens = tokens;
+		this.idx = 0;
+		this.errors = [];
+	}
+	current() {
+		return this.tokens[this.idx];
+	}
+	advance() {
+		return this.tokens[this.idx++];
+	}
+	expect(kind, msg) {
+		if (this.current().kind === kind) return this.advance();
+		this.errors.push({
+			message: msg,
+			pos: this.current().pos
+		});
+		return null;
+	}
+	parse() {
+		const ast = this.parseExpr();
+		return {
+			ast: this.errors.length === 0 ? ast : null,
+			errors: this.errors
+		};
+	}
+	parseExpr() {
+		return this.parseImplication();
+	}
+	parseImplication() {
+		const left = this.parseLogicalOr();
+		if (this.current().kind === "implies") {
+			const pos = this.current().pos;
+			this.advance();
+			return {
+				kind: "implication",
+				antecedent: left,
+				consequent: this.parseLogicalOr(),
+				pos
+			};
+		}
+		return left;
+	}
+	parseLogicalOr() {
+		let left = this.parseLogicalAnd();
+		while (this.current().kind === "or") {
+			const pos = this.current().pos;
+			this.advance();
+			const right = this.parseLogicalAnd();
+			left = {
+				kind: "binaryOp",
+				op: "or",
+				left,
+				right,
+				pos
+			};
+		}
+		return left;
+	}
+	parseLogicalAnd() {
+		let left = this.parseUnary();
+		while (this.current().kind === "and") {
+			const pos = this.current().pos;
+			this.advance();
+			const right = this.parseUnary();
+			left = {
+				kind: "binaryOp",
+				op: "and",
+				left,
+				right,
+				pos
+			};
+		}
+		return left;
+	}
+	parseUnary() {
+		if (this.current().kind === "not") {
+			const pos = this.current().pos;
+			this.advance();
+			return {
+				kind: "unaryOp",
+				op: "not",
+				operand: this.parseUnary(),
+				pos
+			};
+		}
+		return this.parseComparison();
+	}
+	parseComparison() {
+		const left = this.parseAdditive();
+		if ([
+			"gt",
+			"gte",
+			"lt",
+			"lte",
+			"eq",
+			"neq",
+			"in"
+		].includes(this.current().kind)) {
+			const pos = this.current().pos;
+			let op = this.advance().value;
+			if (op === "in" && this.tokens[this.idx - 2]?.kind === "not") op = "not in";
+			const right = this.parseAdditive();
+			return {
+				kind: "binaryOp",
+				op,
+				left,
+				right,
+				pos
+			};
+		}
+		return left;
+	}
+	parseAdditive() {
+		let left = this.parsePrimary();
+		while (this.current().kind === "plus" || this.current().kind === "minus") {
+			const pos = this.current().pos;
+			const op = this.advance().value;
+			const right = this.parsePrimary();
+			left = {
+				kind: "binaryOp",
+				op,
+				left,
+				right,
+				pos
+			};
+		}
+		return left;
+	}
+	parsePrimary() {
+		const tok = this.current();
+		if (tok.kind === "lparen") {
+			const pos = tok.pos;
+			this.advance();
+			const expr = this.parseExpr();
+			this.expect("rparen", "Expected ')' after expression");
+			return {
+				kind: "parens",
+				expr,
+				pos
+			};
+		}
+		if (tok.kind === "exists" || tok.kind === "forall") {
+			const pos = tok.pos;
+			const quant = tok.kind;
+			this.advance();
+			const varTok = this.expect("ident", "Expected variable after " + quant);
+			if (!varTok) return {
+				kind: "literal",
+				value: null,
+				raw: "null",
+				pos
+			};
+			this.expect("in", "Expected 'in' after variable");
+			const typeTok = this.expect("ident", "Expected type after 'in'");
+			if (!typeTok) return {
+				kind: "literal",
+				value: null,
+				raw: "null",
+				pos
+			};
+			this.expect("colon", "Expected ':' after type in quantifier");
+			const body = this.parseExpr();
+			return {
+				kind: "quantifier",
+				quant,
+				variable: varTok.value,
+				typeName: typeTok.value,
+				body,
+				pos
+			};
+		}
+		if (tok.kind === "ident" && this.tokens[this.idx + 1]?.kind === "lparen") {
+			const pos = tok.pos;
+			const name = this.advance().value;
+			this.advance();
+			const args = [];
+			if (this.current().kind !== "rparen") {
+				args.push(this.parseExpr());
+				while (this.current().kind === "comma") {
+					this.advance();
+					args.push(this.parseExpr());
+				}
+			}
+			this.expect("rparen", `Expected ')' after args of ${name}`);
+			return {
+				kind: "funcCall",
+				name,
+				args,
+				pos
+			};
+		}
+		if (tok.kind === "ident") {
+			const pos = tok.pos;
+			const path = [this.advance().value];
+			while (this.current().kind === "dot") {
+				this.advance();
+				const next = this.expect("ident", "Expected identifier after '.'");
+				if (next) path.push(next.value);
+			}
+			return {
+				kind: "propAccess",
+				path,
+				pos
+			};
+		}
+		if (tok.kind === "number") {
+			const pos = tok.pos;
+			const raw = tok.value;
+			this.advance();
+			return {
+				kind: "literal",
+				value: raw.includes(".") ? parseFloat(raw) : parseInt(raw, 10),
+				raw,
+				pos
+			};
+		}
+		if (tok.kind === "string") {
+			const pos = tok.pos;
+			const val = tok.value;
+			this.advance();
+			return {
+				kind: "literal",
+				value: val,
+				raw: "'" + val + "'",
+				pos
+			};
+		}
+		if (tok.kind === "boolean") {
+			const pos = tok.pos;
+			const val = tok.value === "true";
+			this.advance();
+			return {
+				kind: "literal",
+				value: val,
+				raw: tok.value,
+				pos
+			};
+		}
+		if (tok.kind === "null") {
+			const pos = tok.pos;
+			this.advance();
+			return {
+				kind: "literal",
+				value: null,
+				raw: "null",
+				pos
+			};
+		}
+		this.errors.push({
+			message: `Unexpected token: ${tok.value}`,
+			pos: tok.pos
+		});
+		return {
+			kind: "literal",
+			value: null,
+			raw: "null",
+			pos: tok.pos
+		};
+	}
+};
+function collectRefs(node, boundVars = /* @__PURE__ */ new Set()) {
+	if (!node) return [];
+	const refs = [];
+	function walk(n, bv) {
+		switch (n.kind) {
+			case "propAccess":
+				if (n.path.length >= 1) {
+					const first = n.path[0];
+					if (bv.has(first)) break;
+					refs.push({
+						kind: "property",
+						name: n.path.join("."),
+						path: n.path,
+						pos: n.pos
+					});
+				}
+				break;
+			case "funcCall":
+				if (!bv.has(n.name)) refs.push({
+					kind: "unknown",
+					name: n.name,
+					path: [n.name],
+					pos: n.pos
+				});
+				n.args.forEach((a) => walk(a, bv));
+				break;
+			case "quantifier": {
+				refs.push({
+					kind: "type",
+					name: n.typeName,
+					path: [n.typeName],
+					pos: n.pos
+				});
+				const inner = new Set(bv);
+				inner.add(n.variable);
+				walk(n.body, inner);
+				break;
+			}
+			case "binaryOp":
+				walk(n.left, bv);
+				walk(n.right, bv);
+				break;
+			case "unaryOp":
+				walk(n.operand, bv);
+				break;
+			case "implication":
+				walk(n.antecedent, bv);
+				walk(n.consequent, bv);
+				break;
+			case "parens": walk(n.expr, bv);
+		}
+	}
+	walk(node, boundVars);
+	return refs;
+}
+function findSerenityRoot() {
+	if (ROOT !== void 0) return ROOT;
+	let dir = resolve(__dirname, "..", "..", "..");
+	const maxDepth = 20;
+	for (let i = 0; i < maxDepth; i++) {
+		const marker = resolve(dir, ".opencode", "skills", TOP_SKILL, "SKILL.md");
+		if (existsSync(marker)) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	throw new MsmError("HOME_ROOT_NOT_FOUND", "system", "Cannot locate serenity root", {
+		startDir: __dirname,
+		topSkill: TOP_SKILL
+	}, "Pass the container root via runOntologyCli(argv, { cwd }) — or run from inside the container workspace");
+}
+function loadOntoFile(filePath) {
+	const absPath = resolve(BASE, filePath);
+	if (!existsSync(absPath)) throw new MsmError("ONTO_FILE_NOT_FOUND", "system", `Ontology file not found: ${absPath}`, { path: absPath }, "Check the file path");
+	let raw;
+	try {
+		raw = readFileSync(absPath, "utf-8");
+	} catch (err) {
+		throw new MsmError("ONTO_PARSE_ERROR", "system", `Failed to read file: ${absPath}`, { path: absPath }, void 0, err);
+	}
+	const result = parseTurtle(raw);
+	if (result.errors.length > 0) throw new MsmError("ONTO_PARSE_ERROR", "system", `Failed to parse Turtle: ${absPath}\n  ${result.errors.join("\n  ")}`, {
+		path: absPath,
+		errors: result.errors
+	}, "Check Turtle syntax");
+	return {
+		onto: turtleToOnto(result),
+		raw
+	};
+}
+function loadOntoFileWithImports(filePath, visited = /* @__PURE__ */ new Set()) {
+	const absPath = resolve(BASE, filePath);
+	if (visited.has(absPath)) throw new MsmError("ONTO_VALIDATION_FAILED", "user", `Circular import detected: ${absPath}`, {
+		path: absPath,
+		chain: [...visited, absPath]
+	}, "Remove the circular dependency in imports");
+	visited.add(absPath);
+	const { onto: local } = loadOntoFile(absPath);
+	const baseDir = dirname(absPath);
+	return deepMergeOnto(local.imports && local.imports.length > 0 ? deepMergeOntoList(local.imports.map((imp) => {
+		return loadOntoFileWithImports(resolve(baseDir, imp), new Set(visited));
+	})) : emptyOnto(), local);
+}
+function emptyOnto() {
+	return {
+		types: {},
+		relations: {},
+		axioms: [],
+		imports: []
+	};
+}
+function deepMergeOnto(base, overlay) {
+	return {
+		name: overlay.name !== void 0 ? overlay.name : base.name,
+		version: overlay.version !== void 0 ? overlay.version : base.version,
+		imports: [...base.imports || [], ...overlay.imports || []],
+		types: {
+			...base.types || {},
+			...overlay.types || {}
+		},
+		relations: {
+			...base.relations || {},
+			...overlay.relations || {}
+		},
+		axioms: [...base.axioms || [], ...overlay.axioms || []]
+	};
+}
+function deepMergeOntoList(ontos) {
+	return ontos.reduce((acc, o) => deepMergeOnto(acc, o), emptyOnto());
+}
+function validateOnto(onto, level) {
+	const issues = [];
+	const types = onto.types || {};
+	const relations = onto.relations || {};
+	const axioms = onto.axioms || [];
+	const typeNames = new Set(Object.keys(types));
+	const relNames = new Set(Object.keys(relations));
+	for (const [name, td] of Object.entries(types)) {
+		for (const st of td.superTypes || []) if (!typeNames.has(st)) issues.push({
+			check: "M1",
+			severity: "error",
+			message: `Type "${name}" superType "${st}" does not exist`
+		});
+		for (const dep of td.dependsOn || []) if (!typeNames.has(dep)) issues.push({
+			check: "M1",
+			severity: "error",
+			message: `Type "${name}" dependsOn "${dep}" which does not exist`
+		});
+	}
+	for (const [name, rd] of Object.entries(relations)) {
+		if (rd.domain && !typeNames.has(rd.domain)) issues.push({
+			check: "M1",
+			severity: "error",
+			message: `Relation "${name}" domain "${rd.domain}" does not exist`
+		});
+		if (rd.range && !typeNames.has(rd.range)) issues.push({
+			check: "M1",
+			severity: "error",
+			message: `Relation "${name}" range "${rd.range}" does not exist`
+		});
+	}
+	function detectCycle(typeName, visiting = /* @__PURE__ */ new Set()) {
+		if (visiting.has(typeName)) return true;
+		visiting.add(typeName);
+		const td = types[typeName];
+		if (td?.superTypes) {
+			for (const st of td.superTypes) if (typeNames.has(st) && detectCycle(st, new Set(visiting))) return true;
+		}
+		return false;
+	}
+	for (const tn of typeNames) if (detectCycle(tn)) {
+		issues.push({
+			check: "M2",
+			severity: "error",
+			message: `Inheritance cycle detected involving type "${tn}"`
+		});
+		break;
+	}
+	for (const [name, td] of Object.entries(types)) if (td.superTypes && td.rigidity) for (const st of td.superTypes) {
+		const parent = types[st];
+		if (parent?.rigidity) {
+			if (td.rigidity === "rigid" && parent.rigidity !== "rigid") issues.push({
+				check: "M3",
+				severity: "error",
+				message: `Type "${name}" is rigid but parent "${st}" is ${parent.rigidity} — child cannot be more rigid than parent`
+			});
+		}
+	}
+	function getIdentity(typeName) {
+		const td = types[typeName];
+		if (!td) return void 0;
+		if (td.identity && td.identity.length > 0) return td.identity;
+		if (td.superTypes) for (const st of td.superTypes) {
+			const inherited = typeNames.has(st) ? getIdentity(st) : void 0;
+			if (inherited) return inherited;
+		}
+	}
+	for (const [name, td] of Object.entries(types)) if (td.rigidity === "rigid") {
+		const id = getIdentity(name);
+		if (!id || id.length === 0) issues.push({
+			check: "M4",
+			severity: "warning",
+			message: `Type "${name}" is rigid but has no identity criteria (own or inherited)`
+		});
+	}
+	function detectDepCycle(typeName, visiting = /* @__PURE__ */ new Set()) {
+		if (visiting.has(typeName)) return true;
+		visiting.add(typeName);
+		const td = types[typeName];
+		if (td?.dependsOn) {
+			for (const dep of td.dependsOn) if (typeNames.has(dep) && detectDepCycle(dep, new Set(visiting))) return true;
+		}
+		return false;
+	}
+	for (const tn of typeNames) if (detectDepCycle(tn)) {
+		issues.push({
+			check: "M5",
+			severity: "error",
+			message: `Dependency cycle detected involving type "${tn}"`
+		});
+		break;
+	}
+	for (const [name, rd] of Object.entries(relations)) if (rd.functional) {
+		const card = rd.cardinality || "";
+		if (/min\s+(\d+)/.test(card) && parseInt(card.match(/min\s+(\d+)/)[1], 10) >= 2 || /^[2-9]/.test(card) || /\.\.\*/.test(card) || /\.\.[2-9]/.test(card)) issues.push({
+			check: "M6",
+			severity: "error",
+			message: `Relation "${name}" is functional but cardinality "${card}" allows multiple values`
+		});
+	}
+	for (const [typeName, td] of Object.entries(types)) if (td.properties) {
+		for (const [propName, pd] of Object.entries(td.properties)) if (pd.type === "enum" && (!pd.values || pd.values.length === 0)) issues.push({
+			check: "M7",
+			severity: "error",
+			message: `Type "${typeName}" property "${propName}" is enum but has no values`
+		});
+	}
+	for (let i = 0; i < axioms.length; i++) {
+		const ax = axioms[i];
+		if (!ax.rule || ax.rule.trim() === "") continue;
+		const { errors: parseErrors } = tokenize(ax.rule);
+		if (parseErrors.length > 0) {
+			issues.push({
+				check: "M8",
+				severity: "error",
+				message: `Axiom #${i + 1} tokenization error: ${parseErrors[0].message}`
+			});
+			continue;
+		}
+		const { tokens } = tokenize(ax.rule);
+		const parser = new AxiomParser(tokens);
+		const result = parser.parse();
+		if (parser.errors.length > 0 || !result.ast) for (const e of parser.errors) issues.push({
+			check: "M8",
+			severity: "error",
+			message: `Axiom #${i + 1} parse error at pos ${e.pos}: ${e.message}`
+		});
+	}
+	for (let i = 0; i < axioms.length; i++) {
+		const ax = axioms[i];
+		if (!ax.rule || ax.rule.trim() === "") continue;
+		const { tokens } = tokenize(ax.rule);
+		const parser = new AxiomParser(tokens);
+		const result = parser.parse();
+		if (!result.ast || parser.errors.length > 0) continue;
+		const refs = collectRefs(result.ast);
+		for (const ref of refs) {
+			const name = ref.path[0];
+			if (ref.kind === "property" && ref.path.length >= 2) {
+				if (name && !typeNames.has(name) && !relNames.has(name)) issues.push({
+					check: "M9",
+					severity: "warning",
+					message: `Axiom #${i + 1} references unknown type "${name}" in "${ref.path.join(".")}"`
+				});
+			}
+			if (ref.kind === "type") {
+				if (name && !typeNames.has(name)) issues.push({
+					check: "M9",
+					severity: "error",
+					message: `Axiom #${i + 1} quantifier references unknown type "${name}"`
+				});
+			}
+			if (ref.kind === "unknown") {
+				if (name && !typeNames.has(name) && !relNames.has(name)) {}
+			}
+		}
+	}
+	return issues;
+}
+const HOSPITAL_TEMPLATE = ontoToTurtle({
+	name: "hospital-domain",
+	version: "0.1.0",
+	types: {
+		Person: {
+			description: "A human being",
+			rigidity: "rigid",
+			identity: ["nhsNumber"],
+			properties: {
+				nhsNumber: {
+					type: "string",
+					cardinality: "exactly 1"
+				},
+				name: {
+					type: "string",
+					cardinality: "exactly 1"
+				},
+				dateOfBirth: {
+					type: "date",
+					cardinality: "exactly 1"
+				}
+			}
+		},
+		Patient: {
+			superTypes: ["Person"],
+			rigidity: "anti-rigid",
+			dependsOn: ["Admission"],
+			properties: { status: {
+				type: "enum",
+				values: [
+					"admitted",
+					"under_treatment",
+					"discharged",
+					"closed"
+				],
+				cardinality: "exactly 1"
+			} }
+		},
+		Ward: {
+			description: "A physical location housing beds",
+			rigidity: "rigid",
+			identity: ["wardCode"],
+			properties: {
+				wardCode: {
+					type: "string",
+					cardinality: "exactly 1"
+				},
+				bedCapacity: {
+					type: "integer",
+					cardinality: "exactly 1"
+				},
+				status: {
+					type: "enum",
+					values: [
+						"open",
+						"full",
+						"closed"
+					],
+					cardinality: "exactly 1"
+				}
+			}
+		},
+		Bed: {
+			description: "A bed within a ward",
+			rigidity: "rigid",
+			identity: ["ward", "bedNumber"],
+			properties: { bedNumber: {
+				type: "integer",
+				cardinality: "exactly 1"
+			} }
+		},
+		Admission: {
+			description: "An event of a Patient being admitted",
+			rigidity: "rigid",
+			properties: {
+				admissionDate: {
+					type: "datetime",
+					cardinality: "exactly 1"
+				},
+				dischargeDate: {
+					type: "datetime",
+					cardinality: "max 1"
+				}
+			}
+		}
+	},
+	relations: {
+		admittedTo: {
+			domain: "Patient",
+			range: "Ward",
+			cardinality: "exactly 1",
+			functional: true
+		},
+		admittedAs: {
+			domain: "Admission",
+			range: "Patient",
+			cardinality: "exactly 1",
+			functional: true
+		},
+		contains: {
+			domain: "Ward",
+			range: "Bed",
+			cardinality: "min 0"
+		},
+		occupies: {
+			domain: "Patient",
+			range: "Bed",
+			cardinality: "max 1"
+		}
+	},
+	axioms: [
+		{
+			description: "Discharge date must be after admission date",
+			rule: "Admission.dischargeDate > Admission.admissionDate",
+			type: "temporal"
+		},
+		{
+			description: "Only admitted patients can occupy a bed",
+			rule: "occupies(patient, bed) implies admittedTo(patient, ward) and contains(ward, bed)",
+			type: "dependency"
+		},
+		{
+			description: "Closed ward has no patients",
+			rule: "Ward.status == 'closed' implies not exists p in Patient: admittedTo(p, ward)",
+			type: "state"
+		}
+	]
+});
+const MINIMAL_TEMPLATE = ontoToTurtle({
+	name: "example-domain",
+	version: "0.1.0",
+	types: { Thing: {
+		description: "A generic entity",
+		rigidity: "rigid",
+		identity: ["name"],
+		properties: { name: {
+			type: "string",
+			cardinality: "exactly 1"
+		} }
+	} },
+	relations: {},
+	axioms: []
+});
+function cmdInit(args) {
+	if (args.length === 0) throw new MsmError("PARAMETER_MISSING", "user", "init requires a file path", { validArgs: ["<path>"] }, "Usage: ontology init <path> [--template minimal|full]");
+	let filePath = resolve(BASE, args[0]);
+	if (!filePath.endsWith(".ttl")) filePath += ".ttl";
+	let template = "full";
+	for (let i = 1; i < args.length; i++) if (args[i] === "--template" && i + 1 < args.length) {
+		template = args[i + 1];
+		i++;
+	} else if (args[i].startsWith("--template=")) template = args[i].slice(11);
+	else if (args[i].startsWith("-")) throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown flag: ${args[i]}`, {
+		flag: args[i],
+		validFlags: ["--template <minimal|full>"]
+	}, "Usage: ontology init <path> [--template minimal|full]");
+	if (template !== "minimal" && template !== "full") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown template: ${template}`, {
+		template,
+		valid: ["minimal", "full"]
+	}, "Use --template minimal or --template full");
+	const content = template === "minimal" ? MINIMAL_TEMPLATE : HOSPITAL_TEMPLATE;
+	if (existsSync(filePath)) throw new MsmError("PARAMETER_INVALID_VALUE", "user", `File already exists: ${filePath}`, { path: filePath }, "Use a different path or remove the existing file");
+	try {
+		writeFileSync(filePath, content, "utf-8");
+	} catch (err) {
+		throw new MsmError("ONTO_PARSE_ERROR", "system", `Failed to write file: ${filePath}`, { path: filePath }, void 0, err);
+	}
+	emit(`Ontology template created at: ${filePath}\n`);
+	emit(`Template: ${template}\n`);
+}
+function cmdCheck(args) {
+	if (args.length === 0) throw new MsmError("PARAMETER_MISSING", "user", "check requires a file path", { validArgs: ["<path>"] }, "Usage: ontology check <path> [--level normal|strict]");
+	const filePath = args[0];
+	let level = "normal";
+	for (let i = 1; i < args.length; i++) if (args[i] === "--level" && i + 1 < args.length) {
+		const v = args[i + 1];
+		if (v !== "normal" && v !== "strict") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown level: ${v}`, {
+			level: v,
+			valid: ["normal", "strict"]
+		}, "Use --level normal or --level strict");
+		level = v;
+		i++;
+	} else if (args[i].startsWith("--level=")) {
+		const v = args[i].slice(8);
+		if (v !== "normal" && v !== "strict") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown level: ${v}`, {
+			level: v,
+			valid: ["normal", "strict"]
+		}, "Use --level normal or --level strict");
+		level = v;
+	} else if (args[i].startsWith("-")) throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown flag: ${args[i]}`, {
+		flag: args[i],
+		validFlags: ["--level <normal|strict>"]
+	}, "Usage: ontology check <path> [--level normal|strict]");
+	let onto;
+	let issues = [];
+	try {
+		onto = loadOntoFileWithImports(filePath);
+	} catch (err) {
+		if (err instanceof MsmError && err.code === "ONTO_VALIDATION_FAILED" && err.message.startsWith("Circular import")) throw err;
+		issues.push({
+			check: "M10",
+			severity: "error",
+			message: err instanceof MsmError ? err.message : String(err)
+		});
+		onto = loadOntoFile(filePath).onto;
+	}
+	issues = [...issues, ...validateOnto(onto, level)];
+	emit(`\nOntology Validation: ${onto.name || filePath}\n`);
+	emit("=".repeat(60) + "\n");
+	if (issues.length === 0) {
+		emit("All checks passed.\n");
+		return;
+	}
+	const errors = issues.filter((i) => i.severity === "error");
+	const warnings = issues.filter((i) => i.severity === "warning");
+	emit(`\nErrors: ${errors.length}, Warnings: ${warnings.length}\n\n`);
+	for (const issue of issues) emit(`  ${issue.severity === "error" ? "ERR" : "WRN"} [${issue.check}] ${issue.message}\n`);
+	if (level === "strict") {
+		emit(`\n── Strict mode — LLM review suggestions ──\n`);
+		emit(`  (Run through LLM for L1-L5 semantic checks)\n`);
+		printLlmReviewHints(onto, issues);
+	}
+	if (errors.length > 0) throw new MsmError("ONTO_VALIDATION_FAILED", "user", `Validation failed: ${errors.length} error(s), ${warnings.length} warning(s)`, {
+		errors: errors.length,
+		warnings: warnings.length
+	}, "Fix the errors listed above and re-run check");
+}
+function printLlmReviewHints(onto, issues) {
+	const types = onto.types || {};
+	for (const [name, td] of Object.entries(types)) if (!td.rigidity) emit(`  [L1] Type "${name}" has no rigidity label — should it be rigid or anti-rigid?\n`);
+	emit(`  [L2] Review axioms for domain completeness — are there missing temporal or state constraints?\n`);
+	for (const [name, td] of Object.entries(types)) if (td.rigidity === "rigid" && td.identity && td.identity.length === 1) emit(`  [L3] Type "${name}" identity: ${td.identity.join(", ")} — is this sufficient for uniqueness?\n`);
+	const typeNames = Object.keys(types);
+	if (typeNames.length > 0) emit(`  [L4] Review types: ${typeNames.join(", ")} — are there missing distinctions?\n`);
+	if ((onto.axioms || []).map((a) => a.description || a.rule).join("; ")) emit(`  [L5] Axioms reference concepts — review if all referenced entities are defined\n`);
+}
+function cmdExplain(args) {
+	if (args.length === 0) throw new MsmError("PARAMETER_MISSING", "user", "explain requires a file path", { validArgs: ["<path>"] }, "Usage: ontology explain <path>");
+	const filePath = args[0];
+	const { onto } = loadOntoFile(filePath);
+	const merged = onto.imports && onto.imports.length > 0 ? loadOntoFileWithImports(filePath) : onto;
+	emit(`## Ontology: ${onto.name || filePath}\n`);
+	if (onto.version) emit(`Version: ${onto.version}\n`);
+	if (onto.imports && onto.imports.length > 0) emit(`Imports: ${onto.imports.join(", ")}\n`);
+	const types = merged.types || {};
+	emit(`\n### Types (${Object.keys(types).length})\n\n`);
+	emit("| Type | SuperTypes | Rigidity | Properties |\n");
+	emit("|------|-----------|----------|------------|\n");
+	for (const [name, td] of Object.entries(types)) emit(`| ${name} | ${(td.superTypes || []).join(", ") || "-"} | ${td.rigidity || "-"} | ${td.properties ? Object.keys(td.properties).join(", ") : "-"} |\n`);
+	const relations = merged.relations || {};
+	if (Object.keys(relations).length > 0) {
+		emit(`\n### Relations\n\n`);
+		emit("| Name | Domain | Range | Cardinality | Flags |\n");
+		emit("|------|--------|-------|-------------|-------|\n");
+		for (const [name, rd] of Object.entries(relations)) {
+			const flags = [];
+			if (rd.functional) flags.push("functional");
+			if (rd.transitive) flags.push("transitive");
+			if (rd.symmetric) flags.push("symmetric");
+			emit(`| ${name} | ${rd.domain || "-"} | ${rd.range || "-"} | ${rd.cardinality || "-"} | ${flags.join(", ") || "-"} |\n`);
+		}
+	}
+	const axioms = merged.axioms || [];
+	if (axioms.length > 0) {
+		emit(`\n### Axioms (${axioms.length})\n\n`);
+		for (const ax of axioms) emit(`- ${ax.description || "(no description)"}: \`${ax.rule}\` [${ax.type || "rule"}]\n`);
+	}
+	emit(`\n### Dependency Graph\n\n`);
+	for (const [name, td] of Object.entries(merged.types || {})) {
+		const deps = [];
+		if (td.superTypes) deps.push(...td.superTypes.map((s) => `"${name}" -> "${s}" [label="isa"]`));
+		if (td.dependsOn) deps.push(...td.dependsOn.map((d) => `"${name}" -> "${d}" [label="depends"]`));
+		deps.forEach((d) => emit(`  ${d}\n`));
+	}
+}
+function pascalToKebab(name) {
+	return name.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+}
+function isConcreteSkill(typeName, onto) {
+	if (typeName === "Skill" || typeName === "SystemComponent" || typeName === "AccBuiltin") return false;
+	const td = onto.types?.[typeName];
+	if (!td) return false;
+	return (td.superTypes || []).includes("Skill");
+}
+function getOntoSkillList(onto) {
+	return Object.keys(onto.types || {}).filter((n) => isConcreteSkill(n, onto));
+}
+function loadMechRegistry(rootPath) {
+	const regPath = join(rootPath, ".opencode", "skills", TOP_SKILL, "mech-registry.json");
+	if (!existsSync(regPath)) return {};
+	try {
+		const raw = JSON.parse(readFileSync(regPath, "utf-8"));
+		const entries = raw.msms || raw;
+		const result = {};
+		for (const e of Array.isArray(entries) ? entries : Object.values(entries)) if (e.name) result[e.name] = { skill: e.skill || "" };
+		return result;
+	} catch {
+		return {};
+	}
+}
+function cmdVerify(args) {
+	if (args.length === 0) throw new MsmError("PARAMETER_MISSING", "user", "verify requires a file path", { validArgs: ["<path>"] }, "Usage: ontology verify <path> [--level operational|continuity|full]");
+	const filePath = args[0];
+	let level = "operational";
+	for (let i = 1; i < args.length; i++) if (args[i] === "--level" && i + 1 < args.length) {
+		const v = args[i + 1];
+		if (v !== "operational" && v !== "continuity" && v !== "full") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown level: ${v}`, {}, "Use --level operational|continuity|full");
+		level = v;
+		i++;
+	} else if (args[i].startsWith("--level=")) {
+		const v = args[i].slice(8);
+		if (v !== "operational" && v !== "continuity" && v !== "full") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown level: ${v}`, {}, "Use --level operational|continuity|full");
+		level = v;
+	}
+	const runOperational = level === "operational" || level === "full";
+	const runContinuity = level === "continuity" || level === "full";
+	const rootPath = findSerenityRoot();
+	let onto;
+	try {
+		onto = loadOntoFileWithImports(filePath);
+	} catch (err) {
+		onto = loadOntoFile(filePath).onto;
+	}
+	const issues = [];
+	const ontoSkills = new Set(getOntoSkillList(onto));
+	const skillsDir = join(rootPath, ".opencode", "skills");
+	const actualDirs = existsSync(skillsDir) ? readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) : [];
+	const declaredSkills = [];
+	for (const typeName of ontoSkills) {
+		const kebab = pascalToKebab(typeName);
+		declaredSkills.push(kebab);
+		const skillMdPath = join(skillsDir, kebab, "SKILL.md");
+		if (runOperational && !existsSync(skillMdPath)) issues.push({
+			check: "V1",
+			severity: "warning",
+			message: `Ontology declares "${typeName}" but "${kebab}/SKILL.md" not found`
+		});
+	}
+	if (runOperational) {
+		for (const dir of actualDirs) if (!declaredSkills.includes(dir)) issues.push({
+			check: "V2",
+			severity: "warning",
+			message: `Directory ".opencode/skills/${dir}/" exists but no ontology type declares it`
+		});
+	}
+	if (runOperational) {
+		const reg = loadMechRegistry(rootPath);
+		if (Object.keys(reg).length > 0) {
+			for (const [msmName, info] of Object.entries(reg)) if (info.skill) {
+				const kebab = info.skill;
+				if (!declaredSkills.includes(kebab) && !actualDirs.includes(kebab)) {}
+				if (!actualDirs.includes(kebab)) issues.push({
+					check: "V3",
+					severity: "error",
+					message: `MSM "${msmName}" registered under skill "${kebab}" but directory not found`
+				});
+			}
+		} else issues.push({
+			check: "V3",
+			severity: "info",
+			message: "No mech-registry.json found — MSM registration check skipped (MSMs managed by ACC at runtime)"
+		});
+	}
+	if (runContinuity) {
+		const sessionsDir = join(rootPath, "AGENT_SESSIONS");
+		if (existsSync(sessionsDir)) {
+			const sessionDirs = readdirSync(sessionsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+			const goals = [];
+			for (const sd of sessionDirs) {
+				const smPath = join(sessionsDir, sd, "SESSION.md");
+				if (existsSync(smPath)) try {
+					const goalMatch = readFileSync(smPath, "utf-8").match(/## Goal\n(.+)/);
+					if (goalMatch) goals.push(goalMatch[1].trim());
+				} catch {}
+			}
+			const seen = /* @__PURE__ */ new Set();
+			for (const g of goals) {
+				if (seen.has(g)) issues.push({
+					check: "V4",
+					severity: "warning",
+					message: `Duplicate session goal: "${g}" — potential entropy duplication`
+				});
+				seen.add(g);
+			}
+			issues.push({
+				check: "V4",
+				severity: sessionDirs.length > 100 ? "warning" : "info",
+				message: `Session count: ${sessionDirs.length} — ` + (sessionDirs.length > 100 ? "consider archiving old sessions to reduce H_op" : "within normal range")
+			});
+			let staleCount = 0;
+			for (const sd of sessionDirs) {
+				const smPath = join(sessionsDir, sd, "SESSION.md");
+				if (existsSync(smPath)) try {
+					readFileSync(smPath);
+				} catch {
+					staleCount++;
+				}
+			}
+		}
+	}
+	emit(`\nOntology Compliance Verification: ${onto.name || filePath}\n`);
+	emit("=".repeat(60) + "\n");
+	emit(`Level: ${level}\n`);
+	emit(`Ontology skills declared: ${ontoSkills.size}\n`);
+	emit(`Actual skill dirs found: ${actualDirs.length}\n\n`);
+	if (issues.length === 0) {
+		emit("All compliance checks passed.\n");
+		return;
+	}
+	const errors = issues.filter((i) => i.severity === "error");
+	const warnings = issues.filter((i) => i.severity === "warning");
+	const info = issues.filter((i) => i.severity === "info");
+	emit(`Errors: ${errors.length}, Warnings: ${warnings.length}, Info: ${info.length}\n\n`);
+	for (const issue of issues) emit(`  ${issue.severity === "error" ? "ERR" : issue.severity === "warning" ? "WRN" : "INF"} [${issue.check}] ${issue.message}\n`);
+	if (errors.length > 0) throw new MsmError("ONTO_VALIDATION_FAILED", "user", `Compliance verification found ${errors.length} error(s)`, {
+		errors: errors.length,
+		warnings: warnings.length
+	}, "Fix the errors listed above");
+}
+const REVIEW_DIMENSIONS = [
+	{
+		id: "D1",
+		name: "Type Semantics",
+		description: "Are type names, descriptions, and domain boundaries clear and correct?",
+		checklist: [
+			"Are all type names unambiguous within the domain vocabulary?",
+			"Do descriptions clearly demarcate what IS and IS NOT an instance of this type?",
+			"Are there types that should be split into finer-grained subtypes (under-modeled)?",
+			"Are there types that should be merged (over-modeled, redundant distinctions)?",
+			"Are type names consistent with domain conventions (e.g. singular nouns, no verb phrases)?"
+		]
+	},
+	{
+		id: "D2",
+		name: "Taxonomy Quality",
+		description: "Is the subclass hierarchy logically sound and semantically defensible?",
+		checklist: [
+			"Does every superType relation satisfy the 'is-a' test (every X is-a Y in all contexts)?",
+			"Are there missing superType links (concepts that should be generalized)?",
+			"Are there incorrect superType links (passes structural check but fails semantic 'is-a')?",
+			"Are types that should be disjoint from each other declared as disjoint?",
+			"Does the taxonomy depth justify itself (3-7 levels is typical for domain ontologies)?"
+		]
+	},
+	{
+		id: "D3",
+		name: "Rigidity Audit",
+		description: "Is every rigidity assignment (rigid/anti-rigid/semi-rigid) justified?",
+		checklist: [
+			"For each 'rigid' type: would removing this property destroy the entity's identity?",
+			"For each 'anti-rigid' type: is it a role/stage/state that the same entity can stop being?",
+			"For types with no rigidity label: what should it be and why?",
+			"Does the rigidity inheritance hold — is any child more rigid than its parent? (M3 catches this)",
+			"Are there 'semi-rigid' types where rigid or anti-rigid would be more appropriate?"
+		]
+	},
+	{
+		id: "D4",
+		name: "Identity Criteria",
+		description: "Are identity criteria sufficient to guarantee uniqueness for rigid types?",
+		checklist: [
+			"For each rigid type: do the identity keys actually guarantee uniqueness?",
+			"Are identity keys external (natural keys like NHS number) or internal (surrogate)? Prefer natural.",
+			"Are there types that depend on mutable properties for identity (anti-pattern)?",
+			"For types with a single identity property: could there be edge cases where it's not unique?",
+			"Are identity criteria inherited correctly from superTypes?"
+		]
+	},
+	{
+		id: "D5",
+		name: "Relation Semantics",
+		description: "Do relations accurately model real-world connections between entities?",
+		checklist: [
+			"Does every relation have a clear real-world interpretation (not just a technical link)?",
+			"Are domain and range constraints correct — could any non-domain instance legitimately participate?",
+			"Are property characteristics (functional/transitive/symmetric/etc.) consistent with reality?",
+			"Are there missing relations between types that should be connected?",
+			"Do cardinality constraints match what's physically possible in the domain?"
+		]
+	},
+	{
+		id: "D6",
+		name: "Axiom Completeness & Correctness",
+		description: "Do axioms capture the right constraints, and are there gaps?",
+		checklist: [
+			"Are all axioms logically sound (no contradictions, no tautologies)?",
+			"Are there missing temporal constraints (sequencing rules like 'discharge must follow admission')?",
+			"Are there missing state constraints (mutual exclusion, preconditions, invariants)?",
+			"Are there missing dependency constraints (an entity's existence depends on another)?",
+			"Are there missing cardinality constraints on the instance level (not just relation level)?",
+			"Do axioms reference only defined types and relations (M9 catches this)?"
+		]
+	},
+	{
+		id: "D7",
+		name: "Domain Completeness",
+		description: "What important concepts or constraints are missing from this ontology?",
+		checklist: [
+			"What real-world entities in this domain have NOT been modeled?",
+			"What relationships between existing types are unrepresented?",
+			"What temporal aspects (lifecycle stages, state machines) are missing?",
+			"What edge cases (exceptions, rare events) should be representable?",
+			"Is the ontology wide enough for its stated purpose, or too narrow?",
+			"Is it deep enough (sufficient type granularity), or too shallow?"
+		]
+	},
+	{
+		id: "D8",
+		name: "OntoClean Deep Review",
+		description: "Apply OntoClean meta-property analysis to the full taxonomy.",
+		checklist: [
+			"Identity (+I/-I): For each sortal type, what is the identity criterion? Is it consistent down the hierarchy?",
+			"Unity (+U/~U/-U): Can all instances form wholes? Any anti-unity types (e.g. 'pile of sand')?",
+			"Rigidity inheritance: Run the full OntoClean constraint checker — rigid types cannot subsume anti-rigid.",
+			"Dependence (+D/-D): Does any type's existence necessarily imply another type's existence?",
+			"Sortal vs. Non-sortal: Are there types that should be non-sortal (no identity criteria possible)?",
+			"Backbone taxonomy: Does the rigid-only backbone form a consistent tree?"
+		]
+	}
+];
+function cmdReview(args) {
+	if (args.length === 0) throw new MsmError("PARAMETER_MISSING", "user", "review requires a file path", { validArgs: ["<path>"] }, "Usage: ontology review <path> [--level semantic|onto-clean|full] [--format prompt|json]");
+	const filePath = args[0];
+	let level = "full";
+	let format = "prompt";
+	for (let i = 1; i < args.length; i++) if (args[i] === "--level" && i + 1 < args.length) {
+		const v = args[i + 1];
+		if (v !== "semantic" && v !== "onto-clean" && v !== "full") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown level: ${v}`, {
+			level: v,
+			valid: [
+				"semantic",
+				"onto-clean",
+				"full"
+			]
+		});
+		level = v;
+		i++;
+	} else if (args[i].startsWith("--level=")) {
+		const v = args[i].slice(8);
+		if (v !== "semantic" && v !== "onto-clean" && v !== "full") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown level: ${v}`);
+		level = v;
+	} else if (args[i] === "--format" && i + 1 < args.length) {
+		const v = args[i + 1];
+		if (v !== "prompt" && v !== "json") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown format: ${v}`);
+		format = v;
+		i++;
+	} else if (args[i].startsWith("--format=")) {
+		const v = args[i].slice(9);
+		if (v !== "prompt" && v !== "json") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown format: ${v}`);
+		format = v;
+	} else if (args[i].startsWith("-")) throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown flag: ${args[i]}`);
+	const { onto } = loadOntoFile(filePath);
+	const merged = onto.imports && onto.imports.length > 0 ? loadOntoFileWithImports(filePath) : onto;
+	let dimensions;
+	if (level === "semantic") dimensions = REVIEW_DIMENSIONS.filter((d) => parseInt(d.id.slice(1)) <= 6);
+	else if (level === "onto-clean") dimensions = REVIEW_DIMENSIONS.filter((d) => d.id === "D7" || d.id === "D8");
+	else dimensions = REVIEW_DIMENSIONS;
+	if (format === "json") {
+		const types = merged.types || {};
+		const relations = merged.relations || {};
+		const axioms = merged.axioms || [];
+		const out = {
+			ontology: {
+				name: onto.name || filePath,
+				version: onto.version,
+				imports: onto.imports || [],
+				types: Object.entries(types).map(([n, t]) => ({
+					name: n,
+					description: t.description,
+					superTypes: t.superTypes,
+					rigidity: t.rigidity,
+					identity: t.identity,
+					dependsOn: t.dependsOn,
+					properties: t.properties
+				})),
+				relations: Object.entries(relations).map(([n, r]) => ({
+					name: n,
+					...r
+				})),
+				axioms
+			},
+			reviewLevel: level,
+			dimensions: dimensions.map((d) => ({
+				id: d.id,
+				name: d.name,
+				checklist: d.checklist
+			})),
+			instruction: "For each checklist item in each dimension, provide: {severity: 'P0'|'P1'|'P2'|'P3', finding: string, location: string, evidence: string, suggestion: string}"
+		};
+		emit(JSON.stringify(out, null, 2) + "\n");
+		return;
+	}
+	const types = merged.types || {};
+	const relations = merged.relations || {};
+	const axioms = merged.axioms || [];
+	emit(`# Ontology Semantic Review\n`);
+	emit(`**Ontology**: ${onto.name || filePath}\n`);
+	if (onto.version) emit(`**Version**: ${onto.version}\n`);
+	if (onto.imports && onto.imports.length > 0) emit(`**Imports**: ${onto.imports.join(", ")}\n`);
+	emit(`**Review Level**: ${level}\n\n`);
+	emit(`## Context: Ontology to Review\n\n`);
+	emit(`### Types (${Object.keys(types).length})\n\n`);
+	emit("| Type | SuperTypes | Rigidity | Identity | Properties |\n");
+	emit("|------|-----------|----------|----------|------------|\n");
+	for (const [name, td] of Object.entries(types)) emit(`| ${name} | ${(td.superTypes || []).join(", ") || "-"} | ${td.rigidity || "-"} | ${(td.identity || []).join(", ") || "-"} | ${td.properties ? Object.keys(td.properties).join(", ") : "-"} |\n`);
+	if (Object.keys(relations).length > 0) {
+		emit(`\n### Relations\n\n`);
+		emit("| Name | Domain | Range | Cardinality | Flags |\n");
+		emit("|------|--------|-------|-------------|-------|\n");
+		for (const [name, rd] of Object.entries(relations)) {
+			const flags = [];
+			if (rd.functional) flags.push("functional");
+			if (rd.transitive) flags.push("transitive");
+			if (rd.symmetric) flags.push("symmetric");
+			emit(`| ${name} | ${rd.domain || "-"} | ${rd.range || "-"} | ${rd.cardinality || "-"} | ${flags.join(", ") || "-"} |\n`);
+		}
+	}
+	if (axioms.length > 0) {
+		emit(`\n### Axioms (${axioms.length})\n\n`);
+		for (const ax of axioms) emit(`- \`${ax.rule}\` — ${ax.description || "(no description)"} [${ax.type || "rule"}]\n`);
+	}
+	emit(`\n### Type Hierarchy\n\n`);
+	for (const [name, td] of Object.entries(types)) if (td.superTypes && td.superTypes.length > 0) emit(`- ${td.superTypes.join(", ")} → ${name}\n`);
+	emit(`\n---\n\n`);
+	emit(`## Review Dimensions (${dimensions.length})\n\n`);
+	emit(`Review this ontology systematically. For each dimension, examine every checklist item.\n`);
+	emit(`Classify findings by severity:\n`);
+	emit(`- **P0 (Critical)**: Would cause incorrect behavior, data corruption, or violates domain laws\n`);
+	emit(`- **P1 (High)**: Makes the ontology misleading or unusable for its stated purpose\n`);
+	emit(`- **P2 (Medium)**: Reduces quality, clarity, or reusability\n`);
+	emit(`- **P3 (Low)**: Minor improvement or style concern\n\n`);
+	for (const dim of dimensions) {
+		emit(`### ${dim.id}: ${dim.name}\n\n`);
+		emit(`${dim.description}\n\n`);
+		emit("**Checklist**:\n\n");
+		for (let ci = 0; ci < dim.checklist.length; ci++) emit(`${ci + 1}. ${dim.checklist[ci]}\n`);
+		emit(`\n`);
+	}
+	emit(`---\n\n`);
+	emit(`## Expected Output Format\n\n`);
+	emit(`For each finding, produce a row in this format:\n\n`);
+	emit("| Dimension | Severity | Type/Relation/Axiom | Finding | Evidence | Suggestion |\n");
+	emit("|-----------|----------|---------------------|---------|----------|------------|\n\n");
+	emit(`At the end, provide a summary section:\n`);
+	emit("1. **Top 3 issues** — most critical findings that MUST be addressed\n");
+	emit("2. **Ontology health assessment** — overall quality rating (A-F) with justification\n");
+	emit("3. **Recommendations** — ordered list of concrete changes\n");
+}
+function cmdCompliance(args) {
+	if (args.length === 0) throw new MsmError("PARAMETER_MISSING", "user", "compliance requires a file path", { validArgs: ["<path>"] }, "Usage: ontology compliance <path> [--skills <dir>] [--format prompt|json]");
+	const filePath = args[0];
+	let skillsDir = resolve(BASE, ".opencode", "skills");
+	let format = "prompt";
+	for (let i = 1; i < args.length; i++) if (args[i] === "--skills" && i + 1 < args.length) {
+		skillsDir = resolve(BASE, args[i + 1]);
+		i++;
+	} else if (args[i].startsWith("--skills=")) skillsDir = resolve(BASE, args[i].slice(9));
+	else if (args[i] === "--format" && i + 1 < args.length) {
+		const v = args[i + 1];
+		if (v !== "prompt" && v !== "json") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown format: ${v}`);
+		format = v;
+		i++;
+	} else if (args[i].startsWith("--format=")) {
+		const v = args[i].slice(9);
+		if (v !== "prompt" && v !== "json") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown format: ${v}`);
+		format = v;
+	} else if (args[i].startsWith("-")) throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown flag: ${args[i]}`);
+	let skillNames = [];
+	if (existsSync(skillsDir)) skillNames = readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+	const { onto } = loadOntoFile(filePath);
+	const merged = onto.imports && onto.imports.length > 0 ? loadOntoFileWithImports(filePath) : onto;
+	const axioms = merged.axioms || [];
+	const types = merged.types || {};
+	merged.relations;
+	const typeNames = new Set(Object.keys(types));
+	const skillTypeNames = /* @__PURE__ */ new Set();
+	const skillSubtypeNames = /* @__PURE__ */ new Set();
+	for (const [name, td] of Object.entries(types)) if (name === "Skill" || name.endsWith("Skill")) {
+		skillTypeNames.add(name);
+		for (const [sn, sd] of Object.entries(types)) if (sd.superTypes?.includes(name)) skillSubtypeNames.add(sn);
+	}
+	if (skillTypeNames.size === 0) for (const name of typeNames) skillTypeNames.add(name);
+	const checks = [];
+	for (let ai = 0; ai < axioms.length; ai++) {
+		const ax = axioms[ai];
+		if (!ax.rule || ax.rule.trim() === "") continue;
+		const ruleText = ax.rule;
+		const { tokens, errors: tokErrors } = tokenize(ax.rule);
+		if (tokErrors.length > 0) continue;
+		const parser = new AxiomParser(tokens);
+		const result = parser.parse();
+		if (!result.ast || parser.errors.length > 0) continue;
+		const refs = collectRefs(result.ast);
+		const axiomTypeRefs = refs.filter((r) => r.kind === "type").map((r) => r.name);
+		refs.filter((r) => r.kind === "property").map((r) => r.name);
+		let targets = [];
+		let pattern = "unknown";
+		if (axiomTypeRefs.filter((t) => skillTypeNames.has(t) || skillSubtypeNames.has(t)).length > 0) {
+			pattern = "universal-skill";
+			if (skillNames.length > 0) targets = [...skillNames];
+			else targets = ["*"];
+		}
+		for (const ref of refs) if (ref.kind === "unknown" && ref.name === "skillDependsOn") {
+			/**
+			* 只为每条依赖子句取**第一参数**（= 声明义务承担方）。
+			*
+			* 2026-09-14 S188 修（缺陷④）：旧实现把 `skillDependsOn(A, B)` 的两端都收进 targets，
+			* 于是按生成指引逐 target 审会得到一半**方向错误的伪 Fail**（如"home-memory 未声明
+			* 依赖 zhaocai-memory"——B 端根本不欠任何声明）。同时修缺陷⑤：合取式
+			* （`dependsOn(X,A) and dependsOn(X,B)`）里 X 出现两次，旧实现不去重。
+			*/
+			function findDependsOnDeclarers(node) {
+				if (!node) return [];
+				switch (node.kind) {
+					case "funcCall":
+						if (node.name === "skillDependsOn" && node.args.length >= 1) {
+							const a = node.args[0];
+							return [a.kind === "propAccess" ? a.path.join(".") : ""];
+						}
+						return node.args.flatMap(findDependsOnDeclarers);
+					case "quantifier": return findDependsOnDeclarers(node.body);
+					case "binaryOp": return [...findDependsOnDeclarers(node.left), ...findDependsOnDeclarers(node.right)];
+					case "unaryOp": return findDependsOnDeclarers(node.operand);
+					case "implication": return [...findDependsOnDeclarers(node.antecedent), ...findDependsOnDeclarers(node.consequent)];
+					case "parens": return findDependsOnDeclarers(node.expr);
+					default: return [];
+				}
+			}
+			const depArgs = findDependsOnDeclarers(result.ast);
+			/**
+			* 2026-09-14 S188 修（缺陷③）：旧实现用 `pascalToKebab(a) === s` 做**过滤**，
+			* 却输出 `a`（原 PascalCase 类名），导致生成的 verification 路径
+			* `.opencode/skills/HomeMemory/SKILL.md` **根本不存在**。此处输出**匹配到的目录名**。
+			*/
+			const renameMap = /* @__PURE__ */ new Map();
+			for (const s of skillNames) renameMap.set(pascalToKebab(s), s);
+			const depTarget = Array.from(new Set(depArgs.filter((a) => !!a).map((a) => skillNames.includes(a) ? a : renameMap.get(pascalToKebab(a))).filter((s) => !!s)));
+			if (depTarget.length > 0) {
+				pattern = "specific-dependency";
+				targets = depTarget;
+			}
+			break;
+		}
+		if (/forall\s+\w+\s+in\s+Skill\b/.test(ruleText) && skillNames.length > 0) targets = [...skillNames];
+		targets = Array.from(new Set(targets));
+		if (ruleText.includes("skillPrecedes") || ruleText.includes("precedes")) pattern = "precedence";
+		const mentionsThisFile = /\bthisFile\b/.test(ruleText) || /本(文件|注册表)/.test(ax.description || "");
+		const mentionsMsmInventory = /MSMInventory|MSM 清单|mech-registry/.test(ruleText + (ax.description || "")) || /forall\s+\w+\s+in\s+MSM\b/.test(ruleText);
+		let verification = "";
+		let question = "";
+		if (mentionsThisFile || mentionsMsmInventory) {
+			const subject = mentionsMsmInventory ? `MSM 注册表（.opencode/skills/${TOP_SKILL}/references/mech-registry.json）` : "本注册表文件自身";
+			pattern = "self-check";
+			targets = [subject];
+			question = `Does ${subject} satisfy this axiom?`;
+			verification = `Read ${subject}，核对该约束（**不是**读 skill 文档）`;
+		} else if (ax.type === "structural" || ruleText.includes("Skill.hasSkillMd") || ruleText.includes("SKILL.md")) {
+			pattern = "structural-hasSkillMd";
+			if (targets.length === 0 || targets[0] === "*") targets = skillNames.length > 0 ? [...skillNames] : ["*"];
+			question = `Does this skill have a SKILL.md file?`;
+			verification = `Check if .opencode/skills/{skill}/SKILL.md exists`;
+		} else if (ax.type === "dependency" || pattern === "specific-dependency") {
+			question = `Is this dependency declared in the skill's SKILL.md?`;
+			verification = `Read .opencode/skills/{skill}/SKILL.md, check \"相关技能\" / \"Related Skills\" section for the required dependency`;
+		} else if (ax.type === "cce" || ax.type === "eap") {
+			question = `Does this skill's implementation satisfy the CCE/EAP constraint?`;
+			verification = `Read .opencode/skills/{skill}/SKILL.md and references/, evaluate against the axiom`;
+			pattern = pattern === "unknown" ? ax.type : pattern;
+		} else if (ax.type === "constraint" || ax.type === "domain") {
+			question = `Does this skill satisfy the constraint?`;
+			verification = `Read .opencode/skills/{skill}/SKILL.md and check constraint compliance`;
+		} else if (pattern === "universal-skill") {
+			question = `Does this skill satisfy the axiom?`;
+			verification = `Read .opencode/skills/{skill}/SKILL.md, evaluate compliance`;
+		} else {
+			question = `Is this axiom satisfied?`;
+			verification = `Read relevant skill files and evaluate`;
+		}
+		let severity = "P1";
+		if (ax.type === "structural") severity = "P0";
+		else if (ax.type === "cce") severity = "P0";
+		else if (ruleText.includes("Skill.hasSkillMd")) severity = "P0";
+		else if (ruleText.includes("not exists")) severity = "P1";
+		else if (ax.type === "eap") severity = "P2";
+		if (targets.length === 0) continue;
+		/**
+		* 2026-09-14 S188 修（缺陷①）：检查 ID 由**位置派生**（`C{axiomIndex+1}`）改为
+		* **规则文本稳定哈希**。
+		*
+		* 旧行为之害（实测）：axiom 集合是 `cce ← ccc ← serenity-skills` 三者合并，
+		* 注册表一增删公理，**全体 ID 平移** —— v0.2.0（55 公理/33 检查）与 v0.3.0（53/29）
+		* 之间，同一字母数字指向不同公理；历史报告引用的 C055 在现行清单中已不存在。
+		* 任何「关闭 C0xx」式的跨会话交接都会失准。
+		*
+		* 新 ID = `C-` + 规则文本 sha256 前 6 位十六进制：与公理内容绑定，与顺序无关；
+		* 同一规则在任意版本生成同一 ID，跨报告可比。旧的**序号**另存为 `axiomIndex` 字段
+		* （仅供排序/展示，不用于引用）。
+		*/
+		const idHash = createHash("sha256").update(ax.rule.trim().replace(/\s+/g, " ")).digest("hex").slice(0, 6);
+		checks.push({
+			id: `C-${idHash}`,
+			axiomIndex: ai,
+			axiomRule: ax.rule,
+			axiomDescription: ax.description || "(no description)",
+			axiomType: ax.type || "rule",
+			pattern,
+			severity,
+			targets,
+			question,
+			verification
+		});
+	}
+	/**
+	* 2026-09-14 S188 修（缺陷①收尾）：按**规范化规则**去重。
+	*
+	* 为什么要去重而不是保留重复项：ID 现在绑定规则文本，重复公理会产生**同名 ID 的两条
+	* 检查**——对下游审计是毒药（同一 ID 两条记录，无法引用）。去重后「一个 ID = 一条公理」，
+	* 冗余则通过 stderr 显式报告，交给注册表维护者决定是否清理（不静默吞掉）。
+	*/
+	const byRule = /* @__PURE__ */ new Map();
+	const dupReports = [];
+	for (const c of checks) {
+		const key = c.axiomRule.trim().replace(/\s+/g, " ");
+		const prev = byRule.get(key);
+		if (prev) {
+			dupReports.push(`  ${c.id}  重复公理：${c.axiomRule}`);
+			prev.targets = Array.from(/* @__PURE__ */ new Set([...prev.targets, ...c.targets]));
+			continue;
+		}
+		byRule.set(key, c);
+	}
+	const dedupedChecks = Array.from(byRule.values());
+	if (dupReports.length > 0) emitErr(`[compliance] 警告：注册表内存在 ${dupReports.length} 条重复公理（同一规则写了多遍）。\n已按规则合并为单一检查项；建议清理注册表以消除冗余：\n` + dupReports.join("\n") + "\n");
+	checks.length = 0;
+	checks.push(...dedupedChecks);
+	if (format === "json") {
+		const output = {
+			ontology: merged.name || filePath,
+			skills_dir: skillsDir,
+			skill_count: skillNames.length,
+			axiom_count: axioms.length,
+			check_count: checks.length,
+			checks: checks.map((c) => ({
+				...c,
+				targets: c.targets.filter((t) => t !== "*")
+			}))
+		};
+		emit(JSON.stringify(output, null, 2) + "\n");
+		return;
+	}
+	emit(`# Compliance Checklist — ${merged.name || filePath}\n\n`);
+	emit(`**Generated by ontology-engineering compliance**\n\n`);
+	emit(`- Skills directory: \`${skillsDir}\`\n`);
+	emit(`- Skills found: ${skillNames.length}\n`);
+	emit(`- Axioms analyzed: ${axioms.length}\n`);
+	emit(`- Compliance checks generated: ${checks.length}\n\n`);
+	emit(`---\n\n`);
+	emit(`## Instructions for Subagent\n\n`);
+	emit(`You are auditing skill implementations against an ontology. For each check item:\n\n`);
+	emit(`1. **Read the relevant files** as specified in the verification column\n`);
+	emit(`2. **Determine pass/fail** based on evidence from the files\n`);
+	emit(`3. **Report** in table format: Check ID | Skill | Pass/Fail | Evidence | Notes\n\n`);
+	emit(`---\n\n`);
+	emit(`## Checks\n\n`);
+	const byTarget = /* @__PURE__ */ new Map();
+	for (const c of checks) for (const t of c.targets) {
+		const key = t === "*" ? "ALL" : t;
+		if (!byTarget.has(key)) byTarget.set(key, []);
+		byTarget.get(key).push(c);
+	}
+	for (const [target, items] of byTarget.entries()) {
+		emit(`### ${target === "ALL" ? "All Skills" : target}\n\n`);
+		emit("| ID | Severity | Pattern | Axiom | What to Verify |\n");
+		emit("|----|----------|---------|-------|----------------|\n");
+		for (const item of items) {
+			const axShort = item.axiomDescription.length > 60 ? item.axiomDescription.slice(0, 57) + "..." : item.axiomDescription;
+			const verifyShort = item.verification.length > 80 ? item.verification.slice(0, 77) + "..." : item.verification;
+			emit(`| ${item.id} | **${item.severity}** | ${item.pattern} | ${axShort} | ${verifyShort} |\n`);
+		}
+		emit("\n");
+		for (const item of items) {
+			emit(`<details>\n<summary>**${item.id}** — ${item.axiomDescription}</summary>\n\n`);
+			emit(`- **Axiom:** \`${item.axiomRule}\`\n`);
+			emit(`- **Type:** ${item.axiomType}\n`);
+			emit(`- **Severity:** ${item.severity}\n`);
+			emit(`- **Target skills:** ${item.targets.join(", ")}\n\n`);
+			emit(`**Verification:** ${item.verification}\n\n`);
+			if (item.targets.length === 1 && item.targets[0] !== "*") emit(`**File path:** \`${item.verification.replace(/\{skill\}/g, item.targets[0])}\`\n\n`);
+			emit(`</details>\n\n`);
+		}
+	}
+	emit(`---\n\n`);
+	emit(`## Summary\n\n`);
+	emit(`- **P0 (blocking):** ${checks.filter((c) => c.severity === "P0").length} checks\n`);
+	emit(`- **P1 (important):** ${checks.filter((c) => c.severity === "P1").length} checks\n`);
+	emit(`- **P2 (nice-to-have):** ${checks.filter((c) => c.severity === "P2").length} checks\n`);
+}
+function rejectProtocolFlags(args) {
+	for (const arg of args) if (arg === "--json" || arg === "--help" || arg === "-h" || arg === "--log") throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Business MSM does not accept protocol flag: ${arg}`, {
+		arg,
+		validSubcommands: [
+			"init",
+			"check",
+			"explain",
+			"verify",
+			"review",
+			"compliance"
+		]
+	}, "Use the `ontology` tool (see its description for flags) — e.g. ontology(command=\"check\", path=…)");
+}
+const VALID_SUBCOMMANDS = [
+	"init",
+	"check",
+	"explain",
+	"verify",
+	"review",
+	"compliance"
+];
+function dispatch$1(argv) {
+	if (argv.length === 0) throw new MsmError("PARAMETER_MISSING", "user", "Missing subcommand", { validSubcommands: VALID_SUBCOMMANDS }, "Usage: ontology <init|check|explain|verify|review|compliance> [args...]");
+	rejectProtocolFlags(argv);
+	const subcommand = argv[0];
+	const subArgs = argv.slice(1);
+	switch (subcommand) {
+		case "init":
+			cmdInit(subArgs);
+			return 0;
+		case "check":
+			cmdCheck(subArgs);
+			return 0;
+		case "explain":
+			cmdExplain(subArgs);
+			return 0;
+		case "verify":
+			cmdVerify(subArgs);
+			return 0;
+		case "review":
+			cmdReview(subArgs);
+			return 0;
+		case "compliance":
+			cmdCompliance(subArgs);
+			return 0;
+		default: throw new MsmError("PARAMETER_INVALID_VALUE", "user", `Unknown subcommand: ${subcommand}`, {
+			subcommand,
+			validSubcommands: VALID_SUBCOMMANDS
+		}, "Usage: ontology <init|check|explain|verify|review|compliance> [args...]");
+	}
+}
+/**
+* runOntologyCli —— 同步跑一次引擎调用，**返回**输出与退出码（不打印、不退出）。
+*
+* 调用方（工具壳 `src/tools/ontology-eng.ts`）负责：路径守卫（必须落在 CCC 内）、
+* 以及把 `code !== 0` 翻成响亮的回执（引擎的 stderr 文案**逐字保留**，不重写）。
+*/
+function runOntologyCli(argv, opts = {}) {
+	let out = "";
+	let err = "";
+	const prevOut = OUT;
+	const prevErr = ERR;
+	const prevRoot = ROOT;
+	const prevTopSkill = TOP_SKILL;
+	const prevSr = SR;
+	const prevBase = BASE;
+	OUT = { write: (s) => {
+		out += s;
+	} };
+	ERR = { write: (s) => {
+		err += s;
+	} };
+	let code = 0;
+	try {
+		if (opts.cwd !== void 0) {
+			ROOT = opts.cwd;
+			BASE = opts.cwd;
+		}
+		if (opts.topSkill !== void 0) TOP_SKILL = opts.topSkill;
+		if (opts.namespace !== void 0) SR = opts.namespace;
+		code = dispatch$1(argv);
+	} catch (e) {
+		if (e instanceof MsmError) {
+			emitError(e);
+			code = e.exitCode();
+		} else {
+			const ie = e instanceof Error ? e : new Error(String(e));
+			const fallback = new MsmError("INTERNAL_UNHANDLED_STATE", "internal", `Unhandled exception: ${ie.message}`, { stack: ie.stack }, "Report this bug to the Agent", ie);
+			emitError(fallback);
+			code = fallback.exitCode();
+		}
+	} finally {
+		BASE = prevBase;
+		ROOT = prevRoot;
+		TOP_SKILL = prevTopSkill;
+		SR = prevSr;
+		OUT = prevOut;
+		ERR = prevErr;
+	}
+	return {
+		code,
+		stdout: out,
+		stderr: err
+	};
+}
+//#endregion
+//#region src/tools/ontology-eng.ts
+/**
+* ontology-eng.ts（工具面）— 本体工程**引擎**（v1.52.0，S142 D121）
+*
+* 来源：宁静号 CCC 的 MSM `ontology-engineering`，owner 2026-10-11 裁「**搬到 ACC**」。
+* 判据：ACC 侧此前只有 `praxis ontology` 的**文本手册**（说得出判据 M1–M10 的编号与含义），
+* 却**一行可执行代码都没有** —— 能真跑 `check/verify/compliance` 的是引擎，不是手册。
+*
+* 🔴 **三段分工，别混**：
+*   · **引擎** `src/ontology/engine.ts` —— 解析 Turtle、M1–M10 结构检查、L1–L5 提示、
+*     V1–V4 运行时合规、review/compliance 提示词生成。纯函数、只用 node 内建模块。
+*   · **本文件（工具壳）** —— 参数 → argv、**路径守卫**、把 `(code, stdout, stderr)` 翻成回执。
+*   · **方法手册** `src/tools/ontology.ts`（praxis 第四段）—— 给人/模型读的"怎么做本体工程"。
+*
+* 🔴 **为什么路径必须先过 `resolveInside`**：引擎会 `process.chdir(cccRoot)` 再按路径读写，
+*   且 `init` **会写文件** ⇒ 入参路径不先证"在容器内"，就等于绕过 CCC 边界（P3）。
+*
+* 🔴 **退出码是返回值不是进程退出**（搬迁改写 ②）：引擎不再 `process.exit`，
+*   本壳把 `code !== 0` 连同引擎**逐字保留**的 stderr 文案一起回执（不重写引擎的报错）。
+*/
+const COMMANDS = [
+	"init",
+	"check",
+	"explain",
+	"verify",
+	"review",
+	"compliance"
+];
+const LEVELS = [
+	"normal",
+	"strict",
+	"operational",
+	"continuity",
+	"full",
+	"semantic",
+	"onto-clean"
+];
+const TEMPLATES = ["minimal", "full"];
+const FORMATS = ["prompt", "json"];
+/** 各子命令接受的 level 取值（否则引擎会以 PARAMETER_INVALID_VALUE 拒掉——这里先拦，报错更直白） */
+const LEVELS_BY_COMMAND = {
+	check: ["normal", "strict"],
+	verify: [
+		"operational",
+		"continuity",
+		"full"
+	],
+	review: [
+		"semantic",
+		"onto-clean",
+		"full"
+	]
+};
+function renderText$5(value) {
+	return [{
+		type: "text",
+		text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+	}];
+}
+/**
+* 把引擎结果翻成**一段文本回执**（本工具返回 string —— 见 `schema: 'string'` 的理由）。
+*
+* 🔴 **为什么返回字符串而不是 JSON 对象**：引擎的报告是**多行 Markdown 式**（表格 ＋ 逐条 ERR/WRN），
+*   走 `schema:'json'` 会被 `JSON.stringify` 把换行转义成 `\n` ⇒ 模型读到的是**一坨转义串**，
+*   可读性直接没了。字符串形态还能原样保留引擎文案（"逐字"是搬迁的硬要求）。
+*   退出码印在**首行**（回执自带判据，不必让调用方去数文本）。
+*/
+function receiptOf(v) {
+	const parts = [`[ontology ${v.command}] ${v.ok ? "✓" : "✗"} exit ${v.code} — ${v.path}`];
+	if (v.stdout.trim() !== "") parts.push(v.stdout.trimEnd());
+	if (!v.ok && v.stderr.trim() !== "") parts.push(v.stderr.trimEnd());
+	if (!v.ok) parts.push(v.code === 1 ? "（exit 1 = 参数或校验失败：修完再跑；引擎的 ERR 行在正文里）" : v.code === 2 ? "（exit 2 = 文件缺失／解析失败：先确认路径与 .ttl 语法）" : "（exit 4 = 引擎内部错误：把上面整段报给 ACC 维护者）");
+	return parts.join("\n\n");
+}
+/**
+* 本体工程引擎（`ontology`）—— 六个子命令：init/check/explain/verify/review/compliance。
+* 只读的五个不写任何文件；`init` 会在容器内**新建** .ttl 模板。
+*/
+function createOntologyTool() {
+	return defineTool({
+		name: "ontology",
+		description: "Ontology engineering engine (parses Turtle .ttl, runs the judgement sets, emits reports). Subcommands: init (write a template) / check (M1-M10 structural validation; level=strict adds L1-L5 hints) / explain (natural-language summary) / verify (V1-V4 runtime compliance: declaration vs reality) / review (semantic review prompt for a read-only subagent; level=semantic|onto-clean|full) / compliance (axiom-vs-skill compliance checklist; skill by skill). path must stay inside this container (relative to the container root, or an absolute path inside it). Exit code is returned in the receipt: 0 = clean, 1 = parameter/validation failure, 2 = file/parse failure, 4 = internal. The engine text is passed through verbatim — read it, do not assume success from the call alone.",
+		parameters: {
+			command: {
+				type: "string",
+				enum: [...COMMANDS],
+				description: "Subcommand: init / check / explain / verify / review / compliance."
+			},
+			path: {
+				type: "string",
+				description: "Path to the .ttl file, inside this container (relative to the container root, or an absolute path that stays inside it)."
+			},
+			level: {
+				type: "string",
+				enum: [...LEVELS],
+				description: "Depth knob, meaning depends on the subcommand: check → normal|strict; verify → operational|continuity|full; review → semantic|onto-clean|full."
+			},
+			template: {
+				type: "string",
+				enum: [...TEMPLATES],
+				description: "init only: template size, minimal (default) or full."
+			},
+			skills: {
+				type: "string",
+				description: "compliance only: skills directory to scan (default .opencode/skills inside the container)."
+			},
+			format: {
+				type: "string",
+				enum: [...FORMATS],
+				description: "review / compliance only: prompt (LLM-readable checklist, default) or json."
+			}
+		},
+		output: {
+			schema: { type: "string" },
+			render: (_args, value) => renderText$5(value)
+		},
+		async execute(args, exec) {
+			const root = cccRootForExec(exec);
+			if (!root) throw new Error(NO_CCC_FROM_AGENT_CWD);
+			const command = typeof args.command === "string" ? args.command.trim() : "";
+			if (!COMMANDS.includes(command)) throw new Error(`ontology: \`command\` must be one of ${COMMANDS.join(" / ")} (got: ${command === "" ? "(missing)" : command})`);
+			const rawPath = typeof args.path === "string" ? args.path.trim() : "";
+			if (rawPath === "") throw new Error("ontology: `path` is required (a .ttl file inside this container)");
+			const absPath = resolveInside(root, rawPath);
+			const relPath = relative(root, absPath) || ".";
+			const argv = [command, absPath];
+			const level = typeof args.level === "string" ? args.level.trim() : "";
+			if (level !== "") {
+				const allowed = LEVELS_BY_COMMAND[command];
+				if (allowed === void 0) throw new Error(`ontology: \`level\` does not apply to \`${command}\` (it applies to: check / verify / review)`);
+				if (!allowed.includes(level)) throw new Error(`ontology: level "${level}" is not valid for \`${command}\` — use one of ${allowed.join(" / ")}`);
+				argv.push("--level", level);
+			}
+			const template = typeof args.template === "string" ? args.template.trim() : "";
+			if (template !== "") {
+				if (command !== "init") throw new Error(`ontology: \`template\` applies to \`init\` only (got command: ${command})`);
+				if (!TEMPLATES.includes(template)) throw new Error(`ontology: template "${template}" is not valid — use one of ${TEMPLATES.join(" / ")}`);
+				argv.push("--template", template);
+			}
+			const format = typeof args.format === "string" ? args.format.trim() : "";
+			if (format !== "") {
+				if (command !== "review" && command !== "compliance") throw new Error(`ontology: \`format\` applies to review / compliance only (got command: ${command})`);
+				if (!FORMATS.includes(format)) throw new Error(`ontology: format "${format}" is not valid — use one of ${FORMATS.join(" / ")}`);
+				argv.push("--format", format);
+			}
+			const skills = typeof args.skills === "string" ? args.skills.trim() : "";
+			if (skills !== "") {
+				if (command !== "compliance") throw new Error(`ontology: \`skills\` applies to \`compliance\` only (got command: ${command})`);
+				argv.push("--skills", resolveInside(root, skills));
+			}
+			const res = runOntologyCli(argv, { cwd: root });
+			return receiptOf({
+				ok: res.code === 0,
+				code: res.code,
+				command,
+				path: relPath,
+				stdout: res.stdout,
+				stderr: res.stderr
+			});
+		}
+	});
+}
+//#endregion
 //#region src/handyman-preset-inherit.ts
 /**
 * 解析 handyman worker 从父 agent 继承的 preset，并组装创建 setup 钩子。
@@ -17696,7 +20531,7 @@ function matchCcc(input, candidates) {
 		error: "empty ccc"
 	};
 	if (trimmed.startsWith("/")) {
-		const root = findSerenityRoot(trimmed);
+		const root = findSerenityRoot$1(trimmed);
 		if (!root) return {
 			ok: false,
 			error: `no CCC found from path: ${trimmed}`,
@@ -20764,6 +23599,7 @@ function apply(ctx, config) {
 		ctx.tools.register(gitTool);
 		ctx.tools.register(msmTool);
 		ctx.tools.register(praxisTool);
+		ctx.tools.register(createOntologyTool());
 		ctx.tools.register(createHandymanTool(ctx));
 		ctx.tools.register(localstoreTool);
 		ctx.tools.register(createContainerAdminTool(ctx));