@systemfsoftware/omp-claude-compat 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryan Lee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,1059 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, extname, isAbsolute, resolve, sep } from "node:path";
+import { execFile } from "node:child_process";
+//#region ../../../node_modules/.pnpm/@jsr+std__collections@1.3.0/node_modules/@jsr/std__collections/deep_merge.js
+/** Default merging options - cached to avoid object allocation on each call */ const DEFAULT_OPTIONS = {
+	arrays: "merge",
+	sets: "merge",
+	maps: "merge"
+};
+function deepMerge(record, other, options) {
+	return deepMergeInternal(record, other, /* @__PURE__ */ new Set(), options ?? DEFAULT_OPTIONS);
+}
+function deepMergeInternal(record, other, seen, options) {
+	const result = {};
+	const keys = /* @__PURE__ */ new Set([...getKeys(record), ...getKeys(other)]);
+	for (const key of keys) {
+		if (key === "__proto__") continue;
+		const a = record[key];
+		if (!Object.hasOwn(other, key)) {
+			result[key] = a;
+			continue;
+		}
+		const b = other[key];
+		if (isNonNullObject(a) && isNonNullObject(b) && !seen.has(a) && !seen.has(b)) {
+			seen.add(a);
+			seen.add(b);
+			result[key] = mergeObjects(a, b, seen, options);
+			continue;
+		}
+		result[key] = b;
+	}
+	return result;
+}
+function mergeObjects(left, right, seen, options) {
+	if (isMergeable(left) && isMergeable(right)) return deepMergeInternal(left, right, seen, options);
+	if (isIterable(left) && isIterable(right)) {
+		if (Array.isArray(left) && Array.isArray(right)) {
+			if (options.arrays === "merge") return left.concat(right);
+			return right;
+		}
+		if (left instanceof Map && right instanceof Map) {
+			if (options.maps === "merge") {
+				const result = new Map(left);
+				for (const [k, v] of right) result.set(k, v);
+				return result;
+			}
+			return right;
+		}
+		if (left instanceof Set && right instanceof Set) {
+			if (options.sets === "merge") {
+				const result = new Set(left);
+				for (const v of right) result.add(v);
+				return result;
+			}
+			return right;
+		}
+	}
+	return right;
+}
+/**
+* Test whether a value is mergeable or not
+* Builtins that look like objects, null and user defined classes
+* are not considered mergeable (it means that reference will be copied)
+*/ function isMergeable(value) {
+	return Object.getPrototypeOf(value) === Object.prototype;
+}
+function isIterable(value) {
+	return typeof value[Symbol.iterator] === "function";
+}
+function isNonNullObject(value) {
+	return value !== null && typeof value === "object";
+}
+function getKeys(record) {
+	const keys = Object.keys(record);
+	const symbols = Object.getOwnPropertySymbols(record);
+	if (symbols.length === 0) return keys;
+	for (const sym of symbols) if (Object.prototype.propertyIsEnumerable.call(record, sym)) keys.push(sym);
+	return keys;
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/@jsr+std__toml@1.0.11/node_modules/@jsr/std__toml/_parser.js
+/**
+* Copy of `import { isLeap } from "@std/datetime";` because it cannot be impoted as long as it is unstable.
+*/ function isLeap(yearNumber) {
+	return yearNumber % 4 === 0 && yearNumber % 100 !== 0 || yearNumber % 400 === 0;
+}
+function success(body) {
+	return {
+		ok: true,
+		body
+	};
+}
+function failure() {
+	return { ok: false };
+}
+/**
+* Creates a nested object from the keys and values.
+*
+* e.g. `unflat(["a", "b", "c"], 1)` returns `{ a: { b: { c: 1 } } }`
+*/ function unflat(keys, values = { __proto__: null }) {
+	return keys.reduceRight((acc, key) => ({ [key]: acc }), values);
+}
+function or(parsers) {
+	return (scanner) => {
+		for (const parse of parsers) {
+			const result = parse(scanner);
+			if (result.ok) return result;
+		}
+		return failure();
+	};
+}
+/** Join the parse results of the given parser into an array.
+*
+* If the parser fails at the first attempt, it will return an empty array.
+*/ function join(parser, separator) {
+	const Separator = character(separator);
+	return (scanner) => {
+		const out = [];
+		const first = parser(scanner);
+		if (!first.ok) return success(out);
+		out.push(first.body);
+		while (!scanner.eof()) {
+			if (!Separator(scanner).ok) break;
+			const result = parser(scanner);
+			if (!result.ok) throw new SyntaxError(`Invalid token after "${separator}"`);
+			out.push(result.body);
+		}
+		return success(out);
+	};
+}
+/** Join the parse results of the given parser into an array.
+*
+* This requires the parser to succeed at least once.
+*/ function join1(parser, separator) {
+	const Separator = character(separator);
+	return (scanner) => {
+		const first = parser(scanner);
+		if (!first.ok) return failure();
+		const out = [first.body];
+		while (!scanner.eof()) {
+			if (!Separator(scanner).ok) break;
+			const result = parser(scanner);
+			if (!result.ok) throw new SyntaxError(`Invalid token after "${separator}"`);
+			out.push(result.body);
+		}
+		return success(out);
+	};
+}
+function kv(keyParser, separator, valueParser) {
+	const Separator = character(separator);
+	return (scanner) => {
+		const position = scanner.position;
+		const key = keyParser(scanner);
+		if (!key.ok) return failure();
+		if (!Separator(scanner).ok) throw new SyntaxError(`key/value pair doesn't have "${separator}"`);
+		const value = valueParser(scanner);
+		if (!value.ok) {
+			const lineEndIndex = scanner.source.indexOf("\n", scanner.position);
+			const endPosition = lineEndIndex > 0 ? lineEndIndex : scanner.source.length;
+			const line = scanner.source.slice(position, endPosition);
+			throw new SyntaxError(`Cannot parse value on line '${line}'`);
+		}
+		return success(unflat(key.body, value.body));
+	};
+}
+function surround(left, parser, right) {
+	const Left = character(left);
+	const Right = character(right);
+	return (scanner) => {
+		if (!Left(scanner).ok) return failure();
+		const result = parser(scanner);
+		if (!result.ok) throw new SyntaxError(`Invalid token after "${left}"`);
+		if (!Right(scanner).ok) throw new SyntaxError(`Not closed by "${right}" after started with "${left}"`);
+		return success(result.body);
+	};
+}
+function character(str) {
+	return (scanner) => {
+		scanner.skipWhitespaces();
+		if (!scanner.startsWith(str)) return failure();
+		scanner.next(str.length);
+		scanner.skipWhitespaces();
+		return success(void 0);
+	};
+}
+const BARE_KEY_REGEXP = /[A-Za-z0-9_-]+/y;
+function bareKey(scanner) {
+	scanner.skipWhitespaces();
+	const key = scanner.match(BARE_KEY_REGEXP)?.[0];
+	if (!key) return failure();
+	scanner.next(key.length);
+	return success(key);
+}
+function escapeSequence(scanner) {
+	if (scanner.char() !== "\\") return failure();
+	scanner.next();
+	switch (scanner.char()) {
+		case "b":
+			scanner.next();
+			return success("\b");
+		case "t":
+			scanner.next();
+			return success("	");
+		case "n":
+			scanner.next();
+			return success("\n");
+		case "f":
+			scanner.next();
+			return success("\f");
+		case "r":
+			scanner.next();
+			return success("\r");
+		case "u":
+		case "U": {
+			const codePointLen = scanner.char() === "u" ? 4 : 6;
+			const codePoint = parseInt("0x" + scanner.slice(1, 1 + codePointLen), 16);
+			const str = String.fromCodePoint(codePoint);
+			scanner.next(codePointLen + 1);
+			return success(str);
+		}
+		case "\"":
+			scanner.next();
+			return success("\"");
+		case "\\":
+			scanner.next();
+			return success("\\");
+		default: throw new SyntaxError(`Invalid escape sequence: \\${scanner.char()}`);
+	}
+}
+function basicString(scanner) {
+	scanner.skipWhitespaces();
+	if (scanner.char() !== "\"") return failure();
+	scanner.next();
+	const acc = [];
+	while (scanner.char() !== "\"" && !scanner.eof()) {
+		if (scanner.char() === "\n") throw new SyntaxError("Single-line string cannot contain EOL");
+		const escapedChar = escapeSequence(scanner);
+		if (escapedChar.ok) acc.push(escapedChar.body);
+		else {
+			acc.push(scanner.char());
+			scanner.next();
+		}
+	}
+	if (scanner.eof()) throw new SyntaxError(`Single-line string is not closed:\n${acc.join("")}`);
+	scanner.next();
+	return success(acc.join(""));
+}
+function literalString(scanner) {
+	scanner.skipWhitespaces();
+	if (scanner.char() !== "'") return failure();
+	scanner.next();
+	const acc = [];
+	while (scanner.char() !== "'" && !scanner.eof()) {
+		if (scanner.char() === "\n") throw new SyntaxError("Single-line string cannot contain EOL");
+		acc.push(scanner.char());
+		scanner.next();
+	}
+	if (scanner.eof()) throw new SyntaxError(`Single-line string is not closed:\n${acc.join("")}`);
+	scanner.next();
+	return success(acc.join(""));
+}
+function multilineBasicString(scanner) {
+	scanner.skipWhitespaces();
+	if (!scanner.startsWith("\"\"\"")) return failure();
+	scanner.next(3);
+	if (scanner.char() === "\n") scanner.next();
+	else if (scanner.startsWith("\r\n")) scanner.next(2);
+	const acc = [];
+	while (!scanner.startsWith("\"\"\"") && !scanner.eof()) {
+		if (scanner.startsWith("\\\n")) {
+			scanner.next();
+			scanner.nextUntilChar({ skipComments: false });
+			continue;
+		} else if (scanner.startsWith("\\\r\n")) {
+			scanner.next();
+			scanner.nextUntilChar({ skipComments: false });
+			continue;
+		}
+		const escapedChar = escapeSequence(scanner);
+		if (escapedChar.ok) acc.push(escapedChar.body);
+		else {
+			acc.push(scanner.char());
+			scanner.next();
+		}
+	}
+	if (scanner.eof()) throw new SyntaxError(`Multi-line string is not closed:\n${acc.join("")}`);
+	if (scanner.char(3) === "\"") {
+		acc.push("\"");
+		scanner.next();
+	}
+	scanner.next(3);
+	return success(acc.join(""));
+}
+function multilineLiteralString(scanner) {
+	scanner.skipWhitespaces();
+	if (!scanner.startsWith("'''")) return failure();
+	scanner.next(3);
+	if (scanner.char() === "\n") scanner.next();
+	else if (scanner.startsWith("\r\n")) scanner.next(2);
+	const acc = [];
+	while (!scanner.startsWith("'''") && !scanner.eof()) {
+		acc.push(scanner.char());
+		scanner.next();
+	}
+	if (scanner.eof()) throw new SyntaxError(`Multi-line string is not closed:\n${acc.join("")}`);
+	if (scanner.char(3) === "'") {
+		acc.push("'");
+		scanner.next();
+	}
+	scanner.next(3);
+	return success(acc.join(""));
+}
+const BOOLEAN_REGEXP = /(?:true|false)\b/y;
+function boolean(scanner) {
+	scanner.skipWhitespaces();
+	const match = scanner.match(BOOLEAN_REGEXP);
+	if (!match) return failure();
+	const string = match[0];
+	scanner.next(string.length);
+	return success(string === "true");
+}
+const INFINITY_MAP = /* @__PURE__ */ new Map([
+	["inf", Infinity],
+	["+inf", Infinity],
+	["-inf", -Infinity]
+]);
+const INFINITY_REGEXP = /[+-]?inf\b/y;
+function infinity(scanner) {
+	scanner.skipWhitespaces();
+	const match = scanner.match(INFINITY_REGEXP);
+	if (!match) return failure();
+	const string = match[0];
+	scanner.next(string.length);
+	return success(INFINITY_MAP.get(string));
+}
+const NAN_REGEXP = /[+-]?nan\b/y;
+function nan(scanner) {
+	scanner.skipWhitespaces();
+	const match = scanner.match(NAN_REGEXP);
+	if (!match) return failure();
+	const string = match[0];
+	scanner.next(string.length);
+	return success(NaN);
+}
+const dottedKey = join1(or([
+	bareKey,
+	basicString,
+	literalString
+]), ".");
+const BINARY_REGEXP = /0b[01]+(?:_[01]+)*\b/y;
+function binary(scanner) {
+	scanner.skipWhitespaces();
+	const match = scanner.match(BINARY_REGEXP)?.[0];
+	if (!match) return failure();
+	scanner.next(match.length);
+	const value = match.slice(2).replaceAll("_", "");
+	const number = parseInt(value, 2);
+	return isNaN(number) ? failure() : success(number);
+}
+const OCTAL_REGEXP = /0o[0-7]+(?:_[0-7]+)*\b/y;
+function octal(scanner) {
+	scanner.skipWhitespaces();
+	const match = scanner.match(OCTAL_REGEXP)?.[0];
+	if (!match) return failure();
+	scanner.next(match.length);
+	const value = match.slice(2).replaceAll("_", "");
+	const number = parseInt(value, 8);
+	return isNaN(number) ? failure() : success(number);
+}
+const HEX_REGEXP = /0x[0-9a-f]+(?:_[0-9a-f]+)*\b/iy;
+function hex(scanner) {
+	scanner.skipWhitespaces();
+	const match = scanner.match(HEX_REGEXP)?.[0];
+	if (!match) return failure();
+	scanner.next(match.length);
+	const value = match.slice(2).replaceAll("_", "");
+	const number = parseInt(value, 16);
+	return isNaN(number) ? failure() : success(number);
+}
+const INTEGER_REGEXP = /[+-]?(?:0|[1-9][0-9]*(?:_[0-9]+)*)\b/y;
+function integer(scanner) {
+	scanner.skipWhitespaces();
+	const match = scanner.match(INTEGER_REGEXP)?.[0];
+	if (!match) return failure();
+	scanner.next(match.length);
+	const value = match.replaceAll("_", "");
+	return success(parseInt(value, 10));
+}
+const FLOAT_REGEXP = /[+-]?(?:0|[1-9][0-9]*(?:_[0-9]+)*)(?:\.[0-9]+(?:_[0-9]+)*)?(?:e[+-]?[0-9]+(?:_[0-9]+)*)?\b/iy;
+function float(scanner) {
+	scanner.skipWhitespaces();
+	const match = scanner.match(FLOAT_REGEXP)?.[0];
+	if (!match) return failure();
+	scanner.next(match.length);
+	const value = match.replaceAll("_", "");
+	const float = parseFloat(value);
+	if (isNaN(float)) return failure();
+	return success(float);
+}
+const DATE_TIME_REGEXP = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})(?:[ 0-9TZ.:+-]+)?\b/y;
+function dateTime(scanner) {
+	scanner.skipWhitespaces();
+	const match = scanner.match(DATE_TIME_REGEXP);
+	if (!match) return failure();
+	const string = match[0];
+	scanner.next(string.length);
+	const groups = match.groups;
+	if (groups.month == "02") {
+		const days = parseInt(groups.day);
+		if (days > 29) throw new SyntaxError(`Invalid date string "${match}"`);
+		const year = parseInt(groups.year);
+		if (days > 28 && !isLeap(year)) throw new SyntaxError(`Invalid date string "${match}"`);
+	}
+	const date = new Date(string.trim());
+	if (isNaN(date.getTime())) throw new SyntaxError(`Invalid date string "${match}"`);
+	return success(date);
+}
+const LOCAL_TIME_REGEXP = /(\d{2}):(\d{2}):(\d{2})(?:\.[0-9]+)?\b/y;
+function localTime(scanner) {
+	scanner.skipWhitespaces();
+	const match = scanner.match(LOCAL_TIME_REGEXP)?.[0];
+	if (!match) return failure();
+	scanner.next(match.length);
+	return success(match);
+}
+function arrayValue(scanner) {
+	scanner.skipWhitespaces();
+	if (scanner.char() !== "[") return failure();
+	scanner.next();
+	const array = [];
+	while (!scanner.eof()) {
+		scanner.nextUntilChar();
+		const result = value(scanner);
+		if (!result.ok) break;
+		array.push(result.body);
+		scanner.skipWhitespaces();
+		if (scanner.char() !== ",") break;
+		scanner.next();
+	}
+	scanner.nextUntilChar();
+	if (scanner.char() !== "]") throw new SyntaxError("Array is not closed");
+	scanner.next();
+	return success(array);
+}
+function inlineTable(scanner) {
+	scanner.nextUntilChar();
+	if (scanner.char(1) === "}") {
+		scanner.next(2);
+		return success({ __proto__: null });
+	}
+	const pairs = surround("{", join(pair, ","), "}")(scanner);
+	if (!pairs.ok) return failure();
+	let table = { __proto__: null };
+	for (const pair of pairs.body) table = deepMerge(table, pair);
+	return success(table);
+}
+const value = or([
+	multilineBasicString,
+	multilineLiteralString,
+	basicString,
+	literalString,
+	boolean,
+	infinity,
+	nan,
+	dateTime,
+	localTime,
+	binary,
+	octal,
+	hex,
+	float,
+	integer,
+	arrayValue,
+	inlineTable
+]);
+const pair = kv(dottedKey, "=", value);
+surround("[", dottedKey, "]");
+surround("[[", dottedKey, "]]");
+//#endregion
+//#region ../omp-utils/dist/index.js
+/**
+* ACL: detect and extract shell commands from context-mode tool invocations.
+*
+* Context-mode tools (ctx_execute, ctx_batch_execute) can execute shell
+* commands that should be inspected by shell-guard hooks.
+*/
+const CONTEXT_MODE_SHELL_TOOLS = {
+	ctx_execute: true,
+	ctx_batch_execute: true
+};
+function isContextModeShellTool(toolName, input) {
+	if (!CONTEXT_MODE_SHELL_TOOLS[toolName]) return false;
+	if (toolName === "ctx_execute") return input["language"] === "shell";
+	return true;
+}
+function extractShellCommand(toolName, input) {
+	if (!isContextModeShellTool(toolName, input)) return void 0;
+	if (toolName === "ctx_execute") return typeof input["code"] === "string" ? input["code"] : void 0;
+	if (Array.isArray(input["commands"])) return input["commands"].map((entry) => typeof entry === "object" && entry !== null ? entry["command"] : "").filter((cmd) => typeof cmd === "string").join("\n");
+}
+/**
+* ACL: match OMP tool names against Claude Code hook matcher patterns.
+*
+* Hook matchers are pipe-separated regex patterns (e.g. "Write|Edit").
+* An empty/undefined matcher matches everything.
+*/
+const regexCache = /* @__PURE__ */ new Map();
+function matchesMatcher(toolName, matcher) {
+	if (!matcher || matcher.length === 0) return true;
+	const pattern = matcher.split("|").map((part) => part.trim()).filter(Boolean).join("|");
+	if (pattern.length === 0) return true;
+	const cached = regexCache.get(pattern);
+	if (cached !== void 0) return cached.test(toolName);
+	const regex = new RegExp(`^(?:${pattern})$`);
+	regexCache.set(pattern, regex);
+	return regex.test(toolName);
+}
+function sessionIds(getSessionId) {
+	return {
+		session_id: getSessionId(),
+		agent_id: null
+	};
+}
+/**
+* Create a telemetry emitter for a plugin.
+*
+* @param plugin - The event prefix (e.g. `claude_compat`, `agent_discipline`).
+* @param logger - The `pi.logger` instance injected by the host at factory time.
+*/
+function createTelemetry(plugin, logger) {
+	return (eventName, fields) => {
+		try {
+			logger.info(eventName, {
+				plugin,
+				event: eventName,
+				...fields
+			});
+		} catch {}
+	};
+}
+/**
+* ACL: translate OMP tool input shapes to Claude Code hook input shapes.
+*
+* OMP sends `edits: [{ old_text, new_text }]` and `path`;
+* Claude Code hooks expect `old_string`/`new_string` and `file_path`.
+*/
+const FILE_TOOLS = {
+	Write: true,
+	Edit: true,
+	Read: true,
+	MultiEdit: true,
+	Update: true,
+	Create: true
+};
+const EDIT_TOOLS = {
+	Edit: true,
+	MultiEdit: true,
+	Update: true
+};
+function isOmpEditArray(value) {
+	return Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "object" && entry !== null && ("new_text" in entry || "old_text" in entry));
+}
+function normalizeToolInput(toolName, input) {
+	let out = input;
+	if (FILE_TOOLS[toolName] === true && "path" in out && !("file_path" in out)) {
+		const { path, ...rest } = out;
+		out = {
+			file_path: path,
+			...rest
+		};
+	}
+	if (EDIT_TOOLS[toolName] === true && "edits" in out && isOmpEditArray(out["edits"]) && !("new_string" in out)) {
+		const claudeEdits = out["edits"].map((entry) => ({
+			old_string: typeof entry["old_text"] === "string" ? entry["old_text"] : "",
+			new_string: typeof entry["new_text"] === "string" ? entry["new_text"] : ""
+		}));
+		out = {
+			...out,
+			edits: claudeEdits,
+			old_string: claudeEdits.map((entry) => entry["old_string"]).join("\n"),
+			new_string: claudeEdits.map((entry) => entry["new_string"]).join("\n")
+		};
+	}
+	return out;
+}
+/**
+* ACL: normalize OMP tool names to Claude Code convention.
+*
+* OMP emits lowercase tool names (write, bash, read);
+* Claude Code hook system expects capitalized (Write, Bash, Read).
+*/
+function normalizeToolName(name) {
+	if (name.length === 0) return name;
+	return name.charAt(0).toUpperCase() + name.slice(1);
+}
+//#endregion
+//#region src/hook-dispatcher.ts
+function getSessionIds(ctx) {
+	return sessionIds(() => ctx.sessionManager.getSessionId());
+}
+/** Module-scoped telemetry emitter, initialized in the default export. */
+let tel = () => {};
+function hookDispatcherExtension(pi) {
+	tel = createTelemetry("claude_compat", pi.logger);
+	pi.on("tool_call", async (event, ctx) => {
+		const settings = loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		return runPreToolUseHooks(settings, event, ctx);
+	});
+	pi.on("tool_result", async (event, ctx) => {
+		const settings = loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		const result = await runPostToolUseHooks(settings, event, ctx);
+		if (result?.block) return {
+			isError: true,
+			content: [{
+				type: "text",
+				text: result.reason ?? `Blocked by PostToolUse hook`
+			}]
+		};
+		if (result?.warning) return {
+			content: [...event.content ?? [], {
+				type: "text",
+				text: result.warning
+			}],
+			isError: event.isError
+		};
+	});
+	pi.on("input", async (event, ctx) => {
+		const settings = loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		return runUserPromptSubmitHooks(settings, event, ctx);
+	});
+	pi.on("session_start", async (_event, ctx) => {
+		const settings = loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		await runSessionStartHooks(settings, "start", ctx);
+	});
+	pi.on("session_compact", async (_event, ctx) => {
+		const settings = loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		await runSessionStartHooks(settings, "compact", ctx);
+	});
+	pi.on("agent_start", async (_event, ctx) => {
+		const settings = loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		await runSessionStartHooks(settings, "resume", ctx);
+	});
+	pi.on("session_shutdown", async (_event, ctx) => {
+		const settings = loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		await runLifecycleHooks(settings.hooks.SessionEnd, ctx);
+	});
+	pi.on("session_stop", async (_event, ctx) => {
+		const settings = loadSettings(ctx.cwd);
+		if (!settings) return void 0;
+		await runLifecycleHooks(settings.hooks.Stop, ctx);
+	});
+}
+const settingsCache = /* @__PURE__ */ new Map();
+function loadSettings(cwd) {
+	const cached = settingsCache.get(cwd);
+	if (cached !== void 0) return cached;
+	const settingsPath = resolve(cwd, ".claude", "settings.json");
+	if (!existsSync(settingsPath)) return null;
+	try {
+		const data = JSON.parse(readFileSync(settingsPath, "utf-8"));
+		const source = data.hooks ?? data;
+		const group = (key) => Array.isArray(source[key]) ? source[key] : [];
+		const result = { hooks: {
+			PreToolUse: group("PreToolUse"),
+			PostToolUse: group("PostToolUse"),
+			UserPromptSubmit: group("UserPromptSubmit"),
+			Stop: group("Stop"),
+			SessionStart: group("SessionStart"),
+			SessionEnd: group("SessionEnd")
+		} };
+		settingsCache.set(cwd, result);
+		return result;
+	} catch {
+		return null;
+	}
+}
+function resolveCommand(command, cwd) {
+	const trimmed = command.replace(/"\$OMP_PROJECT_DIR"|'\$OMP_PROJECT_DIR'/g, JSON.stringify(cwd)).replace(/"\$\{OMP_PROJECT_DIR\}"|'\$\{OMP_PROJECT_DIR\}'/g, JSON.stringify(cwd)).replace(/"\$CLAUDE_PROJECT_DIR"|'\$CLAUDE_PROJECT_DIR'/g, JSON.stringify(cwd)).replace(/"\$\{CLAUDE_PROJECT_DIR\}"|'\$\{CLAUDE_PROJECT_DIR\}'/g, JSON.stringify(cwd)).replace(/\$OMP_PROJECT_DIR|\$\{OMP_PROJECT_DIR\}/g, JSON.stringify(cwd)).replace(/\$CLAUDE_PROJECT_DIR|\$\{CLAUDE_PROJECT_DIR\}/g, JSON.stringify(cwd)).trim();
+	const unquoted = trimmed.startsWith("\"") && trimmed.endsWith("\"") ? trimmed.slice(1, -1) : trimmed;
+	const pathPart = unquoted.split(/\s+/)[0] ?? "";
+	if (extname(pathPart) === ".ts") return {
+		cmd: "bun",
+		args: [resolve(cwd, pathPart)]
+	};
+	return {
+		cmd: "sh",
+		args: ["-c", unquoted]
+	};
+}
+async function runHookScript(command, input, cwd, timeoutMs = 1e4) {
+	const { cmd, args } = resolveCommand(command, cwd);
+	const stdin = JSON.stringify(input);
+	const { promise, resolve, reject } = Promise.withResolvers();
+	const child = execFile(cmd, [...args], {
+		cwd,
+		timeout: timeoutMs,
+		killSignal: "SIGKILL",
+		env: {
+			...process.env,
+			OMP_PROJECT_DIR: cwd,
+			CLAUDE_PROJECT_DIR: cwd
+		},
+		maxBuffer: 1024 * 1024
+	}, (error, stdout, stderr) => {
+		if (error && typeof error.code !== "number") {
+			reject(error);
+			return;
+		}
+		resolve({
+			code: error?.code ?? 0,
+			stdout,
+			stderr
+		});
+	});
+	child.stdin?.on("error", () => {}).write(stdin);
+	child.stdin?.end();
+	return promise;
+}
+async function runHooksForEvent(entries, matchValue, input, ctx, event) {
+	const cwd = ctx.cwd;
+	let warning;
+	let inputModified = false;
+	for (const entry of entries) {
+		if (!matchesMatcher(matchValue, entry.matcher)) continue;
+		for (const hook of entry.hooks) {
+			const hookName = hook.command.split(/[\\/]/).pop() ?? hook.command;
+			const hookStart = performance.now();
+			if (hook.async) {
+				runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3).then((result) => {
+					const durationMs = Math.round(performance.now() - hookStart);
+					tel("hook.executed", {
+						hook: hookName,
+						duration_ms: durationMs,
+						exit_code: result.code
+					});
+				}, (err) => {
+					const durationMs = Math.round(performance.now() - hookStart);
+					tel("hook.executed", {
+						hook: hookName,
+						duration_ms: durationMs,
+						exit_code: null,
+						error: err instanceof Error ? err.message : "unknown error"
+					});
+				});
+				continue;
+			}
+			let result;
+			try {
+				result = await runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3);
+			} catch (err) {
+				const durationMs = Math.round(performance.now() - hookStart);
+				tel("hook.executed", {
+					hook: hookName,
+					duration_ms: durationMs,
+					exit_code: null,
+					error: err instanceof Error ? err.message : "unknown error"
+				});
+				throw err;
+			}
+			const durationMs = Math.round(performance.now() - hookStart);
+			tel("hook.executed", {
+				hook: hookName,
+				duration_ms: durationMs,
+				exit_code: result.code
+			});
+			if (result.code === 2) return {
+				block: true,
+				reason: result.stderr.trim() || `Blocked by ${event} hook`
+			};
+			if (result.code !== 0) {
+				const msg = result.stderr.trim();
+				if (msg && warning === void 0) warning = msg;
+				continue;
+			}
+			const stdout = result.stdout.trim();
+			if (stdout.length > 0) try {
+				const parsed = JSON.parse(stdout);
+				const hookOutput = parsed.hookSpecificOutput;
+				if (hookOutput?.permissionDecision === "deny") return {
+					block: true,
+					reason: hookOutput.permissionDecisionReason ?? `Blocked by ${event} hook`
+				};
+				if (parsed.decision === "block") return {
+					block: true,
+					reason: parsed.reason ?? `Blocked by ${event} hook`
+				};
+				if (hookOutput?.updatedInput) {
+					input = {
+						...input,
+						...hookOutput.updatedInput
+					};
+					inputModified = true;
+				}
+			} catch {}
+		}
+	}
+	return {
+		...inputModified ? { updatedInput: input } : {},
+		...warning !== void 0 ? { warning } : {}
+	};
+}
+async function runPreToolUseHooks(settings, event, ctx) {
+	const claudeToolName = normalizeToolName(event.toolName);
+	const input = {
+		...getSessionIds(ctx),
+		tool_name: claudeToolName,
+		tool_input: normalizeToolInput(claudeToolName, event.input),
+		tool_call_id: event.toolCallId
+	};
+	const shellCommand = extractShellCommand(event.toolName, event.input);
+	if (shellCommand !== void 0 && shellCommand.length > 0) {
+		const bashInput = {
+			...getSessionIds(ctx),
+			tool_name: "Bash",
+			tool_input: { command: shellCommand },
+			tool_call_id: event.toolCallId
+		};
+		const bashResult = await runHooksForEvent(settings.hooks.PreToolUse, "Bash", bashInput, ctx, "PreToolUse");
+		if (bashResult.block) {
+			tel("tool_call.decision", {
+				tool_name: claudeToolName,
+				decision: "block",
+				reason: bashResult.reason ?? `Bash blocked for ${shellCommand}`
+			});
+			return bashResult.reason === void 0 ? { block: true } : {
+				block: true,
+				reason: bashResult.reason
+			};
+		}
+	}
+	const result = await runHooksForEvent(settings.hooks.PreToolUse, claudeToolName, input, ctx, "PreToolUse");
+	if (result.block) {
+		tel("tool_call.decision", {
+			tool_name: claudeToolName,
+			decision: "block",
+			reason: result.reason ?? void 0
+		});
+		return result.reason === void 0 ? { block: true } : {
+			block: true,
+			reason: result.reason
+		};
+	}
+	if (result.updatedInput && typeof result.updatedInput === "object" && "tool_input" in result.updatedInput && result.updatedInput["tool_input"] && typeof result.updatedInput["tool_input"] === "object") {
+		const updated = result.updatedInput["tool_input"];
+		for (const [key, value] of Object.entries(updated)) event.input[key] = value;
+	}
+	tel("tool_call.decision", {
+		tool_name: claudeToolName,
+		decision: "allow"
+	});
+}
+async function runPostToolUseHooks(settings, event, ctx) {
+	const claudeToolName = normalizeToolName(event.toolName);
+	const input = {
+		...getSessionIds(ctx),
+		tool_name: claudeToolName,
+		tool_input: normalizeToolInput(claudeToolName, event.input),
+		tool_call_id: event.toolCallId,
+		output: event.content,
+		is_error: event.isError ?? false
+	};
+	return runHooksForEvent(settings.hooks.PostToolUse, claudeToolName, input, ctx, "PostToolUse");
+}
+async function runUserPromptSubmitHooks(settings, event, ctx) {
+	const entries = settings.hooks.UserPromptSubmit;
+	if (entries.length === 0) return void 0;
+	const cwd = ctx.cwd;
+	let injected = "";
+	const input = {
+		...getSessionIds(ctx),
+		prompt: event.text,
+		source: event.source
+	};
+	for (const entry of entries) for (const hook of entry.hooks) {
+		const result = await runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3);
+		if (result.code !== 0) continue;
+		const stdout = result.stdout.trim();
+		if (stdout.length > 0) injected += (injected.length > 0 ? "\n\n" : "") + stdout;
+	}
+	if (injected.length === 0) return void 0;
+	const result = { text: `${injected}\n\n${event.text}` };
+	if (event.images !== void 0) result.images = event.images;
+	return result;
+}
+async function runSessionStartHooks(settings, reason, ctx) {
+	const entries = settings.hooks.SessionStart;
+	if (entries.length === 0) return;
+	const cwd = ctx.cwd;
+	const input = {
+		...getSessionIds(ctx),
+		reason
+	};
+	for (const entry of entries) {
+		if (entry.matcher && !matchesMatcher(reason, entry.matcher)) continue;
+		for (const hook of entry.hooks) {
+			const hookName = hook.command.split(/[\\/]/).pop() ?? hook.command;
+			if (hook.async) {
+				runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3).then((result) => {
+					tel("hook.executed", {
+						hook: hookName,
+						exit_code: result.code
+					});
+				}, (err) => {
+					tel("hook.executed", {
+						hook: hookName,
+						exit_code: null,
+						error: err instanceof Error ? err.message : "unknown error"
+					});
+				});
+				continue;
+			}
+			await runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3).then((result) => {
+				tel("hook.executed", {
+					hook: hookName,
+					exit_code: result.code
+				});
+			}, (err) => {
+				tel("hook.executed", {
+					hook: hookName,
+					exit_code: null,
+					error: err instanceof Error ? err.message : "unknown error"
+				});
+			});
+		}
+	}
+}
+async function runLifecycleHooks(entries, ctx) {
+	if (entries.length === 0) return;
+	const cwd = ctx.cwd;
+	const input = { ...getSessionIds(ctx) };
+	for (const entry of entries) for (const hook of entry.hooks) {
+		const hookName = hook.command.split(/[\\/]/).pop() ?? hook.command;
+		if (hook.async) runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3).then((result) => {
+			tel("hook.executed", {
+				hook: hookName,
+				exit_code: result.code
+			});
+		}, (err) => {
+			tel("hook.executed", {
+				hook: hookName,
+				exit_code: null,
+				error: err instanceof Error ? err.message : "unknown error"
+			});
+		});
+		else await runHookScript(hook.command, input, cwd, (hook.timeout ?? 10) * 1e3).then((result) => {
+			tel("hook.executed", {
+				hook: hookName,
+				exit_code: result.code
+			});
+		}, (err) => {
+			tel("hook.executed", {
+				hook: hookName,
+				exit_code: null,
+				error: err instanceof Error ? err.message : "unknown error"
+			});
+		});
+	}
+}
+//#endregion
+//#region src/inject-instructions.ts
+/**
+* Find all @-references in a CLAUDE.md file.
+*
+* Supports:
+*   - Plain @-ref:         `@path/to/file.md`
+*   - Bullet-list @-ref:   `- @path/to/file.md`
+*
+* Only extracts refs where the @-token is the first thing on the line after
+* stripping leading list markers (`- `, `* `, `+ `) — conservative contract
+* that avoids matching inline prose references.
+*/
+function extractRefs(filePath, projectDir) {
+	let content;
+	try {
+		content = readFileSync(filePath, "utf-8");
+	} catch {
+		return [];
+	}
+	const baseDir = dirname(filePath);
+	const refs = [];
+	for (const rawLine of content.split("\n")) {
+		const noMarker = rawLine.trim().replace(/^[-*+]\s+/, "");
+		if (!noMarker.startsWith("@")) continue;
+		const ref = noMarker.slice(1).trim();
+		if (!ref || ref.includes(" ")) continue;
+		if (isAbsolute(ref)) continue;
+		const baseResolved = resolve(baseDir, ref);
+		if ((baseResolved.startsWith(projectDir + sep) || baseResolved === projectDir) && existsSync(baseResolved)) {
+			refs.push({
+				sourcePath: filePath,
+				resolvedPath: baseResolved
+			});
+			continue;
+		}
+		const rootResolved = resolve(projectDir, ref);
+		if ((rootResolved.startsWith(projectDir + sep) || rootResolved === projectDir) && existsSync(rootResolved)) refs.push({
+			sourcePath: filePath,
+			resolvedPath: rootResolved
+		});
+	}
+	return refs;
+}
+/**
+* Read all @-referenced files and format them for injection.
+*/
+function loadReferencedContent(projectDir) {
+	const claudeMdPaths = [resolve(projectDir, "CLAUDE.md"), resolve(projectDir, ".claude", "CLAUDE.md")];
+	const allRefs = [];
+	for (const filePath of claudeMdPaths) if (existsSync(filePath)) allRefs.push(...extractRefs(filePath, projectDir));
+	const seen = /* @__PURE__ */ new Set();
+	const uniqueRefs = [];
+	for (const ref of allRefs) if (!seen.has(ref.resolvedPath)) {
+		seen.add(ref.resolvedPath);
+		uniqueRefs.push(ref);
+	}
+	if (uniqueRefs.length === 0) return "";
+	const parts = ["# Injected @-references from CLAUDE.md"];
+	parts.push("The following files were @-imported by CLAUDE.md and contain project rules.");
+	parts.push("");
+	for (const ref of uniqueRefs) {
+		const relativePath = ref.resolvedPath.slice(projectDir.length + 1);
+		parts.push(`## ${relativePath}`);
+		try {
+			const content = readFileSync(ref.resolvedPath, "utf-8");
+			parts.push(content);
+		} catch {
+			parts.push(`[error reading ${relativePath}]`);
+		}
+		parts.push("");
+	}
+	return parts.join("\n");
+}
+function injectInstructionsExtension(pi) {
+	const projectDir = process.env["CLAUDE_PROJECT_DIR"] ?? process.cwd();
+	let cached;
+	pi.on("before_agent_start", async (event) => {
+		if (cached === void 0) cached = loadReferencedContent(projectDir);
+		if (!cached) return void 0;
+		return { systemPrompt: [
+			...event.systemPrompt,
+			"",
+			cached
+		] };
+	});
+}
+//#endregion
+//#region src/index.ts
+function claudeCompatExtension(pi) {
+	hookDispatcherExtension(pi);
+	injectInstructionsExtension(pi);
+}
+//#endregion
+export { claudeCompatExtension as default };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@systemfsoftware/omp-claude-compat",
+  "license": "MIT",
+  "version": "0.0.0",
+  "author": "Ryan Lee <drdgvhbh@gmail.com>",
+  "description": "OMP Claude Code compatibility: dispatch .claude/settings.json hooks + inject CLAUDE.md @-references",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {},
+  "peerDependencies": {
+    "@oh-my-pi/pi-coding-agent": "^17.0.5"
+  },
+  "devDependencies": {
+    "@oh-my-pi/pi-coding-agent": "^17.0.5",
+    "@types/node": "^24",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.22.9",
+    "typescript": "^7",
+    "vitest": "^4",
+    "@systemfsoftware/tsconfig": "^1.1.0",
+    "@systemfsoftware/omp-utils": "^0.0.0",
+    "@systemfsoftware/oxlint-config": "^0.1.0"
+  },
+  "omp": {
+    "extensions": [
+      "./dist/index.js"
+    ]
+  },
+  "inlinedDependencies": {
+    "@jsr/std__collections": "1.3.0",
+    "@jsr/std__toml": "1.0.11"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "rimraf dist && tsdown",
+    "verify-dist": "node ../../scripts/check-dist-builtins.mjs --dist dist/index.js --expect node:child_process node:fs node:path",
+    "postbuild": "pnpm verify-dist",
+    "typecheck": "tsc --noEmit --incremental",
+    "test": "vitest run",
+    "lint": "oxlint . ${AGENT:+--format=unix --quiet}"
+  }
+}